forked from FWGS/Paranoia2
729 lines
21 KiB
C++
729 lines
21 KiB
C++
/***
|
|
*
|
|
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
|
*
|
|
* This product contains software technology licensed from Id
|
|
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
|
* All Rights Reserved.
|
|
*
|
|
****/
|
|
|
|
// studio.c
|
|
|
|
#include "qrad.h"
|
|
#include "..\..\engine\studio.h"
|
|
#include "model_trace.h"
|
|
#include "imagelib.h"
|
|
|
|
typedef struct
|
|
{
|
|
char name[64];
|
|
mstudiomodel_t *pmodel;
|
|
bool shadow;
|
|
} TmpModel_t;
|
|
|
|
static void ExtractAnimValue( int frame, mstudioanim_t *panim, int dof, float scale, float &v1 )
|
|
{
|
|
if( !panim || panim->offset[dof] == 0 )
|
|
{
|
|
v1 = 0.0f;
|
|
return;
|
|
}
|
|
|
|
const mstudioanimvalue_t *panimvalue = (mstudioanimvalue_t *)((byte *)panim + panim->offset[dof]);
|
|
int k = frame;
|
|
|
|
while( panimvalue->num.total <= k )
|
|
{
|
|
k -= panimvalue->num.total;
|
|
panimvalue += panimvalue->num.valid + 1;
|
|
|
|
if( panimvalue->num.total == 0 )
|
|
{
|
|
v1 = 0.0f;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Bah, missing blend!
|
|
if( panimvalue->num.valid > k )
|
|
{
|
|
v1 = panimvalue[k+1].value * scale;
|
|
}
|
|
else
|
|
{
|
|
// get last valid data block
|
|
v1 = panimvalue[panimvalue->num.valid].value * scale;
|
|
}
|
|
}
|
|
|
|
static void StudioCalcBoneTransform( int frame, mstudiobone_t *pbone, mstudioanim_t *panim, vec3_t pos, vec4_t q )
|
|
{
|
|
vec3_t origin;
|
|
vec3_t angles;
|
|
|
|
ExtractAnimValue( frame, panim, 0, pbone->scale[0], origin[0] );
|
|
ExtractAnimValue( frame, panim, 1, pbone->scale[1], origin[1] );
|
|
ExtractAnimValue( frame, panim, 2, pbone->scale[2], origin[2] );
|
|
ExtractAnimValue( frame, panim, 3, pbone->scale[3], angles[0] );
|
|
ExtractAnimValue( frame, panim, 4, pbone->scale[4], angles[1] );
|
|
ExtractAnimValue( frame, panim, 5, pbone->scale[5], angles[2] );
|
|
|
|
for( int j = 0; j < 3; j++ )
|
|
{
|
|
origin[j] = pbone->value[j+0] + origin[j];
|
|
angles[j] = pbone->value[j+3] + angles[j];
|
|
}
|
|
|
|
AngleQuaternion( angles, q );
|
|
VectorCopy( origin, pos );
|
|
}
|
|
|
|
static void StudioSetupTriangle( tmesh_t *mesh, int index )
|
|
{
|
|
tface_t *face = &mesh->faces[index];
|
|
|
|
// calculate mins & maxs
|
|
ClearBounds( face->absmin, face->absmax );
|
|
face->contents = CONTENTS_SOLID;
|
|
|
|
assert( face->a < mesh->numverts );
|
|
assert( face->b < mesh->numverts );
|
|
assert( face->c < mesh->numverts );
|
|
|
|
// calc bounds
|
|
AddPointToBounds( mesh->verts[face->a].point, face->absmin, face->absmax );
|
|
AddPointToBounds( mesh->verts[face->a].point, mesh->absmin, mesh->absmax );
|
|
AddPointToBounds( mesh->verts[face->b].point, face->absmin, face->absmax );
|
|
AddPointToBounds( mesh->verts[face->b].point, mesh->absmin, mesh->absmax );
|
|
AddPointToBounds( mesh->verts[face->c].point, face->absmin, face->absmax );
|
|
AddPointToBounds( mesh->verts[face->c].point, mesh->absmin, mesh->absmax );
|
|
ExpandBounds( face->absmin, face->absmax, 1.0 );
|
|
|
|
// convert skinref to texture pointer
|
|
face->texture = &mesh->textures[face->skinref];
|
|
// setup efficiency intersection data
|
|
face->PrepareIntersectionData( mesh->verts );
|
|
}
|
|
|
|
static void StudioRelinkFace( aabb_tree_t *tree, tface_t *face )
|
|
{
|
|
// only shadow faces must be linked
|
|
if( !face->shadow ) return;
|
|
|
|
// find the first node that the facet box crosses
|
|
areanode_t *node = tree->areanodes;
|
|
|
|
while( 1 )
|
|
{
|
|
if( node->axis == -1 ) break;
|
|
if( face->absmin[node->axis] > node->dist )
|
|
node = node->children[0];
|
|
else if( face->absmax[node->axis] < node->dist )
|
|
node = node->children[1];
|
|
else break; // crosses the node
|
|
}
|
|
|
|
// link it in
|
|
InsertLinkBefore( &face->area, &node->solid_edicts );
|
|
}
|
|
|
|
static int StudioCreateMeshFromTriangles( entity_t *ent, studiohdr_t *phdr, const char *modname, int body, int skin, int flags, matrix3x4 transform[] )
|
|
{
|
|
TmpModel_t submodel[MAXSTUDIOMODELS]; // list of unique models
|
|
int i, j, k, totalVertSize = 0;
|
|
int num_submodels = 0;
|
|
mstudiobodyparts_t *pbodypart;
|
|
mstudiomodel_t *psubmodel;
|
|
|
|
memset( submodel, 0, sizeof( submodel ));
|
|
|
|
// build list of unique submodels (by name)
|
|
for( i = 0; i < phdr->numbodyparts; i++ )
|
|
{
|
|
pbodypart = (mstudiobodyparts_t *)((byte *)phdr + phdr->bodypartindex) + i;
|
|
|
|
for( j = 0; j < pbodypart->nummodels; j++ )
|
|
{
|
|
psubmodel = (mstudiomodel_t *)((byte *)phdr + pbodypart->modelindex) + j;
|
|
if( !psubmodel->nummesh ) continue; // blank submodel, ignore it
|
|
|
|
for( k = 0; k < num_submodels; k++ )
|
|
{
|
|
if( !Q_stricmp( submodel[k].name, psubmodel->name ))
|
|
break;
|
|
}
|
|
|
|
// add new one
|
|
if( k == num_submodels )
|
|
{
|
|
Q_strncpy( submodel[k].name, psubmodel->name, sizeof( submodel[k].name ));
|
|
submodel[k].pmodel = psubmodel;
|
|
num_submodels++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// find which parts are used by current body
|
|
for( i = 0; i < phdr->numbodyparts; i++ )
|
|
{
|
|
pbodypart = (mstudiobodyparts_t *)((byte *)phdr + phdr->bodypartindex) + i;
|
|
|
|
int index = body / pbodypart->base;
|
|
index = index % pbodypart->nummodels;
|
|
psubmodel = (mstudiomodel_t *)((byte *)phdr + pbodypart->modelindex) + index;
|
|
|
|
for( j = 0; j < num_submodels; j++ )
|
|
{
|
|
if( submodel[j].pmodel == psubmodel )
|
|
{
|
|
submodel[j].shadow = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// count unique model vertices
|
|
for( i = 0; i < num_submodels; i++ )
|
|
{
|
|
psubmodel = submodel[i].pmodel;
|
|
totalVertSize += psubmodel->numverts;
|
|
}
|
|
|
|
tface_t *faces = (tface_t *)Mem_Alloc( sizeof( tface_t ) * totalVertSize * 8 ); // allocate face lighting array
|
|
tvert_t *verts = (tvert_t *)Mem_Alloc( sizeof( tvert_t ) * totalVertSize * 8 ); // allocate vertex array
|
|
mstudiotexture_t *ptexture = (mstudiotexture_t *)((byte *)phdr + phdr->textureindex);
|
|
dvlightofs_t vsubmodels[MAXSTUDIOMODELS];
|
|
dflightofs_t fsubmodels[MAXSTUDIOMODELS];
|
|
int numFaces = 0, numVerts = 0;
|
|
|
|
memset( vsubmodels, 0, sizeof( vsubmodels ));
|
|
memset( fsubmodels, 0, sizeof( fsubmodels ));
|
|
|
|
for( k = 0; k < num_submodels; k++ )
|
|
{
|
|
mstudiomodel_t *psubmodel = submodel[k].pmodel;
|
|
|
|
if( psubmodel->numverts <= 0 )
|
|
continue; // a blank submodel
|
|
|
|
vec3_t *pstudioverts = (vec3_t *)((byte *)phdr + psubmodel->vertindex);
|
|
vec3_t *pstudionorms = (vec3_t *)((byte *)phdr + psubmodel->normindex);
|
|
vec3_t *m_verts = (vec3_t *)Mem_Alloc( sizeof( vec3_t ) * psubmodel->numverts );
|
|
vec3_t *m_norms = (vec3_t *)Mem_Alloc( sizeof( vec3_t ) * psubmodel->numnorms );
|
|
byte *pvertbone = ((byte *)phdr + psubmodel->vertinfoindex);
|
|
byte *pnormbone = ((byte *)phdr + psubmodel->norminfoindex);
|
|
short *pskinref = (short *)((byte *)phdr + phdr->skinindex);
|
|
int m_skinnum = bound( 0, skin, MAXSTUDIOSKINS - 1 );
|
|
|
|
// setup skin
|
|
if( m_skinnum != 0 && m_skinnum < phdr->numskinfamilies )
|
|
pskinref += (m_skinnum * phdr->numskinref);
|
|
|
|
// setup all the vertices
|
|
for( i = 0; i < psubmodel->numverts; i++ )
|
|
Matrix3x4_VectorTransform( transform[pvertbone[i]], pstudioverts[i], m_verts[i] );
|
|
|
|
// setup all the normals
|
|
for( i = 0; i < psubmodel->numnorms; i++ )
|
|
Matrix3x4_VectorRotate( transform[pnormbone[i]], pstudionorms[i], m_norms[i] );
|
|
|
|
vsubmodels[k].submodel_offset = (byte *)psubmodel - (byte *)phdr;
|
|
vsubmodels[k].vertex_offset = numVerts;
|
|
fsubmodels[k].submodel_offset = (byte *)psubmodel - (byte *)phdr;
|
|
fsubmodels[k].surface_offset = numFaces;
|
|
|
|
// build all the light vertices because we should include all the bodies into the buffer
|
|
for( j = 0; j < psubmodel->nummesh; j++ )
|
|
{
|
|
mstudiomesh_t *pmesh = (mstudiomesh_t *)((byte *)phdr + psubmodel->meshindex) + j;
|
|
float s = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].width;
|
|
float t = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].height;
|
|
short *ptricmds = (short *)((byte *)phdr + pmesh->triindex);
|
|
int flags = ptexture[pskinref[pmesh->skinref]].flags;
|
|
|
|
while( i = *( ptricmds++ ))
|
|
{
|
|
int vertexState = 0;
|
|
bool tri_strip;
|
|
|
|
if( i < 0 )
|
|
{
|
|
tri_strip = false;
|
|
i = -i;
|
|
}
|
|
else tri_strip = true;
|
|
|
|
for( ; i > 0; i--, ptricmds += 4 )
|
|
{
|
|
tvert_t *tv = &verts[numVerts];
|
|
tface_t *tf = &faces[numFaces];
|
|
|
|
if( submodel[k].shadow )
|
|
tf->shadow = true;
|
|
tf->skinref = pskinref[pmesh->skinref];
|
|
|
|
// build in indices
|
|
if( vertexState++ < 3 )
|
|
{
|
|
switch( vertexState )
|
|
{
|
|
case 1:
|
|
tf->a = numVerts;
|
|
break;
|
|
case 2:
|
|
tf->b = numVerts;
|
|
break;
|
|
case 3:
|
|
tf->c = numVerts;
|
|
numFaces++;
|
|
break;
|
|
}
|
|
}
|
|
else if( tri_strip )
|
|
{
|
|
// flip triangles between clockwise and counter clockwise
|
|
if( vertexState & 1 )
|
|
{
|
|
// draw triangle [n-2 n-1 n]
|
|
tf->a = numVerts - 2;
|
|
tf->b = numVerts - 1;
|
|
tf->c = numVerts;
|
|
}
|
|
else
|
|
{
|
|
// draw triangle [n-1 n-2 n]
|
|
tf->a = numVerts - 1;
|
|
tf->b = numVerts - 2;
|
|
tf->c = numVerts;
|
|
}
|
|
numFaces++;
|
|
}
|
|
else
|
|
{
|
|
// draw triangle fan [0 n-1 n]
|
|
tf->a = numVerts - ( vertexState - 1 );
|
|
tf->b = numVerts - 1;
|
|
tf->c = numVerts;
|
|
numFaces++;
|
|
}
|
|
|
|
if( FBitSet( flags, STUDIO_NF_CHROME ))
|
|
{
|
|
// probably always equal 64 (see studiomdl.c for details)
|
|
tv->st[0] = float( s );
|
|
tv->st[1] = float( t );
|
|
}
|
|
else if( FBitSet( flags, STUDIO_NF_UV_COORDS ))
|
|
{
|
|
tv->st[0] = HalfToFloat( ptricmds[2] );
|
|
tv->st[1] = HalfToFloat( ptricmds[3] );
|
|
}
|
|
else
|
|
{
|
|
tv->st[0] = float( ptricmds[2] * s );
|
|
tv->st[1] = float( ptricmds[3] * t );
|
|
}
|
|
|
|
VectorCopy( m_verts[ptricmds[0]], tv->point );
|
|
VectorCopy( m_norms[ptricmds[1]], tv->normal );
|
|
VectorNormalize2( tv->normal );
|
|
numVerts++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// don't keep this because different submodels may have difference count of normals
|
|
Mem_Free( m_norms );
|
|
Mem_Free( m_verts );
|
|
}
|
|
|
|
// perfomance warning
|
|
if( numFaces >= MAX_TRIANGLES )
|
|
{
|
|
MsgDev( D_ERROR, "%s have too many triangles (%i). Ignored\n", modname, numFaces );
|
|
Mem_Free( verts );
|
|
Mem_Free( faces );
|
|
return 0; // failed to build (too many triangles)
|
|
}
|
|
else if( numFaces >= (MAX_TRIANGLES>>1))
|
|
MsgDev( D_WARN, "%s have too many triangles (%i)\n", modname, numFaces );
|
|
|
|
size_t texdata_size = sizeof( timage_t ) * phdr->numtextures;
|
|
char diffuse[128], texname[128], mdlname[64];
|
|
rgbdata_t *external_textures[256];
|
|
|
|
COM_FileBase( modname, mdlname );
|
|
memset( external_textures, 0 , sizeof( external_textures ));
|
|
|
|
// store only texdata where we has alpha-testing
|
|
for( i = 0; i < phdr->numtextures; i++ )
|
|
{
|
|
mstudiotexture_t *tex = &ptexture[i];
|
|
|
|
COM_FileBase( tex->name, texname );
|
|
Q_snprintf( diffuse, sizeof( diffuse ), "textures/%s/%s", mdlname, texname );
|
|
|
|
#ifdef HLRAD_EXTERNAL_TEXTURES
|
|
if( FBitSet( tex->flags, STUDIO_NF_ADDITIVE|STUDIO_NF_MASKED ) && IMAGE_EXISTS( diffuse ))
|
|
{
|
|
rgbdata_t *test = COM_LoadImage( diffuse );
|
|
|
|
// external texture has alpha - use it
|
|
if( test )
|
|
{
|
|
if( FBitSet( test->flags, IMAGE_HAS_ALPHA ))
|
|
{
|
|
MsgDev( D_REPORT, "load external texture %s\n", diffuse );
|
|
texdata_size += test->width * test->height;
|
|
external_textures[i] = test;
|
|
}
|
|
else
|
|
{
|
|
// has no alpha
|
|
Mem_Free( test );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
if( external_textures[i] ) continue; // already loaded
|
|
|
|
// NOTE: store the only pixels, we doesn't need a palette
|
|
if( FBitSet( tex->flags, STUDIO_NF_MASKED ))
|
|
texdata_size += tex->width * tex->height;
|
|
}
|
|
|
|
size_t memsize = sizeof( tmesh_t ) + ( sizeof( tface_t ) * numFaces ) + ( sizeof( tvert_t ) * numVerts ) + texdata_size;
|
|
|
|
// alloc vislight matrix
|
|
if( FBitSet( flags, FMESH_MODEL_LIGHTMAPS|FMESH_VERTEX_LIGHTING ))
|
|
memsize += (g_numworldlights + 7) / 8;
|
|
|
|
// alloc lighting faces
|
|
if( FBitSet( flags, FMESH_MODEL_LIGHTMAPS ))
|
|
memsize += sizeof( lface_t ) * numFaces;
|
|
|
|
// alloc lighting verts
|
|
if( FBitSet( flags, FMESH_VERTEX_LIGHTING ))
|
|
memsize += sizeof( lvert_t ) * numVerts;
|
|
|
|
// Msg( "%s alloc %s\n", modname, Q_memprint( memsize ));
|
|
|
|
byte *meshdata = (byte *)Mem_Alloc( memsize );
|
|
byte *meshend = meshdata + memsize; // bounds checking
|
|
tmesh_t *mesh = (tmesh_t *)meshdata;
|
|
|
|
if( ent->cache ) Mem_Free( ent->cache ); // throw previous instance
|
|
ent->cache = meshdata; // FreeEntities will be automatically free that
|
|
|
|
// setup pointers
|
|
meshdata += sizeof( tmesh_t );
|
|
mesh->textures = (timage_t *)meshdata;
|
|
meshdata += sizeof( timage_t ) * phdr->numtextures;
|
|
mesh->faces = (tface_t *)meshdata;
|
|
meshdata += sizeof( tface_t ) * numFaces;
|
|
mesh->numfaces = numFaces;
|
|
|
|
// store faces
|
|
memcpy( mesh->faces, faces, sizeof( tface_t ) * mesh->numfaces );
|
|
Mem_Free( faces );
|
|
|
|
// setup additional lightdata if present
|
|
if( FBitSet( flags, FMESH_MODEL_LIGHTMAPS ))
|
|
{
|
|
for( int i = 0; i < numFaces; i++ )
|
|
{
|
|
mesh->faces[i].light = (lface_t *)meshdata;
|
|
meshdata += sizeof( lface_t );
|
|
|
|
// clearing lightdata
|
|
for( int j = 0; j < MAXLIGHTMAPS; j++ )
|
|
mesh->faces[i].light->styles[j] = 255;
|
|
mesh->faces[i].light->lightofs = -1;
|
|
}
|
|
}
|
|
|
|
mesh->verts = (tvert_t *)meshdata;
|
|
meshdata += sizeof( tvert_t ) * numVerts;
|
|
mesh->numverts = numVerts;
|
|
|
|
// store vertexes
|
|
memcpy( mesh->verts, verts, sizeof( tvert_t ) * mesh->numverts );
|
|
Mem_Free( verts );
|
|
|
|
// setup additional lightdata if present
|
|
if( FBitSet( flags, FMESH_VERTEX_LIGHTING ))
|
|
{
|
|
for( int i = 0; i < numVerts; i++ )
|
|
{
|
|
mesh->verts[i].light = (lvert_t *)meshdata;
|
|
meshdata += sizeof( lvert_t );
|
|
VectorCopy( mesh->verts[i].point, mesh->verts[i].light->pos );
|
|
}
|
|
}
|
|
|
|
memcpy( mesh->vsubmodels, vsubmodels, sizeof( mesh->vsubmodels ));
|
|
memcpy( mesh->fsubmodels, fsubmodels, sizeof( mesh->fsubmodels ));
|
|
|
|
if( FBitSet( flags, FMESH_MODEL_LIGHTMAPS|FMESH_VERTEX_LIGHTING ))
|
|
{
|
|
mesh->vislight = (byte *)meshdata;
|
|
meshdata += (g_numworldlights + 7) / 8;
|
|
}
|
|
|
|
for( int l = 0; l < MAXLIGHTMAPS; l++ )
|
|
mesh->styles[l] = 255;
|
|
|
|
// store only texdata where we has alpha-testing
|
|
for( i = 0; i < phdr->numtextures; i++ )
|
|
{
|
|
mstudiotexture_t *src = &ptexture[i];
|
|
timage_t *dst = &mesh->textures[i];
|
|
|
|
dst->width = src->width;
|
|
dst->height = src->height;
|
|
dst->flags = src->flags;
|
|
|
|
if( external_textures[i] )
|
|
{
|
|
rgbdata_t *test = external_textures[i];
|
|
dst->data = meshdata;
|
|
dst->width = test->width;
|
|
dst->height = test->height;
|
|
|
|
// copy alpha channel from external texture
|
|
for( j = 0; j < test->width * test->height; j++ )
|
|
dst->data[j] = test->buffer[j*4+3] < 255 ? 255 : 0; // because we used palette index, not alpha value
|
|
meshdata += test->width * test->height; // move pointer
|
|
external_textures[i] = NULL;
|
|
Mem_Free( test );
|
|
}
|
|
else if( FBitSet( src->flags, STUDIO_NF_MASKED ))
|
|
{
|
|
// NOTE: store the only pixels, we doesn't need a palette
|
|
dst->data = meshdata;
|
|
memcpy( dst->data, (byte *)phdr + src->index, src->width * src->height );
|
|
meshdata += src->width * src->height; // move pointer
|
|
}
|
|
}
|
|
|
|
if( meshdata != meshend )
|
|
Msg( "%s memory corrupted\n", modname );
|
|
|
|
ClearBounds( mesh->absmin, mesh->absmax );
|
|
|
|
// do some post-initialization
|
|
for( i = 0; i < numFaces; i++ )
|
|
StudioSetupTriangle( mesh, i );
|
|
|
|
return numFaces;
|
|
}
|
|
|
|
bool StudioConstructMesh( entity_t *ent, void *extradata, const char *modname, uint modelCRC, int flags )
|
|
{
|
|
studiohdr_t *phdr = (studiohdr_t *)extradata;
|
|
double start = I_FloatTime();
|
|
vec3_t origin, angles;
|
|
int body, skin;
|
|
int numFaces;
|
|
vec3_t xform;
|
|
float scale;
|
|
|
|
if( phdr->numbones < 1 )
|
|
return false;
|
|
|
|
// get model properties
|
|
GetVectorForKey( ent, "origin", origin );
|
|
GetVectorForKey( ent, "angles", angles );
|
|
|
|
angles[0] = -angles[0]; // Stupid quake bug workaround
|
|
scale = FloatForKey( ent, "scale" );
|
|
body = IntForKey( ent, "body" );
|
|
skin = IntForKey( ent, "skin" );
|
|
|
|
GetVectorForKey( ent, "xform", xform );
|
|
|
|
if( VectorIsNull( xform ))
|
|
VectorFill( xform, scale );
|
|
|
|
// check xform values
|
|
if( xform[0] < 0.01f ) xform[0] = 1.0f;
|
|
if( xform[1] < 0.01f ) xform[1] = 1.0f;
|
|
if( xform[2] < 0.01f ) xform[2] = 1.0f;
|
|
if( xform[0] > 16.0f ) xform[0] = 16.0f;
|
|
if( xform[1] > 16.0f ) xform[1] = 16.0f;
|
|
if( xform[2] > 16.0f ) xform[2] = 16.0f;
|
|
|
|
// compute default pose for building mesh from
|
|
mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)phdr + phdr->seqindex);
|
|
mstudioseqgroup_t *pseqgroup = (mstudioseqgroup_t *)((byte *)phdr + phdr->seqgroupindex);
|
|
mstudioanim_t *panim = (mstudioanim_t *)((byte *)phdr + pseqdesc->animindex);
|
|
mstudiobone_t *pbone = (mstudiobone_t *)((byte *)phdr + phdr->boneindex);
|
|
static vec3_t pos[MAXSTUDIOBONES];
|
|
static vec4_t q[MAXSTUDIOBONES];
|
|
|
|
for( int i = 0; i < phdr->numbones; i++, pbone++, panim++ )
|
|
StudioCalcBoneTransform( 0, pbone, panim, pos[i], q[i] );
|
|
pbone = (mstudiobone_t *)((byte *)phdr + phdr->boneindex);
|
|
matrix3x4 transform, bonematrix, bonetransform[MAXSTUDIOBONES];
|
|
Matrix3x4_CreateFromEntityScale3f( transform, angles, origin, xform );
|
|
|
|
// compute bones for default anim
|
|
for( i = 0; i < phdr->numbones; i++ )
|
|
{
|
|
// initialize bonematrix
|
|
Matrix3x4_FromOriginQuat( bonematrix, q[i], pos[i] );
|
|
|
|
if( pbone[i].parent == -1 )
|
|
Matrix3x4_ConcatTransforms( bonetransform[i], transform, bonematrix );
|
|
else Matrix3x4_ConcatTransforms( bonetransform[i], bonetransform[pbone[i].parent], bonematrix );
|
|
}
|
|
|
|
if(( numFaces = StudioCreateMeshFromTriangles( ent, phdr, modname, body, skin, flags, bonetransform )) == 0 )
|
|
return false;
|
|
|
|
tmesh_t *mesh = (tmesh_t *)ent->cache;
|
|
size_t memsize = Mem_Size( ent->cache );
|
|
int maxDepth = AREA_MIN_DEPTH;
|
|
|
|
// FIXME: check this efficiency
|
|
if( numFaces < 1000 )
|
|
maxDepth = AREA_MIN_DEPTH;
|
|
else if( numFaces >= 1000 && numFaces <= 10000 )
|
|
maxDepth = 5;
|
|
else if( numFaces >= 10000 && numFaces <= 20000 )
|
|
maxDepth = 6;
|
|
else if( numFaces >= 20000 && numFaces <= 50000 )
|
|
maxDepth = 7;
|
|
else if( numFaces >= 50000 && numFaces <= 100000 )
|
|
maxDepth = 8;
|
|
else if( numFaces >= 100000 && numFaces <= 200000 )
|
|
maxDepth = 9;
|
|
else maxDepth = AREA_MAX_DEPTH;
|
|
|
|
// create AABB tree for speedup reasons
|
|
CreateAreaNode( &mesh->face_tree, 0, maxDepth, mesh->absmin, mesh->absmax );
|
|
|
|
for( i = 0; i < numFaces; i++ )
|
|
StudioRelinkFace( &mesh->face_tree, &mesh->faces[i] );
|
|
|
|
ent->modtype = mod_studio; // now our mesh is valid and ready to trace
|
|
mesh->modelCRC = modelCRC;
|
|
VectorCopy( origin, mesh->origin );
|
|
VectorCopy( angles, mesh->angles );
|
|
VectorCopy( xform, mesh->scale );
|
|
mesh->backfrac = FloatForKey( ent, "zhlt_backfrac" );
|
|
mesh->flags = flags; // copy settings
|
|
|
|
MsgDev( D_REPORT, "%s: build time %g secs, size %s\n", modname, I_FloatTime() - start, Q_memprint( memsize ));
|
|
|
|
return true;
|
|
}
|
|
|
|
void LoadStudio( entity_t *ent, void *extradata, long fileLength, int flags )
|
|
{
|
|
const char *modname = ValueForKey( ent, "model" );
|
|
dword modelCRC = 0;
|
|
studiohdr_t *phdr;
|
|
|
|
if( !extradata )
|
|
{
|
|
MsgDev( D_WARN, "LoadStudio: couldn't load %s\n", modname );
|
|
return;
|
|
}
|
|
|
|
phdr = (studiohdr_t *)extradata;
|
|
|
|
if( phdr->ident != IDSTUDIOHEADER || phdr->version != STUDIO_VERSION )
|
|
{
|
|
if( phdr->ident != IDSTUDIOHEADER )
|
|
MsgDev( D_WARN, "LoadStudio: %s not a studio model\n", modname );
|
|
else if( phdr->version != STUDIO_VERSION )
|
|
MsgDev( D_WARN, "LoadStudio: %s has wrong version number (%i should be %i)\n", modname, phdr->version, STUDIO_VERSION );
|
|
Mem_Free( extradata, C_FILESYSTEM );
|
|
return;
|
|
}
|
|
|
|
#ifndef HLRAD_VERTEXLIGHTING
|
|
ClearBits( flags, FMESH_VERTEX_LIGHTING );
|
|
#endif
|
|
|
|
#ifndef HLRAD_LIGHTMAPMODELS
|
|
ClearBits( flags, FMESH_MODEL_LIGHTMAPS );
|
|
#endif
|
|
|
|
#if defined( HLRAD_VERTEXLIGHTING ) || defined( HLRAD_LIGHTMAPMODELS )
|
|
CRC32_Init( &modelCRC );
|
|
CRC32_ProcessBuffer( &modelCRC, extradata, phdr->length );
|
|
CRC32_Final( &modelCRC );
|
|
#endif
|
|
// well the textures place in separate file (very stupid case)
|
|
if( phdr->numtextures == 0 )
|
|
{
|
|
char texname[128], texpath[128];
|
|
byte *texdata, *moddata;
|
|
studiohdr_t *thdr, *newhdr;
|
|
|
|
Q_strncpy( texname, modname, sizeof( texname ));
|
|
COM_StripExtension( texname );
|
|
|
|
Q_snprintf( texpath, sizeof( texpath ), "%sT.mdl", texname );
|
|
MsgDev( D_REPORT, "loading %s\n", texpath );
|
|
texdata = FS_LoadFile( texpath, NULL, false );
|
|
|
|
if( !texdata )
|
|
{
|
|
MsgDev( D_WARN, "LoadStudioModel: couldn't load %s\n", texpath );
|
|
Mem_Free( extradata, C_FILESYSTEM );
|
|
return;
|
|
}
|
|
|
|
moddata = (byte *)extradata;
|
|
phdr = (studiohdr_t *)moddata;
|
|
thdr = (studiohdr_t *)texdata;
|
|
|
|
// merge textures with main model buffer
|
|
extradata = Mem_Alloc( phdr->length + thdr->length - sizeof( studiohdr_t ), C_FILESYSTEM ); // we don't need two headers
|
|
memcpy( extradata, moddata, phdr->length );
|
|
memcpy((byte *)extradata + phdr->length, texdata + sizeof( studiohdr_t ), thdr->length - sizeof( studiohdr_t ));
|
|
|
|
// merge header
|
|
newhdr = (studiohdr_t *)extradata;
|
|
|
|
newhdr->numskinfamilies = thdr->numskinfamilies;
|
|
newhdr->numtextures = thdr->numtextures;
|
|
newhdr->numskinref = thdr->numskinref;
|
|
newhdr->textureindex = phdr->length;
|
|
newhdr->skinindex = newhdr->textureindex + ( newhdr->numtextures * sizeof( mstudiotexture_t ));
|
|
newhdr->texturedataindex = newhdr->skinindex + (newhdr->numskinfamilies * newhdr->numskinref * sizeof( short ));
|
|
newhdr->length = phdr->length + thdr->length - sizeof( studiohdr_t );
|
|
|
|
// and finally merge datapointers for textures
|
|
for( int i = 0; i < newhdr->numtextures; i++ )
|
|
{
|
|
mstudiotexture_t *ptexture = (mstudiotexture_t *)(((byte *)newhdr) + newhdr->textureindex);
|
|
ptexture[i].index += ( phdr->length - sizeof( studiohdr_t ));
|
|
}
|
|
|
|
Mem_Free( moddata, C_FILESYSTEM );
|
|
Mem_Free( texdata, C_FILESYSTEM );
|
|
}
|
|
|
|
StudioConstructMesh( ent, extradata, modname, modelCRC, flags );
|
|
Mem_Free( extradata, C_FILESYSTEM );
|
|
}
|
|
|
|
void StudioGetBounds( entity_t *ent, vec3_t mins, vec3_t maxs )
|
|
{
|
|
tmesh_t *mesh = (tmesh_t *)ent->cache;
|
|
|
|
// assume point hull
|
|
VectorClear( mins );
|
|
VectorClear( maxs );
|
|
|
|
if( !mesh || ent->modtype != mod_studio )
|
|
return;
|
|
|
|
VectorSubtract( mesh->absmin, ent->origin, mins );
|
|
VectorSubtract( mesh->absmax, ent->origin, maxs );
|
|
} |