04 Sep 2009
This commit is contained in:
g-cont
parent
b2a84e1e9e
commit
f288f67e46
|
|
@ -236,6 +236,10 @@ typedef enum
|
|||
// engine built-in default shader
|
||||
#define MAP_DEFAULT_SHADER "*black"
|
||||
|
||||
// client modelindexes
|
||||
#define VMODEL_ENTINDEX -1 // can get viewmodel for local client
|
||||
#define WMODEL_ENTINDEX -2 // engine always return NULL, only for internal use
|
||||
|
||||
// basic console charwidths
|
||||
#define TINYCHAR_WIDTH (SMALLCHAR_WIDTH)
|
||||
#define TINYCHAR_HEIGHT (SMALLCHAR_HEIGHT/2)
|
||||
|
|
|
|||
|
|
@ -40,6 +40,7 @@ Studio models are position independent, so the cache manager can move them.
|
|||
// model global flags
|
||||
#define STUDIO_STATIC 0x0001 // model without anims
|
||||
#define STUDIO_RAGDOLL 0x0002 // ragdoll animation pose
|
||||
#define STUDIO_HAS_CHROME 0x0008 // if any of the textures have chrome on them
|
||||
|
||||
// lighting & rendermode options
|
||||
#define STUDIO_NF_FLATSHADE 0x0001
|
||||
|
|
@ -81,16 +82,10 @@ Studio models are position independent, so the cache manager can move them.
|
|||
// sequence flags
|
||||
#define STUDIO_LOOPING 0x0001
|
||||
|
||||
// render flags
|
||||
#define STUDIO_RENDER 0x0001
|
||||
#define STUDIO_EVENTS 0x0002
|
||||
#define STUDIO_MIRROR 0x0004 // a local player in mirror
|
||||
|
||||
// bone flags
|
||||
#define STUDIO_HAS_NORMALS 0x0001
|
||||
#define STUDIO_HAS_VERTICES 0x0002
|
||||
#define STUDIO_HAS_BBOX 0x0004
|
||||
#define STUDIO_HAS_CHROME 0x0008 // if any of the textures have chrome on them
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
|
|
|||
|
|
@ -23,13 +23,42 @@ edict_t *CL_GetEdictByIndex( int index )
|
|||
{
|
||||
if( index < 0 || index > clgame.numEntities )
|
||||
{
|
||||
if( index == -1 ) return &cl.viewent;
|
||||
if( index == VMODEL_ENTINDEX ) return &cl.viewent;
|
||||
if( index == WMODEL_ENTINDEX ) return NULL;
|
||||
MsgDev( D_ERROR, "CL_GetEntityByIndex: invalid entindex %i\n", index );
|
||||
return NULL;
|
||||
}
|
||||
return EDICT_NUM( index );
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
Studio_FxTransform
|
||||
|
||||
FIXME: move into client.dll
|
||||
====================
|
||||
*/
|
||||
void CL_StudioFxTransform( edict_t *ent, float transform[4][4] )
|
||||
{
|
||||
if( ent->v.renderfx == kRenderFxHologram )
|
||||
{
|
||||
if(!Com_RandomLong( 0, 49 ))
|
||||
{
|
||||
int axis = Com_RandomLong( 0, 1 );
|
||||
if( axis == 1 ) axis = 2; // choose between x & z
|
||||
VectorScale( transform[axis], Com_RandomFloat( 1, 1.484 ), transform[axis] );
|
||||
}
|
||||
else if(!Com_RandomLong( 0, 49 ))
|
||||
{
|
||||
float offset;
|
||||
int axis = Com_RandomLong( 0, 1 );
|
||||
if( axis == 1 ) axis = 2; // choose between x & z
|
||||
offset = Com_RandomFloat( -10, 10 );
|
||||
transform[Com_RandomLong( 0, 2 )][3] += offset;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static trace_t CL_TraceToss( edict_t *tossent, edict_t *ignore)
|
||||
{
|
||||
int i;
|
||||
|
|
|
|||
|
|
@ -602,6 +602,7 @@ void CL_TestEntities( void );
|
|||
void CL_StudioEvent( dstudioevent_t *event, edict_t *ent );
|
||||
edict_t *CL_GetEdictByIndex( int index );
|
||||
edict_t *CL_GetLocalPlayer( void );
|
||||
void CL_StudioFxTransform( edict_t *ent, float transform[4][4] );
|
||||
bool pfnAddParticle( cparticle_t *src, HSPRITE shader, int flags );
|
||||
void pfnAddDecal( float *org, float *dir, float *rgba, float rot, float rad, HSPRITE hSpr, int flags );
|
||||
void pfnAddDLight( const float *org, const float *rgb, float radius, float decay, float time, int key );
|
||||
|
|
|
|||
|
|
@ -79,6 +79,7 @@ void Host_InitRender( void )
|
|||
// studio callbacks
|
||||
ri.UpdateScreen = SCR_UpdateScreen;
|
||||
ri.StudioEvent = CL_StudioEvent;
|
||||
ri.StudioFxTransform = CL_StudioFxTransform;
|
||||
ri.ShowCollision = pe->DrawCollision;
|
||||
ri.GetClientEdict = CL_GetEdictByIndex;
|
||||
ri.GetLocalPlayer = CL_GetLocalPlayer;
|
||||
|
|
|
|||
|
|
@ -1,16 +0,0 @@
|
|||
<html>
|
||||
<body>
|
||||
<pre>
|
||||
<h1>Build Log</h1>
|
||||
<h3>
|
||||
--------------------Configuration: launch - Win32 Release--------------------
|
||||
</h3>
|
||||
<h3>Command Lines</h3>
|
||||
|
||||
|
||||
|
||||
<h3>Results</h3>
|
||||
launch.dll - 0 error(s), 0 warning(s)
|
||||
</pre>
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -103,6 +103,7 @@ typedef struct render_imp_s
|
|||
// client fundamental callbacks
|
||||
void (*UpdateScreen)( void ); // update screen while loading
|
||||
void (*StudioEvent)( dstudioevent_t *event, edict_t *ent );
|
||||
void (*StudioFxTransform)( edict_t *ent, float matrix[4][4] );
|
||||
void (*ShowCollision)( cmdraw_t callback ); // debug
|
||||
bool (*Trace)( const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end );
|
||||
long (*WndProc)( void *hWnd, uint uMsg, uint wParam, long lParam );
|
||||
|
|
|
|||
|
|
@ -224,7 +224,7 @@ static void RoQ_ApplyMotion4x4( cinematics_t *cin, int x, int y, byte mv, char m
|
|||
dst = cin->vid_pic[0] + (y * cin->width + x) * 4;
|
||||
|
||||
for( y = 0; y < 4; y++, src += cin->width * 4, dst += cin->width * 4 )
|
||||
memcpy( dst, src, 4 * 4 );
|
||||
Mem_Copy( dst, src, 4 * 4 );
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -245,7 +245,7 @@ static void RoQ_ApplyMotion8x8( cinematics_t *cin, int x, int y, byte mv, char m
|
|||
dst = cin->vid_pic[0] + (y * cin->width + x) * 4;
|
||||
|
||||
for( y = 0; y < 8; y++, src += cin->width * 4, dst += cin->width * 4 )
|
||||
memcpy( dst, src, 8 * 4 );
|
||||
Mem_Copy( dst, src, 8 * 4 );
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -359,7 +359,7 @@ byte *RoQ_ReadVideo( cinematics_t *cin )
|
|||
if( cin->frame++ == 0 )
|
||||
{
|
||||
// copy initial values to back buffer for motion
|
||||
memcpy ( cin->vid_pic[1], cin->vid_pic[0], cin->width * cin->height * 4 );
|
||||
Mem_Copy( cin->vid_pic[1], cin->vid_pic[0], cin->width * cin->height * 4 );
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
|||
|
|
@ -90,6 +90,9 @@ typedef struct
|
|||
ref_buffer_t *colorsBuffer;
|
||||
ref_buffer_t *tcoordBuffer[MAX_TEXTURE_UNITS];
|
||||
|
||||
// OpenGL matrix states
|
||||
bool modelviewIdentity;
|
||||
|
||||
// builtin textures
|
||||
texture_t *cinTexture; // cinematic texture
|
||||
texture_t *portaltexture1; // portal view
|
||||
|
|
@ -209,10 +212,10 @@ static _inline void R_PushMesh( const mesh_t *mesh, int features )
|
|||
if( features & MF_DEFORMVS )
|
||||
{
|
||||
if( mesh->xyzArray != inVertsArray )
|
||||
memcpy( inVertsArray, mesh->xyzArray, numverts * sizeof( vec4_t ) );
|
||||
Mem_Copy( inVertsArray, mesh->xyzArray, numverts * sizeof( vec4_t ) );
|
||||
|
||||
if( ( features & MF_NORMALS ) && mesh->normalsArray && ( mesh->normalsArray != inNormalsArray ) )
|
||||
memcpy( inNormalsArray, mesh->normalsArray, numverts * sizeof( vec4_t ) );
|
||||
Mem_Copy( inNormalsArray, mesh->normalsArray, numverts * sizeof( vec4_t ) );
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -246,44 +249,44 @@ static _inline void R_PushMesh( const mesh_t *mesh, int features )
|
|||
else
|
||||
{
|
||||
if( mesh->xyzArray != inVertsArray )
|
||||
memcpy( inVertsArray[r_backacc.numVerts], mesh->xyzArray, numverts * sizeof( vec4_t ) );
|
||||
Mem_Copy( inVertsArray[r_backacc.numVerts], mesh->xyzArray, numverts * sizeof( vec4_t ) );
|
||||
|
||||
if( ( features & MF_NORMALS ) && mesh->normalsArray && (mesh->normalsArray != inNormalsArray ) )
|
||||
memcpy( inNormalsArray[r_backacc.numVerts], mesh->normalsArray, numverts * sizeof( vec4_t ) );
|
||||
Mem_Copy( inNormalsArray[r_backacc.numVerts], mesh->normalsArray, numverts * sizeof( vec4_t ) );
|
||||
|
||||
if( ( features & MF_STCOORDS ) && mesh->stArray && (mesh->stArray != inCoordsArray ) )
|
||||
memcpy( inCoordsArray[r_backacc.numVerts], mesh->stArray, numverts * sizeof( vec2_t ) );
|
||||
Mem_Copy( inCoordsArray[r_backacc.numVerts], mesh->stArray, numverts * sizeof( vec2_t ) );
|
||||
|
||||
if( ( features & MF_LMCOORDS ) && mesh->lmstArray[0] )
|
||||
{
|
||||
memcpy( inLightmapCoordsArray[0][r_backacc.numVerts], mesh->lmstArray[0], numverts * sizeof( vec2_t ) );
|
||||
Mem_Copy( inLightmapCoordsArray[0][r_backacc.numVerts], mesh->lmstArray[0], numverts * sizeof( vec2_t ) );
|
||||
if( features & MF_LMCOORDS1 )
|
||||
{
|
||||
memcpy( inLightmapCoordsArray[1][r_backacc.numVerts], mesh->lmstArray[1], numverts * sizeof( vec2_t ) );
|
||||
Mem_Copy( inLightmapCoordsArray[1][r_backacc.numVerts], mesh->lmstArray[1], numverts * sizeof( vec2_t ) );
|
||||
if( features & MF_LMCOORDS2 )
|
||||
{
|
||||
memcpy( inLightmapCoordsArray[2][r_backacc.numVerts], mesh->lmstArray[2], numverts * sizeof( vec2_t ) );
|
||||
Mem_Copy( inLightmapCoordsArray[2][r_backacc.numVerts], mesh->lmstArray[2], numverts * sizeof( vec2_t ) );
|
||||
if( features & MF_LMCOORDS3 )
|
||||
memcpy( inLightmapCoordsArray[3][r_backacc.numVerts], mesh->lmstArray[3], numverts * sizeof( vec2_t ) );
|
||||
Mem_Copy( inLightmapCoordsArray[3][r_backacc.numVerts], mesh->lmstArray[3], numverts * sizeof( vec2_t ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if( ( features & MF_SVECTORS ) && mesh->sVectorsArray && (mesh->sVectorsArray != inSVectorsArray ) )
|
||||
memcpy( inSVectorsArray[r_backacc.numVerts], mesh->sVectorsArray, numverts * sizeof( vec4_t ) );
|
||||
Mem_Copy( inSVectorsArray[r_backacc.numVerts], mesh->sVectorsArray, numverts * sizeof( vec4_t ) );
|
||||
}
|
||||
|
||||
if( ( features & MF_COLORS ) && mesh->colorsArray[0] )
|
||||
{
|
||||
memcpy( inColorsArray[0][r_backacc.numVerts], mesh->colorsArray[0], numverts * sizeof( rgba_t ) );
|
||||
Mem_Copy( inColorsArray[0][r_backacc.numVerts], mesh->colorsArray[0], numverts * sizeof( rgba_t ) );
|
||||
if( features & MF_COLORS1 )
|
||||
{
|
||||
memcpy( inColorsArray[1][r_backacc.numVerts], mesh->colorsArray[1], numverts * sizeof( rgba_t ) );
|
||||
Mem_Copy( inColorsArray[1][r_backacc.numVerts], mesh->colorsArray[1], numverts * sizeof( rgba_t ) );
|
||||
if( features & MF_COLORS2 )
|
||||
{
|
||||
memcpy( inColorsArray[2][r_backacc.numVerts], mesh->colorsArray[2], numverts * sizeof( rgba_t ) );
|
||||
Mem_Copy( inColorsArray[2][r_backacc.numVerts], mesh->colorsArray[2], numverts * sizeof( rgba_t ) );
|
||||
if( features & MF_COLORS3 )
|
||||
memcpy( inColorsArray[3][r_backacc.numVerts], mesh->colorsArray[3], numverts * sizeof( rgba_t ) );
|
||||
Mem_Copy( inColorsArray[3][r_backacc.numVerts], mesh->colorsArray[3], numverts * sizeof( rgba_t ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -355,7 +355,7 @@ unsigned int R_StartCinematics( const char *arg )
|
|||
com.snprintf( uploadName, sizeof( uploadName ), "***r_cinematic%i***", handle->id-1 );
|
||||
name_size = com.strlen( uploadName ) + 1;
|
||||
handle->name = Cin_Malloc( name_size );
|
||||
memcpy( handle->name, uploadName, name_size );
|
||||
Mem_Copy( handle->name, uploadName, name_size );
|
||||
handle->cin = cin;
|
||||
|
||||
// put handle at the start of the list
|
||||
|
|
|
|||
|
|
@ -99,23 +99,20 @@ R_CullSphere
|
|||
Returns true if the sphere is completely outside the frustum
|
||||
=================
|
||||
*/
|
||||
bool R_CullSphere( const vec3_t centre, const float radius, const unsigned int clipflags )
|
||||
bool R_CullSphere( const vec3_t centre, const float radius, const uint clipflags )
|
||||
{
|
||||
unsigned int i;
|
||||
unsigned int bit;
|
||||
uint i, bit;
|
||||
const cplane_t *p;
|
||||
|
||||
if( r_nocull->integer )
|
||||
return false;
|
||||
|
||||
for( i = sizeof( RI.frustum )/sizeof( RI.frustum[0] ), bit = 1, p = RI.frustum; i > 0; i--, bit<<=1, p++ )
|
||||
for( i = sizeof( RI.frustum ) / sizeof( RI.frustum[0] ), bit = 1, p = RI.frustum; i > 0; i--, bit <<= 1, p++ )
|
||||
{
|
||||
if( !( clipflags & bit ) )
|
||||
continue;
|
||||
if(!( clipflags & bit )) continue;
|
||||
if( DotProduct( centre, p->normal ) - p->dist <= -radius )
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -241,7 +238,13 @@ int R_CullModel( ref_entity_t *e, vec3_t mins, vec3_t maxs, float radius )
|
|||
return 1;
|
||||
}
|
||||
|
||||
if( R_CullSphere( e->origin, radius, RI.clipFlags ) )
|
||||
if( RP_FOLLOWENTITY( e ) && RP_LOCALCLIENT( e->parent ) && !RI.refdef.thirdperson )
|
||||
{
|
||||
if(!( RI.params & ( RP_MIRRORVIEW|RP_SHADOWMAPVIEW )))
|
||||
return 1;
|
||||
}
|
||||
|
||||
if( R_CullSphere( e->origin, radius, RI.clipFlags ))
|
||||
return 1;
|
||||
|
||||
if( RI.refdef.rdflags & (RDF_PORTALINVIEW|RDF_SKYPORTALINVIEW) || (RI.params & RP_SKYPORTALVIEW))
|
||||
|
|
|
|||
|
|
@ -168,25 +168,7 @@ enum
|
|||
|
||||
#define RP_NONVIEWERREF ( RP_PORTALVIEW|RP_MIRRORVIEW|RP_ENVVIEW|RP_SKYPORTALVIEW|RP_SHADOWMAPVIEW )
|
||||
#define RP_LOCALCLIENT(e) (((e)->index == ri.GetLocalPlayer()->serialnumber))
|
||||
|
||||
/*
|
||||
=======================================================================
|
||||
|
||||
DOOM1 STYLE AUTOMAP
|
||||
|
||||
=======================================================================
|
||||
*/
|
||||
#define MAX_RADAR_ENTS 1024
|
||||
|
||||
typedef struct radar_ent_s
|
||||
{
|
||||
rgba_t color;
|
||||
vec3_t origin;
|
||||
vec3_t angles;
|
||||
} radar_ent_t;
|
||||
|
||||
extern int numRadarEnts;
|
||||
extern radar_ent_t RadarEnts[MAX_RADAR_ENTS];
|
||||
#define RP_FOLLOWENTITY(e) (((e)->movetype == MOVETYPE_FOLLOW && (e)->parent))
|
||||
|
||||
//====================================================
|
||||
|
||||
|
|
@ -257,6 +239,8 @@ typedef struct studioverts_s
|
|||
{
|
||||
vec3_t *verts;
|
||||
vec3_t *norms;
|
||||
vec3_t *light; // light values
|
||||
vec2_t *chrome; // size match with numverts
|
||||
int numverts;
|
||||
int numnorms;
|
||||
int m_nCachedFrame; // to avoid transform it twice
|
||||
|
|
@ -273,12 +257,14 @@ typedef struct studiovars_s
|
|||
// cached bones, valid only for current frame
|
||||
char bonenames[MAXSTUDIOBONES][32];// used for attached entities
|
||||
matrix4x4 *bonestransform;
|
||||
vec3_t *chromeright;
|
||||
vec3_t *chromeup;
|
||||
int *chromeage;
|
||||
int numbones;
|
||||
|
||||
// StudioBoneLighting (slow and ugly)
|
||||
studiolight_t *light; // FIXME: alloc match size not maximum
|
||||
studioverts_t *mesh[MAXSTUDIOMODELS];
|
||||
int num_models;
|
||||
} studiovars_t;
|
||||
|
||||
typedef struct ref_entity_s
|
||||
|
|
@ -289,7 +275,7 @@ typedef struct ref_entity_s
|
|||
refEntityType_t rtype;
|
||||
|
||||
struct ref_model_s *model; // opaque type outside refresh
|
||||
struct ref_model_s *weaponmodel; // opaque type outside refresh
|
||||
struct ref_entity_s *parent; // link to parent entity (FOLLOW or weaponmodel)
|
||||
|
||||
latchedvars_t prev; // previous frame values for lerping
|
||||
|
||||
|
|
@ -304,6 +290,7 @@ typedef struct ref_entity_s
|
|||
int sequence;
|
||||
float scale;
|
||||
|
||||
byte *mempool; // studio mempool
|
||||
void *extradata; // studiomodel bones, etc
|
||||
|
||||
// misc
|
||||
|
|
@ -469,7 +456,6 @@ extern cvar_t *r_shownormals;
|
|||
extern cvar_t *r_showtextures;
|
||||
extern cvar_t *r_draworder;
|
||||
|
||||
extern cvar_t *r_minimap;
|
||||
extern cvar_t *r_fastsky;
|
||||
extern cvar_t *r_portalonly;
|
||||
extern cvar_t *r_portalmaps;
|
||||
|
|
@ -831,8 +817,6 @@ mspriteframe_t *R_GetSpriteFrame( ref_entity_t *ent );
|
|||
//
|
||||
// r_studio.c
|
||||
//
|
||||
extern byte *studiopool;
|
||||
|
||||
void R_AddStudioModelToList( ref_entity_t *e );
|
||||
void R_DrawStudioModel( const meshbuffer_t *mb );
|
||||
void R_StudioResetSequenceInfo( ref_entity_t *ent );
|
||||
|
|
|
|||
|
|
@ -307,9 +307,12 @@ R_LoadIdentity
|
|||
*/
|
||||
void R_LoadIdentity( void )
|
||||
{
|
||||
if( tr.modelviewIdentity ) return;
|
||||
|
||||
Matrix4x4_LoadIdentity( RI.objectMatrix );
|
||||
Matrix4x4_Copy( RI.modelviewMatrix, RI.worldviewMatrix );
|
||||
GL_LoadMatrix( RI.modelviewMatrix );
|
||||
tr.modelviewIdentity = true;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -332,6 +335,7 @@ void R_RotateForEntity( ref_entity_t *e )
|
|||
#endif
|
||||
Matrix4x4_ConcatTransforms( RI.modelviewMatrix, RI.worldviewMatrix, RI.objectMatrix );
|
||||
GL_LoadMatrix( RI.modelviewMatrix );
|
||||
tr.modelviewIdentity = false;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -351,6 +355,7 @@ void R_TranslateForEntity( ref_entity_t *e )
|
|||
Matrix4x4_SetOrigin( RI.objectMatrix, e->origin[0], e->origin[1], e->origin[2] );
|
||||
Matrix4x4_ConcatTransforms( RI.modelviewMatrix, RI.worldviewMatrix, RI.objectMatrix );
|
||||
GL_LoadMatrix( RI.modelviewMatrix );
|
||||
tr.modelviewIdentity = false;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1370,8 +1375,7 @@ static void R_CullEntities( void )
|
|||
break;
|
||||
}
|
||||
|
||||
if( !culled )
|
||||
r_entVisBits[i>>3] |= ( 1<<( i&7 ) );
|
||||
if( !culled ) r_entVisBits[i>>3] |= ( 1<<( i&7 ));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1600,8 +1604,8 @@ RI.refdef must be set before the first call
|
|||
*/
|
||||
void R_RenderView( const ref_params_t *fd )
|
||||
{
|
||||
int msec = 0;
|
||||
bool shadowMap = RI.params & RP_SHADOWMAPVIEW ? true : false;
|
||||
int msec = 0;
|
||||
bool shadowMap = RI.params & RP_SHADOWMAPVIEW ? true : false;
|
||||
|
||||
RI.refdef = *fd;
|
||||
|
||||
|
|
@ -2202,7 +2206,6 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
|
|||
}
|
||||
|
||||
refent->prev.sequencetime = refent->animtime - refent->prev.animtime;
|
||||
refent->weaponmodel = cl_models[pRefEntity->v.weaponmodel];
|
||||
|
||||
if( refent->ent_type == ED_MOVER || refent->ent_type == ED_BSPBRUSH )
|
||||
{
|
||||
|
|
@ -2238,10 +2241,11 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
|
|||
if( refent->model->type == mod_studio )
|
||||
{
|
||||
studiovars_t *studio;
|
||||
bool hasChrome = (((mstudiomodel_t *)refent->model->extradata)->phdr->flags & STUDIO_HAS_CHROME) ? true : false;
|
||||
int numbones = ((mstudiomodel_t *)refent->model->extradata)->phdr->numbones;
|
||||
|
||||
if( !refent->extradata )
|
||||
refent->extradata = (void *)Mem_Alloc( studiopool, sizeof( studiovars_t ));
|
||||
if( !refent->mempool ) refent->mempool = Mem_AllocPool( va( "Entity Pool %i", refent - r_entities ));
|
||||
if( !refent->extradata ) refent->extradata = (void *)Mem_Alloc( refent->mempool, sizeof( studiovars_t ));
|
||||
studio = (studiovars_t *)refent->extradata;
|
||||
|
||||
// copy controllers
|
||||
|
|
@ -2258,20 +2262,39 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
|
|||
studio->blending[i] = pRefEntity->v.blending[i];
|
||||
}
|
||||
|
||||
if( !studio->bonestransform || studio->numbones != numbones )
|
||||
if( studio->numbones != numbones )
|
||||
{
|
||||
size_t cache_size = sizeof( matrix4x4 ) * numbones;
|
||||
size_t names_size = numbones * 32; // bonename length
|
||||
|
||||
// allocate or merge bones cache
|
||||
studio->bonestransform = (matrix4x4 *)Mem_Realloc( studiopool, studio->bonestransform, cache_size );
|
||||
studio->numbones = numbones;
|
||||
studio->bonestransform = (matrix4x4 *)Mem_Realloc( refent->mempool, studio->bonestransform, cache_size );
|
||||
}
|
||||
|
||||
if( hasChrome )
|
||||
{
|
||||
if( studio->numbones != numbones || !studio->chromeage || !studio->chromeright || !studio->chromeup )
|
||||
{
|
||||
// allocate or merge chrome cache
|
||||
studio->chromeage = (int *)Mem_Realloc( refent->mempool, studio->chromeage, numbones * sizeof( int ));
|
||||
studio->chromeright = (vec3_t *)Mem_Realloc( refent->mempool, studio->chromeright, numbones * sizeof( vec3_t ));
|
||||
studio->chromeup = (vec3_t *)Mem_Realloc( refent->mempool, studio->chromeup, numbones * sizeof( vec3_t ));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if( studio->chromeage ) Mem_Free( studio->chromeage );
|
||||
if( studio->chromeright ) Mem_Free( studio->chromeright );
|
||||
if( studio->chromeup ) Mem_Free( studio->chromeup );
|
||||
studio->chromeright = studio->chromeup = NULL;
|
||||
studio->chromeage = NULL;
|
||||
}
|
||||
studio->numbones = numbones;
|
||||
|
||||
if( r_studio_bonelighting->integer )
|
||||
{
|
||||
if( !studio->light )
|
||||
studio->light = Mem_Alloc( studiopool, sizeof( studiolight_t ));
|
||||
studio->light = Mem_Alloc( refent->mempool, sizeof( studiolight_t ));
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -2282,23 +2305,7 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
|
|||
else
|
||||
{
|
||||
// entity has changed model, so no reason to keep this data
|
||||
if( refent->extradata )
|
||||
{
|
||||
studiovars_t *studio = (studiovars_t *)refent->extradata;
|
||||
|
||||
if( studio->bonestransform ) Mem_Free( studio->bonestransform );
|
||||
if( studio->light ) Mem_Free( studio->light );
|
||||
for( i = 0; i < studio->num_models; i++ )
|
||||
{
|
||||
if( studio->mesh[i] )
|
||||
{
|
||||
if( studio->mesh[i]->verts ) Mem_Free( studio->mesh[i]->verts );
|
||||
if( studio->mesh[i]->norms ) Mem_Free( studio->mesh[i]->norms );
|
||||
Mem_Free( studio->mesh[i] );
|
||||
}
|
||||
}
|
||||
Mem_Free( refent->extradata );
|
||||
}
|
||||
if( refent->extradata ) Mem_EmptyPool( refent->mempool );
|
||||
refent->extradata = NULL;
|
||||
}
|
||||
|
||||
|
|
@ -2394,6 +2401,7 @@ bool R_AddEntityToScene( edict_t *pRefEntity, int ed_type, float lerpfrac )
|
|||
refent->model = cl_models[pRefEntity->v.modelindex];
|
||||
refent->movetype = pRefEntity->v.movetype;
|
||||
refent->framerate = pRefEntity->v.framerate;
|
||||
refent->parent = NULL;
|
||||
|
||||
// setup rtype
|
||||
switch( ed_type )
|
||||
|
|
@ -2405,10 +2413,23 @@ bool R_AddEntityToScene( edict_t *pRefEntity, int ed_type, float lerpfrac )
|
|||
result = R_AddGenericEntity( pRefEntity, refent, ed_type, lerpfrac );
|
||||
break;
|
||||
}
|
||||
|
||||
// add entity
|
||||
r_numEntities++;
|
||||
|
||||
// never adding child entity without parent
|
||||
if( result && pRefEntity->v.weaponmodel && (refent->renderfx != kRenderFxDeadPlayer))
|
||||
{
|
||||
edict_t FollowEntity = *pRefEntity;
|
||||
|
||||
// create attached entity
|
||||
FollowEntity.v.modelindex = pRefEntity->v.weaponmodel;
|
||||
FollowEntity.serialnumber = WMODEL_ENTINDEX;
|
||||
FollowEntity.v.movetype = MOVETYPE_FOLLOW;
|
||||
FollowEntity.v.weaponmodel = 0;
|
||||
|
||||
if( R_AddEntityToScene( &FollowEntity, ED_NORMAL, lerpfrac ))
|
||||
r_entities[r_numEntities-1].parent = refent; // set parent
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -86,15 +86,15 @@ mark0:
|
|||
if( R_MBCmp( meshes[Ri], meshes[Li] ) )
|
||||
R_MBCopy( meshes[Li], median );
|
||||
}
|
||||
else if( R_MBCmp( median, meshes[Ri] ) )
|
||||
else if( R_MBCmp( median, meshes[Ri] ))
|
||||
{
|
||||
R_MBCopy( meshes[Ri], median );
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
while( R_MBCmp( median, meshes[li] ) ) li++;
|
||||
while( R_MBCmp( meshes[ri], median ) ) ri--;
|
||||
while( R_MBCmp( median, meshes[li] )) li++;
|
||||
while( R_MBCmp( meshes[ri], median )) ri--;
|
||||
|
||||
if( li <= ri )
|
||||
{
|
||||
|
|
@ -105,10 +105,9 @@ mark0:
|
|||
li++;
|
||||
ri--;
|
||||
}
|
||||
}
|
||||
while( li < ri );
|
||||
} while( li < ri );
|
||||
|
||||
if( ( Li < ri ) && ( stackdepth < QSORT_MAX_STACKDEPTH ) )
|
||||
if( ( Li < ri ) && ( stackdepth < QSORT_MAX_STACKDEPTH ))
|
||||
{
|
||||
lstack[stackdepth] = li;
|
||||
rstack[stackdepth] = Ri;
|
||||
|
|
@ -137,7 +136,7 @@ mark0:
|
|||
R_MBCopy( meshes[li], tempbuf );
|
||||
ri = li - 1;
|
||||
|
||||
while( ( ri >= 0 ) && ( R_MBCmp( meshes[ri], tempbuf ) ) )
|
||||
while(( ri >= 0 ) && ( R_MBCmp( meshes[ri], tempbuf )))
|
||||
{
|
||||
R_MBCopy( meshes[ri], meshes[ri+1] );
|
||||
ri--;
|
||||
|
|
@ -156,15 +155,15 @@ Insertion sort
|
|||
*/
|
||||
static void R_ISortMeshBuffers( meshbuffer_t *meshes, int num_meshes )
|
||||
{
|
||||
int i, j;
|
||||
meshbuffer_t tempbuf;
|
||||
int i, j;
|
||||
meshbuffer_t tempbuf;
|
||||
|
||||
for( i = 1; i < num_meshes; i++ )
|
||||
{
|
||||
R_MBCopy( meshes[i], tempbuf );
|
||||
j = i - 1;
|
||||
|
||||
while( ( j >= 0 ) && ( R_MBCmp( meshes[j], tempbuf ) ) )
|
||||
while(( j >= 0 ) && ( R_MBCmp( meshes[j], tempbuf )))
|
||||
{
|
||||
R_MBCopy( meshes[j], meshes[j+1] );
|
||||
j--;
|
||||
|
|
@ -350,11 +349,10 @@ meshbuffer_t *R_AddMeshToList( int type, mfog_t *fog, ref_shader_t *shader, int
|
|||
|
||||
if( shader->flags & SHADER_PORTAL )
|
||||
{
|
||||
if( RI.params & ( RP_MIRRORVIEW|RP_PORTALVIEW|RP_SKYPORTALVIEW ) )
|
||||
if( RI.params & ( RP_MIRRORVIEW|RP_PORTALVIEW|RP_SKYPORTALVIEW ))
|
||||
return NULL;
|
||||
RI.meshlist->num_portal_translucent_meshes++;
|
||||
}
|
||||
|
||||
meshbuf = &list->meshbuffer_translucent[list->num_translucent_meshes++];
|
||||
}
|
||||
else
|
||||
|
|
@ -368,7 +366,6 @@ meshbuffer_t *R_AddMeshToList( int type, mfog_t *fog, ref_shader_t *shader, int
|
|||
return NULL;
|
||||
RI.meshlist->num_portal_opaque_meshes++;
|
||||
}
|
||||
|
||||
meshbuf = &list->meshbuffer_opaque[list->num_opaque_meshes++];
|
||||
}
|
||||
|
||||
|
|
@ -389,7 +386,7 @@ meshbuffer_t *R_AddMeshToList( int type, mfog_t *fog, ref_shader_t *shader, int
|
|||
R_AddMeshToList
|
||||
=================
|
||||
*/
|
||||
void R_AddModelMeshToList( unsigned int modhandle, mfog_t *fog, ref_shader_t *shader, int meshnum )
|
||||
void R_AddModelMeshToList( uint modhandle, mfog_t *fog, ref_shader_t *shader, int meshnum )
|
||||
{
|
||||
meshbuffer_t *mb;
|
||||
|
||||
|
|
@ -1041,8 +1038,8 @@ static bool R_DrawPortalSurface( void )
|
|||
|
||||
setup_and_render:
|
||||
RI.previousentity = NULL;
|
||||
memcpy( &oldRI, &prevRI, sizeof( refinst_t ) );
|
||||
memcpy( &prevRI, &RI, sizeof( refinst_t ) );
|
||||
Mem_Copy( &oldRI, &prevRI, sizeof( refinst_t ) );
|
||||
Mem_Copy( &prevRI, &RI, sizeof( refinst_t ) );
|
||||
|
||||
if( refraction )
|
||||
{
|
||||
|
|
@ -1156,8 +1153,8 @@ setup_and_render:
|
|||
|
||||
r_portalSurfMbuffers = RI.surfmbuffers;
|
||||
|
||||
memcpy( &RI, &prevRI, sizeof( refinst_t ) );
|
||||
memcpy( &prevRI, &oldRI, sizeof( refinst_t ) );
|
||||
Mem_Copy( &RI, &prevRI, sizeof( refinst_t ) );
|
||||
Mem_Copy( &prevRI, &oldRI, sizeof( refinst_t ) );
|
||||
|
||||
if( captureTexture )
|
||||
{
|
||||
|
|
@ -1198,8 +1195,8 @@ void R_DrawSkyPortal( skyportal_t *skyportal, vec3_t mins, vec3_t maxs )
|
|||
return;
|
||||
|
||||
RI.previousentity = NULL;
|
||||
memcpy( &oldRI, &prevRI, sizeof( refinst_t ) );
|
||||
memcpy( &prevRI, &RI, sizeof( refinst_t ) );
|
||||
Mem_Copy( &oldRI, &prevRI, sizeof( refinst_t ) );
|
||||
Mem_Copy( &prevRI, &RI, sizeof( refinst_t ) );
|
||||
|
||||
RI.params = ( RI.params|RP_SKYPORTALVIEW ) & ~( RP_OLDVIEWCLUSTER|RP_PORTALCAPTURED|RP_PORTALCAPTURED2 );
|
||||
VectorCopy( skyportal->vieworg, RI.pvsOrigin );
|
||||
|
|
@ -1241,8 +1238,8 @@ void R_DrawSkyPortal( skyportal_t *skyportal, vec3_t mins, vec3_t maxs )
|
|||
r_skyPortalSurfMbuffers = RI.surfmbuffers;
|
||||
r_oldviewcluster = r_viewcluster = -1; // force markleafs next frame
|
||||
|
||||
memcpy( &RI, &prevRI, sizeof( refinst_t ) );
|
||||
memcpy( &prevRI, &oldRI, sizeof( refinst_t ) );
|
||||
Mem_Copy( &RI, &prevRI, sizeof( refinst_t ) );
|
||||
Mem_Copy( &prevRI, &oldRI, sizeof( refinst_t ) );
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ mleaf_t *Mod_PointInLeaf( vec3_t p, ref_model_t *model )
|
|||
}
|
||||
while( node->plane != NULL );
|
||||
|
||||
return ( mleaf_t * )node;
|
||||
return (mleaf_t *)node;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1017,23 +1017,23 @@ static mesh_t *Mod_CreateMeshForSurface( const dsurfacer_t *in, msurface_t *out
|
|||
mesh->normalsArray = ( vec4_t * )buffer; buffer += numVerts * sizeof( vec4_t );
|
||||
mesh->stArray = ( vec2_t * )buffer; buffer += numVerts * sizeof( vec2_t );
|
||||
|
||||
memcpy( mesh->xyzArray, loadmodel_xyz_array + firstVert, numVerts * sizeof( vec4_t ) );
|
||||
memcpy( mesh->normalsArray, loadmodel_normals_array + firstVert, numVerts * sizeof( vec4_t ) );
|
||||
memcpy( mesh->stArray, loadmodel_st_array + firstVert, numVerts * sizeof( vec2_t ) );
|
||||
Mem_Copy( mesh->xyzArray, loadmodel_xyz_array + firstVert, numVerts * sizeof( vec4_t ) );
|
||||
Mem_Copy( mesh->normalsArray, loadmodel_normals_array + firstVert, numVerts * sizeof( vec4_t ) );
|
||||
Mem_Copy( mesh->stArray, loadmodel_st_array + firstVert, numVerts * sizeof( vec2_t ) );
|
||||
|
||||
for( j = 0; j < LM_STYLES && in->lightmapStyles[j] != 255; j++ )
|
||||
{
|
||||
mesh->lmstArray[j] = ( vec2_t * )buffer; buffer += numVerts * sizeof( vec2_t );
|
||||
memcpy( mesh->lmstArray[j], loadmodel_lmst_array[j] + firstVert, numVerts * sizeof( vec2_t ) );
|
||||
Mem_Copy( mesh->lmstArray[j], loadmodel_lmst_array[j] + firstVert, numVerts * sizeof( vec2_t ) );
|
||||
}
|
||||
for( j = 0; j < LM_STYLES && in->vertexStyles[j] != 255; j++ )
|
||||
{
|
||||
mesh->colorsArray[j] = ( rgba_t * )buffer; buffer += numVerts * sizeof( rgba_t );
|
||||
memcpy( mesh->colorsArray[j], loadmodel_colors_array[j] + firstVert, numVerts * sizeof( rgba_t ) );
|
||||
Mem_Copy( mesh->colorsArray[j], loadmodel_colors_array[j] + firstVert, numVerts * sizeof( rgba_t ) );
|
||||
}
|
||||
|
||||
mesh->elems = ( elem_t * )buffer; buffer += numElems * sizeof( elem_t );
|
||||
memcpy( mesh->elems, loadmodel_surfelems + firstElem, numElems * sizeof( elem_t ) );
|
||||
Mem_Copy( mesh->elems, loadmodel_surfelems + firstElem, numElems * sizeof( elem_t ) );
|
||||
|
||||
if( createSTverts )
|
||||
{
|
||||
|
|
@ -1628,7 +1628,7 @@ static void Mod_LoadLightgrid_RBSP( const lump_t *l )
|
|||
loadbmodel->numlightgridelems = count;
|
||||
|
||||
// lightgrid is all 8 bit
|
||||
memcpy( out, in, count*sizeof( *out ) );
|
||||
Mem_Copy( out, in, count*sizeof( *out ) );
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -50,7 +50,6 @@ cvar_t *r_coronascale;
|
|||
cvar_t *r_detailtextures;
|
||||
cvar_t *r_subdivisions;
|
||||
cvar_t *r_faceplanecull;
|
||||
cvar_t *r_minimap;
|
||||
cvar_t *r_showtris;
|
||||
cvar_t *r_shownormals;
|
||||
cvar_t *r_showtextures;
|
||||
|
|
@ -550,7 +549,6 @@ void GL_InitCommands( void )
|
|||
r_shownormals = Cvar_Get( "r_shownormals", "0", CVAR_CHEAT, "show mesh normals" );
|
||||
r_showtextures = Cvar_Get("r_showtextures", "0", CVAR_CHEAT, "show all uploaded textures" );
|
||||
r_draworder = Cvar_Get( "r_draworder", "0", CVAR_CHEAT, "ignore mesh sorting" );
|
||||
r_minimap = Cvar_Get( "r_minimap", "0", CVAR_ARCHIVE, "draw minimap at right bottom corner of screen" );
|
||||
|
||||
r_fastsky = Cvar_Get( "r_fastsky", "0", CVAR_ARCHIVE, "enable algorhytem fo fast sky rendering (for old machines)" );
|
||||
r_portalonly = Cvar_Get( "r_portalonly", "0", 0, "render only portals" );
|
||||
|
|
|
|||
|
|
@ -413,8 +413,8 @@ void R_DrawShadowmaps( void )
|
|||
height = r_lastRefdef.viewport[3];
|
||||
|
||||
RI.previousentity = NULL;
|
||||
memcpy( &oldRI, &prevRI, sizeof( refinst_t ) );
|
||||
memcpy( &prevRI, &RI, sizeof( refinst_t ) );
|
||||
Mem_Copy( &oldRI, &prevRI, sizeof( refinst_t ) );
|
||||
Mem_Copy( &prevRI, &RI, sizeof( refinst_t ) );
|
||||
RI.refdef.rdflags &= ~RDF_SKYPORTALINVIEW;
|
||||
lod_scale = tan( RI.refdef.fov_x * ( M_PI/180 ) * 0.5f );
|
||||
|
||||
|
|
@ -493,8 +493,8 @@ void R_DrawShadowmaps( void )
|
|||
}
|
||||
|
||||
oldRI.shadowBits |= prevRI.shadowBits; // set shadowBits for all RI's so that we won't
|
||||
memcpy( &RI, &prevRI, sizeof( refinst_t ) );
|
||||
memcpy( &prevRI, &oldRI, sizeof( refinst_t ) );
|
||||
Mem_Copy( &RI, &prevRI, sizeof( refinst_t ));
|
||||
Mem_Copy( &prevRI, &oldRI, sizeof( refinst_t ));
|
||||
}
|
||||
|
||||
//==================================================================================
|
||||
|
|
|
|||
|
|
@ -18,22 +18,17 @@
|
|||
*/
|
||||
matrix4x4 m_protationmatrix;
|
||||
matrix4x4 *m_pbonestransform;
|
||||
matrix4x4 m_rgCachedBonesTransform[MAXSTUDIOBONES]; // stack for merged bones
|
||||
|
||||
// lighting stuff
|
||||
vec3_t *m_pxformverts;
|
||||
vec3_t *m_pxformnorms;
|
||||
vec3_t *m_pvlightvalues;
|
||||
vec3_t g_lightvalues[MAXSTUDIOVERTS];
|
||||
vec3_t g_xformverts[MAXSTUDIOMODELS][MAXSTUDIOVERTS]; // cache for current rendering model
|
||||
vec3_t g_xformnorms[MAXSTUDIOMODELS][MAXSTUDIOVERTS]; // cache for current rendering model
|
||||
bool g_cachestate[MAXSTUDIOMODELS]; // true if vertices already transformed
|
||||
vec3_t *m_pxformlight;
|
||||
|
||||
// chrome stuff
|
||||
float g_chrome[MAXSTUDIOVERTS][2]; // texture coords for surface normals
|
||||
int g_chromeage[MAXSTUDIOBONES]; // last time chrome vectors were updated
|
||||
vec3_t g_chromeup[MAXSTUDIOBONES]; // chrome vector "up" in bone reference frames
|
||||
vec3_t g_chromeright[MAXSTUDIOBONES]; // chrome vector "right" in bone reference frames
|
||||
vec2_t *m_pchrome;
|
||||
int *m_pchromeage;
|
||||
vec3_t *m_pchromeup;
|
||||
vec3_t *m_pchromeright;
|
||||
|
||||
// player gait sequence stuff
|
||||
int m_fGaitEstimation;
|
||||
|
|
@ -41,15 +36,10 @@ float m_flGaitMovement;
|
|||
|
||||
// misc variables
|
||||
int m_fDoInterp;
|
||||
int m_pStudioModelCount;
|
||||
int m_nTopColor; // palette substition for top and bottom of model
|
||||
int m_nBottomColor;
|
||||
dstudiomodel_t *m_pSubModel;
|
||||
dstudiobodyparts_t *m_pBodyPart;
|
||||
dstudiohdr_t *m_pStudioHeader;
|
||||
dstudiohdr_t *m_pTextureHeader;
|
||||
dstudiobodyparts_t *m_pBodyPart;
|
||||
static mesh_t studio_mesh;
|
||||
byte *studiopool; // uses for store boneposes
|
||||
vec3_t studio_mins, studio_maxs;
|
||||
float studio_radius;
|
||||
|
||||
|
|
@ -66,16 +56,21 @@ R_StudioInit
|
|||
*/
|
||||
void R_StudioInit( void )
|
||||
{
|
||||
int i;
|
||||
|
||||
m_pBodyPart = NULL;
|
||||
m_pStudioHeader = NULL;
|
||||
m_flGaitMovement = 1;
|
||||
m_pStudioModelCount = 0;
|
||||
|
||||
r_studio_bonelighting = Cvar_Get( "r_studio_bonelighting", "0", CVAR_ARCHIVE, "use bonelighting instead of vertex diffuse lighting on studio models" );
|
||||
r_studio_lambert = Cvar_Get( "r_studio_lambert", "2", CVAR_ARCHIVE, "bonelighting lambert value" );
|
||||
r_studio_lerping = Cvar_Get( "r_studio_lerping", "1", CVAR_ARCHIVE, "enables studio model animation lerping" );
|
||||
|
||||
studiopool = Mem_AllocPool( "Studio Extradata" );
|
||||
for( i = 1; i < MAX_ENTITIES; i++ )
|
||||
{
|
||||
r_entities[i].mempool = NULL;
|
||||
r_entities[i].extradata = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void R_StudioNewMap( void )
|
||||
|
|
@ -83,13 +78,15 @@ void R_StudioNewMap( void )
|
|||
int i;
|
||||
|
||||
for( i = 1; i < MAX_ENTITIES; i++ )
|
||||
{
|
||||
Mem_FreePool( &r_entities[i].mempool );
|
||||
r_entities[i].extradata = NULL;
|
||||
Mem_EmptyPool( studiopool );
|
||||
}
|
||||
}
|
||||
|
||||
void R_StudioShutdown( void )
|
||||
{
|
||||
Mem_FreePool( &studiopool );
|
||||
R_StudioNewMap ();
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -111,14 +108,16 @@ static void R_StudioSetupRender( ref_entity_t *e, ref_model_t *mod )
|
|||
m_pStudioHeader = m_pRefModel->phdr;
|
||||
m_pTextureHeader = m_pRefModel->thdr;
|
||||
|
||||
// set intermediate vertex buffers
|
||||
m_pvlightvalues = &g_lightvalues[0];
|
||||
|
||||
Com_Assert( e->extradata == NULL );
|
||||
|
||||
// set cached bones
|
||||
m_pbonestransform = ((studiovars_t *)e->extradata)->bonestransform;
|
||||
|
||||
// set chrome bones
|
||||
m_pchromeup = ((studiovars_t *)e->extradata)->chromeup;
|
||||
m_pchromeage = ((studiovars_t *)e->extradata)->chromeage;
|
||||
m_pchromeright = ((studiovars_t *)e->extradata)->chromeright;
|
||||
|
||||
// misc info
|
||||
if( r_studio_lerping->integer )
|
||||
m_fDoInterp = (e->flags & EF_NOINTERP) ? false : true;
|
||||
|
|
@ -205,6 +204,7 @@ dstudiohdr_t *R_StudioLoadHeader( ref_model_t *mod, const uint *buffer )
|
|||
if( ptexture[i].flags & (STUDIO_NF_NORMALMAP|STUDIO_NF_BUMPMAP|STUDIO_NF_GLOSSMAP|STUDIO_NF_DECALMAP))
|
||||
continue; // doesn't produce dead shaders - this will be handled in other place
|
||||
R_StudioSurfaceParm( &ptexture[i] );
|
||||
if( ptexture[i].flags & STUDIO_NF_CHROME ) phdr->flags |= STUDIO_HAS_CHROME;
|
||||
com.snprintf( shadername, MAX_STRING, "%s/%s", mod->name, ptexture[i].name );
|
||||
FS_StripExtension( shadername ); // doesn't produce shaders with .ext
|
||||
mod->shaders[i] = R_LoadShader( shadername, SHADER_STUDIO, 0, 0, SHADER_INVALID );
|
||||
|
|
@ -228,7 +228,7 @@ void Mod_StudioLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buf
|
|||
|
||||
if( phdr->numtextures == 0 )
|
||||
{
|
||||
texbuf = FS_LoadFile( R_ExtName( mod ), NULL ); // use buffer again
|
||||
texbuf = FS_LoadFile( R_ExtName( mod ), NULL );
|
||||
if( texbuf ) thdr = R_StudioLoadHeader( mod, texbuf );
|
||||
else MsgDev( D_ERROR, "textures for %s not found!\n", mod->name );
|
||||
|
||||
|
|
@ -238,6 +238,7 @@ void Mod_StudioLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buf
|
|||
if( texbuf ) Mem_Free( texbuf );
|
||||
}
|
||||
else poutmodel->thdr = poutmodel->phdr; // just make link
|
||||
poutmodel->phdr->flags |= poutmodel->thdr->flags; // copy STUDIO_HAS_CHROME flag
|
||||
|
||||
R_StudioExtractBbox( phdr, 0, mod->mins, mod->maxs );
|
||||
mod->radius = RadiusFromBounds( mod->mins, mod->maxs );
|
||||
|
|
@ -283,21 +284,6 @@ int R_StudioGetBodygroup( int iGroup )
|
|||
return (RI.currententity->body / m_pBodyPart->base) % m_pBodyPart->nummodels;
|
||||
}
|
||||
|
||||
void R_StudioAddEntityToRadar( ref_entity_t *e )
|
||||
{
|
||||
if( r_minimap->integer < 2 ) return;
|
||||
|
||||
if( numRadarEnts >= MAX_RADAR_ENTS ) return;
|
||||
if( e->ent_type == ED_VIEWMODEL ) return;
|
||||
|
||||
if( e->ent_type == ED_MONSTER )
|
||||
Vector4Set( RadarEnts[numRadarEnts].color, 255, 0, 128, 255 );
|
||||
else Vector4Set( RadarEnts[numRadarEnts].color, 0, 255, 255, 128 );
|
||||
VectorCopy( e->origin, RadarEnts[numRadarEnts].origin );
|
||||
VectorCopy( e->angles, RadarEnts[numRadarEnts].angles );
|
||||
numRadarEnts++;
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
R_StudioGetSequenceInfo
|
||||
|
|
@ -740,8 +726,15 @@ StudioSetUpTransform
|
|||
void R_StudioSetUpTransform( ref_entity_t *e )
|
||||
{
|
||||
int i;
|
||||
vec3_t angles;
|
||||
vec3_t angles, origin;
|
||||
|
||||
if( RP_FOLLOWENTITY( e ))
|
||||
{
|
||||
Matrix4x4_LoadIdentity( m_protationmatrix );
|
||||
return;
|
||||
}
|
||||
|
||||
VectorCopy( e->origin, origin );
|
||||
VectorCopy( e->angles, angles );
|
||||
|
||||
// TODO: should really be stored with the entity instead of being reconstructed
|
||||
|
|
@ -763,6 +756,9 @@ void R_StudioSetUpTransform( ref_entity_t *e )
|
|||
if( m_fDoInterp ) f = 1.0 - e->backlerp;
|
||||
else f = 0;
|
||||
|
||||
for( i = 0; i < 3; i++ )
|
||||
origin[i] += (e->origin[i] - e->prev.origin[i]) * f;
|
||||
|
||||
for( i = 0; i < 3; i++ )
|
||||
{
|
||||
float ang1, ang2;
|
||||
|
|
@ -782,7 +778,14 @@ void R_StudioSetUpTransform( ref_entity_t *e )
|
|||
angles[PITCH] = 0;
|
||||
}
|
||||
|
||||
Matrix4x4_CreateFromEntity( m_protationmatrix, 0.0f, 0.0f, 0.0f, angles[PITCH], angles[YAW], angles[ROLL], e->scale );
|
||||
Matrix4x4_CreateFromEntity( m_protationmatrix, origin[0], origin[1], origin[2], angles[PITCH], angles[YAW], angles[ROLL], e->scale );
|
||||
|
||||
if( r_lefthand->integer == 1 )
|
||||
{
|
||||
m_protationmatrix[0][1] = -m_protationmatrix[0][1];
|
||||
m_protationmatrix[1][1] = -m_protationmatrix[1][1];
|
||||
m_protationmatrix[2][1] = -m_protationmatrix[2][1];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -866,33 +869,6 @@ void R_StudioCalcRotations( float pos[][3], vec4_t *q, dstudioseqdesc_t *pseqdes
|
|||
if( pseqdesc->motiontype & STUDIO_LZ ) pos[pseqdesc->motionbone][2] += s * pseqdesc->linearmovement[2];
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
Studio_FxTransform
|
||||
|
||||
====================
|
||||
*/
|
||||
void R_StudioFxTransform( ref_entity_t *ent, matrix4x4 transform )
|
||||
{
|
||||
if( ent->renderfx == kRenderFxHologram )
|
||||
{
|
||||
if(!Com_RandomLong( 0, 49 ))
|
||||
{
|
||||
int axis = Com_RandomLong( 0, 1 );
|
||||
if( axis == 1 ) axis = 2; // choose between x & z
|
||||
VectorScale( transform[axis], Com_RandomFloat( 1, 1.484 ), transform[axis] );
|
||||
}
|
||||
else if(!Com_RandomLong( 0, 49 ))
|
||||
{
|
||||
float offset;
|
||||
int axis = Com_RandomLong( 0, 1 );
|
||||
if( axis == 1 ) axis = 2; // choose between x & z
|
||||
offset = Com_RandomFloat( -10, 10 );
|
||||
transform[Com_RandomLong( 0, 2 )][3] += offset;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
StudioEstimateFrame
|
||||
|
|
@ -947,6 +923,7 @@ float R_StudioSetupBones( ref_entity_t *e )
|
|||
static float pos[MAXSTUDIOBONES][3];
|
||||
static vec4_t q[MAXSTUDIOBONES];
|
||||
matrix4x4 bonematrix;
|
||||
edict_t *cl_entity;
|
||||
|
||||
static float pos2[MAXSTUDIOBONES][3];
|
||||
static vec4_t q2[MAXSTUDIOBONES];
|
||||
|
|
@ -959,6 +936,7 @@ float R_StudioSetupBones( ref_entity_t *e )
|
|||
if( e->m_nCachedFrameCount == r_framecount )
|
||||
return 0.0f;
|
||||
|
||||
cl_entity = ri.GetClientEdict( e->index );
|
||||
if( e->sequence >= m_pStudioHeader->numseq ) e->sequence = 0;
|
||||
pseqdesc = (dstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + e->sequence;
|
||||
|
||||
|
|
@ -1077,8 +1055,7 @@ float R_StudioSetupBones( ref_entity_t *e )
|
|||
Matrix4x4_ConcatTransforms( m_pbonestransform[i], m_protationmatrix, bonematrix );
|
||||
|
||||
// apply client-side effects to the transformation matrix
|
||||
// FIXME: move to client.dll
|
||||
R_StudioFxTransform( RI.currententity, m_pbonestransform[i] );
|
||||
if( cl_entity ) ri.StudioFxTransform( cl_entity, m_pbonestransform[i] );
|
||||
}
|
||||
else Matrix4x4_ConcatTransforms( m_pbonestransform[i], m_pbonestransform[pbones[i].parent], bonematrix );
|
||||
}
|
||||
|
|
@ -1100,20 +1077,6 @@ static void R_StudioSaveBones( ref_entity_t *e )
|
|||
com.strncpy( ((studiovars_t *)e->extradata)->bonenames[i], pbones[i].name, 32 );
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
StudioRestoreBones
|
||||
|
||||
====================
|
||||
*/
|
||||
static void R_StudioRestoreBones( ref_entity_t *e )
|
||||
{
|
||||
studiovars_t *pstudio = ((studiovars_t *)e->extradata);
|
||||
|
||||
Mem_Copy( m_rgCachedBonesTransform, pstudio->bonestransform, sizeof( matrix4x4 ) * pstudio->numbones );
|
||||
m_pbonestransform = m_rgCachedBonesTransform; // MergeBones can't modify pstudio->bonestransform
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
StudioMergeBones
|
||||
|
|
@ -1124,7 +1087,6 @@ float R_StudioMergeBones( ref_entity_t *e, ref_model_t *m_pSubModel )
|
|||
{
|
||||
int i, j;
|
||||
double f;
|
||||
int do_hunt = true;
|
||||
int sequence = e->sequence;
|
||||
dstudiobone_t *pbones;
|
||||
dstudioseqdesc_t *pseqdesc;
|
||||
|
|
@ -1133,22 +1095,26 @@ float R_StudioMergeBones( ref_entity_t *e, ref_model_t *m_pSubModel )
|
|||
matrix4x4 bonematrix;
|
||||
static vec4_t q[MAXSTUDIOBONES];
|
||||
static float pos[MAXSTUDIOBONES][3];
|
||||
static matrix4x4 localbones[MAXSTUDIOBONES];
|
||||
edict_t *cl_entity;
|
||||
|
||||
Com_Assert( e->parent == NULL );
|
||||
cl_entity = ri.GetClientEdict( e->parent->index );
|
||||
pstudio = ((studiovars_t *)e->extradata);
|
||||
|
||||
Com_Assert( pstudio == NULL );
|
||||
Mem_Copy( localbones, pstudio->bonestransform, sizeof( matrix4x4 ) * pstudio->numbones );
|
||||
|
||||
pstudio = ((studiovars_t *)e->parent->extradata);
|
||||
|
||||
// weaponmodel can't change e->sequence!
|
||||
if( sequence >= m_pStudioHeader->numseq ) sequence = 0;
|
||||
pseqdesc = (dstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + sequence;
|
||||
pstudio = e->extradata;
|
||||
|
||||
Com_Assert( pstudio == NULL );
|
||||
|
||||
f = R_StudioEstimateFrame( pseqdesc );
|
||||
|
||||
if( e->prev.frame > f )
|
||||
{
|
||||
// Msg("%f %f\n", e->prev.frame, f );
|
||||
}
|
||||
// if( e->prev.frame > f ) Msg("%f %f\n", e->prev.frame, f );
|
||||
|
||||
R_StudioRestoreBones( e );
|
||||
panim = R_StudioGetAnim( m_pSubModel, pseqdesc );
|
||||
R_StudioCalcRotations( pos, q, pseqdesc, panim, f );
|
||||
pbones = (dstudiobone_t *)((byte *)m_pStudioHeader + m_pStudioHeader->boneindex);
|
||||
|
|
@ -1159,7 +1125,7 @@ float R_StudioMergeBones( ref_entity_t *e, ref_model_t *m_pSubModel )
|
|||
{
|
||||
if( !com.stricmp( pbones[i].name, pstudio->bonenames[j] ))
|
||||
{
|
||||
Matrix4x4_Copy( m_pbonestransform[i], pstudio->bonestransform[j] );
|
||||
Matrix4x4_Copy( localbones[i], pstudio->bonestransform[j] );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1168,15 +1134,21 @@ float R_StudioMergeBones( ref_entity_t *e, ref_model_t *m_pSubModel )
|
|||
Matrix4x4_FromOriginQuat( bonematrix, pos[i][0], pos[i][1], pos[i][2], q[i][0], q[i][1], q[i][2], q[i][3] );
|
||||
if( pbones[i].parent == -1 )
|
||||
{
|
||||
Matrix4x4_ConcatTransforms( m_pbonestransform[i], m_protationmatrix, bonematrix );
|
||||
Matrix4x4_ConcatTransforms( localbones[i], m_protationmatrix, bonematrix );
|
||||
|
||||
// apply client-side effects to the transformation matrix
|
||||
// FIXME: move to client.dll
|
||||
R_StudioFxTransform( RI.currententity, m_pbonestransform[i] );
|
||||
if( cl_entity ) ri.StudioFxTransform( cl_entity, m_pbonestransform[i] );
|
||||
}
|
||||
else Matrix4x4_ConcatTransforms( m_pbonestransform[i], m_pbonestransform[pbones[i].parent], bonematrix );
|
||||
else Matrix4x4_ConcatTransforms( localbones[i], m_pbonestransform[pbones[i].parent], bonematrix );
|
||||
}
|
||||
}
|
||||
|
||||
pstudio = ((studiovars_t *)e->extradata);
|
||||
Com_Assert( pstudio == NULL );
|
||||
|
||||
// copy bones back to the merged entity
|
||||
Mem_Copy( pstudio->bonestransform, localbones, sizeof( matrix4x4 ) * m_pStudioHeader->numbones );
|
||||
|
||||
return (float)f;
|
||||
}
|
||||
|
||||
|
|
@ -1247,6 +1219,7 @@ bool R_StudioComputeBBox( vec3_t bbox[8] )
|
|||
bbox[i][0] = DotProduct( vectors[0], tmp );
|
||||
bbox[i][1] = DotProduct( vectors[1], tmp );
|
||||
bbox[i][2] = DotProduct( vectors[2], tmp );
|
||||
VectorAdd( e->origin, bbox[i], bbox[i] );
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
@ -1286,7 +1259,7 @@ void R_StudioSetupLighting( ref_entity_t *e, ref_model_t *mod )
|
|||
R_LightForOrigin( e->lightingOrigin, plight->lightvec, plight->lightcolor, plight->lightdiffuse, 0 );
|
||||
|
||||
for( i = 0; i < m_pStudioHeader->numbones; i++ )
|
||||
Matrix4x4_VectorRotate( m_pbonestransform[i], plight->lightvec, plight->bonelightvec[i] );
|
||||
Matrix4x4_VectorIRotate( m_pbonestransform[i], plight->lightvec, plight->bonelightvec[i] );
|
||||
|
||||
plight->numdynlights = 0;
|
||||
|
||||
|
|
@ -1330,7 +1303,7 @@ void R_StudioSetupLighting( ref_entity_t *e, ref_model_t *mod )
|
|||
VectorScale( vec, dist, vec );
|
||||
}
|
||||
|
||||
Matrix4x4_VectorRotate( m_pbonestransform[i], vec, plight->dynlightvec[plight->numdynlights][i] );
|
||||
Matrix4x4_VectorIRotate( m_pbonestransform[i], vec, plight->dynlightvec[plight->numdynlights][i] );
|
||||
VectorScale( plight->dynlightvec[plight->numdynlights][i], atten, plight->dynlightvec[plight->numdynlights][i] );
|
||||
}
|
||||
|
||||
|
|
@ -1346,8 +1319,6 @@ void R_StudioLighting( vec3_t lv, int bone, int flags, vec3_t normal )
|
|||
float lightcos;
|
||||
studiolight_t *plight;
|
||||
|
||||
if( !r_studio_bonelighting->integer ) return;
|
||||
|
||||
plight = ((studiovars_t *)RI.currententity->extradata)->light;
|
||||
Com_Assert( plight == NULL );
|
||||
|
||||
|
|
@ -1388,11 +1359,11 @@ void R_StudioLighting( vec3_t lv, int bone, int flags, vec3_t normal )
|
|||
VectorScale( illum, 255, lv );
|
||||
}
|
||||
|
||||
void R_StudioSetupChrome( float *pchrome, int bone, vec3_t normal )
|
||||
void R_StudioSetupChrome( float *pchrome, int modelnum, int bone, float *normal )
|
||||
{
|
||||
float n;
|
||||
|
||||
if( g_chromeage[bone] != m_pStudioModelCount )
|
||||
if( m_pchromeage[bone] != (r_framecount+modelnum))
|
||||
{
|
||||
// calculate vectors from the viewer to the bone. This roughly adjusts for position
|
||||
vec3_t chromeupvec; // g_chrome t vector in world reference frame
|
||||
|
|
@ -1409,17 +1380,17 @@ void R_StudioSetupChrome( float *pchrome, int bone, vec3_t normal )
|
|||
CrossProduct( tmp, chromeupvec, chromerightvec );
|
||||
VectorNormalize( chromerightvec );
|
||||
|
||||
Matrix4x4_VectorIRotate( m_pbonestransform[bone], chromeupvec, g_chromeup[bone] );
|
||||
Matrix4x4_VectorIRotate( m_pbonestransform[bone], chromerightvec, g_chromeright[bone] );
|
||||
g_chromeage[bone] = m_pStudioModelCount;
|
||||
Matrix4x4_VectorIRotate( m_pbonestransform[bone], chromeupvec, m_pchromeup[bone] );
|
||||
Matrix4x4_VectorIRotate( m_pbonestransform[bone], chromerightvec, m_pchromeright[bone] );
|
||||
m_pchromeage[bone] = (r_framecount+modelnum);
|
||||
}
|
||||
|
||||
// calc s coord
|
||||
n = DotProduct( normal, g_chromeright[bone] );
|
||||
n = DotProduct( normal, m_pchromeright[bone] );
|
||||
pchrome[0] = (n + 1.0) * 32.0f;
|
||||
|
||||
// calc t coord
|
||||
n = DotProduct( normal, g_chromeup[bone] );
|
||||
n = DotProduct( normal, m_pchromeup[bone] );
|
||||
pchrome[1] = (n + 1.0) * 32.0f;
|
||||
}
|
||||
|
||||
|
|
@ -1473,12 +1444,12 @@ void R_StudioDrawMesh( const meshbuffer_t *mb, short *ptricmds, float s, float t
|
|||
}
|
||||
|
||||
if( flags & STUDIO_NF_CHROME )
|
||||
Vector2Set( inCoordsArray[r_backacc.numVerts], g_chrome[ptricmds[1]][0] * s, g_chrome[ptricmds[1]][1] * t );
|
||||
Vector2Set( inCoordsArray[r_backacc.numVerts], m_pchrome[ptricmds[1]][0] * s, m_pchrome[ptricmds[1]][1] * t );
|
||||
else Vector2Set( inCoordsArray[r_backacc.numVerts], ptricmds[2] * s, ptricmds[3] * t );
|
||||
|
||||
if( r_studio_bonelighting->integer )
|
||||
{
|
||||
lv = m_pvlightvalues[ptricmds[1]];
|
||||
lv = m_pxformlight[ptricmds[1]];
|
||||
Vector4Set( inColorsArray[0][r_backacc.numVerts], lv[0], lv[1], lv[2], 255 );
|
||||
}
|
||||
|
||||
|
|
@ -1497,8 +1468,8 @@ void R_StudioDrawMesh( const meshbuffer_t *mb, short *ptricmds, float s, float t
|
|||
if( features & MF_SVECTORS )
|
||||
R_BuildTangentVectors( r_backacc.numVerts, inVertsArray, inNormalsArray, inCoordsArray, r_backacc.numElems / 3, inElemsArray, inSVectorsArray );
|
||||
|
||||
R_LoadIdentity();
|
||||
r_features = features;
|
||||
R_TranslateForEntity( RI.currententity );
|
||||
R_RenderMeshBuffer( mb );
|
||||
}
|
||||
|
||||
|
|
@ -1721,20 +1692,31 @@ void R_StudioDrawDebug( void )
|
|||
if( RI.currententity->model->type != mod_studio )
|
||||
continue;
|
||||
|
||||
if( RP_LOCALCLIENT( RI.currententity ) && !RI.refdef.thirdperson )
|
||||
if( RP_LOCALCLIENT( RI.currententity ))
|
||||
{
|
||||
// ignore localcient in firstperson mode
|
||||
if( !RI.refdef.thirdperson && !( RI.params & ( RP_MIRRORVIEW|RP_SHADOWMAPVIEW )))
|
||||
continue;
|
||||
}
|
||||
|
||||
if( RP_FOLLOWENTITY( RI.currententity ) && RP_LOCALCLIENT( RI.currententity->parent ) && !RI.refdef.thirdperson )
|
||||
{
|
||||
// ignore entities that linked to localcient
|
||||
if(!( RI.params & ( RP_MIRRORVIEW|RP_SHADOWMAPVIEW )))
|
||||
continue;
|
||||
}
|
||||
|
||||
if( RI.currententity->ent_type == ED_VIEWMODEL )
|
||||
{
|
||||
if(( RI.params & ( RP_MIRRORVIEW|RP_SHADOWMAPVIEW )))
|
||||
if( RI.params & RP_NONVIEWERREF )
|
||||
continue;
|
||||
}
|
||||
|
||||
#if 0
|
||||
// this stuff doesn't working corretly with mirrors. disabled
|
||||
if( RI.currententity->m_nCachedFrameCount != r_framecount )
|
||||
continue; // culled
|
||||
#endif
|
||||
R_StudioSetupRender( RI.currententity, RI.currententity->model );
|
||||
R_TranslateForEntity( RI.currententity );
|
||||
|
||||
switch( r_drawentities->integer )
|
||||
{
|
||||
|
|
@ -1749,11 +1731,6 @@ void R_StudioDrawDebug( void )
|
|||
pglEnable( GL_TEXTURE_2D );
|
||||
}
|
||||
|
||||
void R_StudioSetRemapColors( int m_topColor, int m_bottomColor )
|
||||
{
|
||||
// FIXME: get some code from q1
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
StudioEstimateGait
|
||||
|
|
@ -1914,8 +1891,6 @@ static bool R_StudioSetupModel( ref_entity_t *e, ref_model_t *mod )
|
|||
|
||||
Com_Assert( pstudio == NULL );
|
||||
|
||||
m_pStudioModelCount++; // render data cache cookie
|
||||
|
||||
// sepcial handle for player model
|
||||
if( e->ent_type == ED_CLIENT || e->renderfx == kRenderFxDeadPlayer )
|
||||
{
|
||||
|
|
@ -1927,7 +1902,6 @@ static bool R_StudioSetupModel( ref_entity_t *e, ref_model_t *mod )
|
|||
{
|
||||
// prepare to draw dead player
|
||||
m_pEntity = ri.GetClientEdict( e->renderamt );
|
||||
e->weaponmodel = NULL;
|
||||
e->gaitsequence = 0;
|
||||
}
|
||||
|
||||
|
|
@ -1939,20 +1913,30 @@ static bool R_StudioSetupModel( ref_entity_t *e, ref_model_t *mod )
|
|||
for( i = 0; i < 4; i++ ) // clear torso controllers
|
||||
pstudio->prev.controller[i] = pstudio->controller[i] = 0x7F;
|
||||
e->gaitsequence = 0; // StudioSetupBones() issuses
|
||||
|
||||
R_StudioSetUpTransform ( e );
|
||||
}
|
||||
else R_StudioProcessGait( e, m_pEntity, pstudio );
|
||||
else
|
||||
{
|
||||
vec3_t save_angles;
|
||||
|
||||
R_StudioSetUpTransform( e ); // FIXME: use identity m_protationmatrix instead
|
||||
VectorCopy( e->angles, save_angles );
|
||||
R_StudioProcessGait( e, m_pEntity, pstudio );
|
||||
R_StudioSetUpTransform ( e );
|
||||
VectorCopy( save_angles, e->angles );
|
||||
}
|
||||
}
|
||||
else R_StudioSetUpTransform ( e ); // FIXME: use identity m_protationmatrix instead
|
||||
else R_StudioSetUpTransform ( e );
|
||||
|
||||
if( e->ent_type != ED_CLIENT && e->movetype == MOVETYPE_FOLLOW )
|
||||
if( e->movetype == MOVETYPE_FOLLOW && e->parent )
|
||||
{
|
||||
curframe = R_StudioMergeBones( e, mod );
|
||||
else curframe = R_StudioSetupBones( e );
|
||||
|
||||
if( e->weaponmodel || (m_pEntity && m_pEntity->v.aiment ))
|
||||
}
|
||||
else
|
||||
{
|
||||
curframe = R_StudioSetupBones( e );
|
||||
R_StudioSaveBones( e );
|
||||
|
||||
}
|
||||
R_StudioSetupLighting( e, mod );
|
||||
|
||||
if( m_pEntity && e->m_nCachedFrameCount != r_framecount )
|
||||
|
|
@ -1968,7 +1952,6 @@ static bool R_StudioSetupModel( ref_entity_t *e, ref_model_t *mod )
|
|||
while(( index = R_StudioGetEvent( e, &event, flStart, flEnd, index )) != 0 )
|
||||
ri.StudioEvent( &event, m_pEntity );
|
||||
}
|
||||
|
||||
e->m_nCachedFrameCount = r_framecount; // cached frame
|
||||
|
||||
return 1;
|
||||
|
|
@ -1977,75 +1960,31 @@ static bool R_StudioSetupModel( ref_entity_t *e, ref_model_t *mod )
|
|||
void R_StudioDrawPoints( const meshbuffer_t *mb, ref_entity_t *e )
|
||||
{
|
||||
int i, j, m_skinnum = RI.currententity->skin;
|
||||
int modelnum, flags;
|
||||
int meshnum, features;
|
||||
int infokey = -mb->infokey - 1;
|
||||
byte *pvertbone;
|
||||
byte *pnormbone;
|
||||
float s, t;
|
||||
vec3_t *pstudioverts;
|
||||
vec3_t *pstudionorms;
|
||||
int modelnum = ((-mb->infokey - 1) & 0xFF);
|
||||
int meshnum = (((-mb->infokey - 1) & 0xFF00)>>8);
|
||||
ref_model_t *model = Mod_ForHandle( mb->modhandle );
|
||||
vec3_t *pstudioverts, *pstudionorms;
|
||||
byte *pvertbone, *pnormbone;
|
||||
short *pskinref, *ptricmds;
|
||||
int flags, features;
|
||||
dstudiotexture_t *ptexture;
|
||||
studiovars_t *studio;
|
||||
dstudiomesh_t *pmesh;
|
||||
short *pskinref;
|
||||
short *ptricmds;
|
||||
ref_shader_t *shader;
|
||||
static int old_model;
|
||||
static int old_submodel;
|
||||
static ref_entity_t *old_entity;
|
||||
static int studio_framecount = 0;
|
||||
bool doTransform = false;
|
||||
bool doBonesSetup = false;
|
||||
bool doForceTransform = false;
|
||||
float s, t;
|
||||
|
||||
modelnum = (infokey & 0xFF);
|
||||
meshnum = ((infokey & 0xFF00)>>8);
|
||||
MB_NUM2SHADER( mb->shaderkey, shader );
|
||||
|
||||
if( studio_framecount != r_framecount )
|
||||
{
|
||||
// invalidate at new frame to takes update
|
||||
old_model = old_submodel = 0;
|
||||
old_entity = NULL;
|
||||
studio_framecount = r_framecount;
|
||||
}
|
||||
|
||||
R_StudioSetupRender( e, Mod_ForHandle( mb->modhandle ));
|
||||
|
||||
if( m_pStudioHeader->numbodyparts == 0 )
|
||||
return; // nothing to draw
|
||||
|
||||
if( mb->modhandle != old_model || old_entity != RI.currententity )
|
||||
doBonesSetup = doTransform = true;
|
||||
|
||||
if( modelnum != old_submodel )
|
||||
{
|
||||
old_submodel = modelnum;
|
||||
doTransform = true;
|
||||
}
|
||||
|
||||
if( doBonesSetup )
|
||||
{
|
||||
// first we need to precalculate all bones for model and place result into entity->extradata
|
||||
// also we can pre-calc attachments and events if need
|
||||
if( e->weaponmodel && Mod_ForHandle( mb->modhandle ) == e->weaponmodel )
|
||||
{
|
||||
R_StudioSetupRender( e, Mod_ForHandle( mb->modhandle ));
|
||||
R_StudioMergeBones( e, Mod_ForHandle( mb->modhandle ));
|
||||
doForceTransform = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
R_StudioSetupRender( e, Mod_ForHandle( mb->modhandle ));
|
||||
R_StudioSetupModel( e, Mod_ForHandle( mb->modhandle ));
|
||||
}
|
||||
if( mb->modhandle != old_model ) old_model = mb->modhandle;
|
||||
if( old_entity != RI.currententity ) old_entity = RI.currententity;
|
||||
}
|
||||
|
||||
R_StudioSetupRender( e, model );
|
||||
R_StudioSetupSubModel( RI.currententity->body, modelnum );
|
||||
if( meshnum > m_pSubModel->nummesh ) return;
|
||||
|
||||
if( meshnum > m_pSubModel->nummesh ) return; // invalid mesh
|
||||
|
||||
// setup all mesh pointers
|
||||
pstudioverts = (vec3_t *)((byte *)m_pStudioHeader + m_pSubModel->vertindex);
|
||||
pstudionorms = (vec3_t *)((byte *)m_pStudioHeader + m_pSubModel->normindex);
|
||||
pvertbone = ((byte *)m_pStudioHeader + m_pSubModel->vertinfoindex);
|
||||
pnormbone = ((byte *)m_pStudioHeader + m_pSubModel->norminfoindex);
|
||||
pmesh = (dstudiomesh_t *)((byte *)m_pStudioHeader + m_pSubModel->meshindex) + meshnum;
|
||||
ptexture = (dstudiotexture_t *)((byte *)m_pTextureHeader + m_pTextureHeader->textureindex);
|
||||
pskinref = (short *)((byte *)m_pTextureHeader + m_pTextureHeader->skinindex);
|
||||
|
|
@ -2055,6 +1994,7 @@ void R_StudioDrawPoints( const meshbuffer_t *mb, ref_entity_t *e )
|
|||
s = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].width;
|
||||
t = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].height;
|
||||
flags = ptexture[pskinref[pmesh->skinref]].flags;
|
||||
studio = (studiovars_t *)e->extradata;
|
||||
#if 0
|
||||
Msg( "StudioDrawPoints( entity %i, model %s, doBonesSetup %s, doTransform %s, skin %s, submodel %i, mesh %i\n",
|
||||
e - r_entities, m_pStudioHeader->name, doBonesSetup ? "true" : "false", doTransform ? "true" : "false",
|
||||
|
|
@ -2077,71 +2017,83 @@ void R_StudioDrawPoints( const meshbuffer_t *mb, ref_entity_t *e )
|
|||
features |= MF_NORMALS|(GL_Support( R_SHADER_GLSL100_EXT ) ? MF_ENABLENORMALS : 0);
|
||||
}
|
||||
|
||||
if( doTransform )
|
||||
Com_Assert( studio == NULL );
|
||||
|
||||
// initialize vertex cache
|
||||
if( !studio->mesh[modelnum] )
|
||||
studio->mesh[modelnum] = Mem_Alloc( e->mempool, sizeof( studioverts_t ));
|
||||
|
||||
if( r_studio_bonelighting->integer )
|
||||
{
|
||||
studiovars_t *studio = (studiovars_t *)e->extradata;
|
||||
|
||||
Com_Assert( studio == NULL );
|
||||
|
||||
pvertbone = ((byte *)m_pStudioHeader + m_pSubModel->vertinfoindex);
|
||||
pnormbone = ((byte *)m_pStudioHeader + m_pSubModel->norminfoindex);
|
||||
|
||||
pstudioverts = (vec3_t *)((byte *)m_pStudioHeader + m_pSubModel->vertindex);
|
||||
pstudionorms = (vec3_t *)((byte *)m_pStudioHeader + m_pSubModel->normindex);
|
||||
|
||||
// initialize vertex cache
|
||||
studio->num_models = m_pStudioHeader->numbodyparts;
|
||||
|
||||
if( !studio->mesh[modelnum] || studio->mesh[modelnum]->numverts != m_pSubModel->numverts || studio->mesh[modelnum]->numnorms != m_pSubModel->numnorms )
|
||||
if( !studio->mesh[modelnum]->light || studio->mesh[modelnum]->numnorms != m_pSubModel->numnorms )
|
||||
{
|
||||
if( !studio->mesh[modelnum] )
|
||||
studio->mesh[modelnum] = Mem_Alloc( studiopool, sizeof( studioverts_t ));
|
||||
if( studio->mesh[modelnum]->numverts != m_pSubModel->numverts )
|
||||
{
|
||||
studio->mesh[modelnum]->verts = Mem_Realloc( studiopool, studio->mesh[modelnum]->verts, sizeof( vec3_t ) * m_pSubModel->numverts );
|
||||
studio->mesh[modelnum]->numverts = m_pSubModel->numverts;
|
||||
Msg( "realloc verts()\n" );
|
||||
}
|
||||
if( studio->mesh[modelnum]->numnorms != m_pSubModel->numnorms )
|
||||
{
|
||||
studio->mesh[modelnum]->norms = Mem_Realloc( studiopool, studio->mesh[modelnum]->norms, sizeof( vec3_t ) * m_pSubModel->numnorms );
|
||||
studio->mesh[modelnum]->numnorms = m_pSubModel->numnorms;
|
||||
Msg( "realloc norms()\n" );
|
||||
}
|
||||
}
|
||||
|
||||
m_pxformverts = studio->mesh[modelnum]->verts;
|
||||
m_pxformnorms = studio->mesh[modelnum]->norms;
|
||||
|
||||
if( studio->mesh[modelnum]->m_nCachedFrame != r_framecount || doForceTransform )
|
||||
studio->mesh[modelnum]->light = Mem_Realloc( e->mempool, studio->mesh[modelnum]->light, sizeof( vec3_t ) * m_pSubModel->numnorms );
|
||||
Msg( "realloc lightvalues()\n" );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if( studio->mesh[modelnum]->light )
|
||||
{
|
||||
Mem_Free( studio->mesh[modelnum]->light );
|
||||
Msg( "free lightvalues()\n" );
|
||||
}
|
||||
studio->mesh[modelnum]->light = NULL;
|
||||
}
|
||||
|
||||
if( studio->mesh[modelnum]->numverts != m_pSubModel->numverts )
|
||||
{
|
||||
studio->mesh[modelnum]->verts = Mem_Realloc( e->mempool, studio->mesh[modelnum]->verts, sizeof( vec3_t ) * m_pSubModel->numverts );
|
||||
Msg( "realloc verts()\n" );
|
||||
}
|
||||
|
||||
if( studio->mesh[modelnum]->numnorms != m_pSubModel->numnorms )
|
||||
{
|
||||
studio->mesh[modelnum]->norms = Mem_Realloc( e->mempool, studio->mesh[modelnum]->norms, sizeof( vec3_t ) * m_pSubModel->numnorms );
|
||||
studio->mesh[modelnum]->chrome = Mem_Realloc( e->mempool, studio->mesh[modelnum]->chrome, sizeof( vec2_t ) * m_pSubModel->numnorms );
|
||||
Msg( "realloc norms and chrome()\n" );
|
||||
}
|
||||
|
||||
studio->mesh[modelnum]->numverts = m_pSubModel->numverts;
|
||||
studio->mesh[modelnum]->numnorms = m_pSubModel->numnorms;
|
||||
|
||||
m_pxformverts = studio->mesh[modelnum]->verts;
|
||||
m_pxformnorms = studio->mesh[modelnum]->norms;
|
||||
m_pxformlight = studio->mesh[modelnum]->light;
|
||||
m_pchrome = studio->mesh[modelnum]->chrome;
|
||||
|
||||
// cache transforms
|
||||
if( studio->mesh[modelnum]->m_nCachedFrame != r_framecount )
|
||||
{
|
||||
dstudiomesh_t *pmesh = (dstudiomesh_t *)((byte *)m_pStudioHeader + m_pSubModel->meshindex);
|
||||
float *lv = (float *)m_pxformlight;
|
||||
int vertspermesh = 0;
|
||||
|
||||
for( i = 0; i < m_pSubModel->numverts; i++ )
|
||||
Matrix4x4_VectorTransform( m_pbonestransform[pvertbone[i]], pstudioverts[i], m_pxformverts[i] );
|
||||
|
||||
for( i = 0; ( i < m_pSubModel->numnorms ) && ( features & MF_NORMALS ); i++ )
|
||||
Matrix4x4_VectorRotate( m_pbonestransform[pnormbone[i]], pstudionorms[i], m_pxformnorms[i] );
|
||||
|
||||
if( m_pStudioHeader->flags & STUDIO_HAS_CHROME || r_studio_bonelighting->integer )
|
||||
{
|
||||
dstudiomesh_t *pmesh = (dstudiomesh_t *)((byte *)m_pStudioHeader + m_pSubModel->meshindex);
|
||||
float *lv = (float *)g_lightvalues;
|
||||
|
||||
for( i = 0; i < m_pSubModel->numverts; i++ )
|
||||
{
|
||||
Matrix4x4_VectorTransform( m_pbonestransform[pvertbone[i]], pstudioverts[i], m_pxformverts[i] );
|
||||
}
|
||||
for( i = 0; ( i < m_pSubModel->numnorms ) && ( features & MF_NORMALS ); i++ )
|
||||
{
|
||||
Matrix4x4_VectorRotate( m_pbonestransform[pnormbone[i]], pstudionorms[i], m_pxformnorms[i] );
|
||||
}
|
||||
for( i = 0; i < m_pSubModel->nummesh; i++ )
|
||||
{
|
||||
int flags = ptexture[pskinref[pmesh[i].skinref]].flags;
|
||||
int texflags = ptexture[pskinref[pmesh[i].skinref]].flags;
|
||||
|
||||
for( j = 0; j < pmesh[i].numnorms; j++, lv += 3, pstudionorms++, pnormbone++ )
|
||||
{
|
||||
R_StudioLighting( lv, *pnormbone, flags, (float *)pstudionorms );
|
||||
if( r_studio_bonelighting->integer )
|
||||
R_StudioLighting( lv, *pnormbone, flags, (float *)pstudionorms );
|
||||
|
||||
// FIXME: move this check out of the inner loop
|
||||
if( flags & STUDIO_NF_CHROME )
|
||||
R_StudioSetupChrome( g_chrome[(float (*)[3])lv - g_lightvalues], *pnormbone, (float *)pstudionorms );
|
||||
if(!( texflags & STUDIO_NF_CHROME )) continue;
|
||||
R_StudioSetupChrome( m_pchrome[(float (*)[3])lv - m_pxformlight], modelnum, *pnormbone, (float *)pstudionorms );
|
||||
}
|
||||
}
|
||||
studio->mesh[modelnum]->m_nCachedFrame = r_framecount;
|
||||
}
|
||||
studio->mesh[modelnum]->m_nCachedFrame = r_framecount;
|
||||
}
|
||||
|
||||
R_StudioDrawMesh( mb, ptricmds, s, t, features, flags );
|
||||
}
|
||||
|
||||
|
|
@ -2186,26 +2138,39 @@ void R_DrawStudioModel( const meshbuffer_t *mb )
|
|||
bool R_CullStudioModel( ref_entity_t *e )
|
||||
{
|
||||
int i, j, clipped;
|
||||
int sequence;
|
||||
bool frustum, query;
|
||||
uint modhandle;
|
||||
dstudiotexture_t *ptexture;
|
||||
short *pskinref;
|
||||
meshbuffer_t *mb;
|
||||
|
||||
R_StudioSetupRender( e, e->model );
|
||||
|
||||
if( !e->model->extradata )
|
||||
return true;
|
||||
|
||||
if( e->ent_type == ED_VIEWMODEL && r_lefthand->integer >= 2 )
|
||||
return true;
|
||||
|
||||
modhandle = Mod_Handle( e->model );
|
||||
if(!R_ExtractBbox( e->sequence, studio_mins, studio_maxs ))
|
||||
|
||||
if( RP_FOLLOWENTITY( e ))
|
||||
{
|
||||
// cull child entities with parent volume
|
||||
R_StudioSetupRender( e->parent, e->parent->model );
|
||||
sequence = e->parent->sequence;
|
||||
}
|
||||
else
|
||||
{
|
||||
R_StudioSetupRender( e, e->model );
|
||||
sequence = e->sequence;
|
||||
}
|
||||
|
||||
if(!R_ExtractBbox( sequence, studio_mins, studio_maxs ))
|
||||
return true; // invalid sequence
|
||||
|
||||
studio_radius = RadiusFromBounds( studio_mins, studio_maxs );
|
||||
clipped = R_CullModel( e, studio_mins, studio_maxs, studio_radius );
|
||||
frustum = clipped & 1;
|
||||
if( clipped & 2 )
|
||||
return true;
|
||||
if( clipped & 2 ) return true;
|
||||
|
||||
query = OCCLUSION_QUERIES_ENABLED( RI ) && OCCLUSION_TEST_ENTITY( e ) ? true : false;
|
||||
if( !frustum && query ) R_IssueOcclusionQuery( R_GetOcclusionQueryNum( OQ_ENTITY, e - r_entities ), e, studio_mins, studio_maxs );
|
||||
|
|
@ -2213,6 +2178,8 @@ bool R_CullStudioModel( ref_entity_t *e )
|
|||
if((RI.refdef.rdflags & RDF_NOWORLDMODEL) || (r_shadows->integer != 1 && !(r_shadows->integer == 2 && (e->flags & EF_PLANARSHADOW))) || R_CullPlanarShadow( e, studio_mins, studio_maxs, query ))
|
||||
return frustum; // entity is not in PVS or shadow is culled away by frustum culling
|
||||
|
||||
R_StudioSetupRender( e, e->model );
|
||||
|
||||
// add it
|
||||
ptexture = (dstudiotexture_t *)((byte *)m_pTextureHeader + m_pTextureHeader->textureindex);
|
||||
for( i = 0; i < m_pStudioHeader->numbodyparts; i++ )
|
||||
|
|
@ -2237,36 +2204,6 @@ bool R_CullStudioModel( ref_entity_t *e )
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
if( e->weaponmodel )
|
||||
{
|
||||
// add weaponmodel
|
||||
modhandle = Mod_Handle( e->weaponmodel );
|
||||
R_StudioSetupRender( e, e->weaponmodel );
|
||||
ptexture = (dstudiotexture_t *)((byte *)m_pTextureHeader + m_pTextureHeader->textureindex);
|
||||
for( i = 0; i < m_pStudioHeader->numbodyparts; i++ )
|
||||
{
|
||||
R_StudioSetupSubModel( e->body, i );
|
||||
pskinref = (short *)((byte *)m_pTextureHeader + m_pTextureHeader->skinindex);
|
||||
if( e->skin != 0 && e->skin < m_pTextureHeader->numskinfamilies )
|
||||
pskinref += (e->skin * m_pTextureHeader->numskinref);
|
||||
|
||||
for( j = 0; j < m_pSubModel->nummesh; j++ )
|
||||
{
|
||||
ref_shader_t *shader;
|
||||
dstudiomesh_t *pmesh;
|
||||
|
||||
pmesh = (dstudiomesh_t *)((byte *)m_pStudioHeader + m_pSubModel->meshindex) + j;
|
||||
shader = &r_shaders[ptexture[pskinref[pmesh->skinref]].shader];
|
||||
if( shader && ( shader->sort <= SORT_ALPHATEST ))
|
||||
{
|
||||
mb = R_AddMeshToList( MB_MODEL, NULL, R_PlanarShadowShader(), -(((j<<8)|i)+1 ));
|
||||
if( mb ) mb->modhandle = modhandle;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return frustum;
|
||||
}
|
||||
|
||||
|
|
@ -2278,15 +2215,30 @@ void R_AddStudioModelToList( ref_entity_t *e )
|
|||
mfog_t *fog = NULL;
|
||||
dstudiotexture_t *ptexture;
|
||||
short *pskinref;
|
||||
int sequence;
|
||||
int i, j;
|
||||
|
||||
R_StudioSetupRender( e, e->model );
|
||||
if( !e->model->extradata ) return;
|
||||
|
||||
if(!R_ExtractBbox( e->sequence, studio_mins, studio_maxs )) return; // invalid sequence
|
||||
if( RP_FOLLOWENTITY( e ))
|
||||
{
|
||||
// cull child entities with parent volume
|
||||
R_StudioSetupRender( e->parent, e->parent->model );
|
||||
sequence = e->parent->sequence;
|
||||
}
|
||||
else
|
||||
{
|
||||
R_StudioSetupRender( e, e->model );
|
||||
sequence = e->sequence;
|
||||
}
|
||||
|
||||
if(!R_ExtractBbox( sequence, studio_mins, studio_maxs )) return; // invalid sequence
|
||||
studio_radius = RadiusFromBounds( studio_mins, studio_maxs );
|
||||
modhandle = Mod_Handle( mod );
|
||||
|
||||
R_StudioSetupRender( e, e->model );
|
||||
if( m_pStudioHeader->numbodyparts == 0 ) return; // nothing to draw
|
||||
|
||||
if( RI.params & RP_SHADOWMAPVIEW )
|
||||
{
|
||||
if( r_entShadowBits[entnum] & RI.shadowGroup->bit )
|
||||
|
|
@ -2317,6 +2269,9 @@ void R_AddStudioModelToList( ref_entity_t *e )
|
|||
#endif
|
||||
}
|
||||
|
||||
// setup bones, play events etc
|
||||
R_StudioSetupModel( e, e->model );
|
||||
|
||||
// add base model
|
||||
ptexture = (dstudiotexture_t *)((byte *)m_pTextureHeader + m_pTextureHeader->textureindex);
|
||||
for( i = 0; i < m_pStudioHeader->numbodyparts; i++ )
|
||||
|
|
@ -2336,31 +2291,4 @@ void R_AddStudioModelToList( ref_entity_t *e )
|
|||
if( shader ) R_AddModelMeshToList( modhandle, fog, shader, ((j<<8)|i));
|
||||
}
|
||||
}
|
||||
|
||||
if( e->weaponmodel )
|
||||
{
|
||||
// add weaponmodel
|
||||
modhandle = Mod_Handle( e->weaponmodel );
|
||||
R_StudioSetupRender( e, e->weaponmodel );
|
||||
ptexture = (dstudiotexture_t *)((byte *)m_pTextureHeader + m_pTextureHeader->textureindex);
|
||||
for( i = 0; i < m_pStudioHeader->numbodyparts; i++ )
|
||||
{
|
||||
R_StudioSetupSubModel( e->body, i );
|
||||
pskinref = (short *)((byte *)m_pTextureHeader + m_pTextureHeader->skinindex);
|
||||
if( e->skin != 0 && e->skin < m_pTextureHeader->numskinfamilies )
|
||||
pskinref += (e->skin * m_pTextureHeader->numskinref);
|
||||
|
||||
for( j = 0; j < m_pSubModel->nummesh; j++ )
|
||||
{
|
||||
ref_shader_t *shader;
|
||||
dstudiomesh_t *pmesh;
|
||||
|
||||
pmesh = (dstudiomesh_t *)((byte *)m_pStudioHeader + m_pSubModel->meshindex) + j;
|
||||
shader = &r_shaders[ptexture[pskinref[pmesh->skinref]].shader];
|
||||
if( shader ) R_AddModelMeshToList( modhandle, fog, shader, ((j<<8)|i));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
R_StudioAddEntityToRadar( e );
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -283,21 +283,6 @@ int R_StudioGetBodygroup( int iGroup )
|
|||
return (RI.currententity->body / m_pBodyPart->base) % m_pBodyPart->nummodels;
|
||||
}
|
||||
|
||||
void R_StudioAddEntityToRadar( ref_entity_t *e )
|
||||
{
|
||||
if( r_minimap->integer < 2 ) return;
|
||||
|
||||
if( numRadarEnts >= MAX_RADAR_ENTS ) return;
|
||||
if( e->ent_type == ED_VIEWMODEL ) return;
|
||||
|
||||
if( e->ent_type == ED_MONSTER )
|
||||
Vector4Set( RadarEnts[numRadarEnts].color, 255, 0, 128, 255 );
|
||||
else Vector4Set( RadarEnts[numRadarEnts].color, 0, 255, 255, 128 );
|
||||
VectorCopy( e->origin, RadarEnts[numRadarEnts].origin );
|
||||
VectorCopy( e->angles, RadarEnts[numRadarEnts].angles );
|
||||
numRadarEnts++;
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
R_StudioGetSequenceInfo
|
||||
|
|
@ -2338,6 +2323,4 @@ void R_AddStudioModelToList( ref_entity_t *e )
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
R_StudioAddEntityToRadar( e );
|
||||
}
|
||||
|
|
@ -28,8 +28,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|||
static vec3_t modelorg; // relative to viewpoint
|
||||
static vec3_t modelmins;
|
||||
static vec3_t modelmaxs;
|
||||
int numRadarEnts = 0;
|
||||
radar_ent_t RadarEnts[MAX_RADAR_ENTS];
|
||||
|
||||
/*
|
||||
=============================================================
|
||||
|
|
|
|||
|
|
@ -3,55 +3,54 @@
|
|||
<pre>
|
||||
<h1>Build Log</h1>
|
||||
<h3>
|
||||
--------------------Configuration: render - Win32 Release--------------------
|
||||
--------------------Configuration: render - Win32 Debug--------------------
|
||||
</h3>
|
||||
<h3>Command Lines</h3>
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP2E75.tmp" with contents
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP3869.tmp" with contents
|
||||
[
|
||||
/nologo /MD /W3 /GX /O2 /I "../public" /I "../common" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /Fo"..\temp\render\!release/" /Fd"..\temp\render\!release/" /FD /c
|
||||
/nologo /MDd /W3 /Gm /Gi /GX /ZI /Od /I "../public" /I "../common" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FR"..\temp\render\!debug/" /Fo"..\temp\render\!debug/" /Fd"..\temp\render\!debug/" /FD /c
|
||||
"D:\Xash3D\src_main\render\r_studio.c"
|
||||
]
|
||||
Creating command line "cl.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP2E75.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP2E76.tmp" with contents
|
||||
Creating command line "cl.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP3869.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP386A.tmp" with contents
|
||||
[
|
||||
msvcrt.lib user32.lib gdi32.lib /nologo /subsystem:windows /dll /pdb:none /machine:I386 /nodefaultlib:"libc.lib" /out:"..\temp\render\!release/render.dll" /implib:"..\temp\render\!release/render.lib" /libpath:"../public/libs/"
|
||||
"\Xash3D\src_main\temp\render\!release\cin.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_aliasq.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_backend.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_bloom.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_cin.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_cull.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_draw.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_image.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_light.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_main.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_math.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_mesh.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_model.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_opengl.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_poly.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_program.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_register.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_shader.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_shadow.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_sky.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_sprite.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_studio.obj"
|
||||
"\Xash3D\src_main\temp\render\!release\r_surf.obj"
|
||||
msvcrtd.lib user32.lib gdi32.lib /nologo /subsystem:windows /dll /incremental:yes /pdb:"..\temp\render\!debug/render.pdb" /debug /machine:I386 /nodefaultlib:"msvcrt.lib" /out:"..\temp\render\!debug/render.dll" /implib:"..\temp\render\!debug/render.lib" /pdbtype:sept
|
||||
"\Xash3D\src_main\temp\render\!debug\cin.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_aliasq.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_backend.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_bloom.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_cin.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_cull.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_draw.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_image.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_light.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_main.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_math.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_mesh.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_model.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_opengl.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_poly.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_program.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_register.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_shader.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_shadow.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_sky.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_sprite.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_studio.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_surf.obj"
|
||||
]
|
||||
Creating command line "link.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP2E76.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP2E77.bat" with contents
|
||||
Creating command line "link.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP386A.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP386B.bat" with contents
|
||||
[
|
||||
@echo off
|
||||
copy \Xash3D\src_main\temp\render\!release\render.dll "D:\Xash3D\bin\render.dll"
|
||||
copy \Xash3D\src_main\temp\render\!debug\render.dll "D:\Xash3D\bin\render.dll"
|
||||
]
|
||||
Creating command line "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP2E77.bat"
|
||||
Creating command line "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP386B.bat"
|
||||
Compiling...
|
||||
r_studio.c
|
||||
Linking...
|
||||
Creating library ..\temp\render\!release/render.lib and object ..\temp\render\!release/render.exp
|
||||
<h3>Output Window</h3>
|
||||
Performing Custom Build Step on \Xash3D\src_main\temp\render\!release\render.dll
|
||||
Performing Custom Build Step on \Xash3D\src_main\temp\render\!debug\render.dll
|
||||
‘ª®¯¨à®¢ ® ä ©«®¢: 1.
|
||||
|
||||
|
||||
|
|
|
|||
4
todo.log
4
todo.log
|
|
@ -75,7 +75,7 @@ Beta 13.12.09
|
|||
44. fixup sky rendering OK
|
||||
45. make color as unsigned_byte(4) OK
|
||||
46. RB_RenderShader() OK
|
||||
47. fixup slowly rendering
|
||||
47. fixup slowly rendering OK
|
||||
48. building uimenu.dll
|
||||
49. implement new timers OK
|
||||
50. fixup network packets rate
|
||||
|
|
@ -136,3 +136,5 @@ Beta 13.12.09
|
|||
112. clean up renderer sources
|
||||
113. fixup debug tools OK
|
||||
114. fixup shadowmaps OK
|
||||
115. fixup CullStudioModel OK
|
||||
116. create flashlight for player
|
||||
|
|
|
|||
Reference in New Issue