Model_md3.cpp

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.

===========================================================================
*/
#include "../idlib/precompiled.h"
#pragma hdrstop

#include "tr_local.h"
#include "Model_local.h"
#include "Model_md3.h"

/***********************************************************************

        idMD3Mesh

***********************************************************************/

#define LL(x) x=LittleLong(x)

/*
=================
idRenderModelMD3::InitFromFile
=================
*/
void idRenderModelMD3::InitFromFile( const char *fileName ) {
        int                                     i, j;
        md3Header_t                     *pinmodel;
    md3Frame_t                  *frame;
        md3Surface_t            *surf;
        md3Shader_t                     *shader;
        md3Triangle_t           *tri;
        md3St_t                         *st;
        md3XyzNormal_t          *xyz;
        md3Tag_t                        *tag;
        void                            *buffer;
        int                                     version;
        int                                     size;


        name = fileName;

        size = fileSystem->ReadFile( fileName, &buffer, NULL );
        if (!size || size<0 ) {
                return;
        }

        pinmodel = (md3Header_t *)buffer;

        version = LittleLong (pinmodel->version);
        if (version != MD3_VERSION) {
                fileSystem->FreeFile( buffer );
                common->Warning( "InitFromFile: %s has wrong version (%i should be %i)",
                                 fileName, version, MD3_VERSION);
                return;
        }

        size = LittleLong(pinmodel->ofsEnd);
        dataSize += size;
        md3 = (md3Header_t *)Mem_Alloc( size );

        memcpy (md3, buffer, LittleLong(pinmodel->ofsEnd) );

    LL(md3->ident);
    LL(md3->version);
    LL(md3->numFrames);
    LL(md3->numTags);
    LL(md3->numSurfaces);
    LL(md3->ofsFrames);
    LL(md3->ofsTags);
    LL(md3->ofsSurfaces);
    LL(md3->ofsEnd);

        if ( md3->numFrames < 1 ) {
                common->Warning( "InitFromFile: %s has no frames", fileName );
                fileSystem->FreeFile( buffer );
                return;
        }
    
        // swap all the frames
    frame = (md3Frame_t *) ( (byte *)md3 + md3->ofsFrames );
    for ( i = 0 ; i < md3->numFrames ; i++, frame++) {
        frame->radius = LittleFloat( frame->radius );
        for ( j = 0 ; j < 3 ; j++ ) {
            frame->bounds[0][j] = LittleFloat( frame->bounds[0][j] );
            frame->bounds[1][j] = LittleFloat( frame->bounds[1][j] );
                frame->localOrigin[j] = LittleFloat( frame->localOrigin[j] );
        }
        }

        // swap all the tags
    tag = (md3Tag_t *) ( (byte *)md3 + md3->ofsTags );
    for ( i = 0 ; i < md3->numTags * md3->numFrames ; i++, tag++) {
        for ( j = 0 ; j < 3 ; j++ ) {
                        tag->origin[j] = LittleFloat( tag->origin[j] );
                        tag->axis[0][j] = LittleFloat( tag->axis[0][j] );
                        tag->axis[1][j] = LittleFloat( tag->axis[1][j] );
                        tag->axis[2][j] = LittleFloat( tag->axis[2][j] );
        }
        }

        // swap all the surfaces
        surf = (md3Surface_t *) ( (byte *)md3 + md3->ofsSurfaces );
        for ( i = 0 ; i < md3->numSurfaces ; i++) {

        LL(surf->ident);
        LL(surf->flags);
        LL(surf->numFrames);
        LL(surf->numShaders);
        LL(surf->numTriangles);
        LL(surf->ofsTriangles);
        LL(surf->numVerts);
        LL(surf->ofsShaders);
        LL(surf->ofsSt);
        LL(surf->ofsXyzNormals);
        LL(surf->ofsEnd);
                
                if ( surf->numVerts > SHADER_MAX_VERTEXES ) {
                        common->Error( "InitFromFile: %s has more than %i verts on a surface (%i)",
                                fileName, SHADER_MAX_VERTEXES, surf->numVerts );
                }
                if ( surf->numTriangles*3 > SHADER_MAX_INDEXES ) {
                        common->Error( "InitFromFile: %s has more than %i triangles on a surface (%i)",
                                fileName, SHADER_MAX_INDEXES / 3, surf->numTriangles );
                }
        
                // change to surface identifier
                surf->ident = 0;        //SF_MD3;

                // lowercase the surface name so skin compares are faster
                int slen = (int)strlen( surf->name );
                for( j = 0; j < slen; j++ ) {
                        surf->name[j] = tolower( surf->name[j] );
                }

                // strip off a trailing _1 or _2
                // this is a crutch for q3data being a mess
                j = strlen( surf->name );
                if ( j > 2 && surf->name[j-2] == '_' ) {
                        surf->name[j-2] = 0;
                }

        // register the shaders
        shader = (md3Shader_t *) ( (byte *)surf + surf->ofsShaders );
        for ( j = 0 ; j < surf->numShaders ; j++, shader++ ) {
            const idMaterial *sh;

            sh = declManager->FindMaterial( shader->name );
                        shader->shader = sh;
        }

                // swap all the triangles
                tri = (md3Triangle_t *) ( (byte *)surf + surf->ofsTriangles );
                for ( j = 0 ; j < surf->numTriangles ; j++, tri++ ) {
                        LL(tri->indexes[0]);
                        LL(tri->indexes[1]);
                        LL(tri->indexes[2]);
                }

                // swap all the ST
        st = (md3St_t *) ( (byte *)surf + surf->ofsSt );
        for ( j = 0 ; j < surf->numVerts ; j++, st++ ) {
            st->st[0] = LittleFloat( st->st[0] );
            st->st[1] = LittleFloat( st->st[1] );
        }

                // swap all the XyzNormals
        xyz = (md3XyzNormal_t *) ( (byte *)surf + surf->ofsXyzNormals );
        for ( j = 0 ; j < surf->numVerts * surf->numFrames ; j++, xyz++ ) 
                {
            xyz->xyz[0] = LittleShort( xyz->xyz[0] );
            xyz->xyz[1] = LittleShort( xyz->xyz[1] );
            xyz->xyz[2] = LittleShort( xyz->xyz[2] );

            xyz->normal = LittleShort( xyz->normal );
        }


                // find the next surface
                surf = (md3Surface_t *)( (byte *)surf + surf->ofsEnd );
        }
    
        fileSystem->FreeFile( buffer );
}

/*
=================
idRenderModelMD3::IsDynamicModel
=================
*/
dynamicModel_t idRenderModelMD3::IsDynamicModel() const {
        return DM_CACHED;
}

/*
=================
idRenderModelMD3::LerpMeshVertexes
=================
*/
void idRenderModelMD3::LerpMeshVertexes ( srfTriangles_t *tri, const struct md3Surface_s *surf, const float backlerp, const int frame, const int oldframe ) const {
        short   *oldXyz, *newXyz;
        float   oldXyzScale, newXyzScale;
        int             vertNum;
        int             numVerts;

        newXyz = (short *)((byte *)surf + surf->ofsXyzNormals) + (frame * surf->numVerts * 4);

        newXyzScale = MD3_XYZ_SCALE * (1.0 - backlerp);

        numVerts = surf->numVerts;

        if ( backlerp == 0 ) {
                //
                // just copy the vertexes
                //
                for (vertNum=0 ; vertNum < numVerts ; vertNum++, newXyz += 4 ) {

                        idDrawVert *outvert = &tri->verts[tri->numVerts];

                        outvert->xyz.x = newXyz[0] * newXyzScale;
                        outvert->xyz.y = newXyz[1] * newXyzScale;
                        outvert->xyz.z = newXyz[2] * newXyzScale;

                        tri->numVerts++;
                }
        } else {
                //
                // interpolate and copy the vertexes
                //
                oldXyz = (short *)((byte *)surf + surf->ofsXyzNormals) + (oldframe * surf->numVerts * 4);

                oldXyzScale = MD3_XYZ_SCALE * backlerp;

                for (vertNum=0 ; vertNum < numVerts ; vertNum++, oldXyz += 4, newXyz += 4 ) {

                        idDrawVert *outvert = &tri->verts[tri->numVerts];

                        // interpolate the xyz
                        outvert->xyz.x = oldXyz[0] * oldXyzScale + newXyz[0] * newXyzScale;
                        outvert->xyz.y = oldXyz[1] * oldXyzScale + newXyz[1] * newXyzScale;
                        outvert->xyz.z = oldXyz[2] * oldXyzScale + newXyz[2] * newXyzScale;

                        tri->numVerts++;
                }
        }
}

/*
=============
idRenderModelMD3::InstantiateDynamicModel
=============
*/
idRenderModel *idRenderModelMD3::InstantiateDynamicModel( const struct renderEntity_s *ent, const struct viewDef_s *view, idRenderModel *cachedModel ) {
        int                             i, j;
        float                   backlerp;
        int *                   triangles;
        float *                 texCoords;
        int                             indexes;
        int                             numVerts;
        md3Surface_t *  surface;
        int                             frame, oldframe;
        idRenderModelStatic     *staticModel;

        if ( cachedModel ) {
                delete cachedModel;
                cachedModel = NULL;
        }

        staticModel = new idRenderModelStatic;
        staticModel->bounds.Clear();

        surface = (md3Surface_t *) ((byte *)md3 + md3->ofsSurfaces);

        // TODO: these need set by an entity
        frame = ent->shaderParms[SHADERPARM_MD3_FRAME];                 // probably want to keep frames < 1000 or so
        oldframe = ent->shaderParms[SHADERPARM_MD3_LASTFRAME];
        backlerp = ent->shaderParms[SHADERPARM_MD3_BACKLERP];

        for( i = 0; i < md3->numSurfaces; i++ ) {

                srfTriangles_t *tri = R_AllocStaticTriSurf();
                R_AllocStaticTriSurfVerts( tri, surface->numVerts );
                R_AllocStaticTriSurfIndexes( tri, surface->numTriangles * 3 );
                tri->bounds.Clear();

                modelSurface_t  surf;

                surf.geometry = tri;

                md3Shader_t* shaders = (md3Shader_t *) ((byte *)surface + surface->ofsShaders);
                surf.shader = shaders->shader;

                LerpMeshVertexes( tri, surface, backlerp, frame, oldframe );

                triangles = (int *) ((byte *)surface + surface->ofsTriangles);
                indexes = surface->numTriangles * 3;
                for (j = 0 ; j < indexes ; j++) {
                        tri->indexes[j] = triangles[j];
                }
                tri->numIndexes += indexes;

                texCoords = (float *) ((byte *)surface + surface->ofsSt);

                numVerts = surface->numVerts;
                for ( j = 0; j < numVerts; j++ ) {
                        idDrawVert *stri = &tri->verts[j];
                        stri->st[0] = texCoords[j*2+0];
                        stri->st[1] = texCoords[j*2+1];
                }

                R_BoundTriSurf( tri );

                staticModel->AddSurface( surf );
                staticModel->bounds.AddPoint( surf.geometry->bounds[0] );
                staticModel->bounds.AddPoint( surf.geometry->bounds[1] );

                // find the next surface
                surface = (md3Surface_t *)( (byte *)surface + surface->ofsEnd );
        }

        return staticModel;
}

/*
=====================
idRenderModelMD3::Bounds
=====================
*/

idBounds idRenderModelMD3::Bounds(const struct renderEntity_s *ent) const {
        idBounds                ret;

        ret.Clear();

        if (!ent || !md3) {
                // just give it the editor bounds
                ret.AddPoint(idVec3(-10,-10,-10));
                ret.AddPoint(idVec3( 10, 10, 10));
                return ret;
        }

        md3Frame_t      *frame = (md3Frame_t *)( (byte *)md3 + md3->ofsFrames );

        ret.AddPoint( frame->bounds[0] );
        ret.AddPoint( frame->bounds[1] );

        return ret;
}