31 Aug 2009
This commit is contained in:
g-cont
parent
016ad2f769
commit
9115ecdbdc
|
|
@ -49,6 +49,11 @@ Studio models are position independent, so the cache manager can move them.
|
|||
#define STUDIO_NF_BLENDED 0x0010 // rendering as semiblended
|
||||
#define STUDIO_NF_ADDITIVE 0x0020 // rendering with additive mode
|
||||
#define STUDIO_NF_TRANSPARENT 0x0040 // use texture with alpha channel
|
||||
#define STUDIO_NF_NORMALMAP 0x0080 // indexed normalmap
|
||||
#define STUDIO_NF_BUMPMAP 0x0100 // heightmap that can be used for parallax or normalmap
|
||||
#define STUDIO_NF_GLOSSMAP 0x0200 // glossmap
|
||||
#define STUDIO_NF_DECALMAP 0x0400 // decalmap (currently unused)
|
||||
#define STUDIO_NF_GLOWMAP 0x0800 // optional luma_texture
|
||||
#define STUDIO_NF_QUAKESKIN 0x8000 // special hack for determine alias skins
|
||||
|
||||
// motion flags
|
||||
|
|
|
|||
|
|
@ -72,5 +72,5 @@ if exist xtools\xtools.plg del /f /q xtools\xtools.plg
|
|||
echo Build succeeded!
|
||||
echo Please wait. Xash is now loading
|
||||
cd D:\Xash3D\
|
||||
xash.exe -log -dev 3 +map q3dm0
|
||||
xash.exe -log -dev 3 +map qctest
|
||||
:done
|
||||
|
|
@ -1000,7 +1000,7 @@ void CL_TestLights( void )
|
|||
|
||||
Mem_Set( &dl, 0, sizeof( cdlight_t ));
|
||||
|
||||
for( i = 0; i < 32; i++ )
|
||||
for( i = 0; i < bound( 1, cl_testlights->integer, MAX_DLIGHTS ); i++ )
|
||||
{
|
||||
r = 64 * ( (i%4) - 1.5 );
|
||||
f = 64 * (i/4) + 128;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,75 @@
|
|||
<html>
|
||||
<body>
|
||||
<pre>
|
||||
<h1>Build Log</h1>
|
||||
<h3>
|
||||
--------------------Configuration: engine - Win32 Debug--------------------
|
||||
</h3>
|
||||
<h3>Command Lines</h3>
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP16D0.tmp" with contents
|
||||
[
|
||||
/nologo /MDd /W3 /Gm /Gi /GX /ZI /Od /I "./" /I "common" /I "server" /I "client" /I "../public" /I "../common" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FR"..\temp\engine\!debug/" /Fo"..\temp\engine\!debug/" /Fd"..\temp\engine\!debug/" /FD /c
|
||||
"D:\Xash3D\src_main\engine\client\cl_effects.c"
|
||||
]
|
||||
Creating command line "cl.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP16D0.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP16D1.tmp" with contents
|
||||
[
|
||||
user32.lib msvcrtd.lib /nologo /subsystem:windows /dll /incremental:yes /pdb:"..\temp\engine\!debug/engine.pdb" /debug /machine:I386 /nodefaultlib:"msvcrt.lib" /out:"..\temp\engine\!debug/engine.dll" /implib:"..\temp\engine\!debug/engine.lib" /pdbtype:sept
|
||||
"\Xash3D\src_main\temp\engine\!debug\cinematic.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\cl_cmds.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\cl_demo.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\cl_effects.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\cl_frame.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\cl_game.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\cl_input.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\cl_main.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\cl_parse.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\cl_phys.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\cl_scrn.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\cl_view.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\com_library.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\con_keys.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\con_main.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\con_utils.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\engfuncs.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\engine.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\host.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\infostring.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\input.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\menu.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\net_chan.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\net_huff.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\net_msg.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\sv_client.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\sv_cmds.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\sv_frame.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\sv_game.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\sv_init.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\sv_main.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\sv_move.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\sv_phys.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\sv_save.obj"
|
||||
"\Xash3D\src_main\temp\engine\!debug\sv_world.obj"
|
||||
]
|
||||
Creating command line "link.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP16D1.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP16D2.bat" with contents
|
||||
[
|
||||
@echo off
|
||||
copy \Xash3D\src_main\temp\engine\!debug\engine.dll "D:\Xash3D\bin\engine.dll"
|
||||
]
|
||||
Creating command line "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP16D2.bat"
|
||||
Compiling...
|
||||
cl_effects.c
|
||||
Linking...
|
||||
Creating library ..\temp\engine\!debug/engine.lib and object ..\temp\engine\!debug/engine.exp
|
||||
<h3>Output Window</h3>
|
||||
Performing Custom Build Step on \Xash3D\src_main\temp\engine\!debug\engine.dll
|
||||
‘ª®¯¨à®¢ ® ä ©«®¢: 1.
|
||||
|
||||
|
||||
|
||||
<h3>Results</h3>
|
||||
engine.dll - 0 error(s), 0 warning(s)
|
||||
</pre>
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -205,7 +205,7 @@ int SV_PointContents( const vec3_t point )
|
|||
if( !model || !model->PointContents ) continue;
|
||||
Matrix4x4_CreateFromEntity( matrix, touch->v.origin[0], touch->v.origin[1], touch->v.origin[2], touch->v.angles[0], touch->v.angles[1], touch->v.angles[2], 1 );
|
||||
Matrix4x4_Invert_Simple( imatrix, matrix );
|
||||
Matrix4x4_Transform( imatrix, point, transformed);
|
||||
Matrix4x4_VectorTransform( imatrix, point, transformed);
|
||||
contents |= model->PointContents( transformed, model );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2309,20 +2309,19 @@ int FS_Gets( file_t* file, byte *string, size_t bufsize )
|
|||
while( 1 )
|
||||
{
|
||||
c = FS_Getc( file );
|
||||
if (c == '\r' || c == '\n' || c < 0)
|
||||
if( c == '\r' || c == '\n' || c < 0 )
|
||||
break;
|
||||
if (end < bufsize - 1)
|
||||
if( end < bufsize - 1 )
|
||||
string[end++] = c;
|
||||
}
|
||||
string[end] = 0;
|
||||
|
||||
// remove \n following \r
|
||||
if (c == '\r')
|
||||
if( c == '\r' )
|
||||
{
|
||||
c = FS_Getc(file);
|
||||
if (c != '\n') FS_UnGetc(file, (byte)c);
|
||||
c = FS_Getc( file );
|
||||
if( c != '\n' ) FS_UnGetc( file, (byte)c );
|
||||
}
|
||||
MsgDev(D_INFO, "FS_Gets: %s\n", string);
|
||||
|
||||
return c;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1233,7 +1233,7 @@ void CM_CollisionTraceBrushPolygonTransformFloat( trace_t *trace, const cbrushf_
|
|||
polyf_brushstart.contents = supercontents;
|
||||
|
||||
for( i = 0; i < numpoints; i++ )
|
||||
Matrix4x4_Transform( polygonmatrixstart, points + i * 3, polyf_brushstart.points[i].v );
|
||||
Matrix4x4_VectorTransform( polygonmatrixstart, points + i * 3, polyf_brushstart.points[i].v );
|
||||
|
||||
polyf_brushend.numpoints = numpoints;
|
||||
polyf_brushend.numplanes = numpoints + 2;
|
||||
|
|
@ -1242,7 +1242,7 @@ void CM_CollisionTraceBrushPolygonTransformFloat( trace_t *trace, const cbrushf_
|
|||
polyf_brushend.contents = supercontents;
|
||||
|
||||
for( i = 0; i < numpoints; i++ )
|
||||
Matrix4x4_Transform( polygonmatrixend, points + i * 3, polyf_brushend.points[i].v );
|
||||
Matrix4x4_VectorTransform( polygonmatrixend, points + i * 3, polyf_brushend.points[i].v );
|
||||
|
||||
for( i = 0; i < polyf_brushstart.numplanes; i++ )
|
||||
{
|
||||
|
|
@ -1298,7 +1298,7 @@ cbrushf_t *CM_CollisionBrushForBox( const matrix4x4 matrix, const vec3_t mins, c
|
|||
v[0] = i & 1 ? maxs[0] : mins[0];
|
||||
v[1] = i & 2 ? maxs[1] : mins[1];
|
||||
v[2] = i & 4 ? maxs[2] : mins[2];
|
||||
Matrix4x4_Transform( matrix, v, brush->points[i].v );
|
||||
Matrix4x4_VectorTransform( matrix, v, brush->points[i].v );
|
||||
}
|
||||
// FIXME: optimize!
|
||||
for( i = 0; i < 6; i++ )
|
||||
|
|
@ -1659,8 +1659,8 @@ void CM_CollisionClipToGenericEntity( trace_t *trace, cmodel_t *model, const vec
|
|||
trace->fraction = trace->realfraction = 1;
|
||||
VectorCopy( end, trace->endpos );
|
||||
|
||||
Matrix4x4_Transform( inversematrix, start, starttransformed );
|
||||
Matrix4x4_Transform( inversematrix, end, endtransformed );
|
||||
Matrix4x4_VectorTransform( inversematrix, start, starttransformed );
|
||||
Matrix4x4_VectorTransform( inversematrix, end, endtransformed );
|
||||
|
||||
if( model && model->TraceBox )
|
||||
model->TraceBox( starttransformed, endtransformed, mins, maxs, model, trace, hitsupercontentsmask );
|
||||
|
|
|
|||
|
|
@ -1541,22 +1541,14 @@ void CM_StudioGetVertices( void )
|
|||
{
|
||||
int i;
|
||||
vec3_t *pstudioverts;
|
||||
vec3_t *pstudionorms;
|
||||
byte *pvertbone;
|
||||
byte *pnormbone;
|
||||
|
||||
pvertbone = ((byte *)studio.hdr + studio.submodel->vertinfoindex);
|
||||
pnormbone = ((byte *)studio.hdr + studio.submodel->norminfoindex);
|
||||
pstudioverts = (vec3_t *)((byte *)studio.hdr + studio.submodel->vertindex);
|
||||
pstudionorms = (vec3_t *)((byte *)studio.hdr + studio.submodel->normindex);
|
||||
|
||||
for( i = 0; i < studio.submodel->numverts; i++ )
|
||||
{
|
||||
Matrix4x4_Transform( studio.bones[pvertbone[i]], pstudioverts[i], studio.vtransform[i]);
|
||||
}
|
||||
for( i = 0; i < studio.submodel->numnorms; i++ )
|
||||
{
|
||||
Matrix4x4_Transform( studio.bones[pnormbone[i]], pstudionorms[i], studio.ntransform[i]);
|
||||
Matrix4x4_VectorTransform( studio.bones[pvertbone[i]], pstudioverts[i], studio.vtransform[i]);
|
||||
}
|
||||
CM_StudioLookMeshes();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -394,21 +394,7 @@ _inline void Matrix4x4_Transform3x3( const matrix4x4 in, const float v[3], float
|
|||
#endif
|
||||
}
|
||||
|
||||
// same as Matrix4x4_Transform3x3 but transpose matrix before
|
||||
_inline void Matrix4x4_Rotate3x3( const matrix4x4 in, const float v[3], float out[3] )
|
||||
{
|
||||
#ifdef OPENGL_STYLE
|
||||
out[0] = v[0] * in[0][0] + v[1] * in[0][1] + v[2] * in[0][2];
|
||||
out[1] = v[0] * in[1][0] + v[1] * in[1][1] + v[2] * in[1][2];
|
||||
out[2] = v[0] * in[2][0] + v[1] * in[2][1] + v[2] * in[2][2];
|
||||
#else
|
||||
out[0] = v[0] * in[0][0] + v[1] * in[1][0] + v[2] * in[2][0];
|
||||
out[1] = v[0] * in[0][1] + v[1] * in[1][1] + v[2] * in[2][1];
|
||||
out[2] = v[0] * in[0][2] + v[1] * in[1][2] + v[2] * in[2][2];
|
||||
#endif
|
||||
}
|
||||
|
||||
_inline void Matrix4x4_Transform( const matrix4x4 in, const float v[3], float out[3] )
|
||||
_inline void Matrix4x4_VectorTransform( const matrix4x4 in, const float v[3], float out[3] )
|
||||
{
|
||||
#ifdef OPENGL_STYLE
|
||||
out[0] = v[0] * in[0][0] + v[1] * in[1][0] + v[2] * in[2][0] + in[3][0];
|
||||
|
|
@ -421,6 +407,32 @@ _inline void Matrix4x4_Transform( const matrix4x4 in, const float v[3], float ou
|
|||
#endif
|
||||
}
|
||||
|
||||
_inline void Matrix4x4_VectorRotate( const matrix4x4 in, const float v[3], float out[3] )
|
||||
{
|
||||
#ifdef OPENGL_STYLE
|
||||
out[0] = v[0] * in[0][0] + v[1] * in[1][0] + v[2] * in[2][0];
|
||||
out[1] = v[0] * in[0][1] + v[1] * in[1][1] + v[2] * in[2][1];
|
||||
out[2] = v[0] * in[0][2] + v[1] * in[1][2] + v[2] * in[2][2];
|
||||
#else
|
||||
out[0] = v[0] * in[0][0] + v[1] * in[0][1] + v[2] * in[0][2];
|
||||
out[1] = v[0] * in[1][0] + v[1] * in[1][1] + v[2] * in[1][2];
|
||||
out[2] = v[0] * in[2][0] + v[1] * in[2][1] + v[2] * in[2][2];
|
||||
#endif
|
||||
}
|
||||
|
||||
_inline void Matrix4x4_VectorIRotate( const matrix4x4 in, const float v[3], float out[3] )
|
||||
{
|
||||
#ifdef OPENGL_STYLE
|
||||
out[0] = v[0] * in[0][0] + v[1] * in[0][1] + v[2] * in[0][2];
|
||||
out[1] = v[0] * in[1][0] + v[1] * in[1][1] + v[2] * in[1][2];
|
||||
out[2] = v[0] * in[2][0] + v[1] * in[2][1] + v[2] * in[2][2];
|
||||
#else
|
||||
out[0] = v[0] * in[0][0] + v[1] * in[1][0] + v[2] * in[2][0];
|
||||
out[1] = v[0] * in[0][1] + v[1] * in[1][1] + v[2] * in[2][1];
|
||||
out[2] = v[0] * in[0][2] + v[1] * in[1][2] + v[2] * in[2][2];
|
||||
#endif
|
||||
}
|
||||
|
||||
_inline void Matrix4x4_ConcatVector( const matrix4x4 in, const float v[4], float out[4] )
|
||||
{
|
||||
#ifdef OPENGL_STYLE
|
||||
|
|
|
|||
|
|
@ -1630,8 +1630,17 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
}
|
||||
break;
|
||||
case RGBGEN_LIGHTING_DIFFUSE:
|
||||
if( RI.currententity )
|
||||
R_LightForEntity( RI.currententity, bArray );
|
||||
if( r_studio_bonelighting->integer && RI.currentmodel && RI.currentmodel->type == mod_studio )
|
||||
{
|
||||
// Paranoia-Style bonelighting instead of diffuse lighting (Faster)
|
||||
for( i = 0; i < r_backacc.numColors; i++, bArray += 4, inArray += 4 )
|
||||
{
|
||||
bArray[0] = inArray[0] >> bits;
|
||||
bArray[1] = inArray[1] >> bits;
|
||||
bArray[2] = inArray[2] >> bits;
|
||||
}
|
||||
}
|
||||
else if( RI.currententity ) R_LightForEntity( RI.currententity, bArray );
|
||||
break;
|
||||
case RGBGEN_LIGHTING_DIFFUSE_ONLY:
|
||||
if( RI.currententity && !( RI.params & RP_SHADOWMAPVIEW ) )
|
||||
|
|
|
|||
|
|
@ -1561,6 +1561,7 @@ static rgbdata_t *R_IncludeDepthmap( rgbdata_t *in1, rgbdata_t *in2 )
|
|||
|
||||
pic1 = in1->buffer;
|
||||
pic2 = in2->buffer;
|
||||
|
||||
for( i = (in1->width * in1->height) - 1; i > 0; i--, pic1 += 4, pic2 += 4 )
|
||||
{
|
||||
if( in2->flags & IMAGE_HAS_COLOR )
|
||||
|
|
|
|||
|
|
@ -143,7 +143,7 @@ void R_AddDynamicLights( uint dlightbits, int state )
|
|||
|
||||
for( i = 0, light = r_dlights; i < r_numDlights; i++, light++ )
|
||||
{
|
||||
if( !( dlightbits & ( 1<<i ) ) )
|
||||
if(!( dlightbits & ( 1<<i )))
|
||||
continue; // not lit by this light
|
||||
|
||||
VectorSubtract( light->origin, RI.currententity->origin, dlorigin );
|
||||
|
|
@ -154,7 +154,7 @@ void R_AddDynamicLights( uint dlightbits, int state )
|
|||
}
|
||||
|
||||
shader = light->shader;
|
||||
if( shader && ( shader->flags & SHADER_CULL_BACK ) )
|
||||
if( shader && ( shader->flags & SHADER_CULL_BACK ))
|
||||
cullAway = true;
|
||||
else cullAway = false;
|
||||
|
||||
|
|
@ -163,24 +163,23 @@ void R_AddDynamicLights( uint dlightbits, int state )
|
|||
{
|
||||
for( j = 0; j < r_backacc.numElems; j += 3 )
|
||||
{
|
||||
v1 = (float *)( vertsArray + elemsArray[j+0] );
|
||||
v2 = (float *)( vertsArray + elemsArray[j+1] );
|
||||
v3 = (float *)( vertsArray + elemsArray[j+2] );
|
||||
v1 = (float *)(vertsArray + elemsArray[j+0]);
|
||||
v2 = (float *)(vertsArray + elemsArray[j+1]);
|
||||
v3 = (float *)(vertsArray + elemsArray[j+2]);
|
||||
|
||||
normal[0] = ( v1[1] - v2[1] ) * ( v3[2] - v2[2] ) - ( v1[2] - v2[2] ) * ( v3[1] - v2[1] );
|
||||
normal[1] = ( v1[2] - v2[2] ) * ( v3[0] - v2[0] ) - ( v1[0] - v2[0] ) * ( v3[2] - v2[2] );
|
||||
normal[2] = ( v1[0] - v2[0] ) * ( v3[1] - v2[1] ) - ( v1[1] - v2[1] ) * ( v3[0] - v2[0] );
|
||||
dist = ( dlorigin[0] - v1[0] ) * normal[0] + ( dlorigin[1] - v1[1] ) * normal[1] + ( dlorigin[2] - v1[2] ) * normal[2];
|
||||
dist = (dlorigin[0] - v1[0]) * normal[0] + (dlorigin[1] - v1[1]) * normal[1] + (dlorigin[2] - v1[2]) * normal[2];
|
||||
|
||||
if( dist <= 0 || dist * rsqrt( DotProduct( normal, normal ) ) >= light->intensity )
|
||||
if( dist <= 0 || dist * rsqrt( DotProduct( normal, normal )) >= light->intensity )
|
||||
continue;
|
||||
|
||||
tempElemsArray[numTempElems++] = elemsArray[j+0];
|
||||
tempElemsArray[numTempElems++] = elemsArray[j+1];
|
||||
tempElemsArray[numTempElems++] = elemsArray[j+2];
|
||||
}
|
||||
if( !numTempElems )
|
||||
continue;
|
||||
if( !numTempElems ) continue;
|
||||
}
|
||||
|
||||
inverseIntensity = 1 / light->intensity;
|
||||
|
|
|
|||
|
|
@ -189,66 +189,65 @@ extern radar_ent_t RadarEnts[MAX_RADAR_ENTS];
|
|||
|
||||
typedef struct
|
||||
{
|
||||
vec3_t origin;
|
||||
vec3_t color;
|
||||
vec3_t mins, maxs;
|
||||
float intensity;
|
||||
vec3_t origin;
|
||||
vec3_t color;
|
||||
vec3_t mins, maxs;
|
||||
float intensity;
|
||||
const ref_shader_t *shader;
|
||||
} dlight_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int features;
|
||||
int lightmapNum[LM_STYLES];
|
||||
int lightmapStyles[LM_STYLES];
|
||||
int vertexStyles[LM_STYLES];
|
||||
float stOffset[LM_STYLES][2];
|
||||
int features;
|
||||
int lightmapNum[LM_STYLES];
|
||||
int lightmapStyles[LM_STYLES];
|
||||
int vertexStyles[LM_STYLES];
|
||||
float stOffset[LM_STYLES][2];
|
||||
} superLightStyle_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int params; // rendering parameters
|
||||
int params; // rendering parameters
|
||||
|
||||
ref_params_t refdef;
|
||||
int scissor[4];
|
||||
int viewport[4];
|
||||
meshlist_t *meshlist; // meshes to be rendered
|
||||
meshbuffer_t **surfmbuffers; // pointers to meshbuffers of world surfaces
|
||||
ref_params_t refdef;
|
||||
int scissor[4];
|
||||
int viewport[4];
|
||||
meshlist_t *meshlist; // meshes to be rendered
|
||||
meshbuffer_t **surfmbuffers; // pointers to meshbuffers of world surfaces
|
||||
|
||||
unsigned int shadowBits;
|
||||
uint shadowBits;
|
||||
shadowGroup_t *shadowGroup;
|
||||
|
||||
ref_entity_t *currententity;
|
||||
ref_model_t *currentmodel;
|
||||
ref_entity_t *previousentity;
|
||||
ref_entity_t *currententity;
|
||||
ref_model_t *currentmodel;
|
||||
ref_entity_t *previousentity;
|
||||
|
||||
//
|
||||
// view origin
|
||||
//
|
||||
vec3_t viewOrigin;
|
||||
vec3_t viewAxis[3];
|
||||
vec_t *vup, *vpn, *vright;
|
||||
vec3_t viewOrigin;
|
||||
vec3_t viewAxis[3];
|
||||
vec_t *vup, *vpn, *vright;
|
||||
cplane_t frustum[6];
|
||||
float farClip;
|
||||
float farClip;
|
||||
unsigned int clipFlags;
|
||||
vec3_t visMins, visMaxs;
|
||||
vec3_t visMins, visMaxs;
|
||||
|
||||
matrix4x4 objectMatrix;
|
||||
matrix4x4 worldviewMatrix;
|
||||
matrix4x4 modelviewMatrix; // worldviewMatrix * objectMatrix
|
||||
matrix4x4 modelviewMatrix; // worldviewMatrix * objectMatrix
|
||||
|
||||
matrix4x4 projectionMatrix;
|
||||
matrix4x4 worldviewProjectionMatrix; // worldviewMatrix * projectionMatrix
|
||||
|
||||
float skyMins[2][6];
|
||||
float skyMaxs[2][6];
|
||||
float skyMins[2][6];
|
||||
float skyMaxs[2][6];
|
||||
|
||||
float lod_dist_scale_for_fov;
|
||||
float lod_dist_scale_for_fov;
|
||||
float fog_dist_to_eye[MAX_MAP_FOGS];
|
||||
|
||||
float fog_dist_to_eye[MAX_MAP_FOGS];
|
||||
|
||||
vec3_t lodOrigin;
|
||||
vec3_t pvsOrigin;
|
||||
vec3_t lodOrigin;
|
||||
vec3_t pvsOrigin;
|
||||
cplane_t clipPlane;
|
||||
cplane_t portalPlane;
|
||||
} refinst_t;
|
||||
|
|
@ -382,6 +381,8 @@ extern cvar_t *r_lodbias;
|
|||
extern cvar_t *r_lodscale;
|
||||
extern cvar_t *r_himodels;
|
||||
|
||||
extern cvar_t *r_studio_bonelighting;
|
||||
|
||||
extern cvar_t *r_environment_color;
|
||||
extern cvar_t *r_gamma;
|
||||
extern cvar_t *r_texturebits;
|
||||
|
|
@ -694,11 +695,10 @@ mspriteframe_t *R_GetSpriteFrame( ref_entity_t *ent );
|
|||
//
|
||||
void R_AddStudioModelToList( ref_entity_t *e );
|
||||
void R_DrawStudioModel( const meshbuffer_t *mb );
|
||||
void R_StudioResetSequenceInfo( ref_entity_t *ent, dstudiohdr_t *hdr );
|
||||
void R_StudioResetSequenceInfo( ref_entity_t *ent );
|
||||
float R_StudioFrameAdvance( ref_entity_t *ent, float flInterval );
|
||||
void R_StudioModelBBox( ref_entity_t *e, vec3_t mins, vec3_t maxs );
|
||||
bool R_CullStudioModel( ref_entity_t *e );
|
||||
void R_StudioFreeBoneposes( void );
|
||||
void R_StudioInit( void );
|
||||
void R_StudioShutdown( void );
|
||||
|
||||
|
|
|
|||
|
|
@ -1937,9 +1937,6 @@ void R_EndFrame( void )
|
|||
// flush any remaining 2D bits
|
||||
R_Set2DMode( false );
|
||||
|
||||
// release model boneposes
|
||||
R_StudioFreeBoneposes ();
|
||||
|
||||
// cleanup texture units
|
||||
R_BackendCleanUpTextureUnits();
|
||||
|
||||
|
|
@ -2111,6 +2108,7 @@ bool R_AddLightStyle( int stylenum, vec3_t color )
|
|||
bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type, float lerpfrac )
|
||||
{
|
||||
int i;
|
||||
vec3_t center;
|
||||
|
||||
// check model
|
||||
if( !refent->model ) return false;
|
||||
|
|
@ -2124,13 +2122,7 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
|
|||
refent->scale = 1.0f; // ignore scale for brush models
|
||||
break;
|
||||
case mod_studio:
|
||||
if( !refent->model->phdr )
|
||||
return false;
|
||||
break;
|
||||
case mod_alias:
|
||||
if( !refent->model->extradata )
|
||||
return false;
|
||||
break;
|
||||
case mod_sprite:
|
||||
if( !refent->model->extradata )
|
||||
return false;
|
||||
|
|
@ -2143,7 +2135,12 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
|
|||
// setup latchedvars
|
||||
VectorCopy( pRefEntity->v.oldorigin, refent->prev.origin );
|
||||
VectorCopy( pRefEntity->v.oldangles, refent->prev.angles );
|
||||
VectorCopy( pRefEntity->v.origin, refent->lightingOrigin );
|
||||
|
||||
// setup light origin
|
||||
if( refent->model ) VectorAverage( refent->model->mins, refent->model->maxs, center );
|
||||
else VectorClear( center );
|
||||
VectorAdd( pRefEntity->v.origin, center, refent->lightingOrigin );
|
||||
if( refent->flags & EF_INVLIGHT ) refent->lightingOrigin[2] += center[2];
|
||||
|
||||
// do animate
|
||||
if( refent->flags & EF_ANIMATE )
|
||||
|
|
@ -2155,7 +2152,7 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
|
|||
{
|
||||
pRefEntity->v.frame = refent->frame = 0;
|
||||
refent->sequence = pRefEntity->v.sequence;
|
||||
R_StudioResetSequenceInfo( refent, refent->model->phdr );
|
||||
R_StudioResetSequenceInfo( refent );
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
|||
|
|
@ -307,6 +307,16 @@ STUDIO MODELS
|
|||
|
||||
==============================================================================
|
||||
*/
|
||||
typedef struct mstudiomodel_s
|
||||
{
|
||||
dstudiohdr_t *phdr;
|
||||
dstudiohdr_t *thdr;
|
||||
|
||||
void *submodels;
|
||||
int numsubmodels;
|
||||
vec3_t *m_pSVectors; // UNDONE: calc SVectors on loading, simple transform on rendering
|
||||
|
||||
} mstudiomodel_t;
|
||||
|
||||
/*
|
||||
==============================================================================
|
||||
|
|
@ -369,12 +379,6 @@ typedef struct ref_model_s
|
|||
// memory representation pointer
|
||||
byte *mempool;
|
||||
void *extradata;
|
||||
|
||||
// FIXME!!!! use extradata instead
|
||||
dstudiohdr_t *phdr;
|
||||
dstudiohdr_t *thdr;
|
||||
int numsubmodels;
|
||||
void *submodels;
|
||||
|
||||
int touchFrame;
|
||||
int numlods;
|
||||
|
|
|
|||
|
|
@ -1250,6 +1250,41 @@ static bool Shaderpass_LoadMaterial( texture_t **normalmap, texture_t **glossmap
|
|||
return true;
|
||||
}
|
||||
|
||||
static bool Shaderpass_StudioLoadMaterial( texture_t **normalmap, texture_t **glossmap, texture_t **decalmap, const char *name, int addFlags, float bumpScale )
|
||||
{
|
||||
texture_t *images[3];
|
||||
|
||||
// set defaults
|
||||
images[0] = images[1] = images[2] = NULL;
|
||||
|
||||
// load normalmap image
|
||||
images[0] = R_FindTexture( va( "heightMap( Studio( \"%s_bump\" ), %g );", name, bumpScale ), NULL, 0, addFlags );
|
||||
if( !images[0] )
|
||||
{
|
||||
images[0] = R_FindTexture( va( "mergeDepthmap( Studio( \"%s_norm\" ), Studio( \"%s_depth\" ));", name, name ), NULL, 0, (addFlags|TF_NORMALMAP));
|
||||
|
||||
if( !images[0] )
|
||||
{
|
||||
if( !r_lighting_diffuse2heightmap->integer )
|
||||
return false;
|
||||
images[0] = R_FindTexture( va( "heightMap( Studio( \"%s\" ), 2.0f );", name ), NULL, 0, addFlags );
|
||||
if( !images[0] ) return false;
|
||||
}
|
||||
}
|
||||
|
||||
// load glossmap image
|
||||
if( r_lighting_specular->integer )
|
||||
images[1] = R_FindTexture( va( "Studio( %s_gloss )", name ), NULL, 0, addFlags );
|
||||
|
||||
images[2] = R_FindTexture( va( "Studio( %s_decal )", name ), NULL, 0, addFlags );
|
||||
|
||||
*normalmap = images[0];
|
||||
*glossmap = images[1];
|
||||
*decalmap = images[2];
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool Shaderpass_AnimFrequency( ref_shader_t *shader, ref_stage_t *pass, script_t *script )
|
||||
{
|
||||
float anim_fps;
|
||||
|
|
@ -3443,7 +3478,7 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
|
|||
break;
|
||||
case SHADER_STUDIO:
|
||||
shader->type = SHADER_STUDIO;
|
||||
shader->flags = SHADER_DEPTHWRITE|SHADER_CULL_FRONT;
|
||||
shader->flags = SHADER_DEPTHWRITE|SHADER_CULL_FRONT|SHADER_RENDERMODE;
|
||||
shader->features = MF_STCOORDS|MF_NORMALS;
|
||||
shader->num_stages = 1;
|
||||
shader->name = Shader_Malloc( length + 1 + sizeof( ref_stage_t ) * shader->num_stages );
|
||||
|
|
@ -3494,6 +3529,24 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
|
|||
shader->sort = SORT_OPAQUE;
|
||||
break;
|
||||
}
|
||||
// load default GLSL program if there's a bumpmap was found
|
||||
if(( r_lighting_models_followdeluxe->integer ? mapConfig.deluxeMappingEnabled : GL_Support( R_SHADER_GLSL100_EXT ))
|
||||
&& Shaderpass_StudioLoadMaterial( &materialImages[0], &materialImages[1], &materialImages[2], shortname, addFlags, 2.0f ))
|
||||
{
|
||||
shader->flags &= ~SHADER_RENDERMODE;
|
||||
pass->flags &= ~SHADERSTAGE_RENDERMODE;
|
||||
pass->rgbGen.type = RGBGEN_IDENTITY;
|
||||
pass->program = DEFAULT_GLSL_PROGRAM;
|
||||
pass->program_type = PROGRAM_TYPE_MATERIAL;
|
||||
pass->textures[1] = materialImages[0]; // normalmap
|
||||
pass->num_textures++;
|
||||
pass->textures[2] = materialImages[1]; // glossmap
|
||||
pass->num_textures++;
|
||||
pass->textures[3] = materialImages[2]; // decalmap
|
||||
pass->num_textures++;
|
||||
shader->features |= MF_SVECTORS|MF_ENABLENORMALS;
|
||||
shader->flags |= SHADER_MATERIAL;
|
||||
}
|
||||
break;
|
||||
case SHADER_SPRITE:
|
||||
shader->type = SHADER_SPRITE;
|
||||
|
|
|
|||
|
|
@ -16,17 +16,13 @@
|
|||
|
||||
=============================================================
|
||||
*/
|
||||
|
||||
#define STUDIO_API_VERSION 0.2
|
||||
|
||||
matrix4x4 m_protationmatrix;
|
||||
matrix4x4 m_pbonestransform[MAXSTUDIOBONES];
|
||||
matrix4x4 m_plighttransform[MAXSTUDIOBONES];
|
||||
matrix4x4 m_protationmatrix;
|
||||
static mesh_t studio_mesh;
|
||||
|
||||
vec3_t m_plightcolor; // ambient light color
|
||||
vec3_t m_plightvec; // ambleint light vector
|
||||
vec3_t m_pshadevector; // shadow vector
|
||||
vec3_t m_plightvec; // light vector
|
||||
vec3_t m_plightcolor; // ambient light color
|
||||
vec3_t m_plightdiffuse; // diffuse light color
|
||||
vec3_t studio_mins, studio_maxs;
|
||||
float studio_radius;
|
||||
|
||||
|
|
@ -34,41 +30,43 @@ float studio_radius;
|
|||
vec3_t *m_pxformverts;
|
||||
vec3_t *m_pxformnorms;
|
||||
vec3_t *m_pvlightvalues;
|
||||
vec3_t m_blightvec [MAXSTUDIOBONES];
|
||||
vec3_t g_blightvec[MAXSTUDIOBONES];
|
||||
vec3_t g_lightvalues[MAXSTUDIOVERTS];
|
||||
vec3_t g_dynlightcolor[MAX_DLIGHTS];
|
||||
vec3_t g_bdynlightvec[MAX_DLIGHTS][MAXSTUDIOBONES]; // light vectors in bone reference frames
|
||||
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
|
||||
char m_nCachedBoneNames[MAXSTUDIOBONES][32];
|
||||
matrix4x4 m_rgCachedBonesTransform [MAXSTUDIOBONES];
|
||||
matrix4x4 m_rgCachedLightTransform [MAXSTUDIOBONES];
|
||||
int g_numDynLights;
|
||||
int m_nCachedBones; // number of bones in cache
|
||||
|
||||
// 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
|
||||
|
||||
int m_fDoInterp;
|
||||
int m_pStudioModelCount;
|
||||
int m_nTopColor; // palette substition for top and bottom of model
|
||||
int m_nBottomColor;
|
||||
dstudiomodel_t *m_pSubModel;
|
||||
dstudiohdr_t *m_pStudioHeader;
|
||||
dstudiohdr_t *m_pTextureHeader;
|
||||
dstudiobodyparts_t *m_pBodyPart;
|
||||
|
||||
int m_nCachedBones; // number of bones in cache
|
||||
char m_nCachedBoneNames[MAXSTUDIOBONES][32];
|
||||
matrix4x4 m_rgCachedBonesTransform [MAXSTUDIOBONES];
|
||||
matrix4x4 m_rgCachedLightTransform [MAXSTUDIOBONES];
|
||||
|
||||
// sprite model used for drawing studio model chrome
|
||||
ref_model_t *m_pChromeSprite;
|
||||
byte *r_studiopool;
|
||||
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
|
||||
|
||||
// player gait sequence stuff
|
||||
int m_fGaitEstimation;
|
||||
float m_flGaitMovement;
|
||||
int m_fGaitEstimation;
|
||||
float m_flGaitMovement;
|
||||
|
||||
#define Studio_CopyString( str ) com.stralloc( r_studiopool, str, __FILE__, __LINE__ )
|
||||
// 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;
|
||||
dstudiohdr_t *m_pStudioHeader;
|
||||
dstudiohdr_t *m_pTextureHeader;
|
||||
dstudiobodyparts_t *m_pBodyPart;
|
||||
static mesh_t studio_mesh;
|
||||
|
||||
// studio cvars
|
||||
cvar_t *r_studio_bonelighting;
|
||||
cvar_t *r_studio_lambert;
|
||||
|
||||
/*
|
||||
====================
|
||||
|
|
@ -81,17 +79,14 @@ void R_StudioInit( void )
|
|||
m_pBodyPart = NULL;
|
||||
m_pStudioHeader = NULL;
|
||||
m_flGaitMovement = 1;
|
||||
r_studiopool = Mem_AllocPool( "StudioModels Zone" );
|
||||
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" );
|
||||
}
|
||||
|
||||
void R_StudioShutdown( void )
|
||||
{
|
||||
Mem_FreePool( &r_studiopool );
|
||||
}
|
||||
|
||||
void R_StudioFreeBoneposes( void )
|
||||
{
|
||||
Mem_EmptyPool( r_studiopool );
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -125,7 +120,14 @@ int R_StudioExtractBbox( dstudiohdr_t *phdr, int sequence, float *mins, float *m
|
|||
|
||||
void R_StudioModelBBox( ref_entity_t *e, vec3_t mins, vec3_t maxs )
|
||||
{
|
||||
R_StudioExtractBbox( e->model->phdr, e->sequence, mins, maxs );
|
||||
dstudiohdr_t *hdr;
|
||||
|
||||
if( !e || !e->model || !e->model->extradata )
|
||||
return;
|
||||
|
||||
hdr = ((mstudiomodel_t *)e->model->extradata)->phdr;
|
||||
if( !hdr ) return;
|
||||
R_StudioExtractBbox( hdr, e->sequence, mins, maxs );
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -165,13 +167,16 @@ dstudiohdr_t *R_StudioLoadHeader( ref_model_t *mod, const uint *buffer )
|
|||
if( phdr->textureindex > 0 && phdr->numtextures <= MAXSTUDIOSKINS )
|
||||
{
|
||||
mod->numshaders = phdr->numtextures;
|
||||
mod->shaders = Mem_Alloc( mod->mempool, sizeof( shader_t* ) * mod->numshaders );
|
||||
mod->shaders = Mod_Malloc( mod, sizeof( shader_t* ) * mod->numshaders );
|
||||
|
||||
for( i = 0; i < phdr->numtextures; i++ )
|
||||
{
|
||||
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] );
|
||||
com.snprintf( shadername, MAX_STRING, "%s/%s", mod->name, ptexture[i].name );
|
||||
FS_StripExtension( shadername ); // doesn't produce shaders with .ext
|
||||
Msg( "mod studio texture %s\n", shadername );
|
||||
mod->shaders[i] = R_LoadShader( shadername, SHADER_STUDIO, 0, 0, SHADER_INVALID );
|
||||
ptexture[i].shader = mod->shaders[i]->shadernum;
|
||||
}
|
||||
|
|
@ -183,11 +188,13 @@ void Mod_StudioLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buf
|
|||
{
|
||||
dstudiohdr_t *phdr = R_StudioLoadHeader( mod, buffer );
|
||||
dstudiohdr_t *thdr = NULL;
|
||||
mstudiomodel_t *poutmodel;
|
||||
void *texbuf;
|
||||
|
||||
if( !phdr ) return; // there were problems
|
||||
mod->phdr = (dstudiohdr_t *)Mem_Alloc(mod->mempool, LittleLong(phdr->length));
|
||||
Mem_Copy( mod->phdr, buffer, LittleLong( phdr->length ));
|
||||
mod->extradata = poutmodel = (mstudiomodel_t *)Mod_Malloc( mod, sizeof( mstudiomodel_t ));
|
||||
poutmodel->phdr = (dstudiohdr_t *)Mod_Malloc( mod, LittleLong( phdr->length ));
|
||||
Mem_Copy( poutmodel->phdr, buffer, LittleLong( phdr->length ));
|
||||
|
||||
if( phdr->numtextures == 0 )
|
||||
{
|
||||
|
|
@ -196,11 +203,11 @@ void Mod_StudioLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buf
|
|||
else MsgDev( D_ERROR, "textures for %s not found!\n", mod->name );
|
||||
|
||||
if( !thdr ) return; // there were problems
|
||||
mod->thdr = (dstudiohdr_t *)Mem_Alloc( mod->mempool, LittleLong( thdr->length ));
|
||||
Mem_Copy( mod->thdr, texbuf, LittleLong( thdr->length ));
|
||||
poutmodel->thdr = (dstudiohdr_t *)Mod_Malloc( mod, LittleLong( thdr->length ));
|
||||
Mem_Copy( poutmodel->thdr, texbuf, LittleLong( thdr->length ));
|
||||
if( texbuf ) Mem_Free( texbuf );
|
||||
}
|
||||
else mod->thdr = mod->phdr; // just make link
|
||||
else poutmodel->thdr = poutmodel->phdr; // just make link
|
||||
|
||||
R_StudioExtractBbox( phdr, 0, mod->mins, mod->maxs );
|
||||
mod->radius = RadiusFromBounds( mod->mins, mod->maxs );
|
||||
|
|
@ -316,10 +323,15 @@ float R_StudioFrameAdvance( ref_entity_t *ent, float flInterval )
|
|||
return flInterval;
|
||||
}
|
||||
|
||||
void R_StudioResetSequenceInfo( ref_entity_t *ent, dstudiohdr_t *hdr )
|
||||
void R_StudioResetSequenceInfo( ref_entity_t *ent )
|
||||
{
|
||||
if( !ent || !hdr ) return;
|
||||
dstudiohdr_t *hdr;
|
||||
|
||||
if( !ent || !ent->model || !ent->model->extradata )
|
||||
return;
|
||||
|
||||
hdr = ((mstudiomodel_t *)ent->model->extradata)->phdr;
|
||||
if( !hdr ) return;
|
||||
ent->m_fSequenceLoops = ((R_StudioGetSequenceFlags( hdr, ent ) & STUDIO_LOOPING) != 0 );
|
||||
|
||||
// calc anim time
|
||||
|
|
@ -619,13 +631,15 @@ StudioGetAnim
|
|||
|
||||
====================
|
||||
*/
|
||||
dstudioanim_t *R_StudioGetAnim( ref_model_t *m_pSubModel, dstudioseqdesc_t *pseqdesc )
|
||||
dstudioanim_t *R_StudioGetAnim( ref_model_t *m_pRefModel, dstudioseqdesc_t *pseqdesc )
|
||||
{
|
||||
dstudioseqgroup_t *pseqgroup;
|
||||
byte *paSequences;
|
||||
mstudiomodel_t *m_pSubModel = (mstudiomodel_t *)m_pRefModel->extradata;
|
||||
size_t filesize;
|
||||
byte *buf;
|
||||
|
||||
|
||||
Com_Assert( m_pSubModel == NULL );
|
||||
pseqgroup = (dstudioseqgroup_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqgroupindex) + pseqdesc->seqgroup;
|
||||
if( pseqdesc->seqgroup == 0 )
|
||||
return (dstudioanim_t *)((byte *)m_pStudioHeader + pseqgroup->data + pseqdesc->animindex);
|
||||
|
|
@ -633,24 +647,26 @@ dstudioanim_t *R_StudioGetAnim( ref_model_t *m_pSubModel, dstudioseqdesc_t *pseq
|
|||
|
||||
if( paSequences == NULL )
|
||||
{
|
||||
MsgDev( D_INFO, "loading %s\n", pseqgroup->name );
|
||||
buf = FS_LoadFile (pseqgroup->name, &filesize);
|
||||
if( !buf || !filesize )
|
||||
{
|
||||
MsgDev( D_ERROR, "R_StudioGetAnim: %s not found", pseqgroup->name );
|
||||
Mem_Set( pseqgroup->name, 0, sizeof(pseqgroup->name));
|
||||
return NULL;
|
||||
}
|
||||
if( IDSEQGRPHEADER == LittleLong(*(uint *)buf)) //it's sequence group
|
||||
{
|
||||
byte *pin = (byte *)buf;
|
||||
dstudioseqgroup_t *pseqhdr = (dstudioseqgroup_t *)pin;
|
||||
// allocate sequence groups if needs
|
||||
paSequences = (byte *)Mod_Malloc( m_pRefModel, sizeof( paSequences ) * MAXSTUDIOGROUPS );
|
||||
m_pSubModel->submodels = (void *)paSequences; // just a container
|
||||
}
|
||||
|
||||
if(((mstudiomodel_t *)&(paSequences[pseqdesc->seqgroup])) == NULL )
|
||||
{
|
||||
dstudioseqgroup_t *pseqhdr;
|
||||
|
||||
buf = FS_LoadFile( pseqgroup->name, &filesize );
|
||||
if( !buf || !filesize || IDSEQGRPHEADER != LittleLong(*(uint *)buf ))
|
||||
Host_Error( "R_StudioGetAnim: can't load %s\n", pseqgroup->name );
|
||||
|
||||
pseqhdr = (dstudioseqgroup_t *)buf;
|
||||
MsgDev( D_INFO, "R_StudioGetAnim: loading %s\n", pseqgroup->name );
|
||||
|
||||
paSequences = (byte *)Mem_Alloc( m_pSubModel->mempool, filesize );
|
||||
m_pSubModel->submodels = (void *)paSequences; // just a container
|
||||
Mem_Copy( &paSequences[pseqdesc->seqgroup], buf, filesize );
|
||||
Mem_Free( buf );
|
||||
}
|
||||
paSequences = (byte *)Mod_Malloc( m_pRefModel, filesize );
|
||||
m_pSubModel->submodels = (void *)paSequences; // just a container
|
||||
Mem_Copy( &paSequences[pseqdesc->seqgroup], buf, filesize );
|
||||
Mem_Free( buf );
|
||||
}
|
||||
return (dstudioanim_t *)((byte *)paSequences[pseqdesc->seqgroup] + pseqdesc->animindex );
|
||||
}
|
||||
|
|
@ -1144,7 +1160,7 @@ void R_StudioCalcAttachments( ref_entity_t *e )
|
|||
pattachment = (dstudioattachment_t *)((byte *)m_pStudioHeader + m_pStudioHeader->attachmentindex);
|
||||
for( i = 0; i < m_pStudioHeader->numattachments; i++ )
|
||||
{
|
||||
Matrix4x4_Transform( m_plighttransform[pattachment[i].bone], pattachment[i].org, e->attachment[i] );
|
||||
Matrix4x4_VectorTransform( m_plighttransform[pattachment[i].bone], pattachment[i].org, e->attachment[i] );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1215,6 +1231,27 @@ static bool R_StudioCheckBBox( void )
|
|||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
StudioSetupRender
|
||||
|
||||
====================
|
||||
*/
|
||||
static void R_StudioSetupRender( ref_entity_t *e, ref_model_t *mod )
|
||||
{
|
||||
mstudiomodel_t *m_pRefModel = (mstudiomodel_t *)mod->extradata;
|
||||
|
||||
// set global pointers
|
||||
m_pStudioHeader = m_pRefModel->phdr;
|
||||
m_pTextureHeader = m_pRefModel->thdr;
|
||||
|
||||
// set intermediate vertex buffers
|
||||
m_pvlightvalues = &g_lightvalues[0];
|
||||
|
||||
// misc info
|
||||
m_fDoInterp = (RI.currententity->flags & EF_NOINTERP) ? false : true;
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
StudioSetupModel
|
||||
|
|
@ -1234,62 +1271,121 @@ void R_StudioSetupModel( int body, int bodypart )
|
|||
m_pSubModel = (dstudiomodel_t *)((byte *)m_pStudioHeader + m_pBodyPart->modelindex) + index;
|
||||
}
|
||||
|
||||
void R_StudioSetupLighting( void )
|
||||
void R_StudioSetupLighting( ref_entity_t *e, ref_model_t *mod )
|
||||
{
|
||||
int i;
|
||||
dstudiobone_t *pbone;
|
||||
|
||||
// get light from floor or ceil
|
||||
m_plightvec[0] = 0.0f;
|
||||
m_plightvec[1] = 0.0f;
|
||||
m_plightvec[2] = (RI.currententity->flags & EF_INVLIGHT) ? 1.0f : -1.0f;
|
||||
int i;
|
||||
|
||||
{
|
||||
vec3_t light_org, dir;
|
||||
VectorCopy( RI.currententity->origin, light_org );
|
||||
light_org[2] += 3; // make sure what lightpoint is off the ground
|
||||
R_LightForOrigin( light_org, dir, m_plightcolor, NULL, RI.currentmodel->radius );
|
||||
}
|
||||
if( !r_studio_bonelighting->integer ) return;
|
||||
|
||||
// TODO: only do it for bones that actually have textures
|
||||
for (i = 0; i < m_pStudioHeader->numbones; i++)
|
||||
// set radius to 0 because we want handle dynamic lights manually
|
||||
R_LightForOrigin( e->lightingOrigin, m_plightvec, m_plightcolor, m_plightdiffuse, 0 );
|
||||
R_StudioSetupRender( e, mod );
|
||||
|
||||
for( i = 0; i < m_pStudioHeader->numbones; i++ )
|
||||
Matrix4x4_VectorRotate( m_pbonestransform[i], m_plightvec, g_blightvec[i] );
|
||||
|
||||
g_numDynLights = 0;
|
||||
|
||||
// add dynamic lights
|
||||
if( r_dynamiclight->integer && r_numDlights )
|
||||
{
|
||||
pbone = (dstudiobone_t *)((byte *)m_pStudioHeader + m_pStudioHeader->boneindex + i);
|
||||
//if( pbone->flags & STUDIO_HAS_CHROME )
|
||||
uint lnum;
|
||||
dlight_t *dl;
|
||||
float dist, radius, radius2;
|
||||
vec3_t direction;
|
||||
|
||||
for( lnum = 0, dl = r_dlights; lnum < r_numDlights; lnum++, dl++ )
|
||||
{
|
||||
Matrix4x4_Rotate3x3( m_pbonestransform[i], m_plightvec, m_blightvec[i] );
|
||||
if( !BoundsAndSphereIntersect( dl->mins, dl->maxs, e->lightingOrigin, mod->radius ))
|
||||
continue;
|
||||
|
||||
VectorSubtract( dl->origin, e->lightingOrigin, direction );
|
||||
dist = VectorLength( direction );
|
||||
|
||||
if( !dist || dist > dl->intensity + mod->radius )
|
||||
continue;
|
||||
|
||||
radius = RadiusFromBounds( dl->mins, dl->maxs );
|
||||
radius2 = radius * radius; // squared radius
|
||||
|
||||
for( i = 0; i < m_pStudioHeader->numbones; i++ )
|
||||
{
|
||||
vec3_t vec, org;
|
||||
float dist, atten;
|
||||
|
||||
Matrix4x4_OriginFromMatrix( m_pbonestransform[i], org );
|
||||
VectorSubtract( org, dl->origin, vec );
|
||||
|
||||
dist = DotProduct( vec, vec );
|
||||
atten = (dist / radius2 - 1) * -1;
|
||||
if( atten < 0 ) atten = 0;
|
||||
dist = com.sqrt( dist );
|
||||
if( dist )
|
||||
{
|
||||
dist = 1.0f / dist;
|
||||
VectorScale( vec, dist, vec );
|
||||
}
|
||||
|
||||
Matrix4x4_VectorRotate( m_pbonestransform[i], vec, g_bdynlightvec[g_numDynLights][i] );
|
||||
VectorScale( g_bdynlightvec[g_numDynLights][i], atten, g_bdynlightvec[g_numDynLights][i] );
|
||||
}
|
||||
|
||||
VectorCopy( dl->color, g_dynlightcolor[g_numDynLights] );
|
||||
g_numDynLights++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void R_StudioLighting( float *lv, int bone, int flags, vec3_t normal )
|
||||
{
|
||||
float lightcos;
|
||||
// light->ambientlight == m_lightcolor
|
||||
// light->addlight = m_plightdiffuse
|
||||
// light->lightdir = m_plightvec
|
||||
|
||||
float shadelight = 192.0f;
|
||||
float illum = 32.0f;//RF_MINLIGHT & RF_FULLBRIGHT
|
||||
void R_StudioLighting( vec3_t lv, int bone, int flags, vec3_t normal )
|
||||
{
|
||||
vec3_t illum;
|
||||
float lightcos;
|
||||
|
||||
if( !r_studio_bonelighting->integer ) return;
|
||||
VectorCopy( m_plightcolor, illum );
|
||||
|
||||
if( flags & STUDIO_NF_FLATSHADE )
|
||||
{
|
||||
illum += shadelight * 0.8f;
|
||||
VectorMA( illum, 0.8f, m_plightdiffuse, illum );
|
||||
}
|
||||
else
|
||||
{
|
||||
lightcos = DotProduct (normal, m_blightvec[bone]);// -1 colinear, 1 opposite
|
||||
if (lightcos > 1.0) lightcos = 1;
|
||||
float r;
|
||||
int i;
|
||||
|
||||
illum += shadelight;
|
||||
lightcos = (lightcos + 0.5f) / 1.5f;// do modified hemispherical lighting
|
||||
if (lightcos > 0.0) illum -= shadelight * lightcos;
|
||||
lightcos = DotProduct( normal, g_blightvec[bone] ); // -1 colinear, 1 opposite
|
||||
|
||||
if( lightcos > 1.0f ) lightcos = 1;
|
||||
VectorAdd( illum, m_plightdiffuse, illum );
|
||||
|
||||
r = r_studio_lambert->value;
|
||||
if( r < 1.0f ) r = 1.0f;
|
||||
lightcos = (lightcos + (r - 1.0)) / r; // do modified hemispherical lighting
|
||||
if( lightcos > 0.0f ) VectorMA( illum, -lightcos, m_plightdiffuse, illum );
|
||||
|
||||
if( illum[0] <= 0 ) illum[0] = 0;
|
||||
if( illum[1] <= 0 ) illum[1] = 0;
|
||||
if( illum[2] <= 0 ) illum[2] = 0;
|
||||
|
||||
// buz: now add all dynamic lights
|
||||
for( i = 0; i < g_numDynLights; i++)
|
||||
{
|
||||
lightcos = -DotProduct( normal, g_bdynlightvec[i][bone] );
|
||||
if( lightcos > 0 ) VectorMA( illum, lightcos, g_dynlightcolor[i], illum );
|
||||
}
|
||||
}
|
||||
illum = bound( 0, illum, 255);
|
||||
|
||||
*lv = illum / 255.0; // Light from 0 to 1.0
|
||||
|
||||
ColorNormalize( illum, illum );
|
||||
VectorScale( illum, 255, lv );
|
||||
}
|
||||
|
||||
void R_StudioSetupChrome( float *pchrome, int bone, vec3_t normal )
|
||||
{
|
||||
float n;
|
||||
float n;
|
||||
|
||||
if( g_chromeage[bone] != m_pStudioModelCount )
|
||||
{
|
||||
|
|
@ -1308,8 +1404,8 @@ void R_StudioSetupChrome( float *pchrome, int bone, vec3_t normal )
|
|||
CrossProduct( tmp, chromeupvec, chromerightvec );
|
||||
VectorNormalize( chromerightvec );
|
||||
|
||||
Matrix4x4_Rotate3x3( m_pbonestransform[bone], chromeupvec, g_chromeup[bone] );
|
||||
Matrix4x4_Rotate3x3( m_pbonestransform[bone], chromerightvec, g_chromeright[bone] );
|
||||
Matrix4x4_VectorIRotate( m_pbonestransform[bone], chromeupvec, g_chromeup[bone] );
|
||||
Matrix4x4_VectorIRotate( m_pbonestransform[bone], chromerightvec, g_chromeright[bone] );
|
||||
g_chromeage[bone] = m_pStudioModelCount;
|
||||
}
|
||||
|
||||
|
|
@ -1325,35 +1421,14 @@ void R_StudioSetupChrome( float *pchrome, int bone, vec3_t normal )
|
|||
void R_StudioDrawMesh( const meshbuffer_t *mb, int meshnum, dstudiotexture_t * ptexture, short *pskinref )
|
||||
{
|
||||
int i;
|
||||
float *av, *lv;
|
||||
float lv_tmp;
|
||||
float s, t;
|
||||
float *av, *lv;
|
||||
short *ptricmds;
|
||||
ref_shader_t *m_pSkinShader, *shader;
|
||||
ref_entity_t *e = RI.currententity;
|
||||
ref_shader_t *shader;
|
||||
int flags, features;
|
||||
bool tri_strip, calcNormals, calcSTVectors;
|
||||
dstudiomesh_t *pmesh = (dstudiomesh_t *)((byte *)m_pStudioHeader + m_pSubModel->meshindex);
|
||||
byte *pnormbone = ((byte *)m_pStudioHeader + m_pSubModel->norminfoindex);
|
||||
vec3_t *pstudionorms = (vec3_t *)((byte *)m_pStudioHeader + m_pSubModel->normindex);
|
||||
static int studio_framecount, studio_riparams;
|
||||
static dstudiomesh_t *studio_prevmesh;
|
||||
static ref_shader_t *studio_prevshader;
|
||||
static int max_vertexes = 0;
|
||||
int vertexState = 0;
|
||||
|
||||
if( studio_riparams != RI.params || RI.params & RP_SHADOWMAPVIEW )
|
||||
{
|
||||
studio_riparams = RI.params; // do not try to lock arrays between RI updates
|
||||
studio_framecount = !r_framecount;
|
||||
}
|
||||
|
||||
lv = (float *)m_pvlightvalues;
|
||||
if( meshnum > m_pSubModel->nummesh ) return;
|
||||
dstudiomesh_t *pmesh;
|
||||
|
||||
MB_NUM2SHADER( mb->shaderkey, shader );
|
||||
flags = ptexture[pskinref[pmesh[meshnum].skinref]].flags;
|
||||
|
||||
features = MF_NONBATCHED | shader->features;
|
||||
if( RI.params & RP_SHADOWMAPVIEW )
|
||||
{
|
||||
|
|
@ -1369,62 +1444,26 @@ void R_StudioDrawMesh( const meshbuffer_t *mb, int meshnum, dstudiotexture_t * p
|
|||
features |= MF_NORMALS|(GL_Support( R_SHADER_GLSL100_EXT ) ? MF_ENABLENORMALS : 0);
|
||||
}
|
||||
|
||||
for( i = 0; i < pmesh[meshnum].numnorms; i++, lv += 3, pstudionorms++, pnormbone++)
|
||||
{
|
||||
R_StudioLighting (&lv_tmp, *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 - m_pvlightvalues], *pnormbone, (float *)pstudionorms );
|
||||
VectorScale(m_plightcolor, lv_tmp, lv );
|
||||
}
|
||||
|
||||
pmesh = (dstudiomesh_t *)((byte *)m_pStudioHeader + m_pSubModel->meshindex) + meshnum;
|
||||
ptricmds = (short *)((byte *)m_pStudioHeader + pmesh->triindex);
|
||||
|
||||
calcNormals = calcSTVectors = false;
|
||||
calcNormals = (( features & MF_NORMALS ) != 0 ) && (( RI.currententity->frame != 0 ) || ( RI.currententity->prev.frame != 0 ));
|
||||
|
||||
if( studio_framecount == r_framecount && RI.previousentity && RI.previousentity->model == RI.currententity->model && studio_prevmesh == pmesh && studio_prevshader == shader )
|
||||
{
|
||||
ref_entity_t *pe = RI.previousentity;
|
||||
if( pe->frame == RI.currententity->frame && pe->prev.frame == RI.currententity->prev.frame && ( pe->backlerp == RI.currententity->backlerp || RI.currententity->frame == RI.currententity->prev.frame ))
|
||||
{
|
||||
calcNormals = ( calcNormals && ( shader->features & SHADER_DEFORM_NORMAL ));
|
||||
}
|
||||
}
|
||||
|
||||
s = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].width;
|
||||
t = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].height;
|
||||
flags = ptexture[pskinref[pmesh->skinref]].flags;
|
||||
s = 1.0 / (float)ptexture[pskinref[pmesh->skinref]].width;
|
||||
t = 1.0 / (float)ptexture[pskinref[pmesh->skinref]].height;
|
||||
m_pSkinShader = &r_shaders[ptexture[pskinref[pmesh->skinref]].shader];
|
||||
|
||||
studio_prevmesh = pmesh;
|
||||
studio_prevshader = shader;
|
||||
studio_framecount = r_framecount;
|
||||
|
||||
while( i = *(ptricmds++))
|
||||
{
|
||||
int vertexState = 0;
|
||||
bool tri_strip;
|
||||
|
||||
if( i < 0 )
|
||||
{
|
||||
i = -i;
|
||||
tri_strip = false;
|
||||
}
|
||||
else tri_strip = true;
|
||||
vertexState = 0;
|
||||
|
||||
for( ; i > 0; i--, ptricmds += 4 )
|
||||
{
|
||||
if( flags & STUDIO_NF_CHROME )
|
||||
Vector2Set( inCoordsArray[r_backacc.numVerts], g_chrome[ptricmds[1]][0] * s, g_chrome[ptricmds[1]][1] * t );
|
||||
else Vector2Set( inCoordsArray[r_backacc.numVerts], ptricmds[2] * s, ptricmds[3] * t );
|
||||
|
||||
lv = m_pvlightvalues[ptricmds[1]];
|
||||
//inColorsArray[0][r_backacc.numVerts][0] = (lv[0] * 255);
|
||||
//inColorsArray[0][r_backacc.numVerts][1] = (lv[1] * 255);
|
||||
//inColorsArray[0][r_backacc.numVerts][2] = (lv[2] * 255);
|
||||
//inColorsArray[0][r_backacc.numVerts][3] = 255;
|
||||
|
||||
if( vertexState++ < 3 )
|
||||
{
|
||||
inElemsArray[r_backacc.numElems++] = r_backacc.numVerts;
|
||||
|
|
@ -1454,23 +1493,26 @@ void R_StudioDrawMesh( const meshbuffer_t *mb, int meshnum, dstudiotexture_t * p
|
|||
inElemsArray[r_backacc.numElems++] = r_backacc.numVerts - 1;
|
||||
inElemsArray[r_backacc.numElems++] = r_backacc.numVerts;
|
||||
}
|
||||
|
||||
if( flags & STUDIO_NF_CHROME )
|
||||
Vector2Set( inCoordsArray[r_backacc.numVerts], g_chrome[ptricmds[1]][0] * s, g_chrome[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]];
|
||||
Vector4Set( inColorsArray[0][r_backacc.numVerts], lv[0], lv[1], lv[2], 255 );
|
||||
}
|
||||
av = m_pxformverts[ptricmds[0]]; // verts
|
||||
Vector4Set( inVertsArray[r_backacc.numVerts], av[0], av[1], av[2], 1.0f );
|
||||
lv = m_pxformnorms[ptricmds[1]]; // verts
|
||||
VectorNormalizeFast( lv );
|
||||
Vector4Set( inNormalsArray[r_backacc.numVerts], lv[0], lv[1], lv[2], 1.0f );
|
||||
r_backacc.numVerts++;
|
||||
}
|
||||
}
|
||||
if( calcSTVectors )
|
||||
if( features & MF_SVECTORS )
|
||||
R_BuildTangentVectors( r_backacc.numVerts, inVertsArray, inNormalsArray, inCoordsArray, r_backacc.numElems / 3, inElemsArray, inSVectorsArray );
|
||||
|
||||
if( max_vertexes < r_backacc.numVerts )
|
||||
{
|
||||
Msg("Draw mesh max %i vertexes\n", r_backacc.numVerts );
|
||||
max_vertexes = r_backacc.numVerts;
|
||||
}
|
||||
|
||||
studio_mesh.elems = inElemsArray;
|
||||
studio_mesh.numElems = r_backacc.numElems;
|
||||
studio_mesh.numVertexes = r_backacc.numVerts;
|
||||
|
|
@ -1576,14 +1618,14 @@ void R_StudioDrawHitboxes( void )
|
|||
v[7][1] = bbmin[1];
|
||||
v[7][2] = bbmax[2];
|
||||
|
||||
Matrix4x4_Transform (m_pbonestransform[pbboxes[i].bone], v[0], v2[0]);
|
||||
Matrix4x4_Transform (m_pbonestransform[pbboxes[i].bone], v[1], v2[1]);
|
||||
Matrix4x4_Transform (m_pbonestransform[pbboxes[i].bone], v[2], v2[2]);
|
||||
Matrix4x4_Transform (m_pbonestransform[pbboxes[i].bone], v[3], v2[3]);
|
||||
Matrix4x4_Transform (m_pbonestransform[pbboxes[i].bone], v[4], v2[4]);
|
||||
Matrix4x4_Transform (m_pbonestransform[pbboxes[i].bone], v[5], v2[5]);
|
||||
Matrix4x4_Transform (m_pbonestransform[pbboxes[i].bone], v[6], v2[6]);
|
||||
Matrix4x4_Transform (m_pbonestransform[pbboxes[i].bone], v[7], v2[7]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pbboxes[i].bone], v[0], v2[0]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pbboxes[i].bone], v[1], v2[1]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pbboxes[i].bone], v[2], v2[2]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pbboxes[i].bone], v[3], v2[3]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pbboxes[i].bone], v[4], v2[4]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pbboxes[i].bone], v[5], v2[5]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pbboxes[i].bone], v[6], v2[6]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pbboxes[i].bone], v[7], v2[7]);
|
||||
|
||||
pglBegin( GL_QUAD_STRIP );
|
||||
for (j = 0; j < 10; j++) pglVertex3fv (v2[j & 7]);
|
||||
|
|
@ -1616,10 +1658,10 @@ void R_StudioDrawAttachments( void )
|
|||
dstudioattachment_t *pattachments = (dstudioattachment_t *) ((byte *)m_pStudioHeader + m_pStudioHeader->attachmentindex);
|
||||
vec3_t v[4];
|
||||
|
||||
Matrix4x4_Transform (m_pbonestransform[pattachments[i].bone], pattachments[i].org, v[0]);
|
||||
Matrix4x4_Transform (m_pbonestransform[pattachments[i].bone], pattachments[i].vectors[0], v[1]);
|
||||
Matrix4x4_Transform (m_pbonestransform[pattachments[i].bone], pattachments[i].vectors[1], v[2]);
|
||||
Matrix4x4_Transform (m_pbonestransform[pattachments[i].bone], pattachments[i].vectors[2], v[3]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pattachments[i].bone], pattachments[i].org, v[0]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pattachments[i].bone], pattachments[i].vectors[0], v[1]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pattachments[i].bone], pattachments[i].vectors[1], v[2]);
|
||||
Matrix4x4_VectorTransform (m_pbonestransform[pattachments[i].bone], pattachments[i].vectors[2], v[3]);
|
||||
|
||||
pglBegin (GL_LINES);
|
||||
pglColor3f (1, 0, 0);
|
||||
|
|
@ -1678,16 +1720,6 @@ void R_StudioDrawHulls ( void )
|
|||
pglEnd();
|
||||
}
|
||||
|
||||
void R_StudioDrawShadow ( void )
|
||||
{
|
||||
float an = RI.currententity->angles[1] / 180 * M_PI;
|
||||
|
||||
m_pshadevector[0] = cos(-an);
|
||||
m_pshadevector[1] = sin(-an);
|
||||
m_pshadevector[2] = 1;
|
||||
VectorNormalize( m_pshadevector );
|
||||
}
|
||||
|
||||
void R_StudioSetRemapColors( int m_topColor, int m_bottomColor )
|
||||
{
|
||||
// FIXME: get some code from q1
|
||||
|
|
@ -1720,19 +1752,6 @@ void R_StudioRenderModel( void )
|
|||
}
|
||||
}
|
||||
|
||||
static void R_StudioSetupRender( ref_entity_t *e, ref_model_t *mod )
|
||||
{
|
||||
// set global pointers
|
||||
m_pStudioHeader = mod->phdr;
|
||||
m_pTextureHeader = mod->thdr;
|
||||
|
||||
// set intermediate vertex buffers
|
||||
m_pvlightvalues = &g_lightvalues[0];
|
||||
|
||||
// misc info
|
||||
m_fDoInterp = (RI.currententity->flags & EF_NOINTERP) ? false : true;
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
StudioDrawModel
|
||||
|
|
@ -1776,45 +1795,7 @@ bool R_StudioDrawModel( ref_entity_t *e, int flags )
|
|||
// copy attachments back to client entity
|
||||
Mem_Copy( ent->v.attachment, e->attachment, sizeof( vec3_t ) * MAXSTUDIOATTACHMENTS );
|
||||
while(( index = R_StudioGetEvent( e, &event, flStart, flEnd, index )) != 0 )
|
||||
{
|
||||
ri.StudioEvent( &event, ent );
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
//////// AFTER THIS POINT GO STUDIO MODEL DRAW ///////
|
||||
//////// SAVE BONES INTO LOCAL ARRAY /////////////////
|
||||
|
||||
if( flags & STUDIO_RENDER )
|
||||
{
|
||||
R_StudioSetupLighting( );
|
||||
|
||||
// get remap colors
|
||||
m_nTopColor = RI.currententity->colormap & 0xFF;
|
||||
m_nBottomColor = (RI.currententity->colormap & 0xFF00)>>8;
|
||||
|
||||
R_StudioSetRemapColors( m_nTopColor, m_nBottomColor );
|
||||
R_StudioRenderModel( );
|
||||
|
||||
// draw weaponmodel for monsters
|
||||
if( RI.currententity->weaponmodel )
|
||||
{
|
||||
ref_entity_t saveent = *RI.currententity;
|
||||
ref_model_t *pweaponmodel = RI.currententity->weaponmodel;
|
||||
|
||||
// get remap colors
|
||||
m_nTopColor = RI.currententity->colormap & 0xFF;
|
||||
m_nBottomColor = (RI.currententity->colormap & 0xFF00)>>8;
|
||||
R_StudioSetRemapColors( m_nTopColor, m_nBottomColor );
|
||||
|
||||
m_pStudioHeader = pweaponmodel->phdr;
|
||||
m_pTextureHeader = pweaponmodel->thdr;
|
||||
R_StudioMergeBones( e, pweaponmodel );
|
||||
R_StudioSetupLighting( );
|
||||
|
||||
R_StudioRenderModel( );
|
||||
R_StudioCalcAttachments( e );
|
||||
*RI.currententity = saveent;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -2042,64 +2023,14 @@ int R_StudioDrawPlayer( ref_entity_t *e, int flags )
|
|||
// copy attachments back to client entity
|
||||
Mem_Copy( ent->v.attachment, e->attachment, sizeof( vec3_t ) * MAXSTUDIOATTACHMENTS );
|
||||
while(( index = R_StudioGetEvent( e, &event, flStart, flEnd, index )) != 0 )
|
||||
{
|
||||
ri.StudioEvent( &event, ent );
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
//////// AFTER THIS POINT GO STUDIO MODEL DRAW ///////
|
||||
//////// SAVE BONES INTO LOCAL ARRAY /////////////////
|
||||
|
||||
if( flags & STUDIO_RENDER )
|
||||
{
|
||||
// show highest resolution multiplayer model
|
||||
if( r_himodels->integer && RI.currentmodel != e->model )
|
||||
e->body = 255;
|
||||
|
||||
if(!(glw_state.developer == 0 && ri.GetMaxClients() == 1 ) && ( RI.currentmodel == e->model ))
|
||||
e->body = 1; // force helmet
|
||||
|
||||
R_StudioSetupLighting( );
|
||||
|
||||
// get remap colors
|
||||
m_nTopColor = e->colormap & 0xFF;
|
||||
m_nBottomColor = (e->colormap & 0xFF00)>>8;
|
||||
|
||||
if( m_nTopColor < 0 ) m_nTopColor = 0;
|
||||
if( m_nTopColor > 360 ) m_nTopColor = 360;
|
||||
if( m_nBottomColor < 0 ) m_nBottomColor = 0;
|
||||
if( m_nBottomColor > 360 ) m_nBottomColor = 360;
|
||||
|
||||
R_StudioSetRemapColors( m_nTopColor, m_nBottomColor );
|
||||
|
||||
R_StudioRenderModel( );
|
||||
|
||||
if( e->weaponmodel )
|
||||
{
|
||||
ref_entity_t saveent = *RI.currententity;
|
||||
ref_model_t *pweaponmodel = e->weaponmodel;
|
||||
// get remap colors
|
||||
m_nTopColor = e->colormap & 0xFF;
|
||||
m_nBottomColor = (e->colormap & 0xFF00)>>8;
|
||||
R_StudioSetRemapColors( m_nTopColor, m_nBottomColor );
|
||||
|
||||
m_pStudioHeader = pweaponmodel->phdr;
|
||||
m_pTextureHeader = pweaponmodel->thdr;
|
||||
R_StudioMergeBones( e, pweaponmodel );
|
||||
R_StudioSetupLighting( );
|
||||
|
||||
R_StudioRenderModel( );
|
||||
R_StudioCalcAttachments( e );
|
||||
*RI.currententity = saveent;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
void R_StudioDrawPoints( const meshbuffer_t *mb )
|
||||
{
|
||||
int i, m_skinnum = RI.currententity->skin;
|
||||
int i, j, m_skinnum = RI.currententity->skin;
|
||||
int modelnum;
|
||||
int meshnum;
|
||||
int infokey = -mb->infokey - 1;
|
||||
|
|
@ -2170,36 +2101,51 @@ void R_StudioDrawPoints( const meshbuffer_t *mb )
|
|||
}
|
||||
if( mb->LODModelHandle != old_model ) old_model = mb->LODModelHandle;
|
||||
if( old_entity != RI.currententity ) old_entity = RI.currententity;
|
||||
|
||||
R_StudioSetupLighting( e, Mod_ForHandle( mb->LODModelHandle ));
|
||||
}
|
||||
|
||||
R_StudioSetupModel( RI.currententity->body, modelnum );
|
||||
if( meshnum > m_pSubModel->nummesh ) return;
|
||||
|
||||
pvertbone = ((byte *)m_pStudioHeader + m_pSubModel->vertinfoindex);
|
||||
pnormbone = ((byte *)m_pStudioHeader + m_pSubModel->norminfoindex);
|
||||
ptexture = (dstudiotexture_t *)((byte *)m_pTextureHeader + m_pTextureHeader->textureindex);
|
||||
|
||||
pstudioverts = (vec3_t *)((byte *)m_pStudioHeader + m_pSubModel->vertindex);
|
||||
pstudionorms = (vec3_t *)((byte *)m_pStudioHeader + m_pSubModel->normindex);
|
||||
|
||||
pskinref = (short *)((byte *)m_pTextureHeader + m_pTextureHeader->skinindex);
|
||||
if( m_skinnum != 0 && m_skinnum < m_pTextureHeader->numskinfamilies )
|
||||
pskinref += (m_skinnum * m_pTextureHeader->numskinref);
|
||||
|
||||
if( doTransform )
|
||||
{
|
||||
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);
|
||||
|
||||
m_pxformverts = g_xformverts[modelnum];
|
||||
m_pxformnorms = g_xformnorms[modelnum];
|
||||
|
||||
if( !g_cachestate[modelnum] )
|
||||
{
|
||||
dstudiomesh_t *pmesh = (dstudiomesh_t *)((byte *)m_pStudioHeader + m_pSubModel->meshindex);
|
||||
float *lv = (float *)g_lightvalues;
|
||||
|
||||
for( i = 0; i < m_pSubModel->numverts; i++ )
|
||||
{
|
||||
vec3_t tmp;
|
||||
Matrix4x4_VectorTransform( m_pbonestransform[pvertbone[i]], pstudioverts[i], m_pxformverts[i] );
|
||||
Matrix4x4_VectorIRotate( m_pbonestransform[pvertbone[i]], pstudionorms[i], m_pxformnorms[i] );
|
||||
}
|
||||
for( i = 0; i < m_pSubModel->nummesh; i++ )
|
||||
{
|
||||
int flags = ptexture[pskinref[pmesh[i].skinref]].flags;
|
||||
|
||||
VectorCopy( pstudionorms[i], tmp );
|
||||
VectorNormalizeFast( tmp );
|
||||
Matrix4x4_Transform( m_pbonestransform[pvertbone[i]], pstudioverts[i], m_pxformverts[i] );
|
||||
Matrix4x4_Transform( m_pbonestransform[pvertbone[i]], tmp, m_pxformnorms[i] );
|
||||
for( j = 0; j < pmesh[i].numnorms; j++, lv += 3, pstudionorms++, pnormbone++)
|
||||
{
|
||||
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 );
|
||||
}
|
||||
}
|
||||
g_cachestate[modelnum] = true;
|
||||
}
|
||||
|
|
@ -2254,7 +2200,7 @@ bool R_CullStudioModel( ref_entity_t *e )
|
|||
|
||||
R_StudioSetupRender( e, e->model );
|
||||
|
||||
if( !e->model->phdr )
|
||||
if( !e->model->extradata )
|
||||
return true;
|
||||
|
||||
modhandle = Mod_Handle( e->model );
|
||||
|
|
@ -2341,7 +2287,7 @@ void R_AddStudioModelToList( ref_entity_t *e )
|
|||
int i, j;
|
||||
|
||||
R_StudioSetupRender( e, e->model );
|
||||
if( !e->model->phdr ) return;
|
||||
if( !e->model->extradata ) return;
|
||||
|
||||
if(!R_ExtractBbox( e->sequence, studio_mins, studio_maxs )) return; // invalid sequence
|
||||
studio_radius = RadiusFromBounds( studio_mins, studio_maxs );
|
||||
|
|
|
|||
|
|
@ -0,0 +1,64 @@
|
|||
<html>
|
||||
<body>
|
||||
<pre>
|
||||
<h1>Build Log</h1>
|
||||
<h3>
|
||||
--------------------Configuration: render - Win32 Debug--------------------
|
||||
</h3>
|
||||
<h3>Command Lines</h3>
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP16DC.tmp" with contents
|
||||
[
|
||||
/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_main.c"
|
||||
]
|
||||
Creating command line "cl.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP16DC.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP16DD.tmp" with contents
|
||||
[
|
||||
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_skin.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\RSP16DD.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP16DE.bat" with contents
|
||||
[
|
||||
@echo off
|
||||
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\RSP16DE.bat"
|
||||
Compiling...
|
||||
r_main.c
|
||||
Linking...
|
||||
Creating library ..\temp\render\!debug/render.lib and object ..\temp\render\!debug/render.exp
|
||||
<h3>Output Window</h3>
|
||||
Performing Custom Build Step on \Xash3D\src_main\temp\render\!debug\render.dll
|
||||
‘ª®¯¨à®¢ ® ä ©«®¢: 1.
|
||||
|
||||
|
||||
|
||||
<h3>Results</h3>
|
||||
render.dll - 0 error(s), 0 warning(s)
|
||||
</pre>
|
||||
</body>
|
||||
</html>
|
||||
8
todo.log
8
todo.log
|
|
@ -130,5 +130,9 @@ Beta 13.12.09
|
|||
106. implement q3map2 into xtools.dll OK
|
||||
107. implement shader sorting for rendermodes OK
|
||||
108. prepare QuArK to Xash-ready OK
|
||||
109. implement q1 models instead of q3 models
|
||||
110. loading textures for q1 models
|
||||
109. implement q1 models instead of q3 models OK
|
||||
110. loading textures for q1 models OK
|
||||
111. implement SSE_Transform if possible
|
||||
112. finalize alias models
|
||||
113. clean up renderer sources
|
||||
114. reorganize MathLib.
|
||||
|
|
|
|||
|
|
@ -1123,7 +1123,7 @@ void SimplifyModel( void )
|
|||
{
|
||||
for( j = 0; j < model[k]->numverts; j++ )
|
||||
{
|
||||
Matrix4x4_Transform( bonetransform[model[k]->vert[j].bone], model[k]->vert[j].org, pos );
|
||||
Matrix4x4_VectorTransform( bonetransform[model[k]->vert[j].bone], model[k]->vert[j].org, pos );
|
||||
|
||||
if (pos[0] < bmin[0]) bmin[0] = pos[0];
|
||||
if (pos[1] < bmin[1]) bmin[1] = pos[1];
|
||||
|
|
@ -1360,7 +1360,7 @@ void Build_Reference( s_model_t *pmodel)
|
|||
Matrix4x4_Transpose( bonefixup[i].im, bonefixup[i].m );
|
||||
|
||||
// calc true world coord.
|
||||
Matrix4x4_Transform( bonefixup[parent].m, pmodel->skeleton[i].pos, p );
|
||||
Matrix4x4_VectorTransform( bonefixup[parent].m, pmodel->skeleton[i].pos, p );
|
||||
VectorAdd( p, bonefixup[parent].worldorg, bonefixup[i].worldorg );
|
||||
}
|
||||
}
|
||||
|
|
@ -1392,7 +1392,7 @@ void Grab_Triangles( s_model_t *pmodel )
|
|||
linecount++;
|
||||
|
||||
// check for end
|
||||
if( !com.strcmp( "end\n", line )) return;
|
||||
if( !com.stricmp( "end", line )) return;
|
||||
|
||||
// strip off trailing smag
|
||||
com.strncpy( texturename, line, sizeof( texturename ));
|
||||
|
|
@ -1457,11 +1457,11 @@ void Grab_Triangles( s_model_t *pmodel )
|
|||
|
||||
// move vertex position to object space.
|
||||
VectorSubtract( p.org, bonefixup[p.bone].worldorg, tmp );
|
||||
Matrix4x4_Transform( bonefixup[p.bone].im, tmp, p.org );
|
||||
Matrix4x4_VectorTransform( bonefixup[p.bone].im, tmp, p.org );
|
||||
|
||||
// move normal to object space.
|
||||
VectorCopy( normal.org, tmp );
|
||||
Matrix4x4_Transform( bonefixup[p.bone].im, tmp, normal.org );
|
||||
Matrix4x4_VectorTransform( bonefixup[p.bone].im, tmp, normal.org );
|
||||
VectorNormalize( normal.org );
|
||||
|
||||
ptriv->normindex = lookup_normal( pmodel, &normal );
|
||||
|
|
|
|||
|
|
@ -731,10 +731,20 @@ int lookup_texture( char *texturename )
|
|||
texture[i] = Mem_Alloc( studiopool, sizeof(s_texture_t));
|
||||
com.strncpy( texture[i]->name, texturename, sizeof(texture[i]->name));
|
||||
|
||||
if(com.stristr( texturename, "chrome" ) != NULL)
|
||||
texture[i]->flags = STUDIO_NF_FLATSHADE | STUDIO_NF_CHROME;
|
||||
else if(com.stristr( texturename, "bright" ) != NULL)
|
||||
texture[i]->flags = STUDIO_NF_FLATSHADE | STUDIO_NF_FULLBRIGHT;
|
||||
if( com.stristr( texturename, "chrome" ))
|
||||
texture[i]->flags = (STUDIO_NF_FLATSHADE|STUDIO_NF_CHROME);
|
||||
else if( com.stristr( texturename, "bright" ))
|
||||
texture[i]->flags = (STUDIO_NF_FLATSHADE|STUDIO_NF_FULLBRIGHT);
|
||||
else if( com.stristr( texturename, "_norm" ))
|
||||
texture[i]->flags = STUDIO_NF_NORMALMAP;
|
||||
else if( com.stristr( texturename, "_bump" ) || com.stristr( texturename, "_depth" ))
|
||||
texture[i]->flags = STUDIO_NF_BUMPMAP;
|
||||
else if( com.stristr( texturename, "_gloss" ))
|
||||
texture[i]->flags = STUDIO_NF_GLOSSMAP;
|
||||
else if( com.stristr( texturename, "_decal" ))
|
||||
texture[i]->flags = STUDIO_NF_DECALMAP;
|
||||
else if( com.stristr( texturename, "_glow" ) || com.stristr( texturename, "_luma" ))
|
||||
texture[i]->flags = STUDIO_NF_GLOWMAP;
|
||||
else texture[i]->flags = 0;
|
||||
|
||||
numtextures++;
|
||||
|
|
|
|||
Reference in New Issue