exporter.h

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code 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.

Doom 3 Source Code 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 Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/
#define MAYA_DEFAULT_CAMERA             "camera1"

#define ANIM_TX                 BIT( 0 )
#define ANIM_TY                 BIT( 1 )
#define ANIM_TZ                 BIT( 2 )
#define ANIM_QX                 BIT( 3 )
#define ANIM_QY                 BIT( 4 )
#define ANIM_QZ                 BIT( 5 )

typedef enum {
        WRITE_MESH,
        WRITE_ANIM,
        WRITE_CAMERA
} exportType_t;

typedef struct {
        idCQuat                         q;
        idVec3                          t;
} jointFrame_t;

typedef struct {
        idCQuat                         q;
        idVec3                          t;
        float                           fov;
} cameraFrame_t;

/*
==============================================================================================

        idTokenizer

==============================================================================================
*/

class idTokenizer {
private:
        int                                     currentToken;
        idStrList                       tokens;

public:
                                                idTokenizer()                   { Clear(); };
        void                            Clear( void )                   { currentToken = 0;     tokens.Clear(); };

        int                                     SetTokens( const char *buffer );
        const char                      *NextToken( const char *errorstring = NULL );

        bool                            TokenAvailable( void )  { return currentToken < tokens.Num(); };
        int                                     Num( void )                     { return tokens.Num(); };
        void                            UnGetToken( void )              { if ( currentToken > 0 ) { currentToken--; } };
        const char                      *GetToken( int index )  { if ( ( index >= 0 ) && ( index < tokens.Num() ) ) { return tokens[ index ]; } else { return NULL; } };
        const char                      *CurrentToken( void )   { return GetToken( currentToken ); };
};

/*
==============================================================================================

        idExportOptions

==============================================================================================
*/

class idNamePair {
public:
        idStr   from;
        idStr   to;
};

class idAnimGroup {
public:
        idStr           name;
        idStrList       joints;
};

class idExportOptions {
private:
        idTokenizer                             tokens;
                                                        
        void                                    Reset( const char *commandline );
                                                        
public:                                         
        idStr                                   commandLine;
        idStr                                   src;
        idStr                                   dest;
        idStr                                   game;
        idStr                                   prefix;
        float                                   scale;
        exportType_t                    type;
        bool                                    ignoreMeshes;
        bool                                    clearOrigin;
        bool                                    clearOriginAxis;
        bool                                    ignoreScale;
        int                                             startframe;
        int                                             endframe;
        int                                             framerate;
        float                                   xyzPrecision;
        float                                   quatPrecision;
        idStr                                   align;
        idList<idNamePair>              renamejoints;
        idList<idNamePair>              remapjoints;
        idStrList                               keepjoints;
        idStrList                               skipmeshes;
        idStrList                               keepmeshes;
        idList<idAnimGroup *>   exportgroups;
        idList<idAnimGroup>             groups;
        float                                   rotate;
        float                                   jointThreshold;
        int                                             cycleStart;
                                                        
                                                        idExportOptions( const char *commandline, const char *ospath );
                                                        
        bool                                    jointInExportGroup( const char *jointname );
};

/*
==============================================================================

idExportJoint

==============================================================================
*/

class idExportJoint {
public:
        idStr                                           name;
        idStr                                           realname;
        idStr                                           longname;
        int                                                     index;
        int                                                     exportNum;
        bool                                            keep;
                                                                
        float                                           scale;
        float                                           invscale;
                                                                
        MFnDagNode                                      *dagnode;

        idHierarchy<idExportJoint>      mayaNode;
        idHierarchy<idExportJoint>      exportNode;
                                                        
        idVec3                                          t;
        idMat3                                          wm;

        idVec3                                          idt;
        idMat3                                          idwm;

        idVec3                                          bindpos;
        idMat3                                          bindmat;

        int                                                     animBits;
        int                                                     firstComponent;
        jointFrame_t                            baseFrame;
        int                                                     depth;
                                                                
                                                                idExportJoint();
        idExportJoint                           &operator=( const idExportJoint &other );
};

/*
==============================================================================

misc structures

==============================================================================
*/

typedef struct {
        idExportJoint                   *joint;
        float                                   jointWeight;
        idVec3                                  offset;
} exportWeight_t;

typedef struct {
        idVec3                                  pos;
        idVec2                                  texCoords;
        int                                             startweight;
        int                                             numWeights;
} exportVertex_t;

typedef struct {
        int                                             indexes[ 3 ];
} exportTriangle_t;

typedef struct {
        idVec2                                  uv[ 3 ];
} exportUV_t;

ID_INLINE int operator==( exportVertex_t a, exportVertex_t b ) {
        if ( a.pos != b.pos ) {
                return false;
        }

        if ( ( a.texCoords[ 0 ] != b.texCoords[ 0 ] ) || ( a.texCoords[ 1 ] != b.texCoords[ 1 ] ) ) {
                return false;
        }

        if ( ( a.startweight != b.startweight ) || ( a.numWeights != b.numWeights ) ) {
                return false;
        }

        return true;
}

/*
========================================================================

.MD3 triangle model file format

========================================================================
*/

#define MD3_IDENT                       (('3'<<24)+('P'<<16)+('D'<<8)+'I')
#define MD3_VERSION                     15

// limits
#define MD3_MAX_LODS            4
#define MD3_MAX_TRIANGLES       8192    // per surface
#define MD3_MAX_VERTS           4096    // per surface
#define MD3_MAX_SHADERS         256             // per surface
#define MD3_MAX_FRAMES          1024    // per model
#define MD3_MAX_SURFACES        32              // per model
#define MD3_MAX_TAGS            16              // per frame

// vertex scales
#define MD3_XYZ_SCALE           (1.0/64)

// surface geometry should not exceed these limits
#define SHADER_MAX_VERTEXES     1000
#define SHADER_MAX_INDEXES      (6*SHADER_MAX_VERTEXES)


// the maximum size of game reletive pathnames
#define MAX_Q3PATH              64

typedef struct md3Frame_s {
        idVec3          bounds[2];
        idVec3          localOrigin;
        float           radius;
        char            name[16];
} md3Frame_t;

typedef struct md3Tag_s {
        char            name[MAX_Q3PATH];       // tag name
        idVec3          origin;
        idVec3          axis[3];
} md3Tag_t;

/*
** md3Surface_t
**
** CHUNK                        SIZE
** header                       sizeof( md3Surface_t )
** shaders                      sizeof( md3Shader_t ) * numShaders
** triangles[0]         sizeof( md3Triangle_t ) * numTriangles
** st                           sizeof( md3St_t ) * numVerts
** XyzNormals           sizeof( md3XyzNormal_t ) * numVerts * numFrames
*/
typedef struct {
        int                     ident;                          // 
                                
        char            name[MAX_Q3PATH];       // polyset name
                                
        int                     flags;
        int                     numFrames;                      // all surfaces in a model should have the same
                                
        int                     numShaders;                     // all surfaces in a model should have the same
        int                     numVerts;
                                
        int                     numTriangles;
        int                     ofsTriangles;
                                
        int                     ofsShaders;                     // offset from start of md3Surface_t
        int                     ofsSt;                          // texture coords are common for all frames
        int                     ofsXyzNormals;          // numVerts * numFrames
                                
        int                     ofsEnd;                         // next surface follows
} md3Surface_t;

typedef struct {
        char            name[MAX_Q3PATH];
        int                     shaderIndex;    // for in-game use
} md3Shader_t;

typedef struct {
        int                     indexes[3];
} md3Triangle_t;

typedef struct {
        float           st[2];
} md3St_t;

typedef struct {
        short           xyz[3];
        short           normal;
} md3XyzNormal_t;

typedef struct {
        int                     ident;
        int                     version;

        char            name[MAX_Q3PATH];       // model name

        int                     flags;

        int                     numFrames;
        int                     numTags;                        
        int                     numSurfaces;

        int                     numSkins;

        int                     ofsFrames;                      // offset for first frame
        int                     ofsTags;                        // numFrames * numTags
        int                     ofsSurfaces;            // first surface, others follow

        int                     ofsEnd;                         // end of file
} md3Header_t;

/*
==============================================================================

idExportMesh

==============================================================================
*/

class idExportMesh {
public:

        idStr                                           name;
        idStr                                           shader;

        bool                                            keep;

        idList<exportVertex_t>          verts;
        idList<exportTriangle_t>        tris;
        idList<exportWeight_t>          weights;
        idList<exportUV_t>                      uv;

                                                                idExportMesh() { keep = true; };
        void                                            ShareVerts( void );
        void                                            GetBounds( idBounds &bounds ) const;
        void                                            Merge( idExportMesh *mesh );
};

/*
==============================================================================

idExportModel

==============================================================================
*/

class idExportModel {
public:
        idExportJoint                           *exportOrigin;
        idList<idExportJoint>           joints;
        idHierarchy<idExportJoint>      mayaHead;
        idHierarchy<idExportJoint>      exportHead;
        idList<int>                                     cameraCuts;
        idList<cameraFrame_t>           camera;
        idList<idBounds>                        bounds;
        idList<jointFrame_t>            jointFrames;
        idList<jointFrame_t	*>          frames;
        int                                                     frameRate;
        int                                                     numFrames;
        int                                                     skipjoints;
        int                                                     export_joints;                                                          
        idList<idExportMesh *>          meshes;

                                                                idExportModel();
                                                                ~idExportModel();
        idExportJoint                           *FindJointReal( const char *name );
        idExportJoint                           *FindJoint( const char *name );
        bool                                            WriteMesh( const char *filename, idExportOptions &options );
        bool                                            WriteAnim( const char *filename, idExportOptions &options );
        bool                                            WriteCamera( const char *filename, idExportOptions &options );
};

/*
==============================================================================

Maya

==============================================================================
*/

class idMayaExport {
private:
        idExportModel                   model;
        idExportOptions                 &options;

        void                                    FreeDagNodes( void );

        float                                   TimeForFrame( int num ) const;
        int                                             GetMayaFrameNum( int num ) const;
        void                                    SetFrame( int num );


        void                                    GetBindPose( MObject &jointNode, idExportJoint *joint, float scale );
        void                                    GetLocalTransform( idExportJoint *joint, idVec3 &pos, idMat3 &mat );
        void                                    GetWorldTransform( idExportJoint *joint, idVec3 &pos, idMat3 &mat, float scale );
        
        void                                    CreateJoints( float scale );
        void                                    PruneJoints( idStrList &keepjoints, idStr &prefix );
        void                                    RenameJoints( idList<idNamePair> &renamejoints, idStr &prefix );
        bool                                    RemapParents( idList<idNamePair> &remapjoints );

        MObject                                 FindShader( MObject& setNode );
        void                                    GetTextureForMesh( idExportMesh *mesh, MFnDagNode &dagNode );

        idExportMesh                    *CopyMesh( MFnSkinCluster &skinCluster, float scale );
        void                                    CreateMesh( float scale );
        void                                    CombineMeshes( void );

        void                                    GetAlignment( idStr &alignName, idMat3 &align, float rotate, int startframe );

        const char                              *GetObjectType( MObject object );

        float                                   GetCameraFov( idExportJoint *joint );
        void                                    GetCameraFrame( idExportJoint *camera, idMat3 &align, cameraFrame_t *cam );
        void                                    CreateCameraAnim( idMat3 &align );

        void                                    GetDefaultPose( idMat3 &align );
        void                                    CreateAnimation( idMat3 &align );

public:
                                                        idMayaExport( idExportOptions &exportOptions ) : options( exportOptions ) { };
                                                        ~idMayaExport();

        void                                    ConvertModel( void );
        void                                    ConvertToMD3( void );
};