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

30 Aug 2008

This commit is contained in:
g-cont 2008-08-30 00:00:00 +04:00 committed by Alibek Omarov
parent 000c03a60b
commit bb20a45247
19 changed files with 403 additions and 335 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
engine/client/cl_frame.c
View File

@ -310,7 +310,7 @@ void CL_AddPacketEntities( frame_t *frame )
{
s1 = &cl_parse_entities[(frame->parse_entities + pnum)&(MAX_PARSE_ENTITIES-1)];
ent = PRVM_EDICT_NUM( s1->number );
re->AddRefEntity( &cl.refdef, &ent->priv.cl->current, &ent->priv.cl->prev, cl.lerpfrac );
re->AddRefEntity( &ent->priv.cl->current, &ent->priv.cl->prev, cl.lerpfrac );
}
}
@ -336,7 +336,7 @@ void CL_AddViewWeapon( entity_state_t *ps )
VectorCopy( cl.refdef.viewangles, view->priv.cl->current.angles );
VectorCopy( cl.refdef.vieworg, view->priv.cl->prev.origin );
VectorCopy( cl.refdef.viewangles, view->priv.cl->prev.angles );
re->AddRefEntity( &cl.refdef, &view->priv.cl->current, &view->priv.cl->prev, cl.lerpfrac );
re->AddRefEntity( &view->priv.cl->current, &view->priv.cl->prev, cl.lerpfrac );
}

7
engine/client/cl_fx.c
View File

@ -105,7 +105,7 @@ void CL_AddLightStyles (void)
clightstyle_t *ls;
for( i = 0, ls = cl_lightstyle; i < MAX_LIGHTSTYLES; i++, ls++ )
re->AddLightStyle( &cl.refdef, i, ls->value );
re->AddLightStyle( i, ls->value );
}
/*
@ -232,8 +232,7 @@ void CL_AddDLights (void)
dl = cl_dlights;
for( i = 0; i < MAX_DLIGHTS; i++, dl++ )
{
if( dl->radius )
re->AddDynLight( &cl.refdef, dl->origin, dl->color, dl->radius );
if( dl->radius ) re->AddDynLight( dl->origin, dl->color, dl->radius );
}
}
@ -414,7 +413,7 @@ void CL_AddParticles (void)
org[1] = p->org[1] + p->vel[1] * time + p->accel[1] * time2;
org[2] = p->org[2] + p->vel[2] * time + p->accel[2] * time2;
re->AddParticle( &cl.refdef, org, alpha, color );
re->AddParticle( org, alpha, color );
// PMM
if( p->alphavel == INSTANT_PARTICLE )
{

8
engine/client/cl_main.c
View File

@ -37,7 +37,6 @@ cvar_t *cl_gun;
cvar_t *cl_add_particles;
cvar_t *cl_add_lights;
cvar_t *cl_add_entities;
cvar_t *cl_add_blend;
cvar_t *cl_shownet;
cvar_t *cl_showmiss;
@ -330,7 +329,6 @@ void CL_ClearState (void)
CL_FreeEdicts();
// wipe the entire cl structure
Mem_FreePool( &cl.refdef.mempool );
memset( &cl, 0, sizeof(cl));
MSG_Clear( &cls.netchan.message );
@ -351,13 +349,10 @@ void CL_Disconnect( void )
{
byte final[32];
if (cls.state == ca_disconnected)
if( cls.state == ca_disconnected )
return;
VectorClear( cl.refdef.blend );
cls.connect_time = 0;
SCR_StopCinematic();
CL_Stop_f();
@ -1090,7 +1085,6 @@ void CL_InitLocal (void)
CL_InitInput();
// register our variables
cl_add_blend = Cvar_Get ("cl_blend", "1", 0, "disables client blends" );
cl_add_lights = Cvar_Get ("cl_lights", "1", 0, "disables dynamic lights" );
cl_add_particles = Cvar_Get ("cl_particles", "1", 0, "disables particles engine" );
cl_add_entities = Cvar_Get ("cl_entities", "1", 0, "disables client entities" );

2
engine/client/cl_scrn.c
View File

@ -18,7 +18,6 @@ cvar_t *scr_width;
cvar_t *scr_height;
cvar_t *cl_testentities;
cvar_t *cl_testlights;
cvar_t *cl_testblend;
cvar_t *cl_levelshot_name;
cvar_t *cl_font;
@ -346,7 +345,6 @@ void SCR_Init (void)
cl_font = Cvar_Get("cl_font", "conchars", CVAR_ARCHIVE, "contains path to current charset" );
scr_loading = Cvar_Get("scr_loading", "0", 0, "loading bar progress" );
scr_download = Cvar_Get("scr_download", "0", 0, "downloading bar progress" );
cl_testblend = Cvar_Get ("cl_testblend", "0", 0, "test blending" );
cl_testentities = Cvar_Get ("cl_testentities", "0", 0, "test client entities" );
cl_testlights = Cvar_Get ("cl_testlights", "0", 0, "test dynamic lights" );

19
engine/client/cl_view.c
View File

@ -31,7 +31,7 @@ Specifies the model that will be used as the world
*/
void V_ClearScene( void )
{
re->ClearScene( &cl.refdef );
re->ClearScene();
}
/*
@ -64,7 +64,7 @@ void V_TestEntities( void )
entity_state_t ent;
memset( &ent, 0, sizeof(entity_state_t));
cl.refdef.num_entities = 0;
V_ClearScene();
for( i = 0; i < 32; i++ )
{
@ -77,7 +77,7 @@ void V_TestEntities( void )
ent.model.controller[0] = ent.model.controller[1] = 90.0f;
ent.model.controller[2] = ent.model.controller[3] = 180.0f;
ent.model.index = cl.frame.ps.model.index;
re->AddRefEntity( &cl.refdef, &ent, NULL, 1.0f );
re->AddRefEntity( &ent, NULL, 1.0f );
}
}
@ -94,9 +94,9 @@ void V_TestLights( void )
float f, r;
cdlight_t dl;
cl.refdef.num_dlights = 0;
memset( &dl, 0, sizeof(cdlight_t));
V_ClearScene();
for( i = 0; i < 32; i++ )
{
r = 64 * ( (i%4) - 1.5 );
@ -109,7 +109,7 @@ void V_TestLights( void )
dl.color[1] = (((i%6)+1) & 2)>>1;
dl.color[2] = (((i%6)+1) & 4)>>2;
dl.radius = 200;
re->AddDynLight( &cl.refdef, dl.origin, dl.color, dl.radius );
re->AddDynLight( dl.origin, dl.color, dl.radius );
}
}
@ -161,13 +161,6 @@ void V_RenderView( void )
if( cl_testentities->value ) V_TestEntities();
if( cl_testlights->value ) V_TestLights();
if( cl_testblend->value)
{
cl.refdef.blend[0] = 1;
cl.refdef.blend[1] = 0.5;
cl.refdef.blend[2] = 0.25;
cl.refdef.blend[3] = 0.8;
}
// never let it sit exactly on a node line, because a water plane can
// dissapear when viewed with the eye exactly on it.

2
engine/client/client.h
View File

@ -269,7 +269,6 @@ extern vec4_t g_color_table[8];
// cvars
//
extern cvar_t *cl_gun;
extern cvar_t *cl_add_blend;
extern cvar_t *cl_add_lights;
extern cvar_t *cl_add_particles;
extern cvar_t *cl_add_entities;
@ -302,7 +301,6 @@ extern cvar_t *m_side;
extern cvar_t *cl_mouselook;
extern cvar_t *cl_testentities;
extern cvar_t *cl_testlights;
extern cvar_t *cl_testblend;
extern cvar_t *cl_lightlevel; // FIXME HACK
extern cvar_t *cl_paused;
extern cvar_t *cl_levelshot_name;

5
engine/common/engfuncs.c
View File

@ -1270,9 +1270,10 @@ void VM_drawmodel( void )
refdef.fov_x = 50;
refdef.fov_y = V_CalcFov( refdef.fov_x, refdef.rect.width, refdef.rect.height );
refdef.time = cls.realtime * 0.001f;
refdef.oldtime = refdef.time - 0.005;
refdef.rdflags = RDF_NOWORLDMODEL;
re->ClearScene( &refdef );
re->ClearScene();
re->RegisterModel( modname, MAX_MODELS - 1 );
ent.renderfx = RF_FULLBRIGHT;
ent.model.sequence = sequence;
@ -1286,7 +1287,7 @@ void VM_drawmodel( void )
VectorCopy( angles, ent.angles );
ent.model.frame = frame += 0.7f; // FXIME: needs flag EF_AUTOANIMATE or somewhat
re->AddRefEntity( &refdef, &ent, NULL, 1.0f );
re->AddRefEntity( &ent, NULL, 1.0f );
re->RenderFrame( &refdef );
}

38
public/ref_dllapi.h
View File

@ -1184,27 +1184,15 @@ typedef struct vrect_s
typedef struct
{
vrect_t rect;
float fov_x;
float fov_y;
vec3_t vieworg;
vec3_t viewangles;
vec4_t blend; // rgba 0-1 full screen blend
float time; // time is used to auto animate
float oldtime; // oldtime using for lerping
uint rdflags; // RDF_UNDERWATER, etc
byte *mempool; // entities, dlights etc
// chains are stored in dynamically resized arrays
vrect_t rect; // screen rectangle
float fov_x; // field of view by vertical
float fov_y; // field of view by horizontal
vec3_t vieworg; // client origin + viewoffset
vec3_t viewangles; // client angles
float time; // time is used to shaders auto animate
float oldtime; // oldtime using for lerping studio models
uint rdflags; // client view effects: RDF_UNDERWATER, RDF_MOTIONBLUR, etc
byte *areabits; // if not NULL, only areas with set bits will be drawn
struct lightstyle_s *lightstyles; // [MAX_LIGHTSTYLES]
struct particle_s *particles;
struct ref_entity_s *entities; // [MAX_EDICTS]
struct dlight_s *dlights;
int num_particles;
int num_entities;
int num_dlights;
} refdef_t;
typedef struct pmove_s
@ -1289,11 +1277,11 @@ typedef struct render_exp_s
void (*EndRegistration)( void );
// prepare frame to rendering
bool (*AddRefEntity)( refdef_t *fd, entity_state_t *s1, entity_state_t *s2, float lerp );
bool (*AddDynLight)( refdef_t *fd, vec3_t org, vec3_t color, float intensity );
bool (*AddParticle)( refdef_t *fd, vec3_t org, float alpha, int color );
bool (*AddLightStyle)( refdef_t *fd, int stylenum, vec3_t color );
void (*ClearScene)( refdef_t *fd );
bool (*AddRefEntity)( entity_state_t *s1, entity_state_t *s2, float lerp );
bool (*AddDynLight)( vec3_t org, vec3_t color, float intensity );
bool (*AddParticle)( vec3_t org, float alpha, int color );
bool (*AddLightStyle)( int stylenum, vec3_t color );
void (*ClearScene)( void );
void (*BeginFrame)( void );
void (*RenderFrame)( refdef_t *fd );

7
render/gl_backend.c
View File

@ -514,7 +514,7 @@ void GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char *cv
if(GL_Support( r_ext )) MsgDev( D_NOTE, "- enabled\n");
}
void GL_UpdateGammaRamp( void )
void GL_BuildGammaTable( void )
{
int i, v;
@ -527,6 +527,11 @@ void GL_UpdateGammaRamp( void )
gl_state.gammaRamp[i+256] = ((word)v)<<8;
gl_state.gammaRamp[i+512] = ((word)v)<<8;
}
}
void GL_UpdateGammaRamp( void )
{
GL_BuildGammaTable();
SetDeviceGammaRamp( glw_state.hDC, gl_state.gammaRamp );
}

5
render/r_backend.c
View File

@ -1124,6 +1124,7 @@ static void RB_DrawModelBounds( void )
if( m_pRenderMesh->meshType == MESH_SURFACE )
{
model = m_pCurrentEntity->model;
if( !model ) return;
// compute a full bounding box
for( i = 0; i < 8; i++ )
@ -1272,7 +1273,7 @@ void RB_RenderMeshes( mesh_t *meshes, int numMeshes )
// unpack sort key
shader = r_shaders[(sortKey>>18) & (MAX_SHADERS - 1)];
entity = &r_refdef.entities[(sortKey >> 8) & gl_config.max_entities-1];
entity = &r_entities[(sortKey >> 8) & MAX_ENTITIES-1];
infoKey = sortKey & 255;
// development tool
@ -1320,7 +1321,7 @@ void RB_RenderMeshes( mesh_t *meshes, int numMeshes )
R_DrawStudioModel( RENDERPASS_SOLID ); //FIXME: test
break;
case MESH_SPRITE:
R_DrawSpriteModel( RENDERPASS_ALPHA ); //FIXME: test
R_DrawSpriteModel();
break;
case MESH_BEAM:
R_DrawBeam();

34
render/r_light.c
View File

@ -81,12 +81,12 @@ void R_MarkLights( void )
dlight_t *dl;
int l;
if( !r_dynamiclights->integer || !r_refdef.num_dlights )
if( !r_dynamiclights->integer || !r_numDLights )
return;
r_stats.numDLights += r_refdef.num_dlights;
r_stats.numDLights += r_numDLights;
for( l = 0, dl = r_refdef.dlights; l < r_refdef.num_dlights; l++, dl++ )
for( l = 0, dl = r_dlights; l < r_numDLights; l++, dl++ )
{
if( R_CullSphere( dl->origin, dl->intensity, 15 ))
continue;
@ -181,7 +181,7 @@ static bool R_RecursiveLightPoint( node_t *node, const vec3_t start, const vec3_
for( map = 0; map < surf->numStyles; map++ )
{
VectorScale( r_refdef.lightstyles[surf->styles[map]].rgb, r_modulate->value, scale );
VectorScale( r_lightStyles[surf->styles[map]].rgb, r_modulate->value, scale );
r_pointColor[0] += lm[0] * scale[0];
r_pointColor[1] += lm[1] * scale[1];
@ -226,7 +226,7 @@ void R_LightForPoint( const vec3_t point, vec3_t ambientLight )
// add dynamic lights
if( r_dynamiclights->integer )
{
for( l = 0, dl = r_refdef.dlights; l < r_refdef.num_dlights; l++, dl++ )
for( l = 0, dl = r_dlights; l < r_numDLights; l++, dl++ )
{
VectorSubtract(dl->origin, point, dir);
dist = VectorLength(dir);
@ -315,7 +315,7 @@ void R_LightDir( const vec3_t origin, vec3_t lightDir )
// Add dynamic lights
if( r_dynamiclights->integer )
{
for( l = 0, dl = r_refdef.dlights; l < r_refdef.num_dlights; l++, dl++ )
for( l = 0, dl = r_dlights; l < r_numDLights; l++, dl++ )
{
VectorSubtract( dl->origin, origin, dir );
dist = VectorLength( dir );
@ -379,7 +379,7 @@ void R_LightingAmbient( void )
radius = m_pCurrentEntity->model->radius;
else radius = m_pCurrentEntity->radius;
for( l = 0, dl = r_refdef.dlights; l < r_refdef.num_dlights; l++, dl++ )
for( l = 0, dl = r_dlights; l < r_numDLights; l++, dl++ )
{
VectorSubtract( dl->origin, m_pCurrentEntity->origin, dir );
dist = VectorLength( dir );
@ -474,7 +474,7 @@ void R_LightingDiffuse( void )
radius = m_pCurrentEntity->model->radius;
else radius = m_pCurrentEntity->radius;
for( l = 0, dl = r_refdef.dlights; l < r_refdef.num_dlights; l++, dl++ )
for( l = 0, dl = r_dlights; l < r_numDLights; l++, dl++ )
{
VectorSubtract( dl->origin, m_pCurrentEntity->origin, dir );
dist = VectorLength( dir );
@ -532,7 +532,7 @@ static void R_SetCacheState( surface_t *surf )
int map;
for( map = 0; map < surf->numStyles; map++ )
surf->cachedLight[map] = r_refdef.lightstyles[surf->styles[map]].white;
surf->cachedLight[map] = r_lightStyles[surf->styles[map]].white;
}
/*
@ -552,7 +552,7 @@ static void R_AddDynamicLights( surface_t *surf )
dlight_t *dl;
float *bl;
for( l = 0, dl = r_refdef.dlights; l < r_refdef.num_dlights; l++, dl++ )
for( l = 0, dl = r_dlights; l < r_numDLights; l++, dl++ )
{
if(!(surf->dlightBits & (1<<l)))
continue; // not lit by this light
@ -640,7 +640,7 @@ static void R_BuildLightmap( surface_t *surf, byte *dest, int stride )
else
{
// add all the lightmaps
VectorScale( r_refdef.lightstyles[surf->styles[0]].rgb, r_modulate->value, scale );
VectorScale( r_lightStyles[surf->styles[0]].rgb, r_modulate->value, scale );
for( i = 0, bl = (float *)r_blockLights; i < size; i++, bl += 3, lm += 3 )
{
@ -653,7 +653,7 @@ static void R_BuildLightmap( surface_t *surf, byte *dest, int stride )
{
for( map = 1; map < surf->numStyles; map++ )
{
VectorScale( r_refdef.lightstyles[surf->styles[map]].rgb, r_modulate->value, scale );
VectorScale( r_lightStyles[surf->styles[map]].rgb, r_modulate->value, scale );
for( i = 0, bl = (float *)r_blockLights; i < size; i++, bl += 3, lm += 3 )
{
bl[0] += lm[0] * scale[0];
@ -778,19 +778,17 @@ R_BeginBuildingLightmaps
*/
void R_BeginBuildingLightmaps( void )
{
static lightstyle_t lightstyles[MAX_LIGHTSTYLES];
int i;
// setup the base lightstyles so the lightmaps
// won't have to be regenerated the first time they're seen
for( i = 0; i < MAX_LIGHTSTYLES; i++ )
{
lightstyles[i].white = 3;
lightstyles[i].rgb[0] = 1;
lightstyles[i].rgb[1] = 1;
lightstyles[i].rgb[2] = 1;
r_lightStyles[i].white = 3;
r_lightStyles[i].rgb[0] = 1;
r_lightStyles[i].rgb[1] = 1;
r_lightStyles[i].rgb[2] = 1;
}
r_refdef.lightstyles = lightstyles;
r_lmState.currentNum = -1;
memset( r_lmState.allocated, 0, sizeof( r_lmState.allocated ));

58
render/r_local.h
View File

@ -17,12 +17,15 @@ extern byte *r_temppool;
#define Host_Error com.error
// limits
#define MAX_TEXTURES 4096
#define MAX_TEXTURE_UNITS 8
#define MAX_LIGHTMAPS 128
#define MAX_PROGRAMS 512
#define MAX_SHADERS 1024
#define MAX_LIGHTMAPS 128
#define MAX_ENTITIES 1024
#define MAX_VERTEX_BUFFERS 2048
#define MAX_TEXTURE_UNITS 8
#define MAX_TEXTURES 4096
#define MAX_POLYS 4096
#define MAX_POLY_VERTS 16384
/*
=======================================================================
@ -131,11 +134,12 @@ void R_ShutdownPrograms( void );
// Shader types used for shader loading
typedef enum
{
SHADER_SKY,
SHADER_BSP,
SHADER_SKIN,
SHADER_NOMIP,
SHADER_GENERIC
SHADER_SKY, // sky box shader
SHADER_BSP, // bsp polygon
SHADER_STUDIO, // studio skins
SHADER_SPRITE, // sprite frames
SHADER_NOMIP, // 2d images
SHADER_GENERIC // generic shader
} shaderType_t;
// surfaceParm flags used for shader loading
@ -160,10 +164,9 @@ typedef enum
#define SHADER_POLYGONOFFSET 0x00000400
#define SHADER_CULL 0x00000800
#define SHADER_SORT 0x00001000
#define SHADER_AMMODISPLAY 0x00002000
#define SHADER_TESSSIZE 0x00004000
#define SHADER_SKYPARMS 0x00008000
#define SHADER_DEFORMVERTEXES 0x00010000
#define SHADER_TESSSIZE 0x00002000
#define SHADER_SKYPARMS 0x00004000
#define SHADER_DEFORMVERTEXES 0x00008000
// shader stage flags
#define SHADERSTAGE_NEXTBUNDLE 0x00000001
@ -440,6 +443,7 @@ extern shader_t *r_slimeCausticsShader;
extern shader_t *r_lavaCausticsShader;
shader_t *R_FindShader( const char *name, shaderType_t shaderType, uint surfaceParm );
void R_SetInternalMap( texture_t *mipTex ); // internal textures (skins, spriteframes, etc)
void R_ShaderList_f( void );
void R_InitShaders( void );
void R_ShutdownShaders (void);
@ -503,6 +507,20 @@ typedef struct surfPoly_s
surfPolyVert_t *vertices;
} surfPoly_t;
typedef struct
{
vec3_t xyz;
vec2_t st;
vec4_t modulate;
} polyVert_t;
typedef struct
{
shader_t *shader;
int numVerts;
polyVert_t *verts;
} poly_t;
typedef struct mipTex_s
{
string name;
@ -1010,6 +1028,7 @@ void GL_DepthMask( GLboolean mask );
void GL_SetColor( const void *data );
void GL_LoadMatrix( matrix4x4 source );
void GL_SetDefaultState( void );
void GL_BuildGammaTable( void );
void GL_UpdateGammaRamp( void );
void GL_Setup3D( void );
void GL_Setup2D( void );
@ -1137,7 +1156,20 @@ extern mesh_t r_solidMeshes[MAX_MESHES];
extern int r_numSolidMeshes;
extern mesh_t r_transMeshes[MAX_MESHES];
extern int r_numTransMeshes;
extern ref_entity_t r_entities[MAX_ENTITIES];
extern int r_numEntities;
extern dlight_t r_dlights[MAX_DLIGHTS];
extern int r_numDLights;
extern particle_t r_particles[MAX_PARTICLES];
extern int r_numParticles;
extern poly_t r_polys[MAX_POLYS];
extern int r_numPolys;
extern polyVert_t r_polyVerts[MAX_POLY_VERTS];
extern int r_numPolyVerts;
extern ref_entity_t *r_nullModels[MAX_ENTITIES];
extern int r_numNullModels;
extern lightstyle_t r_lightStyles[MAX_LIGHTSTYLES];
extern refdef_t r_refdef;
extern refstats_t r_stats;
@ -1145,7 +1177,7 @@ void R_DrawStudioModel( int passnum );
void R_AddStudioModelToList( ref_entity_t *entity );
void R_StudioLoadModel( rmodel_t *mod, const void *buffer );
void R_DrawSpriteModel( int passnum );
void R_DrawSpriteModel( void );
void R_AddSpriteModelToList( ref_entity_t *entity );
void R_SpriteLoadModel( rmodel_t *mod, const void *buffer );
mspriteframe_t *R_GetSpriteFrame( ref_entity_t *ent );

271
render/r_main.c
View File

@ -22,8 +22,19 @@ mesh_t r_solidMeshes[MAX_MESHES];
int r_numSolidMeshes;
mesh_t r_transMeshes[MAX_MESHES];
int r_numTransMeshes;
ref_entity_t *r_nullModels[MAX_MAP_MODELS];
rmodel_t *cl_models[MAX_MODELS]; // models with client modelindexes
ref_entity_t *r_nullModels[MAX_ENTITIES];
rmodel_t *cl_models[MAX_MODELS]; // client replacement modeltable
lightstyle_t r_lightStyles[MAX_LIGHTSTYLES];
ref_entity_t r_entities[MAX_ENTITIES];
int r_numEntities;
dlight_t r_dlights[MAX_DLIGHTS];
int r_numDLights;
particle_t r_particles[MAX_PARTICLES];
int r_numParticles;
poly_t r_polys[MAX_POLYS];
int r_numPolys;
polyVert_t r_polyVerts[MAX_POLY_VERTS];
int r_numPolyVerts;
int r_numNullModels;
refdef_t r_refdef;
refstats_t r_stats;
@ -33,9 +44,9 @@ glconfig_t gl_config;
glstate_t gl_state;
// view matrix
vec3_t r_up;
vec3_t r_right;
vec3_t r_forward;
vec3_t r_right;
vec3_t r_up;
vec3_t r_origin;
cvar_t *r_check_errors;
@ -194,153 +205,10 @@ void R_RotateForEntity( ref_entity_t *entity )
// =====================================================================
/*
=================
R_AddSpriteModelToList
I am only keeping this for backwards compatibility
=================
*/
static void R_AddSpriteModelToList( ref_entity_t *entity )
{
mspriteframe_t *frame;
vec3_t vec;
frame = R_GetSpriteFrame( entity );
// cull
if( !r_nocull->integer )
{
VectorSubtract( entity->origin, r_refdef.vieworg, vec );
VectorNormalizeFast( vec );
if( DotProduct( vec, r_forward ) < 0 )
return;
}
// HACK: make it a sprite entity
entity->ent_type = ED_NORMAL;
entity->radius = frame->radius;
entity->rotation = 0;
entity->shader = frame->shader;
// HACK: make it translucent
if(!(entity->shader->flags & SHADER_EXTERNAL))
{
entity->shader->sort = SORT_BLEND;
entity->shader->stages[0]->flags |= SHADERSTAGE_BLENDFUNC;
entity->shader->stages[0]->flags &= ~SHADERSTAGE_DEPTHWRITE;
entity->shader->stages[0]->blendFunc.src = GL_SRC_ALPHA;
entity->shader->stages[0]->blendFunc.dst = GL_ONE_MINUS_SRC_ALPHA;
}
// add it
R_AddMeshToList( MESH_SPRITE, NULL, entity->shader, entity, 0);
}
static void R_AddStudioModelToList( ref_entity_t *entity )
{
}
/*
=================
R_DrawSprite
=================
*/
void R_DrawSprite( void )
{
vec3_t axis[3];
int i;
if( m_pCurrentEntity->rotation )
{
// rotate it around its normal
RotatePointAroundVector( axis[1], r_forward, r_right, m_pCurrentEntity->rotation );
CrossProduct( r_forward, axis[1], axis[2] );
// the normal should point at the viewer
VectorNegate( r_forward, axis[0] );
// Scale the axes by radius
VectorScale( axis[1], m_pCurrentEntity->radius, axis[1] );
VectorScale( axis[2], m_pCurrentEntity->radius, axis[2] );
}
else
{
// the normal should point at the viewer
VectorNegate( r_forward, axis[0] );
// scale the axes by radius
VectorScale( r_right, m_pCurrentEntity->radius, axis[1] );
VectorScale( r_up, m_pCurrentEntity->radius, axis[2] );
}
// draw it
RB_CheckMeshOverflow( 6, 4 );
for( i = 2; i < 4; i++ )
{
indexArray[numIndex++] = numVertex + 0;
indexArray[numIndex++] = numVertex + i-1;
indexArray[numIndex++] = numVertex + i;
}
vertexArray[numVertex+0][0] = m_pCurrentEntity->origin[0] + axis[1][0] + axis[2][0];
vertexArray[numVertex+0][1] = m_pCurrentEntity->origin[1] + axis[1][1] + axis[2][1];
vertexArray[numVertex+0][2] = m_pCurrentEntity->origin[2] + axis[1][2] + axis[2][2];
vertexArray[numVertex+1][0] = m_pCurrentEntity->origin[0] - axis[1][0] + axis[2][0];
vertexArray[numVertex+1][1] = m_pCurrentEntity->origin[1] - axis[1][1] + axis[2][1];
vertexArray[numVertex+1][2] = m_pCurrentEntity->origin[2] - axis[1][2] + axis[2][2];
vertexArray[numVertex+2][0] = m_pCurrentEntity->origin[0] - axis[1][0] - axis[2][0];
vertexArray[numVertex+2][1] = m_pCurrentEntity->origin[1] - axis[1][1] - axis[2][1];
vertexArray[numVertex+2][2] = m_pCurrentEntity->origin[2] - axis[1][2] - axis[2][2];
vertexArray[numVertex+3][0] = m_pCurrentEntity->origin[0] + axis[1][0] - axis[2][0];
vertexArray[numVertex+3][1] = m_pCurrentEntity->origin[1] + axis[1][1] - axis[2][1];
vertexArray[numVertex+3][2] = m_pCurrentEntity->origin[2] + axis[1][2] - axis[2][2];
inTexCoordArray[numVertex+0][0] = 0;
inTexCoordArray[numVertex+0][1] = 0;
inTexCoordArray[numVertex+1][0] = 1;
inTexCoordArray[numVertex+1][1] = 0;
inTexCoordArray[numVertex+2][0] = 1;
inTexCoordArray[numVertex+2][1] = 1;
inTexCoordArray[numVertex+3][0] = 0;
inTexCoordArray[numVertex+3][1] = 1;
for( i = 0; i < 4; i++ )
{
normalArray[numVertex][0] = axis[0][0];
normalArray[numVertex][1] = axis[0][1];
normalArray[numVertex][2] = axis[0][2];
Vector4Copy(m_pCurrentEntity->shaderRGBA, inColorArray[numVertex] );
numVertex++;
}
}
/*
=================
R_AddSpriteToList
=================
*/
static void R_AddSpriteToList( ref_entity_t *entity )
{
vec3_t vec;
// cull
if( !r_nocull->integer )
{
VectorSubtract(entity->origin, r_refdef.vieworg, vec);
VectorNormalizeFast(vec);
if( DotProduct(vec, r_forward ) < 0 )
return;
}
// add it
R_AddMeshToList( MESH_SPRITE, NULL, entity->shader, entity, 0 );
}
/*
=================
R_DrawBeam
@ -432,19 +300,19 @@ static void R_AddEntitiesToList( void )
rmodel_t *model;
int i;
if( !r_drawentities->integer || r_refdef.num_entities == 1 )
if( !r_drawentities->integer || r_numEntities == 1 )
return;
r_stats.numEntities += (r_refdef.num_entities - 1);
r_stats.numEntities += (r_numEntities - 1);
for( i = 1, entity = &r_refdef.entities[1]; i < r_refdef.num_entities; i++, entity++ )
for( i = 1, entity = &r_entities[1]; i < r_numEntities; i++, entity++ )
{
switch( entity->ent_type )
{
case ED_NORMAL:
case ED_CLIENT:
case ED_VIEWMODEL:
model = entity->model;
model = m_pRenderModel = entity->model;
if( !model || model->type == mod_bad )
{
r_nullModels[r_numNullModels++] = entity;
@ -654,12 +522,12 @@ static void R_AddParticlesToList( void )
vec3_t vec;
int i;
if( !r_drawparticles->integer || !r_refdef.num_particles )
if( !r_drawparticles->integer || !r_numParticles )
return;
r_stats.numParticles += r_refdef.num_particles;
r_stats.numParticles += r_numParticles;
for (i = 0, particle = r_refdef.particles; i < r_refdef.num_particles; i++, particle++ )
for (i = 0, particle = r_particles; i < r_numParticles; i++, particle++ )
{
// cull
if( !r_nocull->integer )
@ -805,7 +673,7 @@ void R_AddMeshToList( meshType_t meshType, void *mesh, shader_t *shader, ref_ent
m = &r_transMeshes[r_numTransMeshes++];
}
m->sortKey = (shader->sort<<28) | (shader->shaderNum<<18) | ((entity - r_refdef.entities)<<8) | (infoKey);
m->sortKey = (shader->sort<<28) | (shader->shaderNum<<18) | ((entity - r_entities)<<8) | (infoKey);
m->meshType = meshType;
m->mesh = mesh;
}
@ -1081,39 +949,17 @@ void R_DrawPauseScreen( void )
}
/*
=================
R_ClearScene
=================
=================
R_ClearScene
=================
*/
void R_ClearScene( refdef_t *fd )
void R_ClearScene( void )
{
if( !fd ) return;
if( !fd->mempool )
{
// init arrays
if( fd->rdflags & RDF_NOWORLDMODEL )
{
// menu viewport not needs to many objects
fd->mempool = Mem_AllocPool( "Viewport Zone" );
fd->entities = (ref_entity_t *)Mem_Alloc( fd->mempool, sizeof(ref_entity_t) * 32 );
fd->particles = (particle_t *)Mem_Alloc( fd->mempool, sizeof(particle_t) * 512 );
fd->dlights = (dlight_t *)Mem_Alloc( fd->mempool, sizeof(dlight_t) * 4 );
}
else
{
fd->mempool = Mem_AllocPool("Refdef Zone");
fd->entities = (ref_entity_t *)Mem_Alloc( fd->mempool, sizeof(ref_entity_t) * gl_config.max_entities );
fd->particles = (particle_t *)Mem_Alloc( fd->mempool, sizeof(particle_t) * MAX_PARTICLES );
fd->lightstyles = (lightstyle_t *)Mem_Alloc( fd->mempool, sizeof(lightstyle_t) * MAX_LIGHTSTYLES );
fd->dlights = (dlight_t *)Mem_Alloc( fd->mempool, sizeof(dlight_t) * MAX_DLIGHTS );
}
}
// clear scene
fd->num_dlights = 0;
fd->num_entities = 0;
fd->num_particles = 0;
r_refdef = *fd;
r_numEntities = 1;
r_numDLights = 0;
r_numParticles = 0;
r_numPolys = 0;
r_numPolyVerts = 0;
}
/*
@ -1156,31 +1002,17 @@ void R_SetLightLevel( void )
R_AddEntityToScene
=================
*/
static bool R_AddEntityToScene( refdef_t *fd, entity_state_t *s1, entity_state_t *s2, float lerpfrac )
static bool R_AddEntityToScene( entity_state_t *s1, entity_state_t *s2, float lerpfrac )
{
ref_entity_t *refent;
int i, max_edicts = gl_config.max_entities;
int i;
if( !fd || !fd->entities ) return false; // not init
if( !s1 || !s1->model.index ) return false; // if set to invisible, skip
if( fd->num_entities >= max_edicts )
return false;
if( r_numEntities >= MAX_ENTITIES ) return false;
refent = &fd->entities[fd->num_entities];
refent = &r_entities[r_numEntities];
if( !s2 ) s2 = s1; // no lerping state
if( fd->num_entities == 0 )
{
// add the world
r_worldEntity = &fd->entities[fd->num_entities++];
r_worldEntity->model = r_worldModel;
r_worldEntity->ent_type = ED_NORMAL;
AxisClear( r_worldEntity->axis );
Vector4Set( r_worldEntity->shaderRGBA, 1.0f, 1.0f, 1.0f, 1.0f );
refent = &fd->entities[fd->num_entities];
}
// copy state to render
refent->frame = s1->model.frame;
refent->index = s1->number;
@ -1219,7 +1051,7 @@ static bool R_AddEntityToScene( refdef_t *fd, entity_state_t *s1, entity_state_t
if( refent->effects & EF_ROTATE )
{
// some bonus items auto-rotate
VectorSet( refent->angles, 0, anglemod(fd->time / 10), 0 );
VectorSet( refent->angles, 0, anglemod( r_refdef.time / 10), 0 );
}
else
{
@ -1255,8 +1087,7 @@ static bool R_AddEntityToScene( refdef_t *fd, entity_state_t *s1, entity_state_t
if( !refent->ent_type ) refent->ent_type = ED_NORMAL;
// add entity
fd->num_entities++;
r_refdef = *fd;
r_numEntities++;
return true;
}
@ -1266,20 +1097,18 @@ static bool R_AddEntityToScene( refdef_t *fd, entity_state_t *s1, entity_state_t
R_AddLightToScene
=================
*/
static bool R_AddDynamicLight( refdef_t *fd, vec3_t org, vec3_t color, float intensity )
static bool R_AddDynamicLight( vec3_t org, vec3_t color, float intensity )
{
dlight_t *dl;
if( !fd || !fd->dlights ) return false;
if( fd->num_dlights >= MAX_DLIGHTS )
if( r_numDLights >= MAX_DLIGHTS )
return false;
dl = &fd->dlights[fd->num_dlights];
dl = &r_dlights[r_numDLights];
VectorCopy( org, dl->origin );
VectorCopy( color, dl->color );
dl->intensity = intensity;
fd->num_dlights++;
r_refdef = *fd;
r_numDLights++;
return true;
}
@ -1289,15 +1118,14 @@ static bool R_AddDynamicLight( refdef_t *fd, vec3_t org, vec3_t color, float int
R_AddParticleToScene
=================
*/
bool R_AddParticleToScene( refdef_t *fd, const vec3_t origin, float alpha, int color )
bool R_AddParticleToScene( const vec3_t origin, float alpha, int color )
{
particle_t *p;
if( !fd || !fd->particles ) return false;
if( fd->num_particles >= MAX_PARTICLES)
if( r_numParticles >= MAX_PARTICLES )
return false;
p = &fd->particles[fd->num_particles];
p = &r_particles[r_numParticles];
p->shader = r_defaultShader;
VectorCopy( origin, p->origin );
@ -1306,24 +1134,21 @@ bool R_AddParticleToScene( refdef_t *fd, const vec3_t origin, float alpha, int c
p->length = alpha;
p->rotation = 0;
Vector4Set( p->modulate, 1.0f, 1.0f, 1.0f, 1.0f );
fd->num_particles++;
r_refdef = *fd;
r_numParticles++;
return true;
}
static bool R_AddLightStyle( refdef_t *fd, int style, vec3_t color )
static bool R_AddLightStyle( int style, vec3_t color )
{
lightstyle_t *ls;
if( !fd || !fd->lightstyles ) return false;
if( style < 0 || style > MAX_LIGHTSTYLES )
return false; // invalid lightstyle
ls = &fd->lightstyles[style];
ls = &r_lightStyles[style];
ls->white = color[0] + color[1] + color[2];
VectorCopy( color, ls->rgb );
r_refdef = *fd;
return true;
}

8
render/r_model.c
View File

@ -981,6 +981,7 @@ static void R_SetupSubmodels( void )
model->radius = bm->radius;
if( i == 0 ) *m_pLoadModel = *model;
else com.snprintf( model->name, sizeof(model->name), "*%i", i );
model->numLeafs = bm->visLeafs;
}
}
@ -1373,6 +1374,13 @@ void R_InitModels( void )
r_nummodels = 0;
r_viewCluster = r_oldViewCluster = -1; // force markleafs
r_worldEntity = &r_entities[0]; // First entity is the world
memset( r_worldEntity, 0, sizeof( ref_entity_t ));
r_worldEntity->ent_type = ED_NORMAL;
r_worldEntity->model = r_worldModel;
AxisClear( r_worldEntity->axis );
Vector4Set( r_worldEntity->shaderRGBA, 1.0f, 1.0f, 1.0f, 1.0f );
R_StudioInit();
}

62
render/r_opengl.c
View File

@ -90,6 +90,8 @@ bool R_SetPixelformat( void )
{
long flags = PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_GENERIC_ACCELERATED|PFD_DOUBLEBUFFER;
int pixelformat;
size_t gamma_size;
byte *savedGamma;
PIXELFORMATDESCRIPTOR pfd =
{
@ -145,6 +147,64 @@ bool R_SetPixelformat( void )
// init gamma ramp
ZeroMemory( gl_state.stateRamp, sizeof(gl_state.stateRamp));
gl_config.deviceSupportsGamma = GetDeviceGammaRamp( glw_state.hDC, gl_state.stateRamp );
savedGamma = FS_LoadFile( "config/gamma.rc", &gamma_size );
if( !savedGamma || gamma_size != sizeof( gl_state.stateRamp ))
{
// saved gamma not found or correupted file
FS_WriteFile( "config/gamma.rc", gl_state.stateRamp, sizeof(gl_state.stateRamp));
Msg( "gamma.rc initialized\n" );
}
else
{
GL_BuildGammaTable();
// validate base gamma
if(!memcmp( savedGamma, gl_state.stateRamp, sizeof(gl_state.stateRamp)))
{
// all ok, previous gamma is valid
MsgDev( D_NOTE, "R_SetPixelformat: validate screen gamma - ok\n" );
}
else if(!memcmp( gl_state.gammaRamp, gl_state.stateRamp, sizeof(gl_state.stateRamp)))
{
// screen gamma is equal to render gamma (probably previous instance crashed)
// run additional check to make sure it
if(memcmp( savedGamma, gl_state.stateRamp, sizeof(gl_state.stateRamp)))
{
// yes, current gamma it's totally wrong, restore it from gamma.rc
MsgDev( D_NOTE, "R_SetPixelformat: restore original gamma after crash\n" );
Mem_Copy( gl_state.stateRamp, savedGamma, sizeof( gl_state.gammaRamp ));
}
else
{
// oops, savedGamma == gl_state.stateRamp == gl_state.gammaRamp
// probably vid_gamma set as default
MsgDev( D_NOTE, "R_SetPixelformat: validate screen gamma - disabled\n" );
}
}
else if(!memcmp( gl_state.gammaRamp, savedGamma, sizeof(gl_state.stateRamp)))
{
// saved gamma is equal render gamma, probably gamma.rc writed after crash
// run additional check to make sure it
if(memcmp( savedGamma, gl_state.stateRamp, sizeof(gl_state.stateRamp)))
{
// yes, saved gamma it's totally wrong, get origianl gamma from screen
MsgDev( D_NOTE, "R_SetPixelformat: merge gamma.rc after crash\n" );
FS_WriteFile( "config/gamma.rc", gl_state.stateRamp, sizeof(gl_state.stateRamp));
}
else
{
// oops, savedGamma == gl_state.stateRamp == gl_state.gammaRamp
// probably vid_gamma set as default
MsgDev( D_NOTE, "R_SetPixelformat: validate screen gamma - disabled\n" );
}
}
else
{
// gamma.rc corrupted by stupid user, restore from screen
// probably never reached, but just in case
FS_WriteFile( "config/gamma.rc", gl_state.stateRamp, sizeof(gl_state.stateRamp));
}
}
vid_gamma->modified = true;
return true;
@ -424,5 +484,5 @@ void R_CheckForErrors( void )
str = "UNKNOWN ERROR";
break;
}
Host_Error( "R_CheckForErrors: %s", str );
Host_Error( "R_CheckForErrors: %s\n", str );
}

48
render/r_shader.c
View File

@ -22,6 +22,7 @@ static stageBundle_t r_parseStageTMU[SHADER_MAX_STAGES][MAX_TEXTURE_UNITS];
static shaderScript_t *r_shaderScriptsHash[SHADERS_HASHSIZE];
static shader_t *r_shadersHash[SHADERS_HASHSIZE];
static texture_t *r_internalMiptex;
shader_t *r_shaders[MAX_SHADERS];
int r_numShaders = 0;
@ -3089,7 +3090,7 @@ static shader_t *R_CreateDefaultShader( const char *name, shaderType_t shaderTyp
shader->numStages++;
}
break;
case SHADER_SKIN:
case SHADER_STUDIO:
shader->stages[0]->bundles[0]->flags |= STAGEBUNDLE_MAP;
shader->stages[0]->bundles[0]->textures[0] = R_FindTexture( shader->name, buffer, bufsize, TF_MIPMAPS|TF_COMPRESS, 0 );
if( !shader->stages[0]->bundles[0]->textures[0] )
@ -3101,6 +3102,25 @@ static shader_t *R_CreateDefaultShader( const char *name, shaderType_t shaderTyp
shader->stages[0]->numBundles++;
shader->numStages++;
break;
case SHADER_SPRITE:
shader->stages[0]->bundles[0]->flags |= STAGEBUNDLE_MAP;
shader->stages[0]->bundles[0]->textures[0] = r_internalMiptex; // internal spriteframe
shader->stages[0]->bundles[0]->texType = TEX_GENERIC;
if( !shader->stages[0]->bundles[0]->textures[0] )
{
MsgDev( D_WARN, "couldn't find spriteframe for shader '%s', using default...\n", shader->name );
shader->stages[0]->bundles[0]->textures[0] = r_defaultTexture;
}
// FIXME: make cases for ALPHA, GLOW etc
shader->sort = SORT_BLEND;
shader->stages[0]->flags |= SHADERSTAGE_BLENDFUNC;
shader->stages[0]->flags &= ~SHADERSTAGE_DEPTHWRITE;
shader->stages[0]->blendFunc.src = GL_DST_COLOR;
shader->stages[0]->blendFunc.dst = GL_ONE;
shader->stages[0]->bundles[0]->numTextures++;
shader->stages[0]->numBundles++;
shader->numStages++;
break;
case SHADER_NOMIP:
// don't let user set invalid font
// FIXME: make case SHADER_FONT and func RegisterShaderFont
@ -3305,9 +3325,12 @@ static void R_FinishShader( shader_t *shader )
stage->rgbGen.type = RGBGEN_IDENTITYLIGHTING;
else stage->rgbGen.type = RGBGEN_IDENTITY;
break;
case SHADER_SKIN:
case SHADER_STUDIO:
stage->rgbGen.type = RGBGEN_LIGHTINGDIFFUSE;
break;
case SHADER_SPRITE:
stage->rgbGen.type = RGBGEN_ENTITY; // sprite colormod
break;
case SHADER_NOMIP:
case SHADER_GENERIC:
stage->rgbGen.type = RGBGEN_VERTEX;
@ -3333,7 +3356,10 @@ static void R_FinishShader( shader_t *shader )
}
else stage->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case SHADER_SKIN:
case SHADER_STUDIO:
stage->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case SHADER_SPRITE:
stage->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case SHADER_NOMIP:
@ -3643,6 +3669,12 @@ shader_t *R_FindShader( const char *name, shaderType_t shaderType, uint surfaceP
return R_LoadShader( shader );
}
void R_SetInternalMap( texture_t *mipTex )
{
// never replace with NULL
if( mipTex ) r_internalMiptex = mipTex;
}
/*
=================
R_RegisterShader
@ -3660,7 +3692,7 @@ R_RegisterShaderSkin
*/
shader_t *R_RegisterShaderSkin( const char *name )
{
return R_FindShader( name, SHADER_SKIN, 0 );
return R_FindShader( name, SHADER_STUDIO, 0 );
}
/*
@ -3745,8 +3777,11 @@ void R_ShaderList_f( void )
case SHADER_BSP:
Msg( "bsp " );
break;
case SHADER_SKIN:
Msg( "skn " );
case SHADER_STUDIO:
Msg( "mdl " );
break;
case SHADER_SPRITE:
Msg( "spr " );
break;
case SHADER_NOMIP:
Msg( "pic " );
@ -3805,6 +3840,7 @@ void R_InitShaders( void )
// create built-in shaders
R_CreateBuiltInShaders();
r_internalMiptex = r_defaultTexture;
}
/*

153
render/r_sprite.c
View File

@ -51,7 +51,6 @@ dframetype_t *R_SpriteLoadFrame( rmodel_t *mod, void *pin, mspriteframe_t **ppfr
spr_frame->flags = IMAGE_HAS_ALPHA;
spr_frame->type = PF_INDEXED_32;
spr_frame->size = size; // for bounds checking
spr_frame->numLayers = 1;
spr_frame->numMips = 1;
*ppframe = pspriteframe;
@ -59,18 +58,16 @@ dframetype_t *R_SpriteLoadFrame( rmodel_t *mod, void *pin, mspriteframe_t **ppfr
pspriteframe->height = spr_frame->height = height;
origin[0] = LittleLong(pinframe->origin[0]);
origin[1] = LittleLong(pinframe->origin[1]);
pspriteframe->up = origin[1];
pspriteframe->down = origin[1] - height;
pspriteframe->left = origin[0];
pspriteframe->right = width + origin[0];
pspriteframe->radius = sqrt(((width>>1) * (width>>1)) + ((height>>1) * (height>>1)));
pspriteframe->shader = r_defaultShader;
// extract sprite name from path
FS_FileBase( mod->name, name );
com.strcat(name, va("_%s_%i%i", frame_prefix, framenum/10, framenum%10 ));
pspriteframe->up = origin[1];
pspriteframe->down = origin[1] - height;
pspriteframe->left = origin[0];
pspriteframe->right = width + origin[0];
pspriteframe->radius = sqrt(width * width + height * height);
image = R_LoadTexture( name, spr_frame, 0, 0 );
if( image )
{
@ -82,6 +79,9 @@ dframetype_t *R_SpriteLoadFrame( rmodel_t *mod, void *pin, mspriteframe_t **ppfr
pspriteframe->texture = r_defaultTexture;
}
R_SetInternalMap( image );
pspriteframe->shader = R_FindShader( name, SHADER_SPRITE, 0 );
frames = Mem_Realloc( mod->mempool, frames, sizeof(*frames) * (mod->numTextures + 1));
out = frames + mod->numTextures++;
spr_frametype = (dframetype_t *)((byte *)(pinframe + 1) + size );
@ -103,7 +103,7 @@ dframetype_t *R_SpriteLoadFrame( rmodel_t *mod, void *pin, mspriteframe_t **ppfr
out->numframes = 1;
out->next = NULL;
}
FS_FreeImage( spr_frame );
FS_FreeImage( spr_frame );
return spr_frametype;
}
@ -378,7 +378,138 @@ void R_SpriteSetupLighting( rmodel_t *mod )
}
}
void R_DrawSpriteModel( int passnum )
/*
=================
R_AddSpriteModelToList
I am only keeping this for backwards compatibility
=================
*/
void R_AddSpriteModelToList( ref_entity_t *entity )
{
mspriteframe_t *frame;
vec3_t vec;
frame = R_GetSpriteFrame( entity );
// cull
if( !r_nocull->integer )
{
VectorSubtract( entity->origin, r_refdef.vieworg, vec );
VectorNormalizeFast( vec );
if( DotProduct( vec, r_forward ) < 0 )
return;
}
// copy frame params
entity->radius = frame->radius;
entity->rotation = 0;
entity->shader = frame->shader;
// add it
R_AddMeshToList( MESH_SPRITE, NULL, entity->shader, entity, 0);
}
/*
=================
R_DrawSprite
=================
*/
void R_DrawSpriteModel( void )
{
sprite_t *psprite;
mspriteframe_t *frame;
float angle, sr, cr;
vec3_t axis[3], point;
int i;
// FIXME!!!!!!!!
if( !m_pRenderModel || !m_pCurrentEntity ) return;
psprite = (sprite_t *)m_pRenderModel->extradata;
frame = R_GetSpriteFrame( m_pCurrentEntity );
// setup orientation
switch( psprite->type )
{
case SPR_ORIENTED:
AxisCopy( m_pCurrentEntity->axis, axis );
VectorScale( axis[0], -0.01, axis[0] ); // to avoid z-fighting
VectorSubtract( m_pCurrentEntity->origin, axis[0], m_pCurrentEntity->origin );
break;
case SPR_FACING_UPRIGHT:
VectorSet( axis[2], 0, 0, 1 );
axis[1][0] = m_pCurrentEntity->origin[1] - r_origin[1];
axis[1][1] = -(m_pCurrentEntity->origin[0] - r_origin[0]);
axis[1][2] = 0;
VectorNormalize( axis[1] );
VectorNegate( r_forward, axis[0] );
break;
case SPR_FWD_PARALLEL_UPRIGHT:
VectorSet( axis[2], 0, 0, 1 );
VectorCopy( r_up, axis[1] );
VectorNegate( r_forward, axis[0] );
break;
case SPR_FWD_PARALLEL_ORIENTED:
angle = m_pCurrentEntity->angles[ROLL] * (M_PI*2/360);
sr = sin( angle );
cr = cos( angle );
for( i = 0; i < 3; i++ )
{
axis[0][i] = -r_forward[i];
axis[1][i] = r_right[i] * cr + r_up[i] * sr;
axis[2][i] = r_right[i] * -sr + r_up[i] * cr;
}
break;
case SPR_FWD_PARALLEL:
default: // normal sprite
VectorNegate( r_forward, axis[0] );
VectorCopy( r_right, axis[1] );
VectorCopy( r_up, axis[2] );
break;
}
// draw it
RB_CheckMeshOverflow( 6, 4 );
for( i = 2; i < 4; i++ )
{
indexArray[numIndex++] = numVertex + 0;
indexArray[numIndex++] = numVertex + i-1;
indexArray[numIndex++] = numVertex + i;
}
VectorMA( m_pCurrentEntity->origin, frame->up * m_pCurrentEntity->scale, axis[2], point );
VectorMA( point, frame->left * m_pCurrentEntity->scale, axis[1], vertexArray[numVertex+0] );
VectorMA( m_pCurrentEntity->origin, frame->up * m_pCurrentEntity->scale, axis[2], point );
VectorMA( point, frame->right * m_pCurrentEntity->scale, axis[1], vertexArray[numVertex+1] );
VectorMA( m_pCurrentEntity->origin, frame->down * m_pCurrentEntity->scale, axis[2], point );
VectorMA( point, frame->right * m_pCurrentEntity->scale, axis[1], vertexArray[numVertex+2] );
VectorMA( m_pCurrentEntity->origin, frame->down * m_pCurrentEntity->scale, axis[2], point );
VectorMA( point, frame->left * m_pCurrentEntity->scale, axis[1], vertexArray[numVertex+3] );
inTexCoordArray[numVertex+0][0] = 0;
inTexCoordArray[numVertex+0][1] = 0;
inTexCoordArray[numVertex+1][0] = 1;
inTexCoordArray[numVertex+1][1] = 0;
inTexCoordArray[numVertex+2][0] = 1;
inTexCoordArray[numVertex+2][1] = 1;
inTexCoordArray[numVertex+3][0] = 0;
inTexCoordArray[numVertex+3][1] = 1;
for( i = 0; i < 4; i++ )
{
VectorCopy( axis[0], normalArray[numVertex] );
Vector4Copy(m_pCurrentEntity->shaderRGBA, inColorArray[numVertex] );
numVertex++;
}
}
void R_DrawSpriteModel_old( int passnum )
{
mspriteframe_t *frame;
vec3_t point, forward, right, up;

4
render/r_surface.c
View File

@ -142,7 +142,7 @@ static void R_AddSurfaceToList( surface_t *surf, ref_entity_t *entity )
{
for( map = 0; map < surf->numStyles; map++ )
{
if( surf->cachedLight[map] != r_refdef.lightstyles[surf->styles[map]].white )
if( surf->cachedLight[map] != r_lightStyles[surf->styles[map]].white )
{
lmNum = 255;
break;
@ -220,7 +220,7 @@ void R_AddBrushModelToList( ref_entity_t *entity )
// Calculate dynamic lighting
if( r_dynamiclights->integer )
{
for( l = 0, dl = r_refdef.dlights; l < r_refdef.num_dlights; l++, dl++ )
for( l = 0, dl = r_dlights; l < r_numDLights; l++, dl++ )
{
if( !BoundsAndSphereIntersect( mins, maxs, dl->origin, dl->intensity ))
continue;

3
todo.log
View File

@ -25,11 +25,12 @@ GLOBAL:
3. r_backend.c:1347
4. r_shader.c:3087
5. r_main.c:339
6. r_backend.c:1310
7. r_shader.c:2866
9. r_texture.c:1724
убить кастомные arrays, в r_refdef
TODO LIST
ïîïðàâèòü ïîëå movedir â bsplib/map.c