mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-02 17:02:17 +00:00
399 lines
10 KiB
C++
399 lines
10 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition 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 BFG Edition 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 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition 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 BFG Edition 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.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#pragma hdrstop
|
|
#include "../idlib/precompiled.h"
|
|
|
|
#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, TAG_MODEL );
|
|
|
|
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 viewDef_t* view, idRenderModel* cachedModel )
|
|
{
|
|
int i, j;
|
|
float backlerp;
|
|
int* triangles;
|
|
int indexes;
|
|
int numVerts;
|
|
md3Surface_t* surface;
|
|
int frame, oldframe;
|
|
idRenderModelStatic* staticModel;
|
|
|
|
if( cachedModel )
|
|
{
|
|
delete cachedModel;
|
|
cachedModel = NULL;
|
|
}
|
|
|
|
staticModel = new( TAG_MODEL ) 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;
|
|
|
|
const idVec2* texCoords = ( idVec2* )( ( byte* )surface + surface->ofsSt );
|
|
|
|
numVerts = surface->numVerts;
|
|
for( j = 0; j < numVerts; j++ )
|
|
{
|
|
tri->verts[j].SetTexCoord( texCoords[j] );
|
|
}
|
|
|
|
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;
|
|
}
|
|
|