FWGS
/
Xash3DArchive
Archived
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

05 Aug 2009

This commit is contained in:
g-cont 2009-08-05 00:00:00 +04:00 committed by Alibek Omarov
parent be2ac55788
commit 8a8a350e9b
29 changed files with 939 additions and 499 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
client/client.plg Normal file
View File

@ -0,0 +1,65 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: client - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP516.tmp" with contents
[
/nologo /MDd /W3 /Gm /Gi /GX /ZI /Od /I "./" /I "../common" /I "global" /I "hud" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FR"..\temp\client\!debug/" /Fo"..\temp\client\!debug/" /Fd"..\temp\client\!debug/" /FD /c
"D:\Xash3D\src_main\client\hud\hud_warhead.cpp"
]
Creating command line "cl.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP516.tmp"
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP517.tmp" with contents
[
msvcrtd.lib /nologo /subsystem:windows /dll /incremental:yes /pdb:"..\temp\client\!debug/client.pdb" /debug /machine:I386 /nodefaultlib:"libc.lib" /def:".\client.def" /out:"..\temp\client\!debug/client.dll" /implib:"..\temp\client\!debug/client.lib" /pdbtype:sept /libpath:"..\common\libs"
"\Xash3D\src_main\temp\client\!debug\dll_int.obj"
"\Xash3D\src_main\temp\client\!debug\hud.obj"
"\Xash3D\src_main\temp\client\!debug\hud_ammo.obj"
"\Xash3D\src_main\temp\client\!debug\hud_ammohistory.obj"
"\Xash3D\src_main\temp\client\!debug\hud_battery.obj"
"\Xash3D\src_main\temp\client\!debug\hud_death.obj"
"\Xash3D\src_main\temp\client\!debug\hud_flashlight.obj"
"\Xash3D\src_main\temp\client\!debug\hud_geiger.obj"
"\Xash3D\src_main\temp\client\!debug\hud_health.obj"
"\Xash3D\src_main\temp\client\!debug\hud_icons.obj"
"\Xash3D\src_main\temp\client\!debug\hud_menu.obj"
"\Xash3D\src_main\temp\client\!debug\hud_message.obj"
"\Xash3D\src_main\temp\client\!debug\hud_motd.obj"
"\Xash3D\src_main\temp\client\!debug\hud_msg.obj"
"\Xash3D\src_main\temp\client\!debug\hud_saytext.obj"
"\Xash3D\src_main\temp\client\!debug\hud_scoreboard.obj"
"\Xash3D\src_main\temp\client\!debug\hud_sound.obj"
"\Xash3D\src_main\temp\client\!debug\hud_statusbar.obj"
"\Xash3D\src_main\temp\client\!debug\hud_text.obj"
"\Xash3D\src_main\temp\client\!debug\hud_train.obj"
"\Xash3D\src_main\temp\client\!debug\hud_warhead.obj"
"\Xash3D\src_main\temp\client\!debug\hud_zoom.obj"
"\Xash3D\src_main\temp\client\!debug\tempents.obj"
"\Xash3D\src_main\temp\client\!debug\triapi.obj"
"\Xash3D\src_main\temp\client\!debug\utils.obj"
"\Xash3D\src_main\temp\client\!debug\view.obj"
]
Creating command line "link.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP517.tmp"
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP518.bat" with contents
[
@echo off
copy \Xash3D\src_main\temp\client\!debug\client.dll "D:\Xash3D\bin\client.dll"
]
Creating command line "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP518.bat"
Compiling...
hud_warhead.cpp
Linking...
<h3>Output Window</h3>
Performing Custom Build Step on \Xash3D\src_main\temp\client\!debug\client.dll
‘ª®¯¨à®¢ ­® ä ©«®¢: 1.
<h3>Results</h3>
client.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

3
client/global/tempents.cpp
View File

@ -296,7 +296,7 @@ void CL_TeleportParticles( const Vector org )
void CL_PlaceDecal( Vector pos, Vector dir, float scale, HSPRITE hDecal )
{
float rgba[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
int flags = DECAL_FADE;
int flags = DECAL_FADEALPHA;
g_engfuncs.pEfxAPI->R_SetDecal( pos, dir, rgba, RANDOM_LONG( 0, 360 ), scale, hDecal, flags );
}
@ -328,6 +328,7 @@ void HUD_ParseTempEntity( void )
pos.z = READ_COORD();
READ_SHORT(); // FIXME: skip entindex
g_engfuncs.pEfxAPI->CL_FindExplosionPlane( pos, 10, dir );
CL_BulletParticles( pos, Vector( 0, 0, -1 ));
CL_PlaceDecal( pos, dir, 10, g_engfuncs.pEfxAPI->CL_DecalIndex( READ_BYTE() ));
break;
case TE_DECAL:

6
client/hud/hud_warhead.cpp
View File

@ -118,14 +118,14 @@ int CHudRedeemer :: Draw( float flTime )
// disable fade
SetScreenFade( Vector( 1, 1, 1 ), 0, 0, 0, FFADE_OUT );
}
else if( m_iHudMode == 1 ) // draw videocamera screen
else if( m_iHudMode == 4 ) // draw videocamera screen
{
// play at 15fps
// play at 1.5 fps
frame = (int)(flTime * 1.5f) % SPR_Frames( m_hCamRec );
// draw interlaces
SPR_Set( m_hCamera, 16, 96, 16, 64 ); // give this value from breaklight.bsp (xash03)
SPR_DrawAdditive( frame, 0, 0, ScreenWidth, ScreenHeight );
SPR_DrawAdditive( 0, 0, 0, ScreenWidth, ScreenHeight );
// draw recorder icon
SPR_Set( m_hCamRec, 255, 0, 0, 255 ); // give this value from breaklight.bsp (xash03)

22
common/const.h
View File

@ -75,18 +75,12 @@
#define EF_NODRAW (1<<6) // don't draw entity
#define EF_ROTATE (1<<7) // rotate bonus item
#define EF_MINLIGHT (1<<8) // allways have some light (viewmodel)
#define EF_LIGHT (1<<9) // dynamic light (rockets use)
#define EF_ANIMATE (1<<10) // do client animate (ignore v.frame)
// entity_state_t->renderfx flags (temp)
#define RF_FULLBRIGHT 1 // always draw full intensity
#define RF_NOSHADOW 2
#define RF_VIEWERMODEL 4 // don't draw through eyes, only mirrors
#define RF_WEAPONMODEL 8 // only draw through eyes and depth hack
#define RF_CULLHACK 16
#define RF_FORCENOLOD 32
#define RF_PLANARSHADOW 64
#define RF_OCCLUSIONTEST 128
#define EF_FULLBRIGHT (1<<9) // completely ignore light values
#define EF_LIGHT (1<<10) // dynamic light (rockets use)
#define EF_ANIMATE (1<<11) // do client animate (ignore v.frame)
#define EF_NOSHADOW (1<<12) // ignore shadow for this entity
#define EF_PLANARSHADOW (1<<13) // use fast planarshadow method instead of shadow casters
#define EF_OCCLUSIONTEST (1<<14) // use occlusion test for this entity (e.g. glares)
// pev->takedamage
#define DAMAGE_NO 0 // can't be damaged
@ -236,8 +230,8 @@ typedef enum
#define PARTICLE_INSTANT (1<<5)
// built-in decals flags
#define DECAL_FADE (1<<0) // fade decal when lifetime is expired
#define DECAL_TEMPORARY (1<<1)
#define DECAL_FADEALPHA (1<<0) // fade decal by alpha instead color
#define DECAL_FADEENERGY (1<<1) // fade decal energy balls
// basic console charwidths
#define TINYCHAR_WIDTH (SMALLCHAR_WIDTH)

88
engine/client/cl_effects.c
View File

@ -245,13 +245,12 @@ typedef struct cdecal_s
{
struct cdecal_s *prev, *next;
float die; // remove after this time
float die; // remove after this time
float time; // time when decal is placed
float fadetime;
float fadefreq;
bool fadealpha;
vec4_t color;
shader_t shader;
word flags;
rgba_t color;
poly_t *poly;
} cdecal_t;
@ -347,7 +346,7 @@ void CL_FreeDecal( cdecal_t *dl )
CL_SpawnDecal
=================
*/
void CL_SpawnDecal( vec3_t origin, vec3_t dir, float orient, float radius, float r, float g, float b, float a, float die, float fadetime, bool fadealpha, shader_t shader )
void CL_SpawnDecal( vec3_t org, vec3_t dir, float rot, float rad, float *col, float die, float fadetime, word flags, shader_t handle )
{
int i, j;
cdecal_t *dl;
@ -360,37 +359,32 @@ void CL_SpawnDecal( vec3_t origin, vec3_t dir, float orient, float radius, float
float dietime, fadefreq;
// invalid decal
if( radius <= 0 || VectorCompare( dir, vec3_origin ))
if( rad <= 0 || VectorCompare( dir, vec3_origin ))
return;
// calculate orientation matrix
VectorNormalize2( dir, axis[0] );
PerpendicularVector( axis[1], axis[0] );
RotatePointAroundVector( axis[2], axis[0], axis[1], orient );
RotatePointAroundVector( axis[2], axis[0], axis[1], rot );
CrossProduct( axis[0], axis[2], axis[1] );
numfragments = re->GetFragments( origin, radius, axis, MAX_DECAL_VERTS, verts, MAX_DECAL_FRAGMENTS, fragments );
numfragments = re->GetFragments( org, rad, axis, MAX_DECAL_VERTS, verts, MAX_DECAL_FRAGMENTS, fragments );
// no valid fragments
if( !numfragments ) return;
// clamp and scale colors
if( r < 0 ) r = 0; else if( r > 1 ) r = 255; else r *= 255;
if( g < 0 ) g = 0; else if( g > 1 ) g = 255; else g *= 255;
if( b < 0 ) b = 0; else if( b > 1 ) b = 255; else b *= 255;
if( a < 0 ) a = 0; else if( a > 1 ) a = 255; else a *= 255;
color[0] = (byte)bound( 0, col[0] * 255, 255 );
color[1] = (byte)bound( 0, col[1] * 255, 255 );
color[2] = (byte)bound( 0, col[2] * 255, 255 );
color[3] = (byte)bound( 0, col[3] * 255, 255 );
color[0] = (byte)( r );
color[1] = (byte)( g );
color[2] = (byte)( b );
color[3] = (byte)( a );
radius = 0.5f / radius;
VectorScale( axis[1], radius, axis[1] );
VectorScale( axis[2], radius, axis[2] );
rad = 0.5f / rad;
VectorScale( axis[1], rad, axis[1] );
VectorScale( axis[2], rad, axis[2] );
dietime = cl.time + die;
fadefreq = min( fadetime, die );
fadefreq = 1.0f / min( fadetime, die );
fadetime = cl.time + (die - min( fadetime, die ));
for( i = 0, fr = fragments; i < numfragments; i++, fr++ )
@ -402,19 +396,16 @@ void CL_SpawnDecal( vec3_t origin, vec3_t dir, float orient, float radius, float
// allocate decal
dl = CL_AllocDecal ();
Vector4Copy( color, dl->color );
dl->die = dietime;
dl->time = cl.time;
dl->fadetime = fadetime;
dl->fadefreq = fadefreq;
dl->fadealpha = fadealpha;
dl->shader = shader;
dl->color[0] = r;
dl->color[1] = g;
dl->color[2] = b;
dl->color[3] = a;
dl->flags = flags;
// setup polygon for drawing
poly = dl->poly;
poly->shadernum = shader;
poly->shadernum = handle;
poly->numverts = fr->numverts;
poly->fognum = fr->fognum;
@ -422,7 +413,7 @@ void CL_SpawnDecal( vec3_t origin, vec3_t dir, float orient, float radius, float
vec3_t v;
VectorCopy( verts[fr->firstvert+j], poly->verts[j] );
VectorSubtract( poly->verts[j], origin, v );
VectorSubtract( poly->verts[j], org, v );
poly->stcoords[j][0] = DotProduct( v, axis[1] ) + 0.5f;
poly->stcoords[j][1] = DotProduct( v, axis[2] ) + 0.5f;
*( int * )poly->colors[j] = *( int * )color;
@ -457,12 +448,25 @@ void CL_AddDecals( void )
}
poly = dl->poly;
if( dl->flags & DECAL_FADEENERGY )
{
float time = cl.time - dl->time;
if( time < dl->fadetime )
{
fade = 255 - (time / dl->fadetime);
color[0] = ( byte )( dl->color[0] * fade );
color[1] = ( byte )( dl->color[1] * fade );
color[2] = ( byte )( dl->color[2] * fade );
}
}
// fade out
if( dl->fadetime < cl.time )
{
fade = (dl->die - cl.time) * dl->fadefreq;
if( dl->fadealpha )
if( dl->flags & DECAL_FADEALPHA )
{
color[0] = ( byte )( dl->color[0] );
color[1] = ( byte )( dl->color[1] );
@ -492,12 +496,7 @@ pfnAddDecal
*/
void pfnAddDecal( float *org, float *dir, float *rgba, float rot, float rad, HSPRITE hSpr, int flags )
{
bool fade, temp;
fade = (flags & DECAL_FADE) ? true : false;
temp = (flags & DECAL_TEMPORARY) ? true : false;
CL_SpawnDecal( org, dir, rot, rad, rgba[0], rgba[1], rgba[2], rgba[3], 120.0f, 30.0f, fade, hSpr );
CL_SpawnDecal( org, dir, rot, rad, rgba, 120.0f, 30.0f, flags, hSpr );
}
/*
@ -538,7 +537,7 @@ struct cparticle_s
poly_t poly;
vec3_t pVerts[4];
vec2_t pStcoords[4];
rgba_t pColor;
rgba_t pColor[4];
};
cparticle_t *cl_active_particles, *cl_free_particles;
@ -601,9 +600,9 @@ void CL_ClearParticles( void )
for( i = 0; i < NUMVERTEXNORMALS; i++ )
{
cl_particle_velocities[i][0] = (rand() & 255) * 0.01;
cl_particle_velocities[i][1] = (rand() & 255) * 0.01;
cl_particle_velocities[i][2] = (rand() & 255) * 0.01;
cl_particle_velocities[i][0] = (rand() & 255) * 0.01f;
cl_particle_velocities[i][1] = (rand() & 255) * 0.01f;
cl_particle_velocities[i][2] = (rand() & 255) * 0.01f;
}
}
@ -805,7 +804,10 @@ void CL_AddParticles( void )
p->alphaVelocity = 0;
}
VectorCopy( modulate, p->pColor );
*(int *)p->pColor[0] = *(int *)modulate;
*(int *)p->pColor[1] = *(int *)modulate;
*(int *)p->pColor[2] = *(int *)modulate;
*(int *)p->pColor[3] = *(int *)modulate;
corner[0] = origin[0];
corner[1] = origin[1] - 0.5f * p->scale;
@ -819,7 +821,7 @@ void CL_AddParticles( void )
p->poly.numverts = 4;
p->poly.verts = p->pVerts;
p->poly.stcoords = p->pStcoords;
p->poly.colors = &p->pColor;
p->poly.colors = p->pColor;
p->poly.shadernum = p->shader;
p->poly.fognum = p->fog ? 0 : -1;

16
engine/engine.plg Normal file
View File

@ -0,0 +1,16 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: engine - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
engine.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

16
launch/launch.plg Normal file
View File

@ -0,0 +1,16 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: launch - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
launch.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

2
launch/memlib.c
View File

@ -63,7 +63,7 @@ typedef struct mempool_s
struct mempool_s *next; // linked into global mempool list
const char *filename; // file name and line where Mem_AllocPool was called
int fileline;
char name[32]; // name of the pool
char name[64]; // name of the pool
uint sentinel2; // should always be MEMHEADER_SENTINEL1
} mempool_t;

116
render/r_alias.c
View File

@ -82,10 +82,10 @@ MD3 MODELS
/*
=================
Mod_LoadAliasMD3Model
Mod_AliasLoadModel
=================
*/
void Mod_LoadAliasMD3Model( ref_model_t *mod, ref_model_t *parent, const void *buffer )
void Mod_AliasLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buffer )
{
int version, i, j, l;
int bufsize, numverts;
@ -317,11 +317,10 @@ R_AliasModelLOD
*/
static ref_model_t *R_AliasModelLOD( ref_entity_t *e )
{
int lod;
float dist;
int lod;
float dist;
if( !e->model->numlods || ( e->flags & RF_FORCENOLOD ) )
return e->model;
if( !e->model->numlods ) return e->model;
dist = DistanceFast( e->origin, RI.viewOrigin );
dist *= RI.lod_dist_scale_for_fov;
@ -331,8 +330,7 @@ static ref_model_t *R_AliasModelLOD( ref_entity_t *e )
lod /= r_lodscale->integer;
lod += r_lodbias->integer;
if( lod < 1 )
return e->model;
if( lod < 1 ) return e->model;
return e->model->lods[min( lod, e->model->numlods )-1];
}
@ -357,21 +355,17 @@ static void R_AliasModelLerpBBox( ref_entity_t *e, ref_model_t *mod )
if( ( e->frame >= aliasmodel->numframes ) || ( e->frame < 0 ) )
{
#ifndef WSW_RELEASE
MsgDev( D_ERROR, "R_DrawAliasModel %s: no such frame %d\n", mod->name, e->frame );
#endif
MsgDev( D_ERROR, "R_DrawAliasModel %s: no such frame %g\n", mod->name, e->frame );
e->frame = 0;
}
if( ( e->oldframe >= aliasmodel->numframes ) || ( e->oldframe < 0 ) )
if( ( e->prev.frame >= aliasmodel->numframes ) || ( e->prev.frame < 0 ) )
{
#ifndef WSW_RELEASE
MsgDev( D_ERROR, "R_DrawAliasModel %s: no such oldframe %d\n", mod->name, e->oldframe );
#endif
e->oldframe = 0;
MsgDev( D_ERROR, "R_DrawAliasModel %s: no such oldframe %g\n", mod->name, e->prev.frame );
e->prev.frame = 0;
}
pframe = aliasmodel->frames + e->frame;
poldframe = aliasmodel->frames + e->oldframe;
pframe = aliasmodel->frames + (int)e->frame;
poldframe = aliasmodel->frames + (int)e->prev.frame;
// compute axially aligned mins and maxs
if( pframe == poldframe )
@ -411,9 +405,9 @@ R_AliasModelLerpTag
*/
bool R_AliasModelLerpTag( orientation_t *orient, maliasmodel_t *aliasmodel, int oldframenum, int framenum, float lerpfrac, const char *name )
{
int i;
quat_t quat;
maliastag_t *tag, *oldtag;
int i;
quat_t quat;
maliastag_t *tag, *oldtag;
// find the appropriate tag
for( i = 0; i < aliasmodel->numtags; i++ )
@ -431,16 +425,12 @@ bool R_AliasModelLerpTag( orientation_t *orient, maliasmodel_t *aliasmodel, int
// ignore invalid frames
if( ( framenum >= aliasmodel->numframes ) || ( framenum < 0 ) )
{
#ifndef WSW_RELEASE
MsgDev( D_ERROR, "R_AliasModelLerpTag %s: no such oldframe %i\n", name, framenum );
#endif
framenum = 0;
}
if( ( oldframenum >= aliasmodel->numframes ) || ( oldframenum < 0 ) )
{
#ifndef WSW_RELEASE
MsgDev( D_ERROR, "R_AliasModelLerpTag %s: no such oldframe %i\n", name, oldframenum );
#endif
oldframenum = 0;
}
@ -495,8 +485,8 @@ static void R_DrawAliasFrameLerp( const meshbuffer_t *mb, float backlerp )
return;
mesh = model->meshes + meshnum;
frame = model->frames + e->frame;
oldframe = model->frames + e->oldframe;
frame = model->frames + (int)e->frame;
oldframe = model->frames + (int)e->prev.frame;
for( i = 0; i < 3; i++ )
move[i] = frame->translate[i] + ( oldframe->translate[i] - frame->translate[i] ) * backlerp;
@ -518,17 +508,15 @@ static void R_DrawAliasFrameLerp( const meshbuffer_t *mb, float backlerp )
}
calcNormals = calcSTVectors = false;
calcNormals = ( ( features & MF_NORMALS ) != 0 ) && ( ( e->frame != 0 ) || ( e->oldframe != 0 ) );
calcNormals = (( features & MF_NORMALS ) != 0 ) && (( e->frame != 0 ) || ( e->prev.frame != 0 ));
if( alias_framecount == r_framecount && RI.previousentity && RI.previousentity->model == e->model && alias_prevmesh == mesh && alias_prevshader == shader )
{
ref_entity_t *pe = RI.previousentity;
if( pe->frame == e->frame
&& pe->oldframe == e->oldframe
&& ( pe->backlerp == e->backlerp || e->frame == e->oldframe ) )
if( pe->frame == e->frame && pe->prev.frame == e->prev.frame && ( pe->backlerp == e->backlerp || e->frame == e->prev.frame ))
{
unlockVerts = ( ( ( features & MF_DEFORMVS ) /* && (e->shaderTime != pe->shaderTime)*/ ) );
calcNormals = ( calcNormals && ( shader->features & SHADER_DEFORM_NORMAL ) );
unlockVerts = ((( features & MF_DEFORMVS )));
calcNormals = ( calcNormals && ( shader->features & SHADER_DEFORM_NORMAL ));
}
}
@ -541,7 +529,7 @@ static void R_DrawAliasFrameLerp( const meshbuffer_t *mb, float backlerp )
if( unlockVerts )
{
if( !e->frame && !e->oldframe )
if( !e->frame && !e->prev.frame )
{
calcVerts = false;
@ -552,14 +540,14 @@ static void R_DrawAliasFrameLerp( const meshbuffer_t *mb, float backlerp )
R_LatLongToNorm( v->latlong, inNormalsArray[i] );
}
}
else if( e->frame == e->oldframe )
else if( e->frame == e->prev.frame )
{
calcVerts = true;
for( i = 0; i < 3; i++ )
frontv[i] = frame->scale[i];
v = mesh->vertexes + e->frame * mesh->numverts;
v = mesh->vertexes + (int)e->frame * mesh->numverts;
for( i = 0; i < mesh->numverts; i++, v++ )
{
Vector4Set( inVertsArray[i],
@ -581,8 +569,8 @@ static void R_DrawAliasFrameLerp( const meshbuffer_t *mb, float backlerp )
frontv[i] = ( 1.0f - backlerp ) * frame->scale[i];
}
v = mesh->vertexes + e->frame * mesh->numverts;
ov = mesh->vertexes + e->oldframe * mesh->numverts;
v = mesh->vertexes + (int)e->frame * mesh->numverts;
ov = mesh->vertexes + (int)e->prev.frame * mesh->numverts;
for( i = 0; i < mesh->numverts; i++, v++, ov++ )
{
Vector4Set( inVertsArray[i],
@ -649,23 +637,28 @@ void R_DrawAliasModel( const meshbuffer_t *mb )
}
// hack the depth range to prevent view model from poking into walls
if( e->flags & RF_WEAPONMODEL )
if( e->ent_type == ED_VIEWMODEL )
{
pglDepthRange( gldepthmin, gldepthmin + 0.3 * ( gldepthmax - gldepthmin ) );
// backface culling for left-handed weapons
if( e->flags & RF_CULLHACK )
GL_FrontFace( !glState.frontFace );
// backface culling for left-handed weapons
if( r_lefthand->integer == 1 )
GL_FrontFace( !glState.frontFace );
}
if( !r_lerpmodels->integer )
e->backlerp = 0;
R_DrawAliasFrameLerp( mb, e->backlerp );
if( e->flags & RF_WEAPONMODEL )
if( e->ent_type == ED_VIEWMODEL )
{
pglDepthRange( gldepthmin, gldepthmax );
if( e->flags & RF_CULLHACK )
GL_FrontFace( !glState.frontFace );
// backface culling for left-handed weapons
if( r_lefthand->integer == 1 )
GL_FrontFace( !glState.frontFace );
}
}
/*
@ -721,7 +714,7 @@ bool R_CullAliasModel( ref_entity_t *e )
R_IssueOcclusionQuery( R_GetOcclusionQueryNum( OQ_ENTITY, e - r_entities ), e, alias_mins, alias_maxs );
if( ( RI.refdef.rdflags & RDF_NOWORLDMODEL )
|| ( r_shadows->integer != SHADOW_PLANAR && !( r_shadows->integer == SHADOW_MAPPING && ( e->flags & RF_PLANARSHADOW ) ) )
|| ( r_shadows->integer != SHADOW_PLANAR && !( r_shadows->integer == SHADOW_MAPPING && ( e->flags & EF_PLANARSHADOW )))
|| R_CullPlanarShadow( e, alias_mins, alias_maxs, query ) )
return frustum; // entity is not in PVS or shadow is culled away by frustum culling
@ -730,10 +723,8 @@ bool R_CullAliasModel( ref_entity_t *e )
{
shader = NULL;
if( e->customSkin )
shader = R_FindShaderForSkinFile( e->customSkin, mesh->name );
else if( e->customShader )
shader = e->customShader;
if( e->skinfile )
shader = R_FindShaderForSkinFile( e->skinfile, mesh->name );
else if( mesh->numskins )
{
for( j = 0; j < mesh->numskins; j++ )
@ -745,11 +736,10 @@ bool R_CullAliasModel( ref_entity_t *e )
}
}
if( shader && ( shader->sort <= SORT_ALPHATEST ) )
if( shader && ( shader->sort <= SORT_ALPHATEST ))
{
mb = R_AddMeshToList( MB_MODEL, NULL, R_PlanarShadowShader(), -( i+1 ) );
if( mb )
mb->LODModelHandle = modhandle;
mb = R_AddMeshToList( MB_MODEL, NULL, R_PlanarShadowShader(), -( i+1 ));
if( mb ) mb->LODModelHandle = modhandle;
}
}
@ -781,7 +771,7 @@ void R_AddAliasModelToList( ref_entity_t *e )
{
if( !r_shadows_self_shadow->integer )
r_entShadowBits[entnum] &= ~RI.shadowGroup->bit;
if( e->flags & RF_WEAPONMODEL )
if( e->ent_type == ED_VIEWMODEL )
return;
}
else
@ -796,10 +786,10 @@ void R_AddAliasModelToList( ref_entity_t *e )
{
fog = R_FogForSphere( e->origin, alias_radius );
#if 0
if( !( e->flags & RF_WEAPONMODEL ) && fog )
if( !( e->ent_type == ED_VIEWMODEL ) && fog )
{
R_AliasModelLerpBBox( e, mod );
if( R_CompletelyFogged( fog, e->origin, alias_radius ) )
if( R_CompletelyFogged( fog, e->origin, alias_radius ))
return;
}
#endif
@ -809,22 +799,16 @@ void R_AddAliasModelToList( ref_entity_t *e )
{
shader = NULL;
if( e->customSkin )
shader = R_FindShaderForSkinFile( e->customSkin, mesh->name );
else if( e->customShader )
shader = e->customShader;
if( e->skinfile ) shader = R_FindShaderForSkinFile( e->skinfile, mesh->name );
else if( mesh->numskins )
{
for( j = 0; j < mesh->numskins; j++ )
{
shader = mesh->skins[j].shader;
if( shader )
R_AddModelMeshToList( modhandle, fog, shader, i );
if( shader ) R_AddModelMeshToList( modhandle, fog, shader, i );
}
continue;
}
if( shader )
R_AddModelMeshToList( modhandle, fog, shader, i );
if( shader ) R_AddModelMeshToList( modhandle, fog, shader, i );
}
}

288
render/r_backend.c
View File

@ -970,7 +970,7 @@ static bool R_VertexTCBase( const ref_stage_t *pass, int unit, mat4x4_t matrix )
for( i = 0; i < 3; i++ )
{
genVector[0][i] = pass->tcgenVec[i];
genVector[0][i] = pass->tcgenVec[i+0];
genVector[1][i] = pass->tcgenVec[i+4];
}
genVector[0][3] = genVector[1][3] = 0;
@ -1023,6 +1023,15 @@ static bool R_VertexTCBase( const ref_stage_t *pass, int unit, mat4x4_t matrix )
pglTexGenfv( GL_Q, GL_OBJECT_PLANE, genVector[3] );
return false;
}
case TCGEN_WARP:
for( i = 0; i < r_backacc.numVerts; i++ )
{
coordsArray[i][0] += r_warpsintable[((int)((inCoordsArray[i][1] * 8.0 + r_currentShaderTime) * (256.0/M_PI2))) & 255] * (1.0/64);
coordsArray[i][1] += r_warpsintable[((int)((inCoordsArray[i][0] * 8.0 + r_currentShaderTime) * (256.0/M_PI2))) & 255] * (1.0/64);
}
R_UpdateVertexBuffer( tr.tcoordBuffer[unit], coordsArray, r_backacc.numVerts * sizeof( vec2_t ));
pglTexCoordPointer( 2, GL_FLOAT, 0, tr.tcoordBuffer[unit]->pointer );
return true;
case TCGEN_REFLECTION_CELLSHADE:
if( RI.currententity && !( RI.params & RP_SHADOWMAPVIEW ) )
{
@ -1046,6 +1055,12 @@ static bool R_VertexTCBase( const ref_stage_t *pass, int unit, mat4x4_t matrix )
GL_EnableTexGen( GL_R, GL_REFLECTION_MAP_ARB );
GL_EnableTexGen( GL_Q, 0 );
return true;
case TCGEN_NORMAL:
GL_EnableTexGen( GL_S, GL_NORMAL_MAP_ARB );
GL_EnableTexGen( GL_T, GL_NORMAL_MAP_ARB );
GL_EnableTexGen( GL_R, GL_NORMAL_MAP_ARB );
GL_EnableTexGen( GL_Q, 0 );
return true;
case TCGEN_FOG:
{
int fogPtype;
@ -1147,7 +1162,7 @@ R_ApplyTCMods
static void R_ApplyTCMods( const ref_stage_t *pass, mat4x4_t result )
{
int i;
double t1, t2, sint, cost;
double f, t1, t2, sint, cost;
mat4x4_t m1, m2;
const tcMod_t *tcmod;
waveFunc_t func;
@ -1156,6 +1171,9 @@ static void R_ApplyTCMods( const ref_stage_t *pass, mat4x4_t result )
{
switch( tcmod->type )
{
case TCMOD_TRANSLATE:
Matrix4_Translate2D( result, tcmod->args[0], tcmod->args[1] );
break;
case TCMOD_ROTATE:
cost = tcmod->args[0] * r_currentShaderTime;
sint = R_FastSin( cost );
@ -1199,6 +1217,20 @@ static void R_ApplyTCMods( const ref_stage_t *pass, mat4x4_t result )
Matrix4_Copy2D( result, m1 );
Matrix4_Multiply2D( m2, m1, result );
break;
case TCMOD_CONVEYOR:
if( RI.currententity->framerate == 0.0f ) return;
f = (RI.currententity->framerate * r_currentShaderTime) * 0.0039; // magic number :-)
t1 = RI.currententity->movedir[0];
t2 = RI.currententity->movedir[1];
t1 = f * t1;
t1 -= floor( t1 );
t2 = f * t2;
t2 -= floor( t2 );
result[12] -= t1;
result[13] += t2;
break;
default:
break;
}
@ -1212,6 +1244,25 @@ R_ShaderpassTex
*/
static _inline texture_t *R_ShaderpassTex( const ref_stage_t *pass, int unit )
{
if( pass->flags & SHADERSTAGE_ANGLEDMAP )
{
if( !RI.currententity ) return pass->textures[0]; // assume error
return pass->textures[(int)((RI.refdef.viewangles[1] - RI.currententity->angles[1])/360 * 8 + 0.5 - 4) & 7];
}
if( pass->flags & SHADERSTAGE_FRAMES )
{
if( glState.in2DMode )
return pass->textures[bound( 0, glState.draw_frame, pass->num_textures - 1)];
else if( RI.currententity && RI.currententity->model )
{
switch( RI.currententity->model->type )
{
case mod_brush:
case mod_world:
return pass->textures[bound( 0, (int)RI.currententity->frame, pass->num_textures - 1)];
}
}
}
if( pass->flags & SHADERSTAGE_ANIMFREQUENCY && pass->animFrequency && pass->num_textures )
return pass->textures[(int)( pass->animFrequency * r_currentShaderTime ) % pass->num_textures];
if( pass->flags & SHADERSTAGE_LIGHTMAP )
@ -1232,7 +1283,7 @@ static void R_ShaderpassRenderMode( ref_stage_t *pass )
{
int mod_type = mod_bad; // mod_bad interpretate as orthogonal shader
if(!(pass->flags & SHADERSTAGE_RENDERMODE))
if(!( pass->flags & SHADERSTAGE_RENDERMODE ))
return;
if( RI.currentmodel && !glState.in2DMode )
@ -1241,50 +1292,24 @@ static void R_ShaderpassRenderMode( ref_stage_t *pass )
switch( tr.iRenderMode )
{
case kRenderNormal:
switch( mod_type )
{
case mod_bad:
pass->rgbGen.type = RGBGEN_IDENTITY;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case mod_world:
case mod_brush:
// bsp surfaces uses lightmaps and ignore color values as well
pass->glState &= ~(GLSTATE_BLENDFUNC|GLSTATE_ALPHAFUNC);
pass->glState |= GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case mod_studio:
// UNDONE: wrote R_StudioLighting, change rgbGen to RGBGEN_VERTEX
// UNDONE: setup custom alpha channel for NF_ADDITIVE, change alphaGen to ALPHAGEN_VERTEX
pass->glState &= ~(GLSTATE_BLENDFUNC|GLSTATE_ALPHAFUNC);
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT_ONLY;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case mod_sprite:
pass->glState &= ~(GLSTATE_BLENDFUNC|GLSTATE_ALPHAFUNC);
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT_ONLY;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
break;
}
break;
// restore real state
pass->glState = pass->prev.glState;
pass->flags = pass->prev.flags;
pass->rgbGen = pass->prev.rgbGen;
pass->alphaGen = pass->prev.alphaGen;
break;
case kRenderTransColor:
switch( mod_type )
{
case mod_bad:
pass->glState &= ~GLSTATE_ALPHAFUNC;
pass->glState |= (GLSTATE_SRCBLEND_ZERO|GLSTATE_DSTBLEND_SRC_COLOR);
pass->glState = (GLSTATE_SRCBLEND_ZERO|GLSTATE_DSTBLEND_SRC_COLOR);
pass->flags = SHADERSTAGE_BLEND_DECAL;
pass->rgbGen.type = RGBGEN_VERTEX;
pass->alphaGen.type = ALPHAGEN_VERTEX;
break;
case mod_world:
pass->glState &= ~(GLSTATE_BLENDFUNC|GLSTATE_ALPHAFUNC);
pass->glState |= GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case mod_brush:
case mod_alias:
case mod_studio:
case mod_sprite:
break;
@ -1294,23 +1319,14 @@ static void R_ShaderpassRenderMode( ref_stage_t *pass )
switch( mod_type )
{
case mod_bad:
pass->glState &= ~GLSTATE_ALPHAFUNC;
pass->glState |= (GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA);
pass->glState = (GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA);
pass->flags = SHADERSTAGE_BLEND_MODULATE;
pass->rgbGen.type = RGBGEN_VERTEX;
pass->alphaGen.type = ALPHAGEN_VERTEX;
break;
case mod_world:
pass->glState &= ~(GLSTATE_BLENDFUNC|GLSTATE_ALPHAFUNC);
pass->glState |= GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case mod_brush:
pass->glState &= ~(GLSTATE_DEPTHWRITE|GLSTATE_ALPHAFUNC);
pass->glState |= (GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA);
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING;
pass->alphaGen.type = ALPHAGEN_ENTITY;
break;
case mod_alias:
case mod_studio:
case mod_sprite:
break;
@ -1320,24 +1336,19 @@ static void R_ShaderpassRenderMode( ref_stage_t *pass )
switch( mod_type )
{
case mod_bad:
pass->glState &= ~GLSTATE_ALPHAFUNC;
pass->glState |= (GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE);
pass->glState = (GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE);
pass->flags = SHADERSTAGE_BLEND_ADD;
pass->rgbGen.type = RGBGEN_VERTEX;
pass->alphaGen.type = ALPHAGEN_VERTEX;
break;
case mod_world:
case mod_brush:
// completely ignore glow mode for world surfaces
pass->glState &= ~(GLSTATE_BLENDFUNC|GLSTATE_ALPHAFUNC);
pass->glState |= GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case mod_alias:
case mod_studio:
break;
case mod_sprite:
pass->glState &= ~(GLSTATE_ALPHAFUNC|GLSTATE_DEPTHWRITE|GLSTATE_DEPTHFUNC_EQ);
pass->glState |= (GLSTATE_SRCBLEND_ONE_MINUS_SRC_ALPHA|GLSTATE_DSTBLEND_ONE);
pass->rgbGen.type = RGBGEN_IDENTITY; // hl1 glow sprites ignores color
pass->glState = (GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE|GLSTATE_NO_DEPTH_TEST);
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING; // sprites ignore color in 'add' mode
pass->alphaGen.type = ALPHAGEN_ENTITY;
break;
}
@ -1346,35 +1357,15 @@ static void R_ShaderpassRenderMode( ref_stage_t *pass )
switch( mod_type )
{
case mod_bad:
pass->glState &= ~GLSTATE_BLENDFUNC;
pass->glState |= GLSTATE_AFUNC_GE128;
pass->glState = GLSTATE_AFUNC_GE128;
pass->rgbGen.type = RGBGEN_VERTEX;
pass->alphaGen.type = ALPHAGEN_VERTEX;
break;
case mod_world:
// always ignore transparent surfaces for world
pass->glState &= ~(GLSTATE_BLENDFUNC|GLSTATE_ALPHAFUNC);
pass->glState |= GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case mod_brush:
pass->glState &= ~GLSTATE_BLENDFUNC;
pass->glState |= GLSTATE_AFUNC_GE128;
pass->rgbGen.type = RGBGEN_IDENTITY;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
case mod_alias:
case mod_studio:
// UNDONE: wrote R_StudioLighting, change rgbGen to RGBGEN_VERTEX
// UNDONE: setup custom alpha channel for NF_ADDITIVE, change alphaGen to ALPHAGEN_VERTEX
pass->glState &= ~GLSTATE_BLENDFUNC;
pass->glState |= GLSTATE_AFUNC_GE128;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT_ONLY;
pass->alphaGen.type = ALPHAGEN_ENTITY;
case mod_sprite:
pass->glState &= ~GLSTATE_BLENDFUNC;
pass->glState |= GLSTATE_AFUNC_GE128;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT_ONLY;
pass->alphaGen.type = ALPHAGEN_ENTITY;
break;
}
break;
@ -1382,33 +1373,33 @@ static void R_ShaderpassRenderMode( ref_stage_t *pass )
switch( mod_type )
{
case mod_bad:
pass->glState &= ~GLSTATE_ALPHAFUNC;
pass->glState |= (GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE);
pass->glState = (GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE);
pass->flags = SHADERSTAGE_BLEND_ADD;
pass->rgbGen.type = RGBGEN_VERTEX;
pass->alphaGen.type = ALPHAGEN_VERTEX;
break;
case mod_world:
pass->glState &= ~(GLSTATE_BLENDFUNC|GLSTATE_ALPHAFUNC);
pass->glState |= GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case mod_brush:
pass->glState &= ~(GLSTATE_ALPHAFUNC|GLSTATE_DEPTHWRITE);
pass->glState |= (GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE);
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING;
pass->alphaGen.type = ALPHAGEN_ENTITY;
break;
case mod_alias:
case mod_studio:
break;
case mod_sprite:
pass->glState &= ~(GLSTATE_ALPHAFUNC|GLSTATE_DEPTHWRITE);
pass->glState |= (GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE);
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING;
pass->glState = (GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE);
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING; // sprites ignore color in 'add' mode
pass->alphaGen.type = ALPHAGEN_ENTITY;
break;
}
break;
}
// restore some flags
pass->flags |= SHADERSTAGE_RENDERMODE;
if( pass->prev.flags & SHADERSTAGE_ANIMFREQUENCY )
pass->flags |= SHADERSTAGE_ANIMFREQUENCY;
if( pass->prev.flags & SHADERSTAGE_FRAMES )
pass->flags |= SHADERSTAGE_FRAMES;
if( pass->prev.flags & SHADERSTAGE_ANGLEDMAP )
pass->flags |= SHADERSTAGE_ANGLEDMAP;
}
/*
@ -1501,6 +1492,7 @@ void R_ModifyColor( const ref_stage_t *pass )
*(int *)bArray = c;
break;
case RGBGEN_WAVE:
case RGBGEN_COLORWAVE:
rgbgenfunc = pass->rgbGen.func;
if( rgbgenfunc->type == WAVEFORM_NOISE )
{
@ -1521,10 +1513,13 @@ void R_ModifyColor( const ref_stage_t *pass )
*(int *)bArray = c;
break;
case RGBGEN_ENTITY:
rgba[0] = RI.currententity->rendercolor[0];
rgba[1] = RI.currententity->rendercolor[1];
rgba[2] = RI.currententity->rendercolor[2];
entityAlpha = true;
identityAlpha = ( RI.currententity->color[3] == 255 );
identityAlpha = ( RI.currententity->renderamt == 255 );
for( i = 0, c = *(int *)RI.currententity->color; i < r_backacc.numColors; i++, bArray += 4 )
for( i = 0, c = *(int *)rgba; i < r_backacc.numColors; i++, bArray += 4 )
*(int *)bArray = c;
break;
case RGBGEN_OUTLINE:
@ -1534,9 +1529,9 @@ void R_ModifyColor( const ref_stage_t *pass )
*(int *)bArray = c;
break;
case RGBGEN_ONE_MINUS_ENTITY:
rgba[0] = 255 - RI.currententity->color[0];
rgba[1] = 255 - RI.currententity->color[1];
rgba[2] = 255 - RI.currententity->color[2];
rgba[0] = 255 - RI.currententity->rendercolor[0];
rgba[1] = 255 - RI.currententity->rendercolor[1];
rgba[2] = 255 - RI.currententity->rendercolor[2];
for( i = 0, c = *(int *)rgba; i < r_backacc.numColors; i++, bArray += 4 )
*(int *)bArray = c;
@ -1608,10 +1603,9 @@ void R_ModifyColor( const ref_stage_t *pass )
{
vec4_t diffuse;
if( RI.currententity->flags & RF_FULLBRIGHT )
if( RI.currententity->flags & EF_FULLBRIGHT )
VectorSet( diffuse, 1, 1, 1 );
else
R_LightForOrigin( RI.currententity->lightingOrigin, t, NULL, diffuse, RI.currentmodel->radius * RI.currententity->scale );
else R_LightForOrigin( RI.currententity->lightingOrigin, t, NULL, diffuse, RI.currentmodel->radius * RI.currententity->scale );
rgba[0] = R_FloatToByte( diffuse[0] );
rgba[1] = R_FloatToByte( diffuse[1] );
@ -1626,10 +1620,9 @@ void R_ModifyColor( const ref_stage_t *pass )
{
vec4_t ambient;
if( RI.currententity->flags & RF_FULLBRIGHT )
if( RI.currententity->flags & EF_FULLBRIGHT )
VectorSet( ambient, 1, 1, 1 );
else
R_LightForOrigin( RI.currententity->lightingOrigin, t, ambient, NULL, RI.currentmodel->radius * RI.currententity->scale );
else R_LightForOrigin( RI.currententity->lightingOrigin, t, ambient, NULL, RI.currentmodel->radius * RI.currententity->scale );
rgba[0] = R_FloatToByte( ambient[0] );
rgba[1] = R_FloatToByte( ambient[1] );
@ -1663,8 +1656,7 @@ void R_ModifyColor( const ref_stage_t *pass )
switch( pass->alphaGen.type )
{
case ALPHAGEN_IDENTITY:
if( identityAlpha )
break;
if( identityAlpha ) break;
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
bArray[3] = 255;
break;
@ -1674,6 +1666,7 @@ void R_ModifyColor( const ref_stage_t *pass )
bArray[3] = c;
break;
case ALPHAGEN_WAVE:
case ALPHAGEN_ALPHAWAVE:
alphagenfunc = pass->alphaGen.func;
if( alphagenfunc->type == WAVEFORM_NOISE )
{
@ -1710,10 +1703,14 @@ void R_ModifyColor( const ref_stage_t *pass )
bArray[3] = 255 - inArray[3];
break;
case ALPHAGEN_ENTITY:
if( entityAlpha )
break;
if( entityAlpha ) break;
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
bArray[3] = RI.currententity->color[3];
bArray[3] = RI.currententity->renderamt;
break;
case ALPHAGEN_ONE_MINUS_ENTITY:
rgba[3] = 255 - RI.currententity->renderamt;
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
bArray[3] = rgba[3];
break;
case ALPHAGEN_OUTLINE:
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
@ -1721,10 +1718,9 @@ void R_ModifyColor( const ref_stage_t *pass )
break;
case ALPHAGEN_SPECULAR:
VectorSubtract( RI.viewOrigin, RI.currententity->origin, t );
if( !Matrix_Compare( RI.currententity->axis, axis_identity ) )
if( !Matrix_Compare( RI.currententity->axis, axis_identity ))
Matrix_TransformVector( RI.currententity->axis, t, v );
else
VectorCopy( t, v );
else VectorCopy( t, v );
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
{
@ -1738,13 +1734,12 @@ void R_ModifyColor( const ref_stage_t *pass )
case ALPHAGEN_DOT:
if( !Matrix_Compare( RI.currententity->axis, axis_identity ) )
Matrix_TransformVector( RI.currententity->axis, RI.vpn, v );
else
VectorCopy( RI.vpn, v );
else VectorCopy( RI.vpn, v );
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
{
a = DotProduct( v, inNormalsArray[i] ); if( a < 0 ) a = -a;
bArray[3] = R_FloatToByte( bound( pass->alphaGen.args[0], a, pass->alphaGen.args[1] ) );
bArray[3] = R_FloatToByte( bound( pass->alphaGen.args[0], a, pass->alphaGen.args[1] ));
}
break;
case ALPHAGEN_ONE_MINUS_DOT:
@ -1755,9 +1750,32 @@ void R_ModifyColor( const ref_stage_t *pass )
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
{
a = DotProduct( v, inNormalsArray[i] ); if( a < 0 ) a = -a;a = 1.0f - a;
bArray[3] = R_FloatToByte( bound( pass->alphaGen.args[0], a, pass->alphaGen.args[1] ) );
a = DotProduct( v, inNormalsArray[i] ); if( a < 0 ) a = -a; a = 1.0f - a;
bArray[3] = R_FloatToByte( bound( pass->alphaGen.args[0], a, pass->alphaGen.args[1] ));
}
break;
case ALPHAGEN_FADE:
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
{
VectorAdd( vertsArray[i], RI.currententity->origin, v );
a = VectorDistance( v, RI.viewOrigin );
a = bound( pass->alphaGen.args[0], a, pass->alphaGen.args[1] ) - pass->alphaGen.args[0];
a = a * pass->alphaGen.args[2];
bArray[3] = R_FloatToByte( bound( 0.0, a, 1.0 ));
}
break;
case ALPHAGEN_ONE_MINUS_FADE:
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
{
VectorAdd( vertsArray[i], RI.currententity->origin, v );
a = VectorDistance( v, RI.viewOrigin );
a = bound( pass->alphaGen.args[0], a, pass->alphaGen.args[1] ) - pass->alphaGen.args[0];
a = a * pass->alphaGen.args[2];
bArray[3] = R_FloatToByte( bound( 0.0, 1.0 - a, 1.0 ));
}
break;
default:
break;
}
@ -1910,7 +1928,6 @@ void R_RenderMeshGeneric( void )
{
const ref_stage_t *pass = r_accumPasses[0];
R_ShaderpassRenderMode( (ref_stage_t *)pass );
R_BindShaderpass( pass, NULL, 0 );
R_ModifyColor( pass );
@ -2218,7 +2235,7 @@ static void R_RenderMeshGLSL_Material( void )
}
else if( RI.currententity )
{
if( RI.currententity->flags & RF_FULLBRIGHT )
if( RI.currententity->flags & EF_FULLBRIGHT )
{
Vector4Set( ambient, 1, 1, 1, 1 );
Vector4Set( diffuse, 1, 1, 1, 1 );
@ -2548,6 +2565,8 @@ static void R_AccumulatePass( ref_stage_t *pass )
if( ( RI.params & RP_SHADOWMAPVIEW ) && !( pass->glState & GLSTATE_DEPTHWRITE ))
return;
R_ShaderpassRenderMode( pass );
// see if there are any free texture units
renderNow = ( pass->flags & ( SHADERSTAGE_DLIGHT|SHADERSTAGE_STENCILSHADOW ) ) || pass->program;
accumulate = ( r_numAccumPasses < glConfig.max_texture_units ) && !renderNow;
@ -2661,27 +2680,14 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
}
surf = mb->infokey > 0 ? &r_worldbrushmodel->surfaces[mb->infokey-1] : NULL;
if( surf )
r_superLightStyle = &r_superLightStyles[surf->superLightStyle];
else
r_superLightStyle = NULL;
if( surf ) r_superLightStyle = &r_superLightStyles[surf->superLightStyle];
else r_superLightStyle = NULL;
r_currentMeshBuffer = mb;
MB_NUM2SHADER( mb->shaderkey, r_currentShader );
if( glState.in2DMode )
{
r_currentShaderTime = Sys_DoubleTime();
}
else
{
r_currentShaderTime = (double)RI.refdef.time;
if( RI.currententity )
{
r_currentShaderTime -= (double)RI.currententity->shaderTime;
if( r_currentShaderTime < 0 ) r_currentShaderTime = 0;
}
}
if( glState.in2DMode ) r_currentShaderTime = Sys_DoubleTime();
else r_currentShaderTime = (double)RI.refdef.time;
if( !r_triangleOutlines )
R_SetShaderState();

11
render/r_cull.c
View File

@ -228,26 +228,25 @@ R_CullModel
*/
int R_CullModel( ref_entity_t *e, vec3_t mins, vec3_t maxs, float radius )
{
if( e->flags & RF_WEAPONMODEL )
if( e->ent_type == ED_VIEWMODEL )
{
if( RI.params & RP_NONVIEWERREF )
return 1;
return 0;
}
if( e->flags & RF_VIEWERMODEL )
if( RP_LOCALCLIENT( e ))
{
//if( !(RI.params & RP_NONVIEWERREF) )
if( !( RI.params & ( RP_MIRRORVIEW|RP_SHADOWMAPVIEW ) ) )
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 ) )
if( RI.refdef.rdflags & (RDF_PORTALINVIEW|RDF_SKYPORTALINVIEW) || (RI.params & RP_SKYPORTALVIEW))
{
if( R_VisCullSphere( e->origin, radius ) )
if( R_VisCullSphere( e->origin, radius ))
return 2;
}

2
render/r_draw.c
View File

@ -57,8 +57,8 @@ void R_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, f
}
tr.iRenderMode = glState.draw_rendermode;
pic_mbuffer.infokey -= 4;
pic_mbuffer.shaderkey = shader->sortkey;
pic_mbuffer.infokey -= 4;
// upload video right before rendering
if( shader->flags & SHADER_VIDEOMAP ) R_UploadCinematicShader( shader );

4
render/r_light.c
View File

@ -488,11 +488,11 @@ void R_LightForEntity( ref_entity_t *e, byte *bArray )
vec3_t lightDirs[MAX_DLIGHTS], direction, temp;
vec4_t ambient, diffuse;
if( ( e->flags & RF_FULLBRIGHT ) || r_fullbright->value )
if(( e->flags & EF_FULLBRIGHT ) || r_fullbright->value )
return;
// probably weird shader, see mpteam4 for example
if( !e->model || ( e->model->type == mod_brush ) )
if( !e->model || ( e->model->type == mod_brush ) || (e->model->type == mod_world ))
return;
R_LightForOrigin( e->lightingOrigin, temp, ambient, diffuse, 0 );

54
render/r_local.h
View File

@ -146,17 +146,17 @@ enum
#define BACKFACE_EPSILON 0.01
#define Z_NEAR 4
#define Z_NEAR 4
#define SIDE_FRONT 0
#define SIDE_BACK 1
#define SIDE_ON 2
#define SIDE_FRONT 0
#define SIDE_BACK 1
#define SIDE_ON 2
#define RP_NONE 0x0
#define RP_MIRRORVIEW 0x1 // lock pvs at vieworg
#define RP_PORTALVIEW 0x2
#define RP_ENVVIEW 0x4
#define RP_NOSKY 0x8
#define RP_NONE 0x0
#define RP_MIRRORVIEW 0x1 // lock pvs at vieworg
#define RP_PORTALVIEW 0x2
#define RP_ENVVIEW 0x4
#define RP_NOSKY 0x8
#define RP_SKYPORTALVIEW 0x10
#define RP_PORTALCAPTURED 0x20
#define RP_PORTALCAPTURED2 0x40
@ -164,11 +164,12 @@ enum
#define RP_SHADOWMAPVIEW 0x100
#define RP_FLIPFRONTFACE 0x200
#define RP_WORLDSURFVISIBLE 0x400
#define RP_CLIPPLANE 0x800
#define RP_TRISOUTLINES 0x1000
#define RP_SHOWNORMALS 0x2000
#define RP_CLIPPLANE 0x800
#define RP_TRISOUTLINES 0x1000
#define RP_SHOWNORMALS 0x2000
#define RP_NONVIEWERREF ( RP_PORTALVIEW|RP_MIRRORVIEW|RP_ENVVIEW|RP_SKYPORTALVIEW|RP_SHADOWMAPVIEW )
#define RP_NONVIEWERREF ( RP_PORTALVIEW|RP_MIRRORVIEW|RP_ENVVIEW|RP_SKYPORTALVIEW|RP_SHADOWMAPVIEW )
#define RP_LOCALCLIENT(e) ((e)->index == ri.GetLocalPlayer()->serialnumber )
//====================================================
@ -457,17 +458,17 @@ enum
&& !((RI).params & RP_NONVIEWERREF) && !((RI).refdef.rdflags & RDF_NOWORLDMODEL) \
&& OCCLUSION_QUERIES_CVAR_HACK( RI ) )
#define OCCLUSION_OPAQUE_SHADER( s ) (((s)->sort == SORT_OPAQUE ) && ((s)->flags & SHADER_DEPTHWRITE ) && !(s)->numDeforms )
#define OCCLUSION_TEST_ENTITY( e ) (((e)->flags & (RF_OCCLUSIONTEST|RF_WEAPONMODEL)) == RF_OCCLUSIONTEST )
#define OCCLUSION_TEST_ENTITY( e ) (((e)->flags & EF_OCCLUSIONTEST) || ((e)->ent_type == ED_VIEWMODEL))
void R_InitOcclusionQueries( void );
void R_BeginOcclusionPass( void );
ref_shader_t *R_OcclusionShader( void );
void R_AddOccludingSurface( msurface_t *surf, ref_shader_t *shader );
int R_GetOcclusionQueryNum( int type, int key );
int R_IssueOcclusionQuery( int query, ref_entity_t *e, vec3_t mins, vec3_t maxs );
bool R_OcclusionQueryIssued( int query );
unsigned int R_GetOcclusionQueryResult( int query, bool wait );
bool R_GetOcclusionQueryResultBool( int type, int key, bool wait );
int R_GetOcclusionQueryNum( int type, int key );
int R_IssueOcclusionQuery( int query, ref_entity_t *e, vec3_t mins, vec3_t maxs );
bool R_OcclusionQueryIssued( int query );
uint R_GetOcclusionQueryResult( int query, bool wait );
bool R_GetOcclusionQueryResultBool( int type, int key, bool wait );
void R_EndOcclusionPass( void );
void R_ShutdownOcclusionQueries( void );
@ -543,13 +544,13 @@ void R_EndFrame( void );
void R_RenderView( const ref_params_t *fd );
const char *R_SpeedsMessage( char *out, size_t size );
bool R_CullBox( const vec3_t mins, const vec3_t maxs, const unsigned int clipflags );
bool R_CullSphere( const vec3_t centre, const float radius, const unsigned int clipflags );
bool R_CullBox( const vec3_t mins, const vec3_t maxs, const uint clipflags );
bool R_CullSphere( const vec3_t centre, const float radius, const uint clipflags );
bool R_VisCullBox( const vec3_t mins, const vec3_t maxs );
bool R_VisCullSphere( const vec3_t origin, float radius );
int R_CullModel( ref_entity_t *e, vec3_t mins, vec3_t maxs, float radius );
int R_CullModel( ref_entity_t *e, vec3_t mins, vec3_t maxs, float radius );
mfog_t *R_FogForSphere( const vec3_t centre, const float radius );
mfog_t *R_FogForSphere( const vec3_t centre, const float radius );
bool R_CompletelyFogged( mfog_t *fog, vec3_t origin, float radius );
void R_LoadIdentity( void );
@ -663,6 +664,13 @@ int R_GetClippedFragments( const vec3_t origin, float radius, vec3_t axis[3],
vec3_t *fverts, int maxfragments, fragment_t *fragments );
msurface_t *R_TransformedTraceLine( trace_t *tr, const vec3_t start, const vec3_t end, ref_entity_t *test, int surfumask );
//
// r_sprite.c
//
mspriteframe_t *R_GetSpriteFrame( ref_entity_t *ent );
//
//
// r_register.c
//

173
render/r_main.c
View File

@ -527,23 +527,55 @@ static mesh_t spr_mesh = { 4, spr_xyz, spr_xyz, NULL, spr_st, { 0, 0, 0, 0 }, {
R_PushSprite
=================
*/
static bool R_PushSprite( const meshbuffer_t *mb, float rotation, float right, float left, float up, float down )
static bool R_PushSprite( const meshbuffer_t *mb, int type, float right, float left, float up, float down )
{
int i, features;
vec3_t point;
vec3_t v_right, v_up;
ref_entity_t *e = RI.currententity;
ref_shader_t *shader;
int i, features;
vec3_t v_forward, v_right, v_up;
ref_entity_t *e = RI.currententity;
float angle, sr, cr;
ref_shader_t *shader;
vec3_t point;
if( rotation )
{
RotatePointAroundVector( v_right, RI.vpn, RI.vright, rotation );
CrossProduct( RI.vpn, v_right, v_up );
}
else
switch( type )
{
case SPR_ORIENTED:
VectorCopy( e->axis[0], v_forward );
VectorCopy( e->axis[1], v_right );
VectorCopy( e->axis[2], v_up );
VectorScale( v_forward, 0.01f, v_forward ); // to avoid z-fighting
VectorSubtract( e->origin, v_forward, e->origin );
break;
case SPR_FACING_UPRIGHT:
VectorSet( v_right, e->origin[1] - RI.viewOrigin[1], -(e->origin[0] - RI.viewOrigin[0]), 0 );
VectorSet( v_up, 0, 0, 1 );
VectorNormalize( v_right );
break;
case SPR_FWD_PARALLEL_UPRIGHT:
VectorSet( v_right, RI.vpn[1], -RI.vpn[0], 0 );
VectorSet( v_up, 0, 0, 1 );
break;
case SPR_FWD_PARALLEL_ORIENTED:
angle = e->angles[ROLL] * (M_PI * 2.0f/360.0f);
sr = com.sin( angle );
cr = com.cos( angle );
for( i = 0; i < 3; i++ )
{
v_right[i] = (RI.vright[i] * cr + RI.vup[i] * sr);
v_up[i] = RI.vright[i] * -sr + RI.vup[i] * cr;
}
break;
default:
if( e->spriteshader && e->angles[PITCH] )
{
RotatePointAroundVector( v_right, RI.vpn, RI.vright, e->angles[PITCH] );
CrossProduct( RI.vpn, v_right, v_up );
break;
}
// intentional fallthrough
case SPR_FWD_PARALLEL: // normal sprite
VectorCopy( RI.vright, v_right );
VectorCopy( RI.vup, v_up );
break;
}
VectorScale( v_up, down, point );
@ -567,7 +599,7 @@ static bool R_PushSprite( const meshbuffer_t *mb, float rotation, float right, f
if( shader->features & MF_COLORS )
{
for( i = 0; i < 4; i++ )
Vector4Copy( e->color, spr_color[i] );
Vector4Set( spr_color[i], e->rendercolor[0], e->rendercolor[1], e->rendercolor[2], e->renderamt );
}
features = MF_NOCULL | MF_TRIFAN | shader->features;
@ -698,15 +730,15 @@ R_PushSpriteModel
*/
bool R_PushSpriteModel( const meshbuffer_t *mb )
{
sframe_t *frame;
smodel_t *psprite;
ref_entity_t *e = RI.currententity;
mspriteframe_t *frame;
msprite_t *psprite;
ref_entity_t *e = RI.currententity;
ref_model_t *model = e->model;
psprite = ( smodel_t * )model->extradata;
frame = psprite->frames + e->frame;
psprite = (msprite_t * )model->extradata;
frame = R_GetSpriteFrame( e );
return R_PushSprite( mb, e->rotation, frame->origin_x, frame->origin_x - frame->width, frame->height - frame->origin_y, -frame->origin_y );
return R_PushSprite( mb, psprite->type, frame->left, frame->right, frame->down, frame->up );
}
/*
@ -728,8 +760,7 @@ bool R_PushSpritePoly( const meshbuffer_t *mb )
R_PushFlareSurf( mb );
return false;
}
return R_PushSprite( mb, e->rotation, -e->radius, e->radius, e->radius, -e->radius );
return R_PushSprite( mb, -1, -e->radius, e->radius, e->radius, -e->radius );
}
/*
@ -739,38 +770,46 @@ R_AddSpriteModelToList
*/
static void R_AddSpriteModelToList( ref_entity_t *e )
{
sframe_t *frame;
smodel_t *psprite;
mspriteframe_t *frame;
msprite_t *psprite;
ref_model_t *model = e->model;
float dist;
meshbuffer_t *mb;
ref_shader_t *shader;
float dist;
meshbuffer_t *mb;
if( !( psprite = ( ( smodel_t * )model->extradata ) ) )
if(!( psprite = (( msprite_t* )model->extradata )))
return;
dist =
( e->origin[0] - RI.refdef.vieworg[0] ) * RI.vpn[0] +
( e->origin[1] - RI.refdef.vieworg[1] ) * RI.vpn[1] +
( e->origin[2] - RI.refdef.vieworg[2] ) * RI.vpn[2];
if( dist < 0 )
return; // cull it because we don't want to sort unneeded things
dist = (e->origin[0] - RI.refdef.vieworg[0]) * RI.vpn[0] + (e->origin[1] - RI.refdef.vieworg[1]) * RI.vpn[1] + (e->origin[2] - RI.refdef.vieworg[2]) * RI.vpn[2];
if( dist < 0 ) return; // cull it because we don't want to sort unneeded things
e->frame %= psprite->numframes;
frame = psprite->frames + e->frame;
frame = R_GetSpriteFrame( e );
shader = &r_shaders[frame->shader];
if( RI.refdef.rdflags & ( RDF_PORTALINVIEW|RDF_SKYPORTALINVIEW ) || ( RI.params & RP_SKYPORTALVIEW ) )
if( e->rendermode == kRenderGlow )
{
if( R_VisCullSphere( e->origin, frame->radius ) )
trace_t tr;
/*
if( R_TraceLine( &tr, e->origin, RI.viewOrigin, SURF_NONSOLID ) == NULL )
{
float dist = VectorDistance( e->origin, RI.viewOrigin );
e->scale = bound( 1.0, dist * 0.005f, 10.0f );
e->renderamt = 255 * bound( 0, dist / 1000, 1.0f );
if( e->renderamt >= 255 ) return; // faded
}
else return; // occluded
*/
}
if( RI.refdef.rdflags & (RDF_PORTALINVIEW|RDF_SKYPORTALINVIEW) || ( RI.params & RP_SKYPORTALVIEW ))
{
if( R_VisCullSphere( e->origin, frame->radius ))
return;
}
// select skin
if( e->customShader )
mb = R_AddMeshToList( MB_MODEL, R_FogForSphere( e->origin, frame->radius ), e->customShader, -1 );
else
mb = R_AddMeshToList( MB_MODEL, R_FogForSphere( e->origin, frame->radius ), frame->shader, -1 );
if( mb )
mb->shaderkey |= ( bound( 1, 0x4000 - (unsigned int)dist, 0x4000 - 1 ) << 12 );
mb = R_AddMeshToList( MB_MODEL, R_FogForSphere( e->origin, frame->radius ), shader, -1 );
if( mb ) mb->shaderkey |= ( bound( 1, 0x4000 - (uint)dist, 0x4000 - 1 )<<12 );
}
/*
@ -780,24 +819,20 @@ R_AddSpritePolyToList
*/
static void R_AddSpritePolyToList( ref_entity_t *e )
{
float dist;
meshbuffer_t *mb;
float dist;
meshbuffer_t *mb;
dist = (e->origin[0] - RI.refdef.vieworg[0]) * RI.vpn[0] + (e->origin[1] - RI.refdef.vieworg[1]) * RI.vpn[1] + (e->origin[2] - RI.refdef.vieworg[2]) * RI.vpn[2];
if( dist < 0 ) return; // cull it because we don't want to sort unneeded things
dist =
( e->origin[0] - RI.refdef.vieworg[0] ) * RI.vpn[0] +
( e->origin[1] - RI.refdef.vieworg[1] ) * RI.vpn[1] +
( e->origin[2] - RI.refdef.vieworg[2] ) * RI.vpn[2];
if( dist < 0 )
return; // cull it because we don't want to sort unneeded things
if( RI.refdef.rdflags & ( RDF_PORTALINVIEW|RDF_SKYPORTALINVIEW ) || ( RI.params & RP_SKYPORTALVIEW ) )
{
if( R_VisCullSphere( e->origin, e->radius ) )
return;
}
mb = R_AddMeshToList( MB_SPRITE, R_FogForSphere( e->origin, e->radius ), e->customShader, -1 );
if( mb )
mb->shaderkey |= ( bound( 1, 0x4000 - (unsigned int)dist, 0x4000 - 1 ) << 12 );
mb = R_AddMeshToList( MB_SPRITE, R_FogForSphere( e->origin, e->radius ), e->spriteshader, -1 );
if( mb ) mb->shaderkey |= ( bound( 1, 0x4000 - (unsigned int)dist, 0x4000 - 1 ) << 12 );
}
/*
@ -1353,11 +1388,12 @@ static void R_CategorizeEntities( void )
switch( RI.currentmodel->type )
{
case mod_brush:
case mod_world:
r_bmodelentities[r_numbmodelentities++] = RI.currententity;
break;
case mod_alias:
case mod_studio:
if( !( RI.currententity->renderfx & ( RF_NOSHADOW|RF_PLANARSHADOW ) ) )
if(!( RI.currententity->flags & (EF_NOSHADOW|EF_PLANARSHADOW)))
R_AddShadowCaster( RI.currententity ); // build groups and mark shadow casters
break;
case mod_sprite:
@ -1404,6 +1440,7 @@ static void R_CullEntities( void )
culled = true;
break;
case mod_brush:
case mod_world:
culled = R_CullBrushModel( e );
break;
case mod_sprite:
@ -1413,7 +1450,7 @@ static void R_CullEntities( void )
}
break;
case RT_SPRITE:
culled = ( e->radius <= 0 ) || ( e->customShader == NULL );
culled = ( e->radius <= 0 ) || ( e->spriteshader == NULL );
break;
default:
break;
@ -1491,7 +1528,7 @@ static void R_DrawRegularEntities( void )
if( shadowmap )
{
if( e->flags & RF_NOSHADOW )
if( e->flags & EF_NOSHADOW )
continue;
if( r_entShadowBits[i] & RI.shadowGroup->bit )
goto add; // shadow caster
@ -1551,12 +1588,12 @@ static void R_DrawNullEntities( void )
if( RI.params & RP_MIRRORVIEW )
{
if( RI.currententity->flags & RF_WEAPONMODEL )
if( RI.currententity->ent_type == ED_VIEWMODEL )
continue;
}
else
{
if( RI.currententity->flags & RF_VIEWERMODEL )
if( RP_LOCALCLIENT( RI.currententity ))
continue;
}
R_DrawNullModel();
@ -2158,6 +2195,7 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
switch( refent->model->type )
{
case mod_world:
case mod_brush: break;
case mod_studio:
if( !refent->model->extradata )
@ -2167,7 +2205,7 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
case mod_sprite:
if( !refent->model->extradata )
return false;
refent->rtype = RT_SPRITE;
refent->rtype = RT_MODEL;
break;
case mod_bad: // let the render drawing null model
break;
@ -2176,9 +2214,10 @@ 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 );
// do animate
if( refent->effects & EF_ANIMATE )
if( refent->flags & EF_ANIMATE )
{
switch( refent->model->type )
{
@ -2208,6 +2247,7 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
break;
case mod_sprite:
case mod_brush:
case mod_world:
break;
}
}
@ -2231,7 +2271,7 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
else VectorClear( refent->movedir );
// calculate angles
if( refent->effects & EF_ROTATE )
if( refent->flags & EF_ROTATE )
{
// some bonus items auto-rotate
VectorSet( refent->angles, 0, anglemod( RI.refdef.time / 10), 0 );
@ -2253,7 +2293,6 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
{
if( r_lefthand->integer == 1 )
VectorNegate( refent->axis[1], refent->axis[1] );
refent->flags |= RF_WEAPONMODEL|RF_CULLHACK;
}
// copy controllers
@ -2273,7 +2312,7 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
if( refent->ent_type == ED_CLIENT )
{
refent->gaitsequence = pRefEntity->v.gaitsequence;
refent->flags |= RF_OCCLUSIONTEST;
refent->flags |= EF_OCCLUSIONTEST;
}
else refent->gaitsequence = 0;
@ -2283,6 +2322,7 @@ bool R_AddGenericEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
switch( refent->model->type )
{
case mod_brush:
case mod_world:
refent->ent_type = ED_BSPBRUSH;
break;
case mod_studio:
@ -2304,7 +2344,7 @@ bool R_AddPortalEntity( edict_t *pRefEntity, ref_entity_t *refent, int ed_type,
VectorCopy( pRefEntity->v.origin, refent->origin );
VectorCopy( pRefEntity->v.oldorigin, refent->origin2 );
if( refent->effects & EF_ROTATE )
if( refent->flags & EF_ROTATE )
{
float phase = pRefEntity->v.frame;
float speed = (pRefEntity->v.framerate ? pRefEntity->v.framerate : 50.0f);
@ -2353,14 +2393,13 @@ bool R_AddEntityToScene( edict_t *pRefEntity, int ed_type, float lerpfrac )
refent->skin = pRefEntity->v.skin;
refent->scale = pRefEntity->v.scale;
refent->colormap = pRefEntity->v.colormap;
refent->effects = pRefEntity->v.effects;
refent->flags = pRefEntity->v.effects;
refent->renderfx = pRefEntity->v.renderfx;
VectorCopy( pRefEntity->v.rendercolor, refent->rendercolor );
refent->renderamt = pRefEntity->v.renderamt;
refent->model = cl_models[pRefEntity->v.modelindex];
refent->movetype = pRefEntity->v.movetype;
refent->framerate = pRefEntity->v.framerate;
refent->flags = 0;
// setup rtype
switch( ed_type )

2
render/r_mesh.c
View File

@ -406,12 +406,14 @@ static void R_BatchMeshBuffer( const meshbuffer_t *mb, const meshbuffer_t *nextm
}
type = mb->sortkey & 3;
tr.iRenderMode = RI.currententity->rendermode;
switch( type )
{
case MB_MODEL:
switch( ent->model->type )
{
case mod_world:
case mod_brush:
MB_NUM2SHADER( mb->shaderkey, shader );

40
render/r_mesh.h
View File

@ -56,16 +56,16 @@ enum
typedef struct mesh_s
{
int numVertexes;
vec4_t *xyzArray;
vec4_t *normalsArray;
vec4_t *sVectorsArray;
vec2_t *stArray;
vec2_t *lmstArray[LM_STYLES];
rgba_t *colorsArray[LM_STYLES];
int numVertexes;
vec4_t *xyzArray;
vec4_t *normalsArray;
vec4_t *sVectorsArray;
vec2_t *stArray;
vec2_t *lmstArray[LM_STYLES];
rgba_t *colorsArray[LM_STYLES];
int numElems;
elem_t *elems;
int numElems;
elem_t *elems;
} mesh_t;
#define MB_FOG2NUM( fog ) ( (fog) ? ((((int)((fog) - r_worldbrushmodel->fogs))+1) << 2) : 0 )
@ -82,28 +82,28 @@ typedef struct mesh_s
typedef struct
{
int shaderkey;
unsigned int sortkey;
int infokey; // surface number or mesh number
int shaderkey;
uint sortkey;
int infokey; // surface number or mesh number
union
{
int lastPoly;
unsigned int dlightbits;
unsigned int LODModelHandle;
int lastPoly;
uint dlightbits;
uint LODModelHandle;
};
unsigned int shadowbits;
uint shadowbits;
} meshbuffer_t;
typedef struct
{
int num_opaque_meshes, max_opaque_meshes;
int num_opaque_meshes, max_opaque_meshes;
meshbuffer_t *meshbuffer_opaque;
int num_translucent_meshes, max_translucent_meshes;
int num_translucent_meshes, max_translucent_meshes;
meshbuffer_t *meshbuffer_translucent;
int num_portal_opaque_meshes;
int num_portal_translucent_meshes;
int num_portal_opaque_meshes;
int num_portal_translucent_meshes;
} meshlist_t;
enum

21
render/r_model.c
View File

@ -87,8 +87,9 @@ static mlightmapRect_t *loadmodel_lightmapRects;
static int loadmodel_numshaderrefs;
static mshaderref_t *loadmodel_shaderrefs;
void Mod_LoadAliasMD3Model( ref_model_t *mod, ref_model_t *parent, const void *buffer );
void Mod_LoadBrushModel( ref_model_t *mod, ref_model_t *parent, const void *buffer );
void Mod_SpriteLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buffer );
void Mod_AliasLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buffer );
void Mod_BrushLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buffer );
ref_model_t *Mod_LoadModel( ref_model_t *mod, bool crash );
@ -101,11 +102,12 @@ static byte *mod_mempool;
static modelformatdescriptor_t mod_supportedformats[] =
{
{ ALIASMODHEADER, MD3_ALIAS_MAX_LODS, Mod_LoadAliasMD3Model }, // Quake III Arena .md3 models
{ IDBSPMODHEADER, 0, Mod_LoadBrushModel }, // Quake III Arena .bsp models
{ RBBSPMODHEADER, 0, Mod_LoadBrushModel }, // SOF2 and JK2 .bsp models
{ QFBSPMODHEADER, 0, Mod_LoadBrushModel }, // QFusion .bsp models
{ 0, 0, NULL } // terminator
{ IDSPRITEHEADER, 0, Mod_SpriteLoadModel }, // Half-Life sprite models
{ ALIASMODHEADER, MD3_ALIAS_MAX_LODS, Mod_AliasLoadModel }, // Quake III Arena .md3 models
{ IDBSPMODHEADER, 0, Mod_BrushLoadModel }, // Quake III Arena .bsp models
{ RBBSPMODHEADER, 0, Mod_BrushLoadModel }, // SOF2 and JK2 .bsp models
{ QFBSPMODHEADER, 0, Mod_BrushLoadModel }, // QFusion .bsp models
{ 0, 0, NULL } // terminator
};
static int mod_numsupportedformats = sizeof( mod_supportedformats ) / sizeof( mod_supportedformats[0] ) - 1;
@ -1954,10 +1956,10 @@ static void Mod_Finish( const lump_t *faces, const lump_t *light, vec3_t gridSiz
/*
=================
Mod_LoadBrushModel
Mod_BrushLoadModel
=================
*/
void Mod_LoadBrushModel( ref_model_t *mod, ref_model_t *parent, const void *buffer )
void Mod_BrushLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buffer )
{
int i, version;
dheader_t *header;
@ -2099,6 +2101,7 @@ void R_BeginRegistration( const char *mapname, const dvis_t *visData )
r_worldmodel = Mod_ForName( fullname, true );
r_worldbrushmodel = (mbrushmodel_t *)r_worldmodel->extradata;
r_worldbrushmodel->vis = (dvis_t *)visData;
r_worldmodel->type = mod_world;
r_worldent->scale = 1.0f;
r_worldent->model = r_worldmodel;

34
render/r_model.h
View File

@ -258,23 +258,35 @@ SPRITE MODELS
//
// in memory representation
//
typedef struct
typedef struct mspriteframe_s
{
int width, height;
int origin_x, origin_y; // raster coordinates inside pic
char name[64];
ref_shader_t *shader;
float mins[3], maxs[3];
int width;
int height;
float up, down, left, right;
float radius;
} sframe_t;
shader_t shader;
} mspriteframe_t;
typedef struct
{
int numframes;
sframe_t *frames;
} smodel_t;
float *intervals;
mspriteframe_t *frames[1];
} mspritegroup_t;
typedef struct
{
frametype_t type;
mspriteframe_t *frameptr;
} mspriteframedesc_t;
typedef struct
{
int type;
int rendermode;
int numframes;
mspriteframedesc_t frames[1];
} msprite_t;
//===================================================================

4
render/r_poly.c
View File

@ -762,7 +762,7 @@ msurface_t *R_TransformedTraceLine( trace_t *tr, const vec3_t start, const vec3_
model = test->model;
if( model )
{
if( model->type == mod_brush )
if( model->type == mod_world || model->type == mod_brush )
{
mbrushmodel_t *bmodel = ( mbrushmodel_t * )model->extradata;
vec3_t temp, start_l, end_l, axis[3];
@ -784,7 +784,7 @@ msurface_t *R_TransformedTraceLine( trace_t *tr, const vec3_t start, const vec3_
// world uses a recursive approach using BSP tree, submodels
// just walk the list of surfaces linearly
if( test->model == r_worldmodel )
if( test->model->type == mod_world )
R_RecursiveHullCheck( bmodel->nodes, start_l, end_l );
else if( BoundsIntersect( model->mins, model->maxs, trace_absmins, trace_absmaxs ) )
R_TraceAgainstBmodel( bmodel );

92
render/r_public.h
View File

@ -76,44 +76,43 @@ typedef struct entity_s
int index; // viewmodel has entindex -1
refEntityType_t rtype;
struct ref_model_s *model; // opaque type outside refresh
struct ref_model_s *weaponmodel; // opaque type outside refresh
struct ref_model_s *model; // opaque type outside refresh
struct ref_model_s *weaponmodel; // opaque type outside refresh
struct skinfile_s *skinfile; // registered .skin file
latchedvars_t prev; // previous frame values for lerping
latchedvars_t prev; // previous frame values for lerping
int flags;
float framerate; // custom framerate
float animtime; // lerping animtime
float frame; // also used as RF_BEAM's diameter
float framerate; // custom framerate
float animtime; // lerping animtime
int frame; // also used as RF_BEAM's diameter
int body;
int skin;
int body;
int skin;
float blending[MAXSTUDIOBLENDS];
vec3_t attachment[MAXSTUDIOATTACHMENTS];
float controller[MAXSTUDIOCONTROLLERS];
mouth_t mouth; // for synchronizing mouth movements.
float blending[MAXSTUDIOBLENDS];
vec3_t attachment[MAXSTUDIOATTACHMENTS];
float controller[MAXSTUDIOCONTROLLERS];
mouth_t mouth; // for synchronizing mouth movements.
int gaitsequence; // client->sequence + yaw
float gaitframe; // client->frame + yaw
float gaityaw; // local value
int gaitsequence; // client->sequence + yaw
float gaitframe; // client->frame + yaw
float gaityaw; // local value
int movetype; // entity moving type
int sequence;
float scale;
int movetype; // entity moving type
int sequence;
float scale;
// misc
float backlerp; // 0.0 = current, 1.0 = old
rgb_t rendercolor; // hl1 rendercolor
byte renderamt; // hl1 alphavalues
int rendermode; // hl1 rendermode
int renderfx; // server will be translate hl1 values into flags
int colormap; // q1 and hl1 model colormap (can applied for sprites)
int effects; // q1 effect flags, EF_ROTATE, EF_DIMLIGHT etc
float backlerp; // 0.0 = current, 1.0 = old
rgb_t rendercolor; // hl1 rendercolor
byte renderamt; // hl1 alphavalues
int rendermode; // hl1 rendermode
int renderfx; // server will be translate hl1 values into flags
int colormap; // q1 and hl1 model colormap (can applied for sprites)
int flags; // q1 effect flags, EF_ROTATE, EF_DIMLIGHT etc
int m_fSequenceLoops;
int m_fSequenceFinished;
int m_fSequenceLoops;
int m_fSequenceFinished;
/*
** most recent data
@ -124,37 +123,14 @@ typedef struct entity_s
vec3_t origin, origin2;
vec3_t lightingOrigin;
/*
** previous data for lerping
*/
int oldframe;
/*
** texturing
*/
int skinNum;
struct skinfile_s *customSkin; // registered .skin file
struct ref_shader_s *customShader; // NULL for inline skin
/*
** misc
*/
float shaderTime;
union
{
rgba_t color;
rgba_t shaderRGBA;
};
float radius; // used as RT_SPRITE's radius
float rotation;
// RT_SPRITE stuff
struct ref_shader_s *spriteshader; // client drawing stuff
float radius; // used as RT_SPRITE's radius
// outilne stuff
float outlineHeight;
union
{
rgba_t outlineColor;
rgba_t outlineRGBA;
};
rgba_t outlineColor;
} ref_entity_t;
void R_ModelBounds( const struct ref_model_s *model, vec3_t mins, vec3_t maxs );

50
render/r_shader.c
View File

@ -1754,6 +1754,7 @@ static bool Shaderpass_RGBGen( ref_shader_t *shader, ref_stage_t *pass, script_t
else
{
MsgDev( D_WARN, "unknown 'rgbGen' parameter '%s' in shader '%s'\n", tok.string, shader->name );
pass->rgbGen.type = RGBGEN_IDENTITY;
Shader_SkipLine( script );
return true;
}
@ -1779,6 +1780,7 @@ static bool Shaderpass_AlphaGen( ref_shader_t *shader, ref_stage_t *pass, script
if( !pass->alphaGen.args[0] ) pass->alphaGen.args[0] = 256.0f;
pass->alphaGen.args[0] = 1.0f / pass->alphaGen.args[0];
}
else if( !com.stricmp( tok.string, "identity" )) pass->alphaGen.type = ALPHAGEN_IDENTITY;
else if( !com.stricmp( tok.string, "vertex" )) pass->alphaGen.type = ALPHAGEN_VERTEX;
else if( !com.stricmp( tok.string, "oneMinusVertex" )) pass->alphaGen.type = ALPHAGEN_ONE_MINUS_VERTEX;
else if( !com.stricmp( tok.string, "entity" )) pass->alphaGen.type = ALPHAGEN_ENTITY;
@ -1888,6 +1890,7 @@ static bool Shaderpass_AlphaGen( ref_shader_t *shader, ref_stage_t *pass, script
else
{
MsgDev( D_WARN, "unknown 'alphaGen' parameter '%s' in shader '%s'\n", tok.string, shader->name );
pass->alphaGen.type = ALPHAGEN_IDENTITY;
Shader_SkipLine( script );
return true;
}
@ -2056,8 +2059,8 @@ static bool Shaderpass_TcMod( ref_shader_t *shader, ref_stage_t *pass, script_t
return false;
}
tcMod->args[0] = -tcMod->args[0] / 360.0f;
if( !tcMod->args[0] ) return false;
Com_ReadFloat( script, false, NULL ); // skip second parm if present
if( !tcMod->args[0] ) return true;
tcMod->type = TCMOD_ROTATE;
}
else if( !com.stricmp( tok.string, "scale" ))
@ -2096,7 +2099,6 @@ static bool Shaderpass_TcMod( ref_shader_t *shader, ref_stage_t *pass, script_t
MsgDev( D_ERROR, "missing waveform parameters for 'tcMod stretch' in shader '%s'\n", shader->name );
return false;
}
tcMod->args[0] = func.type;
tcMod->args[5] = func.tableIndex;
for( i = 1; i < 5; i++ )
@ -2171,10 +2173,6 @@ static bool Shaderpass_TcGen( ref_shader_t *shader, ref_stage_t *pass, script_t
}
else if( !com.stricmp( tok.string, "warp" ))
pass->tcgen = TCGEN_WARP;
else if( !com.stricmp( tok.string, "lightVector" ))
pass->tcgen = TCGEN_LIGHTVECTOR;
else if( !com.stricmp( tok.string, "halfAngle" ))
pass->tcgen = TCGEN_HALFANGLE;
else if( !com.stricmp( tok.string, "reflection" ))
pass->tcgen = TCGEN_REFLECTION;
else if( !com.stricmp( tok.string, "normal"))
@ -2305,7 +2303,7 @@ static void Shader_ParseFile( script_t *script, const char *name )
static ref_script_t *Shader_GetCache( const char *name, int type, uint hashKey )
{
ref_script_t *cache;
ref_script_t *cache = NULL;
// see if there's a script for this shader
for( cache = r_shaderScriptsHash[hashKey]; cache; cache = cache->nextHash )
@ -2316,7 +2314,6 @@ static ref_script_t *Shader_GetCache( const char *name, int type, uint hashKey )
if( cache->type == type ) break;
}
}
return cache;
}
@ -2439,7 +2436,7 @@ void R_ShaderDump_f( void )
}
Msg( "found in %s:\n\n", cache->source );
Msg( "^1%s%s\n", name, cache->buffer );
Msg( "^2%s%s\n", name, cache->buffer );
}
void R_RegisterBuiltinShaders( void )
@ -2507,7 +2504,7 @@ void Shader_TouchImages( ref_shader_t *shader, bool free_unused )
// prolonge registration for all shader textures
texture = stage->textures[j];
if( !texture || !texture->name[0] ) continue;
if( !texture || !texture->texnum ) continue;
if( texture->flags & TF_STATIC ) continue;
if( free_unused && texture->touchFrame != tr.registration_sequence )
R_FreeImage( texture );
@ -2797,7 +2794,22 @@ static bool Shader_ParseShader( ref_shader_t *shader, script_t *script )
return false;
}
void Shader_SetFeatures( ref_shader_t *s )
static void Shader_SetRenderMode( ref_shader_t *s )
{
int i;
ref_stage_t *pass;
for( i = 0, pass = s->stages; i < s->num_stages; i++, pass++ )
{
pass->prev.glState = pass->glState;
pass->prev.flags = pass->flags;
pass->prev.rgbGen = pass->rgbGen;
pass->prev.alphaGen = pass->alphaGen;
}
s->realsort = s->sort;
}
static void Shader_SetFeatures( ref_shader_t *s )
{
int i;
ref_stage_t *pass;
@ -2829,6 +2841,9 @@ void Shader_SetFeatures( ref_shader_t *s )
if( pass->program && ( pass->program_type == PROGRAM_TYPE_MATERIAL || pass->program_type == PROGRAM_TYPE_DISTORTION ) )
s->features |= MF_NORMALS|MF_SVECTORS|MF_LMCOORDS|MF_ENABLENORMALS;
if( pass->flags & SHADERSTAGE_RENDERMODE )
s->features |= MF_COLORS;
switch( pass->rgbGen.type )
{
case RGBGEN_LIGHTING_DIFFUSE:
@ -2959,7 +2974,7 @@ void Shader_Finish( ref_shader_t *s )
pass->rgbGen.func = NULL;
}
if( pass->alphaGen.type == ALPHAGEN_WAVE )
if( pass->alphaGen.type == ALPHAGEN_WAVE || pass->rgbGen.type == ALPHAGEN_ALPHAWAVE )
{
pass->alphaGen.func = ( waveFunc_t * )buffer; buffer += sizeof( waveFunc_t );
Mem_Copy( pass->alphaGen.func, r_currentPasses[i].alphaGen.func, sizeof( waveFunc_t ));
@ -3091,6 +3106,7 @@ void Shader_Finish( ref_shader_t *s )
if(( s->flags & SHADER_SKYPARMS ) && ( s->flags & SHADER_DEPTHWRITE ))
s->flags &= ~SHADER_DEPTHWRITE;
Shader_SetRenderMode( s );
Shader_SetFeatures( s );
// refresh registration sequence
@ -3246,7 +3262,7 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
else if( r_numSpriteTextures > 1 )
{
// store group frames into one stage
pass->flags |= SHADERSTAGE_ANIMFREQUENCY;
pass->flags |= SHADERSTAGE_FRAMES;
pass->animFrequency = r_spriteFrequency;
for( i = 0; i < r_numSpriteTextures; i++ )
@ -3261,6 +3277,7 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
{
// single frame
pass->textures[0] = r_spriteTexture[0];
pass->num_textures++;
if( !pass->textures[0] )
{
@ -3301,7 +3318,6 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
shader->sort = SORT_ALPHATEST;
break;
}
shader->num_stages++;
// reset parms
r_numSpriteTextures = 0;
@ -3357,8 +3373,8 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
MsgDev( D_WARN, "couldn't find texture for shader '%s', using default...\n", shader->name );
pass->textures[0] = tr.defaultTexture;
}
pass->rgbGen.type = RGBGEN_VERTEX;
pass->alphaGen.type = ALPHAGEN_VERTEX;
pass->rgbGen.type = RGBGEN_IDENTITY;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
pass->tcgen = TCGEN_BASE;
pass->num_textures++;
break;
@ -3536,6 +3552,8 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
break;
}
Shader_SetRenderMode( shader );
// refresh registration sequence
Shader_TouchImages( shader, false );

13
render/r_shader.h
View File

@ -178,8 +178,6 @@ typedef enum
TCGEN_LIGHTMAP,
TCGEN_ENVIRONMENT,
TCGEN_VECTOR,
TCGEN_LIGHTVECTOR,
TCGEN_HALFANGLE,
TCGEN_WARP,
TCGEN_REFLECTION,
TCGEN_FOG,
@ -270,6 +268,15 @@ typedef struct
waveFunc_t func;
} deform_t;
typedef struct old_stage_s
{
uint flags;
uint glState; // GLSTATE_ flags
rgbGen_t rgbGen;
alphaGen_t alphaGen;
} old_stage_t;
// Per-pass rendering state information
typedef struct ref_stage_s
{
@ -279,6 +286,8 @@ typedef struct ref_stage_s
rgbGen_t rgbGen;
alphaGen_t alphaGen;
old_stage_t prev;
word tcgen;
vec_t *tcgenVec;

6
render/r_shadow.c
View File

@ -83,9 +83,9 @@ bool R_CullPlanarShadow( ref_entity_t *e, vec3_t mins, vec3_t maxs, bool occlusi
vec3_t bbox[8], newmins, newmaxs;
trace_t tr;
if( e->flags & ( RF_NOSHADOW|RF_WEAPONMODEL ) )
if((e->flags & EF_NOSHADOW) || (e->ent_type == ED_VIEWMODEL))
return true;
if( e->flags & RF_VIEWERMODEL )
if( RP_LOCALCLIENT( e ))
return false;
R_GetShadowImpactAndDir( e, &tr, lightdir );
@ -308,7 +308,7 @@ add:
}
r_entShadowBits[ent - r_entities] |= group->bit;
if( ent->flags & RF_WEAPONMODEL )
if( ent->ent_type == ED_VIEWMODEL )
return true;
// rotate local bounding box and compute the full bounding box for this group

282
render/r_sprite.c Normal file
View File

@ -0,0 +1,282 @@
//=======================================================================
// Copyright XashXT Group 2007 ©
// r_sprite.c - render sprite models
//=======================================================================
#include "r_local.h"
#include "mathlib.h"
#include "byteorder.h"
#include "const.h"
/*
=============================================================
SPRITE MODELS
=============================================================
*/
string frame_prefix;
uint frame_type;
uint group_num;
string sp_name;
ref_shader_t **frames = NULL;
/*
====================
Sprite model loader
====================
*/
dframetype_t *R_SpriteLoadFrame( ref_model_t *mod, void *pin, mspriteframe_t **ppframe, int framenum )
{
texture_t *tex;
dspriteframe_t *pinframe;
mspriteframe_t *pspriteframe;
string name, shadername;
// build uinque frame name
if( !sp_name[0] ) FS_FileBase( mod->name, sp_name );
com.snprintf( name, MAX_STRING, "Sprite( %s_%s_%i%i )", sp_name, frame_prefix, framenum/10, framenum%10 );
pinframe = (dspriteframe_t *)pin;
SwapBlock((int *)pinframe, sizeof( dspriteframe_t ));
// setup frame description
pspriteframe = Mem_Alloc( mod->mempool, sizeof( mspriteframe_t ));
pspriteframe->width = pinframe->width;
pspriteframe->height = pinframe->height;
pspriteframe->up = pinframe->origin[1];
pspriteframe->left = pinframe->origin[0];
pspriteframe->down = pinframe->origin[1] - pinframe->height;
pspriteframe->right = pinframe->width + pinframe->origin[0];
pspriteframe->radius = com.sqrt((pinframe->width * pinframe->width) + (pinframe->height * pinframe->height));
tex = R_FindTexture( name, (byte *)pin, pinframe->width * pinframe->height, 0 );
*ppframe = pspriteframe;
R_ShaderSetSpriteTexture( tex );
if( frame_type == SPR_SINGLE )
{
com.snprintf( shadername, MAX_STRING, "sprites/%s.spr/%s_%i%i )", sp_name, frame_prefix, framenum/10, framenum%10 );
pspriteframe->shader = R_LoadShader( shadername, SHADER_SPRITE, true, tex->flags, SHADER_INVALID )->shadernum;
frames = Mem_Realloc( mod->mempool, frames, sizeof( ref_shader_t* ) * (mod->numshaders + 1));
frames[mod->numshaders++] = &r_shaders[pspriteframe->shader];
}
return (dframetype_t *)((byte *)(pinframe + 1) + pinframe->width * pinframe->height );
}
dframetype_t *R_SpriteLoadGroup( ref_model_t *mod, void * pin, mspriteframe_t **ppframe, int framenum )
{
dspritegroup_t *pingroup;
mspritegroup_t *pspritegroup;
dspriteinterval_t *pin_intervals;
float *poutintervals;
shader_t group_shader;
int i, groupsize, numframes;
string shadername;
void *ptemp;
pingroup = (dspritegroup_t *)pin;
numframes = LittleLong( pingroup->numframes );
groupsize = sizeof(mspritegroup_t) + (numframes - 1) * sizeof( pspritegroup->frames[0] );
pspritegroup = Mem_Alloc( mod->mempool, groupsize );
pspritegroup->numframes = numframes;
*ppframe = (mspriteframe_t *)pspritegroup;
pin_intervals = (dspriteinterval_t *)(pingroup + 1);
poutintervals = Mem_Alloc( mod->mempool, numframes * sizeof( float ));
pspritegroup->intervals = poutintervals;
for( i = 0; i < numframes; i++ )
{
*poutintervals = LittleFloat( pin_intervals->interval );
if( *poutintervals <= 0.0 ) *poutintervals = 1.0f; // set error value
if( frame_type == SPR_GROUP ) R_ShaderAddSpriteIntervals( *poutintervals );
poutintervals++;
pin_intervals++;
}
ptemp = (void *)pin_intervals;
for( i = 0; i < numframes; i++ )
{
ptemp = R_SpriteLoadFrame( mod, ptemp, &pspritegroup->frames[i], framenum * 10 + i );
}
com.snprintf( shadername, MAX_STRING, "sprites/%s.spr/%s_%i%i", sp_name, frame_prefix, group_num/10, group_num%10 );
group_shader = R_LoadShader( shadername, SHADER_SPRITE, true, 0, SHADER_INVALID )->shadernum;
frames = Mem_Realloc( mod->mempool, frames, sizeof( ref_shader_t* ) * (mod->numshaders + 1));
frames[mod->numshaders++] = &r_shaders[group_shader];
// apply this shader for all frames in group
for( i = 0; i < numframes; i++ )
pspritegroup->frames[i]->shader = group_shader;
group_num++;
return (dframetype_t *)ptemp;
}
void Mod_SpriteLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buffer )
{
dsprite_t *pin;
short *numi;
msprite_t *psprite;
dframetype_t *pframetype;
int i, size, numframes;
pin = (dsprite_t *)buffer;
i = LittleLong( pin->version );
if( i != SPRITE_VERSION )
{
MsgDev( D_ERROR, "%s has wrong version number (%i should be %i)\n", mod->name, i, SPRITE_VERSION );
return;
}
numframes = LittleLong( pin->numframes );
size = sizeof (msprite_t) + (numframes - 1) * sizeof( psprite->frames );
psprite = Mem_Alloc( mod->mempool, size );
mod->extradata = psprite; // make link to extradata
mod->numshaders = 0; // reset frames
psprite->type = LittleLong( pin->type );
psprite->rendermode = LittleLong( pin->texFormat );
psprite->numframes = numframes;
mod->mins[0] = mod->mins[1] = -LittleLong( pin->bounds[0] ) / 2;
mod->maxs[0] = mod->maxs[1] = LittleLong( pin->bounds[0] ) / 2;
mod->mins[2] = -LittleLong( pin->bounds[1] ) / 2;
mod->maxs[2] = LittleLong( pin->bounds[1] ) / 2;
numi = (short *)(pin + 1);
if( LittleShort( *numi ) == 256 )
{
byte *src = (byte *)(numi+1);
rgbdata_t *pal;
// install palette
switch( psprite->rendermode )
{
case SPR_ADDGLOW:
pal = FS_LoadImage( "#normal.pal", src, 768 );
R_ShaderSetRenderMode( kRenderGlow );
break;
case SPR_ADDITIVE:
pal = FS_LoadImage( "#normal.pal", src, 768 );
R_ShaderSetRenderMode( kRenderTransAdd );
break;
case SPR_INDEXALPHA:
pal = FS_LoadImage( "#decal.pal", src, 768 );
R_ShaderSetRenderMode( kRenderTransAlpha );
break;
case SPR_ALPHTEST:
pal = FS_LoadImage( "#transparent.pal", src, 768 );
R_ShaderSetRenderMode( kRenderTransAlpha );
break;
case SPR_NORMAL:
default:
pal = FS_LoadImage( "#normal.pal", src, 768 );
R_ShaderSetRenderMode( kRenderNormal );
break;
}
pframetype = (dframetype_t *)(src + 768);
FS_FreeImage( pal ); // palette installed, no reason to keep this data
}
else
{
MsgDev( D_ERROR, "%s has wrong number of palette colors %i (should be 256)\n", mod->name, numi );
return;
}
if( numframes < 1 )
{
MsgDev( D_ERROR, "%s has invalid # of frames: %d\n", mod->name, numframes );
return;
}
MsgDev( D_LOAD, "%s, rendermode %d\n", mod->name, psprite->rendermode );
mod->touchFrame = tr.registration_sequence;
frames = NULL; // invalidate pointer
sp_name[0] = 0;
group_num = 0;
for( i = 0; i < numframes; i++ )
{
frametype_t frametype = LittleLong( pframetype->type );
psprite->frames[i].type = frametype;
frame_type = frametype;
switch( frametype )
{
case SPR_SINGLE:
com.strncpy( frame_prefix, "one", MAX_STRING );
pframetype = R_SpriteLoadFrame(mod, pframetype + 1, &psprite->frames[i].frameptr, i );
break;
case SPR_GROUP:
com.strncpy( frame_prefix, "grp", MAX_STRING );
pframetype = R_SpriteLoadGroup(mod, pframetype + 1, &psprite->frames[i].frameptr, i );
break;
case SPR_ANGLED:
com.strncpy( frame_prefix, "ang", MAX_STRING );
pframetype = R_SpriteLoadGroup(mod, pframetype + 1, &psprite->frames[i].frameptr, i );
break;
}
if( pframetype == NULL ) break; // technically an error
}
mod->shaders = frames; // setup texture links
mod->type = mod_sprite;
}
/*
================
R_GetSpriteFrame
================
*/
mspriteframe_t *R_GetSpriteFrame( ref_entity_t *ent )
{
msprite_t *psprite;
mspritegroup_t *pspritegroup;
mspriteframe_t *pspriteframe;
int i, numframes, frame;
float *pintervals, fullinterval, targettime, time;
psprite = ent->model->extradata;
frame = ent->frame;
if((frame >= psprite->numframes) || (frame < 0))
{
MsgDev( D_WARN, "R_GetSpriteFrame: no such frame %d (%s)\n", frame, ent->model->name );
frame = 0;
}
if( psprite->frames[frame].type == SPR_SINGLE )
{
pspriteframe = psprite->frames[frame].frameptr;
}
else if (psprite->frames[frame].type == SPR_GROUP)
{
pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
pintervals = pspritegroup->intervals;
numframes = pspritegroup->numframes;
fullinterval = pintervals[numframes-1];
time = RI.refdef.time;
// when loading in Mod_LoadSpriteGroup, we guaranteed all interval values
// are positive, so we don't have to worry about division by zero
targettime = time - ((int)(time / fullinterval)) * fullinterval;
for( i = 0; i < (numframes - 1); i++ )
{
if (pintervals[i] > targettime)
break;
}
pspriteframe = pspritegroup->frames[i];
}
else if( psprite->frames[frame].type == SPR_ANGLED )
{
// e.g. doom-style sprite monsters
int angleframe = (int)((RI.refdef.viewangles[1] - ent->angles[1])/360*8 + 0.5 - 4) & 7;
pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
pspriteframe = pspritegroup->frames[angleframe];
}
return pspriteframe;
}

2
render/r_surf.c
View File

@ -229,7 +229,7 @@ void R_AddBrushModelToList( ref_entity_t *e )
meshbuffer_t *mb;
e->outlineHeight = r_worldent->outlineHeight;
Vector4Copy( r_worldent->outlineRGBA, e->outlineColor );
Vector4Copy( r_worldent->outlineColor, e->outlineColor );
rotated = !Matrix_Compare( e->axis, axis_identity );
VectorSubtract( RI.refdef.vieworg, e->origin, modelorg );

4
render/render.dsp
View File

@ -198,6 +198,10 @@ SOURCE=.\r_sky.c
# End Source File
# Begin Source File
SOURCE=.\r_sprite.c
# End Source File
# Begin Source File
SOURCE=.\r_surf.c
# End Source File
# End Group

13
render/render.plg
View File

@ -6,13 +6,13 @@
--------------------Configuration: render - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP47C.tmp" with contents
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSPB55.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_backend.c"
]
Creating command line "cl.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP47C.tmp"
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP47D.tmp" with contents
Creating command line "cl.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSPB55.tmp"
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSPB56.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"
@ -36,15 +36,16 @@ msvcrtd.lib user32.lib gdi32.lib /nologo /subsystem:windows /dll /incremental:ye
"\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_surf.obj"
]
Creating command line "link.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP47D.tmp"
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP47E.bat" with contents
Creating command line "link.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSPB56.tmp"
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSPB57.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\RSP47E.bat"
Creating command line "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSPB57.bat"
Compiling...
r_backend.c
Linking...

9
todo.log
View File

@ -111,10 +111,13 @@ Beta 13.12.08
80. implement $rgb, $alpha OK
89. get rid of R_Upload32 OK
90. get rid of Com_ParseExt OK
91. implement rendermodes
91. implement rendermodes OK
92. implement VBO OK
93. implement sky rotate
94. make default sky shader, R_SetupSky
95. support for custom tables (external) OK
96. implement sprite format
97. fix fog color on q3tourney5
96. implement sprite format OK
97. fix fog color in release build
98. fix crash with FOG2NUM in release build
99. rewrote RF_* flags OK
100. implement pglBegin for perfomance testing