path: root/source/gl_models.c

/*
Copyright (C) 2003-2006 Andrey Nazarov

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 2
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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "gl_local.h"
#include "d_md2.h"
#include "d_md3.h"
#include "d_sp2.h"

qboolean MOD_LoadMD2( model_t *model, const void *rawdata, size_t length ) {
    dmd2header_t header;
    dmd2frame_t *src_frame;
    dmd2trivertx_t *src_vert;
    dmd2triangle_t *src_tri;
    dmd2stvert_t *src_tc;
    maliasframe_t *dst_frame;
    maliasvert_t *dst_vert;
    maliasmesh_t *dst_mesh;
    uint32_t *finalIndices;
    maliastc_t *dst_tc;
    int i, j, k;
    uint16_t remap[MD2_MAX_TRIANGLES*3];
    uint16_t vertIndices[MD2_MAX_TRIANGLES*3];
    uint16_t tcIndices[MD2_MAX_TRIANGLES*3];
    int numverts, numindices;
    char skinname[MAX_QPATH];
    char *src_skin;
    image_t *skin;
    vec_t scaleS, scaleT;
    int val;
    vec3_t mins, maxs;

    if( length < sizeof( header ) ) {
        Com_WPrintf( "%s is too short\n", model->name );
        return qfalse;
    }

    /* byte swap the header */
    header = *( dmd2header_t * )rawdata;
    for( i = 0; i < sizeof( header )/4; i++ ) {
        (( uint32_t * )&header)[i] = LittleLong( (( uint32_t * )&header)[i] );
    }

    if( !MOD_ValidateMD2( model, &header, length ) ) {
        return qfalse;
    }

    Hunk_Begin( &model->pool, 0x400000 );

    /* load all triangle indices */
    src_tri = ( dmd2triangle_t * )( ( byte * )rawdata + header.ofs_tris );
    for( i = 0; i < header.num_tris; i++ ) {
        for( j = 0; j < 3; j++ ) {
            uint16_t idx_xyz = LittleShort( src_tri->index_xyz[j] );
            uint16_t idx_st = LittleShort( src_tri->index_st[j] );

            if( idx_xyz >= header.num_xyz || idx_st >= header.num_st ) {
                Com_WPrintf( "%s has bad triangle indices\n", model->name );
                goto fail;
            }

            vertIndices[i*3+j] = idx_xyz; 
            tcIndices[i*3+j] = idx_st;
        }
        src_tri++;
    }

    numindices = header.num_tris * 3;

    model->meshes = Model_Malloc( sizeof( maliasmesh_t ) );
    model->nummeshes = 1;

    dst_mesh = model->meshes;
    dst_mesh->indices = Model_Malloc( numindices * sizeof( uint32_t ) );
    dst_mesh->numtris = header.num_tris;
    dst_mesh->numindices = numindices;

    for( i = 0; i < numindices; i++ ) {
        remap[i] = 0xFFFF;
    }

    numverts = 0;
    src_tc = ( dmd2stvert_t * )( ( byte * )rawdata + header.ofs_st );
    finalIndices = dst_mesh->indices;
    for( i = 0; i < numindices; i++ ) {
        if( remap[i] != 0xFFFF ) {
            continue; /* already remapped */
        }

        for( j = i + 1; j < numindices; j++ ) {
            if( vertIndices[i] == vertIndices[j] &&
                ( src_tc[tcIndices[i]].s == src_tc[tcIndices[j]].s &&
                    src_tc[tcIndices[i]].t == src_tc[tcIndices[j]].t ) )
            {
                /* duplicate vertex */
                remap[j] = i;
                finalIndices[j] = numverts;
            } 
        }

        /* new vertex */
        remap[i] = i;
        finalIndices[i] = numverts++;
    }

    dst_mesh->verts = Model_Malloc( numverts * header.num_frames * sizeof( maliasvert_t ) );
    dst_mesh->tcoords = Model_Malloc( numverts * sizeof( maliastc_t ) );
    dst_mesh->numverts = numverts;

    /* load all skins */
    src_skin = ( char * )rawdata + header.ofs_skins;
    for( i = 0; i < header.num_skins; i++ ) {
        Q_strlcpy( skinname, src_skin, sizeof( skinname ) );
        skin = IMG_Find( skinname, it_skin );
        if( !skin ) {
            skin = r_notexture;
        }
        dst_mesh->skins[i] = skin;
        src_skin += MD2_MAX_SKINNAME;
    }
    dst_mesh->numskins = header.num_skins;

    /* load all tcoords */
    src_tc = ( dmd2stvert_t * )( ( byte * )rawdata + header.ofs_st );
    dst_tc = dst_mesh->tcoords;
    skin = dst_mesh->skins[0];
    scaleS = 1.0f / header.skinwidth;
    scaleT = 1.0f / header.skinheight;
    for( i = 0; i < numindices; i++ ) {
        if( remap[i] == i ) {
            float s = ( signed short )LittleShort( src_tc[ tcIndices[i] ].s );
            float t = ( signed short )LittleShort( src_tc[ tcIndices[i] ].t );

            dst_tc[ finalIndices[i] ].st[0] = s * scaleS;
            dst_tc[ finalIndices[i] ].st[1] = t * scaleT;
        }
    }

    /* load all frames */
    model->frames = Model_Malloc( header.num_frames * sizeof( maliasframe_t ) );
    model->numframes = header.num_frames;

    src_frame = ( dmd2frame_t * )( ( byte * )rawdata + header.ofs_frames );
    dst_frame = model->frames;
    for( j = 0; j < header.num_frames; j++ ) {
        LittleVector( src_frame->scale, dst_frame->scale );
        LittleVector( src_frame->translate, dst_frame->translate );

        /* load frame vertices */
        ClearBounds( mins, maxs );
        for( i = 0; i < numindices; i++ ) {
            if( remap[i] == i ) {
                src_vert = &src_frame->verts[ vertIndices[i] ];
                dst_vert = &dst_mesh->verts[ j * numverts + finalIndices[i] ];

                dst_vert->pos[0] = src_vert->v[0];
                dst_vert->pos[1] = src_vert->v[1];
                dst_vert->pos[2] = src_vert->v[2];
                k = src_vert->lightnormalindex;
                if( k >= NUMVERTEXNORMALS ) {
                    Com_WPrintf( "%s has bad normal indices\n", model->name );
                    goto fail;
                }
                dst_vert->normalindex = k;

                for ( k = 0; k < 3; k++ ) {
                    val = dst_vert->pos[k];
                    if( val < mins[k] )
                        mins[k] = val;
                    if( val > maxs[k] )
                        maxs[k] = val;
                }
            }
        }

        VectorVectorScale( mins, dst_frame->scale, mins );
        VectorVectorScale( maxs, dst_frame->scale, maxs );

        dst_frame->radius = RadiusFromBounds( mins, maxs );

        VectorAdd( mins, dst_frame->translate, dst_frame->bounds[0] );
        VectorAdd( maxs, dst_frame->translate, dst_frame->bounds[1] );

        src_frame = ( dmd2frame_t * )( ( byte * )src_frame + header.framesize );
        dst_frame++;
    }

    Hunk_End( &model->pool );
    return qtrue;

fail:
    Hunk_Free( &model->pool );
    return qfalse;
}

#if USE_MD3
static byte         ll2byte[256][256];
static qboolean     ll2byte_inited;        

static void ll2byte_init( void ) {
    float s[2], c[2];
    vec3_t normal;
    int i, j;

    for( i = 0; i < 256; i++ ) {
        for( j = 0; j < 256; j++ ) {
            s[0] = sin( i / 255.0f );
            c[0] = cos( i / 255.0f );
            
            s[1] = sin( j / 255.0f );
            c[1] = cos( j / 255.0f );

            VectorSet( normal, s[0] * c[1], s[0] * s[1], c[0] );
            ll2byte[i][j] = DirToByte( normal );
        }
    }
}

qboolean MOD_LoadMD3( model_t *model, const void *rawdata, size_t length ) {
    dmd3header_t header;
    uint32_t offset;
    dmd3frame_t *src_frame;
    dmd3mesh_t *src_mesh;
    dmd3vertex_t *src_vert;
    dmd3coord_t *src_tc;
    dmd3skin_t *src_skin;
    uint32_t *src_idx;
    maliasframe_t *dst_frame;
    maliasmesh_t *dst_mesh;
    maliasvert_t *dst_vert;
    maliastc_t *dst_tc;
    uint32_t *dst_idx;
    uint32_t numverts, numtris, numskins;
    uint32_t totalVerts;
    char skinname[MAX_QPATH];
    image_t *skin;
    const byte *rawend;
    int i, j;

    if( length < sizeof( header ) ) {
        Com_WPrintf( "%s is too small to hold MD3 header\n", model->name );
        return qfalse;
    }

    /* byte swap the header */
    header = *( dmd3header_t * )rawdata;
    for( i = 0; i < sizeof( header )/4; i++ ) {
        (( uint32_t * )&header)[i] = LittleLong( (( uint32_t * )&header)[i] );
    }

    if( header.ident != MD3_IDENT ) {
        Com_WPrintf( "%s is not an MD3 file\n", model->name );
        return qfalse;
    }
    if( header.version != MD3_VERSION ) {
        Com_WPrintf( "%s has bad version: %d instead of %d\n",
            model->name, header.version, MD3_VERSION );
        return qfalse;
    }
    if( header.num_frames < 1 || header.num_frames > MD3_MAX_FRAMES ) {
        Com_WPrintf( "%s has bad number of frames\n", model->name );
        return qfalse;
    }
    if( header.num_meshes < 1 || header.num_meshes > MD3_MAX_MESHES ) {
        Com_WPrintf( "%s has bad number of meshes\n", model->name );
        return qfalse;
    }
    
    Hunk_Begin( &model->pool, 0x400000 );
    model->numframes = header.num_frames;
    model->nummeshes = header.num_meshes;
    model->meshes = Model_Malloc( sizeof( maliasmesh_t ) * header.num_meshes );
    model->frames = Model_Malloc( sizeof( maliasframe_t ) * header.num_frames );

    rawend = ( byte * )rawdata + length;
    
    /* load all frames */
    src_frame = ( dmd3frame_t * )( ( byte * )rawdata + header.ofs_frames );
    if( ( byte * )( src_frame + header.num_frames ) > rawend ) {
        Com_WPrintf( "%s has bad frames offset\n", model->name );
        goto fail;
    }
    dst_frame = model->frames;
    for( i = 0; i < header.num_frames; i++ ) {
        LittleVector( src_frame->translate, dst_frame->translate );
        VectorSet( dst_frame->scale, MD3_XYZ_SCALE, MD3_XYZ_SCALE, MD3_XYZ_SCALE );

        LittleVector( src_frame->mins, dst_frame->bounds[0] );
        LittleVector( src_frame->maxs, dst_frame->bounds[1] );
        dst_frame->radius = LittleFloat( src_frame->radius );

        src_frame++; dst_frame++;
    }
    
    /* load all meshes */
    src_mesh = ( dmd3mesh_t * )( ( byte * )rawdata + header.ofs_meshes );
    dst_mesh = model->meshes;
    for( i = 0; i < header.num_meshes; i++ ) {
        if( ( byte * )( src_mesh + 1 ) > rawend ) {
            Com_WPrintf( "%s has bad offset for mesh %d\n", model->name, i );
            goto fail;
        }

        numverts = LittleLong( src_mesh->num_verts );
        numtris = LittleLong( src_mesh->num_tris );

        if( numverts < 3 || numverts > TESS_MAX_VERTICES ) {
            Com_WPrintf( "%s has bad number of vertices for mesh %d\n", model->name, i );
            goto fail;
        }
        if( numtris < 1 || numtris > TESS_MAX_INDICES / 3 ) {
            Com_WPrintf( "%s has bad number of faces for mesh %d\n", model->name, i );
            goto fail;
        }
        
        dst_mesh->numtris = numtris;
        dst_mesh->numindices = numtris * 3;
        dst_mesh->numverts = numverts;
        dst_mesh->verts = Model_Malloc( sizeof( maliasvert_t ) * numverts * header.num_frames );
        dst_mesh->tcoords = Model_Malloc( sizeof( maliastc_t ) * numverts );
        dst_mesh->indices = Model_Malloc( sizeof( uint32_t ) * numtris * 3 );

        /* load all skins */
        numskins = LittleLong( src_mesh->num_skins );
        if( numskins > MAX_ALIAS_SKINS ) {
            Com_WPrintf( "%s has bad number of skins for mesh %d\n", model->name, i );
            goto fail;
        }
        offset = LittleLong( src_mesh->ofs_skins );
        src_skin = ( dmd3skin_t * )( ( byte * )src_mesh + offset );
        if( ( byte * )( src_skin + numskins ) > rawend ) {
            Com_WPrintf( "%s has bad skins offset for mesh %d\n", model->name, i );
            goto fail;
        }
        for( j = 0; j < numskins; j++ ) {
            Q_strlcpy( skinname, src_skin->name, sizeof( skinname ) );
            skin = IMG_Find( skinname, it_skin );
            if( !skin ) {
                skin = r_notexture;
            }
            dst_mesh->skins[j] = skin;
        }
        dst_mesh->numskins = numskins;
        
        /* load all vertices */
        totalVerts = numverts * header.num_frames;
        offset = LittleLong( src_mesh->ofs_verts );
        src_vert = ( dmd3vertex_t * )( ( byte * )src_mesh + offset );
        if( ( byte * )( src_vert + totalVerts ) > rawend ) {
            Com_WPrintf( "%s has bad vertices offset for mesh %d\n", model->name, i );
            goto fail;
        }
        dst_vert = dst_mesh->verts;
        for( j = 0; j < totalVerts; j++ ) {
            dst_vert->pos[0] = ( signed short )LittleShort( src_vert->point[0] );
            dst_vert->pos[1] = ( signed short )LittleShort( src_vert->point[1] );
            dst_vert->pos[2] = ( signed short )LittleShort( src_vert->point[2] );

            if( !ll2byte_inited ) {
                ll2byte_init();
                ll2byte_inited = qtrue;
            }
            dst_vert->normalindex = ll2byte[src_vert->norm[0]]
                [src_vert->norm[1]];

            src_vert++; dst_vert++;
        }
        
        /* load all texture coords */
        offset = LittleLong( src_mesh->ofs_tcs );
        src_tc = ( dmd3coord_t * )( ( byte * )src_mesh + offset );
        if( ( byte * )( src_tc + numverts ) > rawend ) {
            Com_WPrintf( "%s has bad tcoords offset for mesh %d\n", model->name, i );
            goto fail;
        }
        dst_tc = dst_mesh->tcoords;
        for( j = 0; j < numverts; j++ ) {
            dst_tc->st[0] = LittleFloat( src_tc->st[0] );
            dst_tc->st[1] = LittleFloat( src_tc->st[1] );
            src_tc++; dst_tc++;
        }

        /* load all triangle indices */
        offset = LittleLong( src_mesh->ofs_indexes );
        src_idx = ( uint32_t * )( ( byte * )src_mesh + offset );
        if( ( byte * )( src_idx + numtris * 3 ) > rawend ) {
            Com_WPrintf( "%s has bad indices offset for mesh %d\n", model->name, i );
            goto fail;
        }
        dst_idx = dst_mesh->indices;
        for( j = 0; j < numtris; j++ ) {
            dst_idx[0] = LittleLong( src_idx[0] );
            dst_idx[1] = LittleLong( src_idx[1] );
            dst_idx[2] = LittleLong( src_idx[2] );
            if( dst_idx[0] >= numverts || dst_idx[1] >= numverts || dst_idx[2] >= numverts ) {
                Com_WPrintf( "%s has bad indices for triangle %d in mesh %d\n", model->name, j, i );
                goto fail;
            }
            src_idx += 3; dst_idx += 3;
        }
        
        offset = LittleLong( src_mesh->meshsize );
        src_mesh = ( dmd3mesh_t * )( ( byte * )src_mesh + offset );
        dst_mesh++;
    }

    Hunk_End( &model->pool );
    return qtrue;

fail:
    Hunk_Free( &model->pool );
    return qfalse;
}
#endif

void MOD_Reference( model_t *model ) {
    int i, j;

    if( model->frames ) {
        for( i = 0; i < model->nummeshes; i++ ) {
            maliasmesh_t *mesh = &model->meshes[i];
            for( j = 0; j < mesh->numskins; j++ ) {
                mesh->skins[j]->registration_sequence = registration_sequence;
            }
        }
    } else if( model->spriteframes ) {
        for( i = 0; i < model->numframes; i++ ) {
            model->spriteframes[i].image->registration_sequence = registration_sequence;
        }
    } else {
        Com_Error( ERR_FATAL, "%s: bad model type", __func__ );
    }

    model->registration_sequence = registration_sequence;
}