w3dappdata.h

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(tm)
**  Copyright 2025 Electronic Arts Inc.
**
**  This program is free software: you can redistribute it and/or modify
**  it under the terms of the GNU General Public License as published by
**  the Free Software Foundation, either version 3 of the License, or
**  (at your option) any later version.
**
**  This program is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : Max2W3d                                                      *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/Tools/max2w3d/w3dappdata.h                   $*
 *                                                                                             *
 *              Original Author:: Greg Hjelstrom                                               *
 *                                                                                             *
 *                      $Author:: Greg_h                                                      $*
 *                                                                                             *
 *                     $Modtime:: 8/21/01 9:44a                                               $*
 *                                                                                             *
 *                    $Revision:: 8                                                           $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
#ifndef W3DAPPDATA_H
#define W3DAPPDATA_H
 
#include <Max.h>
 
/*
** The W3DUtilityClass uses several app-data chunks to store user-options for INodes
** in the MAX scene.  Below are the IDs for each app-data chunk type:
*/
 
#define W3D_APPDATA_0           0
#define W3D_APPDATA_1           1
#define W3D_APPDATA_2           2
#define W3D_DAZZLE_APPDATA      3
 
 
/*
**  Classifying INodes for w3d exporting
**
** NOTE: Use these utility functions rather than going straight to the AppData
** structure!
**
**  - There are bits stored in AppData for each node
**  - These bits indicate wether something should be exported as hierarchy,
**    geometry (and if so, what type of geometry: mesh, collision box, bitmap, etc)
** 
** When we say something is "Hierarchy" that means its transform should be put
** into any hierarchy tree or motion being created.  In some places I used
** the term "Bone" which means the same thing.
**
** When we say something is "Geometry" that means that the object will become
** some sort of render object (normal mesh, bitmap, collision mesh, etc)
**
*/
 
/*
** Either or both of these will return true for a given INode
*/
bool    Is_Bone(INode * node);
bool    Is_Geometry(INode * node);
 
/*
** Geometry Type:
** One of the following will return true if the given INode is
** to have its geometry exported
*/
bool    Is_Normal_Mesh(INode * node);
bool    Is_Camera_Aligned_Mesh(INode * node);
bool    Is_Camera_Oriented_Mesh(INode * node);
bool    Is_Collision_AABox(INode * node);
bool    Is_Collision_OBBox(INode * node);
bool    Is_Skin(INode * node);
bool    Is_Shadow(INode * node);
bool    Is_Null_Object(INode * node);
bool    Is_Dazzle(INode * node);
bool    Is_Aggregate(INode * node);
 
/*
** Collision Bits, any or all of these may return true for a given INode
*/
bool    Is_Physical_Collision(INode * node);
bool    Is_Projectile_Collision(INode * node);
bool    Is_Vis_Collision(INode * node);
bool    Is_Camera_Collision(INode * node);
bool    Is_Vehicle_Collision(INode * node);
 
/*
** Miscellaneous settings
*/
bool    Is_Hidden(INode * node);
bool    Is_Two_Sided(INode * node);
bool    Is_ZNormals(INode * node);
bool    Is_Vertex_Alpha(INode * node);
bool    Is_Shatterable(INode * node);
bool    Is_NPatchable(INode * node);
 
/*
** Proxy support.  If a node has a name which contains a ~ it is considered a 
** proxy for an application defined named object.  This overrides all other
** settings (in the future, we shouldn't do things this way!)
*/
inline bool Is_Proxy(INode &node)
{
    return (::strchr (node.GetName (), '~') != NULL);
}
 
 
 
/*
** AJA 9/24/99
** NOTE: Whenever you add a new W3DAppDataStruct, you must add an accessor function
** to the bottom of this file. Then the WWScript.dlx project must be modified. That
** project implements an extension to the MAXScript language in the form of a function
** called "wwCopyAppData". The implementation of this wwCopyAppData function must be
** aware of the new W3DAppDataStruct. The modification is pretty straightfoward.
**
** The wwCopyAppData extension was added to MAXScript so that the data we define
** below can be preserve when a model is cloned (copy/instance/reference). What
** happens without using wwCopyAppData is that a new INode is created that contains
** a copy/instance/reference to the original mesh/bone in the source model. When
** this new INode is created, it has no app data. When the app data is examined later
** on, it gets the default values! That means all information concerning Export
** Geometry/Transform, mesh type, and damage region is lost. wwCopyAppData allows
** a script to duplicate a model INCLUDING all W3D app data, so that this information
** is preserved.
*/
 
 
/*
** The W3DAppData0Struct contains a bitfield.  These #defines are 
** used to interpret the bits.
** (gth) NOTE: AppData0 is now OBSOLETE!!!  Use W3DAppData2Struct now.
*/
#define EXPORT_TYPE_MASK                    0x000F
#define GEOMETRY_TYPE_MASK                  0x01F0
#define COLLISION_TYPE_MASK             0xF000
 
#define EXPORT_BONE_FLAG                    0x0001  // export a bone (transform) for this node
#define EXPORT_GEOMETRY_FLAG                0x0002  // export the geometry for this node
#define EXPORT_HIDDEN_FLAG                  0x0004  // mesh should be hidden by default
#define EXPORT_TWO_SIDED_FLAG               0x0008  // mesh should be two sided
 
#define GEOMETRY_TYPE_CAMERA_ALIGNED    0x0010  // interpret this geometry as a camera-aligned mesh
#define GEOMETRY_TYPE_NORMAL_MESH       0x0020  // this is a normal mesh
#define GEOMETRY_TYPE_OBBOX             0x0030  // this is an oriented box (should have 8 verts, etc)
#define GEOMETRY_TYPE_AABOX             0x0040  // this is an axis aligned box
#define GEOMETRY_TYPE_CAMERA_ORIENTED   0x0050  // interpret this geometry as a camera-oriented mesh
#define GEOMETRY_TYPE_NULL                  0x0100  // this is a null (for LOD)
 
#define EXPORT_CAST_SHADOW_FLAG         0x0200  // this mesh casts a shadow
#define EXPORT_VERTEX_ALPHA_FLAG            0x0400  // convert vertex colors to alpha
#define EXPORT_ZNORMALS_FLAG                0x0800  // force vertex normals to point along +z
 
#define COLLISION_TYPE_PHYSICAL         0x1000  // runtime engine performs physical collision against this mesh
#define COLLISION_TYPE_PROJECTILE       0x2000  // perform projectile collisions against this mesh
#define COLLISION_TYPE_VIS                  0x4000  // perform vis group collisions against this mesh
 
#define DEFAULT_MESH_EXPORT_FLAGS       (EXPORT_BONE_FLAG | EXPORT_GEOMETRY_FLAG | GEOMETRY_TYPE_NORMAL_MESH)
#define DEFAULT_EXPORT_FLAGS                0
 
 
/*
** W3D Utility AppData sub-type 0  (OBSOLETE!)
** ----------------------------------------------------
** The utility provides a right-click menu which allows
** the user to toggle the export flags.
** (gth) NOTE: AppData0 is now OBSOLETE!!!  Use W3DAppData2Struct now.
*/
struct W3DAppData0Struct
{
    W3DAppData0Struct(void) : ExportFlags(DEFAULT_EXPORT_FLAGS) {}
 
    bool    Is_Bone(void)                            { return (ExportFlags & EXPORT_BONE_FLAG) == EXPORT_BONE_FLAG; }
    bool    Is_Geometry(void)                        { return (ExportFlags & EXPORT_GEOMETRY_FLAG) == EXPORT_GEOMETRY_FLAG; }
 
    bool    Is_Normal_Mesh(void)                  { return (ExportFlags & GEOMETRY_TYPE_MASK) == GEOMETRY_TYPE_NORMAL_MESH; }
    bool    Is_Camera_Aligned_Mesh(void)      { return (ExportFlags & GEOMETRY_TYPE_MASK) == GEOMETRY_TYPE_CAMERA_ALIGNED; }
    bool    Is_Camera_Oriented_Mesh(void)        { return (ExportFlags & GEOMETRY_TYPE_MASK) == GEOMETRY_TYPE_CAMERA_ORIENTED; }
    bool    Is_Collision_AABox(void)          { return (ExportFlags & GEOMETRY_TYPE_MASK) == GEOMETRY_TYPE_AABOX; }
    bool    Is_Collision_OBBox(void)          { return (ExportFlags & GEOMETRY_TYPE_MASK) == GEOMETRY_TYPE_OBBOX; }
    bool    Is_Null(void)                            { return (ExportFlags & GEOMETRY_TYPE_MASK) == GEOMETRY_TYPE_NULL; }
 
    bool    Is_Physical_Collision(void)        { return (ExportFlags & COLLISION_TYPE_PHYSICAL) == COLLISION_TYPE_PHYSICAL; }
    bool    Is_Projectile_Collision(void)        { return (ExportFlags & COLLISION_TYPE_PROJECTILE) == COLLISION_TYPE_PROJECTILE; }
    bool    Is_Vis_Collision(void)              { return (ExportFlags & COLLISION_TYPE_VIS) == COLLISION_TYPE_VIS; }
 
    bool    Is_Hidden(void)                        { return (ExportFlags & EXPORT_HIDDEN_FLAG) == EXPORT_HIDDEN_FLAG; }
    bool    Is_Two_Sided(void)                  { return (ExportFlags & EXPORT_TWO_SIDED_FLAG) == EXPORT_TWO_SIDED_FLAG; }
    bool    Is_Vertex_Alpha(void)                { return (ExportFlags & EXPORT_VERTEX_ALPHA_FLAG) == EXPORT_VERTEX_ALPHA_FLAG; }
    bool    Is_ZNormals(void)                        { return (ExportFlags & EXPORT_ZNORMALS_FLAG) == EXPORT_ZNORMALS_FLAG; }
    bool    Is_Shadow(void)                        { return (ExportFlags & EXPORT_CAST_SHADOW_FLAG) == EXPORT_CAST_SHADOW_FLAG; }
    
    unsigned short ExportFlags;  // what was I thinking??? (gth)
};
 
 
 
/*
** W3D Utility AppData sub-type 1
** ----------------------------------------------------
** This AppData contains the damage region number for
** the current object.
*/
 
// Maximum number of damage regions on a model.
#define MAX_DAMAGE_REGIONS      ((char)16)
// Value that represents no damage region.
#define NO_DAMAGE_REGION        ((char)-1)
 
struct W3DAppData1Struct
{
    W3DAppData1Struct(void) : DamageRegion(NO_DAMAGE_REGION) { }
 
    /*
    ** NO_DAMAGE_REGION means the object isn't part of
    ** any damage region, 0 through MAX_DAMAGE_REGIONS-1
    ** are valid damage regions.
    */
    char DamageRegion;
};
 
 
 
/*
** W3D Utility AppData sub-type 2
** ----------------------------------------------------
** This is an app-data struct that is meant to contain all
** of the w3d export options for an object in MAX.  It
** replaces the old AppData sub-type 0.  Call the static
** member functions in the class to get a pointer to
** the AppData2 struct hanging off any INode and automatically
** create one for you if there isn't already one...
*/
 
struct W3DAppData2Struct
{
    W3DAppData2Struct(void);
    W3DAppData2Struct(W3DAppData0Struct & olddata);
 
    void    Init_With_Mesh_Defaults(void);
    void    Init_With_Other_Defaults(void);
    void    Init_From_AppData0(W3DAppData0Struct & olddata);
    void    Update_Version(void);
 
    enum GeometryTypeEnum
    {
        GEO_TYPE_CAMERA_ALIGNED =    0x00000001,     // Geometry types are mutually exclusive
        GEO_TYPE_NORMAL_MESH =      0x00000002,
        GEO_TYPE_OBBOX =              0x00000003,
        GEO_TYPE_AABOX =              0x00000004,
        GEO_TYPE_CAMERA_ORIENTED =  0x00000005,
        GEO_TYPE_NULL =                0x00000006, 
        GEO_TYPE_DAZZLE =                0x00000007,
        GEO_TYPE_AGGREGATE =          0x00000008,
    };
    
    /*
    ** Read Access
    */
    bool    Is_Bone(void) const                          { return (ExportFlags & EXPORT_TRANSFORM) == EXPORT_TRANSFORM; }
    bool    Is_Geometry(void)    const                       { return (ExportFlags & EXPORT_GEOMETRY) == EXPORT_GEOMETRY; }
 
    int Get_Geometry_Type(void)    const               { return GeometryType; }
    bool    Is_Normal_Mesh(void)  const                   { return GeometryType == GEO_TYPE_NORMAL_MESH; }
    bool    Is_Camera_Aligned_Mesh(void) const        { return GeometryType == GEO_TYPE_CAMERA_ALIGNED; }
    bool    Is_Camera_Oriented_Mesh(void) const      { return GeometryType == GEO_TYPE_CAMERA_ORIENTED; }
    bool    Is_Collision_AABox(void) const            { return GeometryType == GEO_TYPE_AABOX; }
    bool    Is_Collision_OBBox(void) const            { return GeometryType == GEO_TYPE_OBBOX; }
    bool    Is_Null(void) const                          { return GeometryType == GEO_TYPE_NULL; }
    bool    Is_Dazzle(void) const                      { return GeometryType == GEO_TYPE_DAZZLE; }
 
    bool    Is_Hidden_Enabled(void) const              { return (GeometryFlags & GEOMETRY_FLAG_HIDDEN) == GEOMETRY_FLAG_HIDDEN; }
    bool    Is_Two_Sided_Enabled(void) const            { return (GeometryFlags & GEOMETRY_FLAG_TWO_SIDED) == GEOMETRY_FLAG_TWO_SIDED; }
    bool    Is_Vertex_Alpha_Enabled(void) const      { return (GeometryFlags & GEOMETRY_FLAG_VERTEX_ALPHA) == GEOMETRY_FLAG_VERTEX_ALPHA; }
    bool    Is_ZNormals_Enabled(void) const          { return (GeometryFlags & GEOMETRY_FLAG_ZNORMALS) == GEOMETRY_FLAG_ZNORMALS; }
    bool    Is_Shadow_Enabled(void) const              { return (GeometryFlags & GEOMETRY_FLAG_CAST_SHADOW) == GEOMETRY_FLAG_CAST_SHADOW; }
    bool    Is_Shatterable_Enabled(void) const        { return (GeometryFlags & GEOMETRY_FLAG_SHATTERABLE) == GEOMETRY_FLAG_SHATTERABLE; }
    bool    Is_NPatchable_Enabled(void) const      { return (GeometryFlags & GEOMETRY_FLAG_NPATCHABLE) == GEOMETRY_FLAG_NPATCHABLE; }
 
    bool    Is_Physical_Collision_Enabled(void) const      { return (CollisionFlags & COLLISION_FLAG_PHYSICAL) == COLLISION_FLAG_PHYSICAL; }
    bool    Is_Projectile_Collision_Enabled(void) const  { return (CollisionFlags & COLLISION_FLAG_PROJECTILE) == COLLISION_FLAG_PROJECTILE; }
    bool    Is_Vis_Collision_Enabled(void) const            { return (CollisionFlags & COLLISION_FLAG_VIS) == COLLISION_FLAG_VIS; }
    bool    Is_Camera_Collision_Enabled(void) const      { return (CollisionFlags & COLLISION_FLAG_CAMERA) == COLLISION_FLAG_CAMERA; }
    bool    Is_Vehicle_Collision_Enabled(void) const        { return (CollisionFlags & COLLISION_FLAG_VEHICLE) == COLLISION_FLAG_VEHICLE; }
 
    /*
    ** Write Access
    */
    void    Enable_Export_Transform(bool onoff)          { if (onoff) { ExportFlags |= EXPORT_TRANSFORM; } else { ExportFlags &= ~EXPORT_TRANSFORM; } }
    void    Enable_Export_Geometry(bool onoff)            { if (onoff) { ExportFlags |= EXPORT_GEOMETRY; } else { ExportFlags &= ~EXPORT_GEOMETRY; } }
 
    void    Set_Geometry_Type(GeometryTypeEnum type)   { GeometryType = (unsigned int)type; }
 
    void    Enable_Hidden(bool onoff)                      { if (onoff) { GeometryFlags |= GEOMETRY_FLAG_HIDDEN; } else { GeometryFlags &= ~GEOMETRY_FLAG_HIDDEN; } }
    void    Enable_Two_Sided(bool onoff)                    { if (onoff) { GeometryFlags |= GEOMETRY_FLAG_TWO_SIDED; } else { GeometryFlags &= ~GEOMETRY_FLAG_TWO_SIDED; } }
    void    Enable_Shadow(bool onoff)                      { if (onoff) { GeometryFlags |= GEOMETRY_FLAG_CAST_SHADOW; } else { GeometryFlags &= ~GEOMETRY_FLAG_CAST_SHADOW; } }
    void    Enable_Vertex_Alpha(bool onoff)              { if (onoff) { GeometryFlags |= GEOMETRY_FLAG_VERTEX_ALPHA; } else { GeometryFlags &= ~GEOMETRY_FLAG_VERTEX_ALPHA; } }
    void    Enable_ZNormals(bool onoff)                  { if (onoff) { GeometryFlags |= GEOMETRY_FLAG_ZNORMALS; } else { GeometryFlags &= ~GEOMETRY_FLAG_ZNORMALS; } }
    void    Enable_Shatterable(bool onoff)                { if (onoff) { GeometryFlags |= GEOMETRY_FLAG_SHATTERABLE; } else { GeometryFlags &= ~GEOMETRY_FLAG_SHATTERABLE; } }
    void    Enable_NPatchable(bool onoff)                  { if (onoff) { GeometryFlags |= GEOMETRY_FLAG_NPATCHABLE; } else { GeometryFlags &= ~GEOMETRY_FLAG_NPATCHABLE; } }
 
    void    Enable_Physical_Collision(bool onoff)      { if (onoff) { CollisionFlags |= COLLISION_FLAG_PHYSICAL; } else { CollisionFlags &= ~COLLISION_FLAG_PHYSICAL; } }
    void    Enable_Projectile_Collision(bool onoff)  { if (onoff) { CollisionFlags |= COLLISION_FLAG_PROJECTILE; } else { CollisionFlags &= ~COLLISION_FLAG_PROJECTILE; } }
    void    Enable_Vis_Collision(bool onoff)                { if (onoff) { CollisionFlags |= COLLISION_FLAG_VIS; } else { CollisionFlags &= ~COLLISION_FLAG_VIS; } }
    void    Enable_Camera_Collision(bool onoff)          { if (onoff) { CollisionFlags |= COLLISION_FLAG_CAMERA; } else { CollisionFlags &= ~COLLISION_FLAG_CAMERA; } }
    void    Enable_Vehicle_Collision(bool onoff)        { if (onoff) { CollisionFlags |= COLLISION_FLAG_VEHICLE; } else { CollisionFlags &= ~COLLISION_FLAG_VEHICLE; } }
 
    /*
    ** Comparison
    */
    bool    operator == (const W3DAppData2Struct & that);
    bool    operator != (const W3DAppData2Struct & that)   { return !(*this == that); }
    bool    Geometry_Options_Match(const W3DAppData2Struct & that);
 
    /*
    ** Get the W3DAppData2Struct for a given INode and create one if
    ** there isn't already one.
    */
    static W3DAppData2Struct * Get_App_Data(INode * node,bool create_if_missing = true);
 
protected:
 
    void    Set_Version(int ver)                             { ExportFlags &= ~VERSION_MASK; ExportFlags |= (ver<<VERSION_SHIFT); }
    int Get_Version(void)                                    { return (ExportFlags & VERSION_MASK)>>VERSION_SHIFT; }
 
    enum ExportFlagsEnum
    {
        EXPORT_TRANSFORM =                  0x00000001,     // Export flags bit-field
        EXPORT_GEOMETRY =                        0x00000002,
        
        VERSION_MASK =                          0xFFFF0000,     // upper 16bits is version number.
        VERSION_SHIFT =                        16,
    };
    
    enum GeometryFlagsEnum
    {
        GEOMETRY_FLAG_HIDDEN =              0x00000001,     // Geometry Flags bitfield
        GEOMETRY_FLAG_TWO_SIDED =            0x00000002,
        GEOMETRY_FLAG_CAST_SHADOW =        0x00000004,
        GEOMETRY_FLAG_VERTEX_ALPHA =      0x00000008,
        GEOMETRY_FLAG_ZNORMALS =          0x00000010,
        GEOMETRY_FLAG_SHATTERABLE =        0x00000020,
        GEOMETRY_FLAG_NPATCHABLE =          0x00000040,
    };
 
    enum CollisionFlagsEnum
    {
        COLLISION_FLAG_PHYSICAL =            0x00000001,
        COLLISION_FLAG_PROJECTILE =        0x00000002,
        COLLISION_FLAG_VIS =                  0x00000004,
        COLLISION_FLAG_CAMERA =                0x00000008,
        COLLISION_FLAG_VEHICLE =          0x00000010,
    };
 
    unsigned int ExportFlags;                
    unsigned int GeometryType;              
    unsigned int GeometryFlags;
    unsigned int CollisionFlags;
 
    // future expansion, initialized to zeros
    unsigned int UnUsed[4];
};
 
 
 
/*
** W3D Utility Dazzle App Data
** ----------------------------------------------------
** This app-data struct is used to contain parameters 
** specific to dazzle render objects.  It currently only
** contains a type name which is limited to 128 characters
** and some padding variables for future use.
*/
 
struct W3DDazzleAppDataStruct
{
    /*
    ** Constructor, zeros everything, then initializes DazzleType to "DEFAULT"
    */
    W3DDazzleAppDataStruct(void);
 
    /*
    ** Get the W3DAppData2Struct for a given INode and create one if
    ** there isn't already one.
    */
    static W3DDazzleAppDataStruct * Get_App_Data(INode * node,bool create_if_missing = true);
 
    /*
    ** Members
    */
    unsigned int    UnUsed[4];
    char                DazzleType[128];
};
 
 
#endif