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

18 Oct 2008

This commit is contained in:
g-cont 2008-10-18 00:00:00 +04:00 committed by Alibek Omarov
parent 92c5a0e536
commit 5773b3c2e4
22 changed files with 724 additions and 656 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
public/basetypes.h
View File

@ -22,10 +22,12 @@ typedef unsigned short word;
typedef unsigned long dword;
typedef unsigned int uint;
typedef signed __int64 int64;
typedef uint elem_t;
typedef int func_t;
typedef int sound_t;
typedef int model_t;
typedef int video_t;
typedef int shader_t;
typedef int string_t;
typedef float vec_t;
typedef vec_t vec2_t[2];

7
public/ref_dfiles.h
View File

@ -792,7 +792,12 @@ typedef struct
int flags;
int width;
int height;
int index;
union
{
int index; // disk: buffer index
shader_t shader; // mem: shader number
};
} dstudiotexture_t;
// skin families

45
render/r_backend.c
View File

@ -405,7 +405,7 @@ static float *RB_TableForFunc( const waveFunc_t *func )
{
switch( func->type )
{
case WAVEFORM_SIN:
case WAVEFORM_SINE:
return rb_sinTable;
case WAVEFORM_TRIANGLE:
return rb_triangleTable;
@ -870,8 +870,8 @@ RB_DeformVertexes
*/
static void RB_DeformVertexes( void )
{
deformVerts_t *deformVertexes = Ref.m_pCurrentShader->deformVertexes;
uint deformVertexesNum = Ref.m_pCurrentShader->deformVertexesNum;
deformVerts_t *deformVertexes = Ref.m_pCurrentShader->deformVerts;
uint deformVertexesNum = Ref.m_pCurrentShader->deformVertsNum;
float deflect, *quad[4];
double temp, params[4];
vec3_t tv, rot_centre;
@ -1395,7 +1395,6 @@ static void RB_CalcVertexColors( const shaderStage_t *stage )
fArray[3] = a;
break;
case ALPHAGEN_FADE:
case ALPHAGEN_PORTAL:
VectorAdd( vertexArray[0], Ref.m_pCurrentEntity->origin, v );
VectorSubtract( Ref.vieworg, v, t );
a = VectorLength( t ) * alphaGen->func.params[0];
@ -1404,6 +1403,8 @@ static void RB_CalcVertexColors( const shaderStage_t *stage )
for( i = 0; i < r_stats.numColors; i++, fArray += 4 )
fArray[3] = a;
break;
case ALPHAGEN_ONEMINUSFADE:
break;
case ALPHAGEN_VERTEX:
for( i = 0; i < r_stats.numColors; i++, fArray += 4, inArray += 4 )
fArray[3] = inArray[3];
@ -1483,10 +1484,10 @@ static void RB_CalcVertexColors( const shaderStage_t *stage )
else alphaFog = true;
fogPlane = r_colorFog->visible;
fogShaderDistScale = 1.0 / (r_colorFog->shader->fog_dist - r_colorFog->shader->fogClearDist);
fogShaderDistScale = 1.0 / (r_colorFog->shader->fogDist - r_colorFog->shader->fogClearDist);
dist = Ref.fog_dist_to_eye[r_colorFog - r_worldBrushModel->fogs];
if( Ref.m_pCurrentShader->flags & SHADER_SKY )
if( Ref.m_pCurrentShader->flags & SHADER_SKYPARMS )
{
if( dist > 0 ) VectorScale( fogPlane->normal, -dist, viewtofog );
else VectorClear( viewtofog );
@ -1574,6 +1575,7 @@ static bool RB_CalcTextureCoords( const stageBundle_t *bundle, uint unit, matrix
switch( tcGen->type )
{
default:
case TCGEN_BASE:
RB_DisableTexGen();
@ -1704,17 +1706,17 @@ static bool RB_CalcTextureCoords( const stageBundle_t *bundle, uint unit, matrix
return true;
case TCGEN_FOG:
{
int fogPtype;
cplane_t *fogPlane;
shader_t *fogShader;
vec3_t viewtofog;
float fogNormal[3], vpnNormal[3];
float dist, vdist, fogDist, vpnDist;
int fogPtype;
cplane_t *fogPlane;
ref_shader_t *fogShader;
vec3_t viewtofog;
float fogNormal[3], vpnNormal[3];
float dist, vdist, fogDist, vpnDist;
fogPlane = r_texFog->visible;
fogShader = r_texFog->shader;
matrix[0][0] = matrix[1][1] = 1.0f / ( fogShader->fog_dist - fogShader->fogClearDist );
matrix[0][0] = matrix[1][1] = 1.0f / ( fogShader->fogDist - fogShader->fogClearDist );
// FIXME: HACK
#ifdef OPENGL_STYLE
matrix[3][1] = 1.5f / (float)FOG_TEXTURE_HEIGHT;
@ -1724,7 +1726,7 @@ static bool RB_CalcTextureCoords( const stageBundle_t *bundle, uint unit, matrix
// distance to fog
dist = Ref.fog_dist_to_eye[r_texFog - r_worldBrushModel->fogs];
if( Ref.m_pCurrentShader->flags & SHADER_SKY )
if( Ref.m_pCurrentShader->flags & SHADER_SKYPARMS )
{
if( dist > 0 ) VectorMA( Ref.vieworg, -dist, fogPlane->normal, viewtofog );
else VectorCopy( Ref.vieworg, viewtofog );
@ -1793,7 +1795,6 @@ static bool RB_CalcTextureCoords( const stageBundle_t *bundle, uint unit, matrix
RB_DisableTexGen();
Matrix4x4_Concat( matrix, r_currentCastGroup->worldProjectionMatrix, Ref.entityMatrix );
break;
default: break;
}
return identityMatrix;
@ -2005,7 +2006,7 @@ static void RB_SetupTextureUnit( const shaderStage_t *stage, const stageBundle_t
//CIN_RunCinematic( bundle->cinematicHandle );
//CIN_DrawCinematic( bundle->cinematicHandle );
break;
case TEX_PORTAL:
case TEX_RENDERVIEW:
image = r_portaltexture;
break;
case TEX_DLIGHT:
@ -2113,7 +2114,7 @@ static void RB_RenderMeshGeneric( void )
GL_TexEnv( GL_MODULATE );
GL_SetState( r_currentShaderState|( stage->flags & r_currentShaderPassMask ));
/*for( i = 0; i < rb_numAccumStages; i++ )
for( i = 0; i < rb_numAccumStages; i++ )
{
stage = Ref.m_pCurrentShader->stages[i];
@ -2130,7 +2131,7 @@ static void RB_RenderMeshGeneric( void )
bundle = stage->bundles[j];
RB_CleanupTextureUnit( bundle, j );
}
}*/
}
R_FlushArrays();
}
@ -2275,7 +2276,7 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
else r_superLightStyle = NULL;
m_pRenderMeshBuffer = mb;
R_SHADER_FOR_KEY( mb->shaderKey, Ref.m_pCurrentShader );
Shader_ForKey( mb->shaderKey, Ref.m_pCurrentShader );
if( gl_state.orthogonal )
{
@ -2293,7 +2294,7 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
if( !r_triangleOutlines ) RB_SetShaderState();
if( Ref.m_pCurrentShader->deformVertexesNum )
if( Ref.m_pCurrentShader->deformVertsNum )
RB_DeformVertexes();
if( r_features & MF_KEEPLOCK )
@ -2320,7 +2321,7 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
if( fog && !fog->shader ) fog = NULL;
// can we fog the geometry with alpha texture?
r_texFog = ( fog && (( Ref.m_pCurrentShader->sort <= SORT_ALPHATEST && ( Ref.m_pCurrentShader->flags & ( SHADER_DEPTHWRITE|SHADER_SKY ))) || Ref.m_pCurrentShader->fog_dist )) ? fog : NULL;
r_texFog = ( fog && (( Ref.m_pCurrentShader->sort <= SORT_ALPHATEST && ( Ref.m_pCurrentShader->flags & ( SHADER_SKYPARMS ))) || Ref.m_pCurrentShader->fogDist )) ? fog : NULL;
// check if the fog volume is present but we can't use alpha texture
r_colorFog = ( fog && !r_texFog ) ? fog : NULL;
@ -2404,7 +2405,7 @@ meshbuffer_t pic_mbuffer;
RB_DrawStretchPic
===============
*/
void RB_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, float s2, float t2, shader_t *shader )
void RB_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, float s2, float t2, ref_shader_t *shader )
{
if( !shader ) return;

47
render/r_backend.h Normal file
View File

@ -0,0 +1,47 @@
//=======================================================================
// Copyright XashXT Group 2008 ©
// r_backend.h - rendering backend
//=======================================================================
#ifndef R_BACKEND_H
#define R_BACKEND_H
#define MAX_VERTEXES 4096
#define MAX_ELEMENTS MAX_VERTEXES * 6 // quad
#define MAX_TRIANGLES MAX_ELEMENTS / 3
#define MAX_NEIGHBORS MAX_TRIANGLES *3
typedef struct
{
vec3_t xyz;
vec3_t normal;
vec3_t tangents[2];
vec2_t st;
vec3_t color;
float alpha;
} vertexArray_t;
typedef struct ref_backend_s
{
// src arrays
vec4_t *inColors[LM_STYLES]; // RGBA[4]
vec2_t *inTexCoords;
elem_t *inIndices;
vec2_t *inLMCoords;
vec3_t *inNormals;
vec3_t *inSVectors;
vec3_t *inTVectors;
vec3_t *inVertices;
// dst arrays
elem_t indexArray[MAX_ELEMENTS]; // vertsArray[num]
vec3_t vertsArray[MAX_VERTEXES]; // XYZ point
vec3_t normalArray[MAX_VERTEXES]; // R point
vec3_t tangentArray[MAX_VERTEXES]; // S point
vec3_t binormalArray[MAX_VERTEXES]; // T point
vec3_t texCoordArray[MAX_TEXTURE_UNITS][MAX_VERTEXES]; // STR (tangent, binormal, normal)
vec2_t lmsCoordArray[LM_STYLES][MAX_VERTEXES]; // ST for all lightmaps
vec4_t ColorArray[MAX_VERTEXES]; // sum of all lightstyles
} ref_backend_t;
#endif//R_BACKEND_H

8
render/r_cull.c
View File

@ -224,7 +224,7 @@ static byte r_queriesBits[MAX_OQ_TOTAL/8];
static GLuint r_occlusionQueries[MAX_OQ_TOTAL];
static meshbuffer_t r_occluderMB;
static shader_t *r_occlusionShader;
static ref_shader_t *r_occlusionShader;
static bool r_occludersQueued;
static ref_entity_t *r_occlusionEntity;
@ -240,7 +240,7 @@ void R_InitOcclusionQueries( void )
meshbuffer_t *meshbuf = &r_occluderMB;
if( !r_occlusionShader )
r_occlusionShader = R_FindShader( "***r_occlusion***", SHADER_OPAQUE_OCCLUDER, 0 );
r_occlusionShader = R_FindShader( "***r_occlusion***", SHADER_GENERIC, 0 );
if( !GL_Support( R_OCCLUSION_QUERY ))
return;
@ -317,7 +317,7 @@ static void R_RenderOccludingSurfaces( void )
R_OcclusionShader
===============
*/
shader_t *R_OcclusionShader( void )
ref_shader_t *R_OcclusionShader( void )
{
return r_occlusionShader;
}
@ -327,7 +327,7 @@ shader_t *R_OcclusionShader( void )
R_AddOccludingSurface
===============
*/
void R_AddOccludingSurface( msurface_t *surf, shader_t *shader )
void R_AddOccludingSurface( msurface_t *surf, ref_shader_t *shader )
{
int diff = shader->flags ^ r_occlusionShader->flags;

4
render/r_draw.c
View File

@ -14,7 +14,7 @@ this is needed by some client drawing functions
*/
void R_GetPicSize( int *w, int *h, const char *pic )
{
shader_t *shader = R_RegisterShaderNoMip(va( "gfx/%s", pic ));
ref_shader_t *shader = R_RegisterShaderNoMip(va( "gfx/%s", pic ));
*w = (int)shader->stages[0]->bundles[0]->textures[0]->width;
*h = (int)shader->stages[0]->bundles[0]->textures[0]->height;
}
@ -30,7 +30,7 @@ Call RB_RenderMesh to flush.
*/
void R_DrawStretchPic( float x, float y, float w, float h, float sl, float tl, float sh, float th, const char *name )
{
shader_t *shader = R_RegisterShaderNoMip(va( "gfx/%s", name ));
ref_shader_t *shader = R_RegisterShaderNoMip(va( "gfx/%s", name ));
RB_DrawStretchPic( x, y, w, h, sl, tl, sh, th, shader );
}

0
render/r_init.c Normal file
View File

8
render/r_light.c
View File

@ -23,13 +23,13 @@ R_SurfPotentiallyLit
*/
bool R_SurfPotentiallyLit( msurface_t *surf )
{
shader_t *shader;
ref_shader_t *shader;
if( surf->flags & ( SURF_SKY|SURF_NODLIGHT|SURF_NODRAW ))
return false;
shader = surf->shader;
if(( shader->flags & ( SHADER_SKY|SHADER_FLARE )) || !shader->numStages )
if(( shader->flags & ( SHADER_SKYPARMS|SHADER_FLARE )) || !shader->numStages )
return false;
return ( surf->mesh && ( surf->faceType != MST_FLARE ));
}
@ -86,7 +86,7 @@ void R_AddDynamicLights( uint dlightbits, int state )
uint i, j, numTempIndices;
bool cullAway;
const dlight_t *light;
const shader_t *shader;
const ref_shader_t *shader;
vec3_t tvec, dlorigin, normal;
uint tempIndexArray[MAX_ARRAY_ELEMENTS];
float inverseIntensity, *v1, *v2, *v3, dist;
@ -219,7 +219,7 @@ void R_AddDynamicLights( uint dlightbits, int state )
//===================================================================
static shader_t *r_coronaShader;
static ref_shader_t *r_coronaShader;
/*
=================

481
render/r_local.h
View File

@ -20,7 +20,6 @@ extern byte *r_shaderpool;
// limits
#define MAX_TEXTURE_UNITS 8
#define MAX_LIGHTMAPS 128
#define MAX_SHADERS 1024
#define MAX_ENTITIES 1024
#define MAX_VERTEX_BUFFERS 2048
#define MAX_TEXTURES 4096
@ -140,8 +139,8 @@ void R_ImageFreeUnused( void );
#define RP_ENVVIEW (1<<2) // render only bmodels (for envshots)
#define RP_NOSKY (1<<3)
#define RP_SKYPORTALVIEW (1<<4) // view from sky pass
#define RP_PORTALCAPTURED (1<<5) // base portal image
#define RP_PORTALCAPTURED2 (1<<6) // refracted portal image ?
#define RP_REFLECTED (1<<5) // base portal image
#define RP_REFRACTED (1<<6) // refracted portal image ?
#define RP_OLDVIEWCLUSTER (1<<7)
#define RP_SHADOWMAPVIEW (1<<8) // shadowmap pass
#define RP_FLIPFRONTFACE (1<<9)
@ -161,8 +160,38 @@ void R_ImageFreeUnused( void );
#define R_EDICTNUM( ent ) ((int)((ent) - r_entities)<<20 )
#define R_EDICT_FOR_KEY( num, ent ) ( ent = r_entities + (((num)>>20) & (MAX_ENTITIES-1)))
#define R_SHADERNUM( s ) ((s)->sort << 26 ) | ((s)->shaderNum )
#define R_SHADER_FOR_KEY( num, s ) ((s) = r_shaders[((num) & 0xFFF)])
// GLSTATE machine flags
#define GLSTATE_DEFAULT 0 // reset state to default
#define GLSTATE_SRCBLEND_ZERO (1<<0)
#define GLSTATE_SRCBLEND_ONE (1<<1)
#define GLSTATE_SRCBLEND_ONE_MINUS_DST_COLOR (1<<2)
#define GLSTATE_SRCBLEND_ONE_MINUS_DST_ALPHA (1<<3)
#define GLSTATE_DSTBLEND_ZERO (1<<4)
#define GLSTATE_DSTBLEND_ONE (1<<5)
#define GLSTATE_DSTBLEND_ONE_MINUS_SRC_COLOR (1<<6)
#define GLSTATE_DSTBLEND_ONE_MINUS_DST_ALPHA (1<<7)
#define GLSTATE_AFUNC_GT0 (1<<8)
#define GLSTATE_AFUNC_LT128 (1<<9)
#define GLSTATE_AFUNC_GE128 (1<<10)
#define GLSTATE_DEPTHWRITE (1<<11)
#define GLSTATE_DEPTHFUNC_EQ (1<<12)
#define GLSTATE_OFFSET_FILL (1<<13)
#define GLSTATE_NO_DEPTH_TEST (1<<14)
#define GLSTATE_BLEND_MTEX (1<<15)
// GLSTATE masks
#define GLSTATE_MASK ((1<<16) - 1 )
#define GLSTATE_SRCBLEND_DST_COLOR (GLSTATE_SRCBLEND_ZERO|GLSTATE_SRCBLEND_ONE)
#define GLSTATE_SRCBLEND_SRC_ALPHA (GLSTATE_SRCBLEND_ZERO|GLSTATE_SRCBLEND_ONE_MINUS_DST_COLOR)
#define GLSTATE_SRCBLEND_ONE_MINUS_SRC_ALPHA (GLSTATE_SRCBLEND_ONE|GLSTATE_SRCBLEND_ONE_MINUS_DST_COLOR)
#define GLSTATE_SRCBLEND_DST_ALPHA (GLSTATE_SRCBLEND_ZERO|GLSTATE_SRCBLEND_ONE|GLSTATE_SRCBLEND_ONE_MINUS_DST_COLOR)
#define GLSTATE_DSTBLEND_SRC_COLOR (GLSTATE_DSTBLEND_ZERO|GLSTATE_DSTBLEND_ONE)
#define GLSTATE_DSTBLEND_SRC_ALPHA (GLSTATE_DSTBLEND_ZERO|GLSTATE_DSTBLEND_ONE_MINUS_SRC_COLOR)
#define GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA (GLSTATE_DSTBLEND_ONE|GLSTATE_DSTBLEND_ONE_MINUS_SRC_COLOR)
#define GLSTATE_DSTBLEND_DST_ALPHA (GLSTATE_DSTBLEND_ZERO|GLSTATE_DSTBLEND_ONE|GLSTATE_DSTBLEND_ONE_MINUS_SRC_COLOR)
#define GLSTATE_ALPHAFUNC (GLSTATE_AFUNC_GT0|GLSTATE_AFUNC_LT128|GLSTATE_AFUNC_GE128)
#define GLSTATE_SRCBLEND_MASK (((GLSTATE_SRCBLEND_DST_ALPHA)<<1)-GLSTATE_SRCBLEND_ZERO)
#define GLSTATE_DSTBLEND_MASK (((GLSTATE_DSTBLEND_DST_ALPHA)<<1)-GLSTATE_DSTBLEND_ZERO)
enum
{
@ -185,8 +214,8 @@ enum
&& r_drawentities->integer && !((ri).params & RP_NONVIEWERREF) \
&& !((Ref).refdef.rdflags & RDF_NOWORLDMODEL) \
&& OCCLUSION_QUERIES_CVAR_HACK( Ref ))
#define OCCLUSION_OPAQUE_SHADER( s ) (((s)->sort == SORT_OPAQUE ) && ((s)->flags & SHADER_DEPTHWRITE ) \
&& !(s)->deformVertexesNum )
#define OCCLUSION_OPAQUE_SHADER( s ) (((s)->sort == SORT_OPAQUE ) && ((s)->stages[0]->flags & SHADERSTAGE_DEPTHWRITE ) \
&& !(s)->deformVertsNum )
#define OCCLUSION_TEST_ENTITY( e ) (((e)->flags & (RF_OCCLUSIONTEST|RF_WEAPONMODEL)) == RF_OCCLUSIONTEST )
/*
@ -252,397 +281,7 @@ void R_ShutdownPrograms( void );
void R_ProgramList_f( void );
void R_ProgramDump_f( void );
/*
=======================================================================
SHADERS
=======================================================================
*/
#define SHADER_MAX_EXPRESSIONS 16
#define SHADER_MAX_STAGES 8
#define SHADER_MAX_DEFORMVERTEXES 8
#define SHADER_MAX_TEXTURES 16
#define SHADER_MAX_TCMOD 8
// Shader types used for shader loading
typedef enum
{
SHADER_INVALID = -1, // invalid shaders
SHADER_GENERIC,
SHADER_SURFACE, // bsp surface
SHADER_VERTEX, // vertex manipulation (lighting, deform etc)
SHADER_FLARE, // light flares
SHADER_STUDIO, // studio meshes
SHADER_SPRITE, // sprite frames
SHADER_NOMIP, // 2d images
SHADER_FONT, // speical case for displayed fonts
SHADER_FARBOX, // sky farbox
SHADER_NEARBOX, // sky nearbox
SHADER_PLANAR_SHADOW, // customizable shadow
SHADER_OPAQUE_OCCLUDER // occluder controls
} shaderType_t;
// shader flags
#define SHADER_DEPTHWRITE (1<<0)
#define SHADER_SKYPARMS (1<<1)
#define SHADER_POLYGONOFFSET (1<<2)
#define SHADER_CULL (1<<3)
#define SHADER_SORT (1<<4)
#define SHADER_VIDEOMAP (1<<5)
#define SHADER_MATERIAL (1<<6)
#define SHADER_DEFORMVERTEXES (1<<7)
#define SHADER_ENTITYMERGABLE (1<<8)
#define SHADER_FLARE (1<<9)
#define SHADER_AUTOSPRITE (1<<10)
#define SHADER_NO_MODULATIVE_DLIGHTS (1<<11)
#define SHADER_LIGHTMAP (1<<12)
#define SHADER_PORTAL (1<<13)
#define SHADER_PORTAL_CAPTURE (1<<14)
#define SHADER_PORTAL_CAPTURE2 (1<<15)
#define SHADER_SKY (1<<16)
// glstats presets
#define GLSTATE_NONE 0
#define GLSTATE_SRCBLEND_ZERO (1<<0)
#define GLSTATE_SRCBLEND_ONE (1<<1)
#define GLSTATE_SRCBLEND_DST_COLOR (GLSTATE_SRCBLEND_ZERO|GLSTATE_SRCBLEND_ONE)
#define GLSTATE_SRCBLEND_ONE_MINUS_DST_COLOR (1<<2)
#define GLSTATE_SRCBLEND_SRC_ALPHA (GLSTATE_SRCBLEND_ZERO|GLSTATE_SRCBLEND_ONE_MINUS_DST_COLOR)
#define GLSTATE_SRCBLEND_ONE_MINUS_SRC_ALPHA (GLSTATE_SRCBLEND_ONE|GLSTATE_SRCBLEND_ONE_MINUS_DST_COLOR)
#define GLSTATE_SRCBLEND_DST_ALPHA (GLSTATE_SRCBLEND_ZERO|GLSTATE_SRCBLEND_ONE|GLSTATE_SRCBLEND_ONE_MINUS_DST_COLOR)
#define GLSTATE_SRCBLEND_ONE_MINUS_DST_ALPHA (1<<4)
#define GLSTATE_DSTBLEND_ZERO (1<<5)
#define GLSTATE_DSTBLEND_ONE (1<<6)
#define GLSTATE_DSTBLEND_SRC_COLOR (GLSTATE_DSTBLEND_ZERO|GLSTATE_DSTBLEND_ONE)
#define GLSTATE_DSTBLEND_ONE_MINUS_SRC_COLOR (1<<7)
#define GLSTATE_DSTBLEND_SRC_ALPHA (GLSTATE_DSTBLEND_ZERO|GLSTATE_DSTBLEND_ONE_MINUS_SRC_COLOR)
#define GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA (GLSTATE_DSTBLEND_ONE|GLSTATE_DSTBLEND_ONE_MINUS_SRC_COLOR)
#define GLSTATE_DSTBLEND_DST_ALPHA (GLSTATE_DSTBLEND_ZERO|GLSTATE_DSTBLEND_ONE|GLSTATE_DSTBLEND_ONE_MINUS_SRC_COLOR)
#define GLSTATE_DSTBLEND_ONE_MINUS_DST_ALPHA (1<<8)
#define GLSTATE_AFUNC_GT0 (1<<9)
#define GLSTATE_AFUNC_LT128 (1<<10)
#define GLSTATE_AFUNC_GE128 (1<<11)
#define GLSTATE_ALPHAFUNC (GLSTATE_AFUNC_GT0|GLSTATE_AFUNC_LT128|GLSTATE_AFUNC_GE128)
#define GLSTATE_DEPTHWRITE (1<<12)
#define GLSTATE_DEPTHFUNC_EQ (1<<13)
#define GLSTATE_OFFSET_FILL (1<<14)
#define GLSTATE_NO_DEPTH_TEST (1<<15)
#define GLSTATE_BLEND_MTEX (1<<16) // FIXME: remove ?
#define GLSTATE_MARK_END 0x10000 // STAGEBUNDLE_MARK_BEGIN
#define GLSTATE_MASK ( GLSTATE_MARK_END-1 )
#define GLSTATE_SRCBLEND_MASK 0xF
#define GLSTATE_DSTBLEND_MASK 0xF0
// shader stage flags
#define SHADERSTAGE_NEXTBUNDLE (1<<0)
#define SHADERSTAGE_ALPHAFUNC (1<<1)
#define SHADERSTAGE_BLENDFUNC (1<<2)
#define SHADERSTAGE_DEPTHFUNC (1<<3)
#define SHADERSTAGE_DEPTHWRITE (1<<4)
#define SHADERSTAGE_DETAIL (1<<5) // detail textures
#define SHADERSTAGE_RGBGEN (1<<6)
#define SHADERSTAGE_ALPHAGEN (1<<7)
#define SHADERSTAGE_NOCOLORARRAY (1<<8)
#define SHADERSTAGE_DLIGHT (1<<9)
#define SHADERSTAGE_BLENDDECAL (1<<10)
#define SHADERSTAGE_STENCILSHADOW (1<<11)
// translate to TF_* flags
#define STAGEBUNDLE_NOMIPMAPS (GLSTATE_MARK_END<<0)
#define STAGEBUNDLE_NOPICMIP (GLSTATE_MARK_END<<1)
#define STAGEBUNDLE_NOCOMPRESS (GLSTATE_MARK_END<<2)
#define STAGEBUNDLE_CLAMPTEXCOORDS (GLSTATE_MARK_END<<3)
// STAGEBUNDLE_* flags
#define STAGEBUNDLE_ANIMFREQUENCY (GLSTATE_MARK_END<<4)
#define STAGEBUNDLE_MAP (GLSTATE_MARK_END<<5)
#define STAGEBUNDLE_BUMPMAP (GLSTATE_MARK_END<<6)
#define STAGEBUNDLE_CUBEMAP (GLSTATE_MARK_END<<7)
#define STAGEBUNDLE_VIDEOMAP (GLSTATE_MARK_END<<8)
#define STAGEBUNDLE_TEXENVCOMBINE (GLSTATE_MARK_END<<9)
#define STAGEBUNDLE_TCGEN (GLSTATE_MARK_END<<10)
#define STAGEBUNDLE_TCMOD (GLSTATE_MARK_END<<11)
#define STAGEBUNDLE_STENCILSHADOW (GLSTATE_MARK_END<<14)
typedef enum
{
WAVEFORM_SIN,
WAVEFORM_TRIANGLE,
WAVEFORM_SQUARE,
WAVEFORM_SAWTOOTH,
WAVEFORM_INVERSESAWTOOTH,
WAVEFORM_NOISE,
WAVEFORM_CONSTANT
} waveForm_t;
typedef enum
{
SORT_NONE = 0,
SORT_PORTAL,
SORT_SKY,
SORT_OPAQUE,
SORT_DECAL,
SORT_ALPHATEST,
SORT_BANNER,
SORT_UNDERWATER = 8,
SORT_ADDITIVE,
SORT_NEAREST = 16
} sort_t;
typedef enum
{
DEFORMVERTEXES_NONE = 0,
DEFORMVERTEXES_WAVE,
DEFORMVERTEXES_MOVE,
DEFORMVERTEXES_NORMAL,
DEFORMVERTEXES_BULGE,
DEFORMVERTEXES_AUTOSPRITE, // same as SPR_VP_PARALLEL
DEFORMVERTEXES_AUTOSPRITE2,
DEFORMVERTEXES_PROJECTION_SHADOW,
DEFORMVERTEXES_AUTOPARTICLE
} deformVertsType_t;
typedef enum
{
TCGEN_BASE,
TCGEN_LIGHTMAP,
TCGEN_ENVIRONMENT,
TCGEN_VECTOR,
TCGEN_FOG,
TCGEN_WARP, // q1/q2 warp surfaces (water, slime, lava)
TCGEN_LIGHTVECTOR,
TCGEN_HALFANGLE,
TCGEN_REFLECTION,
TCGEN_SVECTORS,
TCGEN_PROJECTION,
TCGEN_PROJECTION_SHADOW,
TCGEN_NORMAL
} tcGenType_t;
typedef enum
{
TCMOD_TRANSLATE,
TCMOD_SCALE,
TCMOD_SCROLL,
TCMOD_ROTATE,
TCMOD_STRETCH,
TCMOD_TURB,
TCMOD_TRANSFORM
} tcModType_t;
typedef enum
{
RGBGEN_IDENTITY,
RGBGEN_IDENTITYLIGHTING,
RGBGEN_CONST,
RGBGEN_WAVE,
RGBGEN_ENTITY,
RGBGEN_ONEMINUSENTITY,
RGBGEN_VERTEX,
RGBGEN_EXACTVERTEX,
RGBGEN_ONEMINUSVERTEX,
RGBGEN_LIGHTINGAMBIENT,
RGBGEN_LIGHTINGDIFFUSE,
RGBGEN_LIGHTINGDIFFUSE_ONLY,
RGBGEN_LIGHTINGAMBIENT_ONLY,
RGBGEN_FOG,
RGBGEN_ENVIRONMENT
} rgbGenType_t;
typedef enum
{
ALPHAGEN_IDENTITY,
ALPHAGEN_CONST,
ALPHAGEN_WAVE,
ALPHAGEN_PORTAL,
ALPHAGEN_VERTEX,
ALPHAGEN_ONEMINUSVERTEX,
ALPHAGEN_ENTITY,
ALPHAGEN_ONEMINUSENTITY,
ALPHAGEN_SPECULAR,
ALPHAGEN_DOT,
ALPHAGEN_ONEMINUSDOT,
ALPHAGEN_FADE,
ALPHAGEN_ONEMINUSFADE,
} alphaGenType_t;
typedef enum
{
TEX_GENERIC = 0,
TEX_LIGHTMAP,
TEX_CINEMATIC,
TEX_PORTAL,
TEX_DLIGHT
} texType_t;
typedef struct
{
waveForm_t type;
float params[4];
} waveFunc_t;
typedef struct
{
GLenum mode;
} cull_t;
typedef struct
{
texture_t *farBox[6];
float cloudHeight;
texture_t *nearBox[6];
} skyParms_t;
typedef struct
{
deformVertsType_t type;
waveFunc_t func;
float params[3];
} deformVerts_t;
typedef struct
{
GLint rgbCombine;
GLint rgbSource[3];
GLint rgbOperand[3];
GLint rgbScale;
GLint alphaCombine;
GLint alphaSource[3];
GLint alphaOperand[3];
GLint alphaScale;
GLfloat constColor[4];
} texEnvCombine_t;
typedef struct
{
tcGenType_t type;
float params[8];
} tcGen_t;
typedef struct
{
tcModType_t type;
waveFunc_t func;
float params[6];
} tcMod_t;
typedef struct
{
GLenum func;
GLclampf ref;
} alphaFunc_t;
typedef struct
{
GLenum func; // GL_MODULATE, GL_ADD etc
GLenum src;
GLenum dst;
} blendFunc_t;
typedef struct
{
GLenum func;
} depthFunc_t;
typedef struct
{
rgbGenType_t type;
waveFunc_t func;
float params[4];
} rgbGen_t;
typedef struct
{
alphaGenType_t type;
waveFunc_t func;
float params[3];
} alphaGen_t;
typedef struct
{
texType_t texType;
uint flags;
texture_t *textures[SHADER_MAX_TEXTURES];
uint numTextures;
float animFrequency;
video_t cinematicHandle;
GLint texEnv;
texEnvCombine_t texEnvCombine;
tcGen_t tcGen;
tcMod_t tcMod[SHADER_MAX_TCMOD];
uint tcModNum;
} stageBundle_t;
typedef struct
{
bool ignore;
uint flags;
stageBundle_t *bundles[MAX_TEXTURE_UNITS];
uint numBundles;
// glsl
const char *program;
progType_t progType;
alphaFunc_t alphaFunc;
blendFunc_t blendFunc;
depthFunc_t depthFunc;
rgbGen_t rgbGen;
alphaGen_t alphaGen;
} shaderStage_t;
typedef struct shader_s
{
string name;
int shaderNum;
shaderType_t shaderType;
uint surfaceParm;
uint contentFlags;
uint features;
uint flags;
cull_t cull;
sort_t sort;
uint sortKey;
skyParms_t skyParms;
deformVerts_t deformVertexes[SHADER_MAX_DEFORMVERTEXES];
vec4_t fogColor;
float fog_dist;
float fogClearDist;
float offsetMapping_scale;
uint deformVertexesNum;
shaderStage_t *stages[SHADER_MAX_STAGES];
uint numStages;
struct shader_s *nextHash;
} shader_t;
extern shader_t *r_shaders[MAX_SHADERS];
extern int r_numShaders;
extern shader_t *r_defaultShader;
extern shader_t *r_lightmapShader;
extern shader_t *r_waterCausticsShader;
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);
#include "r_shader.h"
/*
=======================================================================
@ -665,7 +304,7 @@ typedef struct dlight_s
vec3_t mins;
vec3_t maxs;
float intensity;
const shader_t *shader; // for some effects
const ref_shader_t *shader; // for some effects
} dlight_t;
typedef struct lightstyle_s
@ -676,7 +315,7 @@ typedef struct lightstyle_s
typedef struct particle_s
{
shader_t *shader;
ref_shader_t *shader;
vec3_t origin;
vec3_t old_origin;
float radius;
@ -745,8 +384,8 @@ typedef struct
rb_mesh_t *meshes;
vec2_t *sphereStCoords[5]; // sky dome coords
vec2_t *linearStCoords[6];
shader_t *farboxShaders[6];
shader_t *nearboxShaders[6];
ref_shader_t *farboxShaders[6];
ref_shader_t *nearboxShaders[6];
} skydome_t;
typedef struct
@ -765,7 +404,7 @@ typedef struct
vec3_t *verts;
vec2_t *st;
vec4_t *colors;
shader_t *shader;
ref_shader_t *shader;
int fognum;
vec3_t normal;
} poly_t;
@ -780,7 +419,7 @@ BRUSH MODELS
*/
typedef struct
{
shader_t *shader;
ref_shader_t *shader;
cplane_t *visible;
int numplanes;
@ -793,7 +432,7 @@ typedef struct msurface_s
dmst_t faceType;
int flags;
shader_t *shader;
ref_shader_t *shader;
rb_mesh_t *mesh;
mfog_t *fog;
cplane_t *plane;
@ -939,7 +578,7 @@ typedef struct
mstudioneighbor_t *neighbors;
mstudiopoint_t *points;
mstudiost_t *st;
shader_t *shaders;
ref_shader_t *shaders;
int numTriangles;
int numVertices;
@ -966,7 +605,7 @@ typedef struct mspriteframe_s
int height;
float up, down, left, right;
float radius;
shader_t *shader;
ref_shader_t *shader;
texture_t *texture;
} mspriteframe_t;
@ -1014,7 +653,7 @@ typedef struct rmodel_s
float radius;
int numShaders;
shader_t *shaders[MAX_SHADERS];
ref_shader_t *shaders[MAX_SHADERS];
// memory representation pointer
void *extradata; // mbrushmodel_t\mstudiomodel_t\mspritemodel_t
@ -1100,7 +739,7 @@ typedef struct ref_entity_s
float gaityaw; // local value
// shader information
shader_t *shader;
ref_shader_t *shader;
float shaderTime; // subtracted from refdef time to control effect start times
float radius; // bbox approximate radius
float rotation; // what the hell ???
@ -1141,7 +780,7 @@ typedef struct ref_state_s
ref_entity_t *m_pCurrentEntity;
rmodel_t *m_pCurrentModel;
ref_entity_t *m_pPrevEntity;
shader_t *m_pCurrentShader;
ref_shader_t *m_pCurrentShader;
//
// view origin
@ -1452,7 +1091,7 @@ void RB_ShowTextures( void );
void RB_DebugGraphics( void );
void RB_CheckMeshOverflow( int numIndices, int numVertices );
void RB_RenderMesh( void );
void RB_DrawStretchPic( float x, float y, float w, float h, float sl, float tl, float sh, float th, shader_t *shader );
void RB_DrawStretchPic( float x, float y, float w, float h, float sl, float tl, float sh, float th, ref_shader_t *shader );
void RB_DrawTriangleOutlines( bool showTris, bool showNormals );
void RB_BeginTriangleOutlines( void );
void RB_EndTriangleOutlines( void );
@ -1572,19 +1211,19 @@ bool R_CompletelyFogged( mfog_t *fog, vec3_t origin, float radius );
void R_TranslateForEntity( ref_entity_t *ent );
void R_RotateForEntity( ref_entity_t *entity );
void R_CleanUpTextureUnits( void );
shader_t *R_OcclusionShader( void );
ref_shader_t *R_OcclusionShader( void );
void R_SurfIssueOcclusionQueries( void );
void R_ClearSurfOcclusionQueryKeys( void );
int R_GetOcclusionQueryNum( int type, int key );
void R_AddOccludingSurface( msurface_t *surf, shader_t *shader );
void R_AddOccludingSurface( msurface_t *surf, ref_shader_t *shader );
int R_IssueOcclusionQuery( int query, ref_entity_t *e, vec3_t mins, vec3_t maxs );
int R_SurfOcclusionQueryKey( ref_entity_t *e, msurface_t *surf );
bool R_GetOcclusionQueryResultBool( int type, int key, bool wait );
void R_BeginOcclusionPass( void );
void R_EndOcclusionPass( void );
meshbuffer_t *R_AddMeshToList( meshType_t meshType, mfog_t *fog, shader_t *shader, int infoKey );
meshbuffer_t *R_AddMeshToList( meshType_t meshType, mfog_t *fog, ref_shader_t *shader, int infoKey );
void R_RenderMeshBuffer( const meshbuffer_t *mb );
void R_AddModelMeshToList( mfog_t *fog, shader_t *shader, int meshnum );
void R_AddModelMeshToList( mfog_t *fog, ref_shader_t *shader, int meshnum );
void R_MarkLeaves( void );
void R_DrawWorld( void );
void R_DrawSprite( void );
@ -1598,7 +1237,7 @@ void R_AddShadowToList( ref_entity_t *entity );
void R_RenderShadows( void );
void R_BloomBlend ( const refdef_t *fd );
bool R_AddSkySurface( msurface_t *fa );
void R_DrawSky( shader_t *shader );
void R_DrawSky( ref_shader_t *shader );
void R_ClearSky( void );
void R_ClipSkySurface( msurface_t *surf );
void R_AddSkyToList( void );
@ -1635,11 +1274,11 @@ void R_BeginRegistration( const char *map );
rmodel_t *R_RegisterModel( const char *name );
void R_SetupSky( const char *name, float rotate, const vec3_t axis );
void R_EndRegistration( void );
void R_ShaderRegisterImages( shader_t *shader ); // prolonge registration
shader_t *R_RegisterShader( const char *name );
shader_t *R_RegisterShaderSkin( const char *name );
shader_t *R_RegisterShaderNoMip( const char *name );
void R_DeformVertexesBBoxForShader( const shader_t *shader, vec3_t ebbox );
void R_ShaderRegisterImages( ref_shader_t *shader ); // prolonge registration
ref_shader_t *R_RegisterShader( const char *name );
ref_shader_t *R_RegisterShaderSkin( const char *name );
ref_shader_t *R_RegisterShaderNoMip( const char *name );
void R_DeformVertexesBBoxForShader( const ref_shader_t *shader, vec3_t ebbox );
bool VID_ScreenShot( const char *filename, bool levelshot );
void R_DrawFill( float x, float y, float w, float h );
void R_DrawStretchRaw( int x, int y, int w, int h, int width, int height, const byte *raw, bool dirty );

18
render/r_main.c
View File

@ -301,7 +301,7 @@ bool R_CompletelyFogged( mfog_t *fog, vec3_t origin, float radius )
if( fog && fog->shader && Ref.fog_dist_to_eye[fog - r_worldBrushModel->fogs] < 0 )
{
float vpnDist = (( Ref.vieworg[0] - origin[0] ) * Ref.forward[0] + ( Ref.vieworg[1] - origin[1] ) * Ref.forward[1] + ( Ref.vieworg[2] - origin[2] ) * Ref.forward[2] );
return (( vpnDist + radius ) / fog->shader->fog_dist ) < -1;
return (( vpnDist + radius ) / fog->shader->fogDist ) < -1;
}
return false;
}
@ -346,7 +346,7 @@ static bool R_PushSprite( const meshbuffer_t *mb, float rotation, float right, f
vec3_t point;
vec3_t v_right, v_up;
ref_entity_t *e = Ref.m_pCurrentEntity;
shader_t *shader;
ref_shader_t *shader;
if( rotation )
{
@ -373,7 +373,7 @@ static bool R_PushSprite( const meshbuffer_t *mb, float rotation, float right, f
VectorScale( spr_points[i], e->scale, spr_points[i] );
}
R_SHADER_FOR_KEY( mb->shaderKey, shader );
Shader_ForKey( mb->shaderKey, shader );
// the code below is disgusting, but some q3a shaders use 'rgbgen vertex'
// and 'alphagen vertex' for effects instead of 'rgbgen entity' and 'alphagen entity'
@ -412,7 +412,7 @@ static void R_PushFlareSurf( const meshbuffer_t *mb )
float up = radius, down = -radius, left = -radius, right = radius;
mbrushmodel_t *bmodel = ( mbrushmodel_t * )Ref.m_pCurrentModel->extradata;
msurface_t *surf = &bmodel->surfaces[mb->infoKey - 1];
shader_t *shader;
ref_shader_t *shader;
if( Ref.m_pCurrentModel != r_worldModel )
{
@ -450,7 +450,7 @@ static void R_PushFlareSurf( const meshbuffer_t *mb )
for( i = 0; i < 4; i++ )
Vector4Copy( color, spr_color[i] );
R_SHADER_FOR_KEY( mb->shaderKey, shader );
Shader_ForKey( mb->shaderKey, shader );
R_PushMesh( &spr_mesh, MF_NOCULL|MF_TRIFAN|shader->features );
}
@ -471,7 +471,7 @@ static void R_PushCorona( const meshbuffer_t *mb )
float down = -radius;
float left = -radius;
float right = radius;
shader_t *shader;
ref_shader_t *shader;
VectorCopy( light->origin, origin );
@ -491,7 +491,7 @@ static void R_PushCorona( const meshbuffer_t *mb )
for( i = 0; i < 4; i++ )
Vector4Copy( color, spr_color[i] );
R_SHADER_FOR_KEY( mb->shaderKey, shader );
Shader_ForKey( mb->shaderKey, shader );
R_PushMesh( &spr_mesh, MF_NOCULL|MF_TRIFAN|shader->features );
}
@ -821,7 +821,7 @@ static float R_SetFarClip( void )
if( r_worldBrushModel->globalfog )
{
float fogdist = r_worldBrushModel->globalfog->shader->fog_dist;
float fogdist = r_worldBrushModel->globalfog->shader->fogDist;
if( farDist > fogdist ) farDist = fogdist;
else Ref.clipFlags &= ~16;
}
@ -1798,7 +1798,7 @@ void R_RenderScene( refdef_t *fd )
if( r_worldModel && !( Ref.refdef.rdflags & RDF_NOWORLDMODEL ) && r_worldBrushModel->globalfog )
{
Ref.farClip = r_worldBrushModel->globalfog->shader->fog_dist;
Ref.farClip = r_worldBrushModel->globalfog->shader->fogDist;
Ref.farClip = max( r_farclip_min, Ref.farClip ) + r_farclip_bias;
Ref.clipFlags |= 16;
}

49
render/r_mesh.c
View File

@ -191,7 +191,7 @@ Calculate sortkey and store info used for batching and sorting.
All 3D-geometry passes this function.
=================
*/
meshbuffer_t *R_AddMeshToList( int type, mfog_t *fog, shader_t *shader, int infokey )
meshbuffer_t *R_AddMeshToList( int type, mfog_t *fog, ref_shader_t *shader, int infokey )
{
meshlist_t *list;
meshbuffer_t *meshbuf;
@ -244,7 +244,7 @@ meshbuffer_t *R_AddMeshToList( int type, mfog_t *fog, shader_t *shader, int info
R_AddMeshToList
=================
*/
void R_AddModelMeshToList( mfog_t *fog, shader_t *shader, int meshnum )
void R_AddModelMeshToList( mfog_t *fog, ref_shader_t *shader, int meshnum )
{
meshbuffer_t *mb;
@ -263,7 +263,7 @@ static void R_BatchMeshBuffer( const meshbuffer_t *mb, const meshbuffer_t *nextm
int type, features;
bool nonMergable;
ref_entity_t *ent;
shader_t *shader;
ref_shader_t *shader;
msurface_t *surf, *nextSurf;
R_EDICT_FOR_KEY( mb->sortKey, ent );
@ -284,11 +284,12 @@ static void R_BatchMeshBuffer( const meshbuffer_t *mb, const meshbuffer_t *nextm
{
case mod_world:
case mod_brush:
R_SHADER_FOR_KEY( mb->shaderKey, shader );
Shader_ForKey( mb->shaderKey, shader );
if( shader->flags & SHADER_SKY )
{ // draw sky
if( !( Ref.params & RP_NOSKY ) )
if( shader->flags & SHADER_SKYPARMS )
{
// draw sky
if( !( Ref.params & RP_NOSKY ))
R_DrawSky( shader );
return;
}
@ -400,7 +401,7 @@ void R_DrawPortals( void )
{
int i, trynum, num_meshes, total_meshes;
meshbuffer_t *mb;
shader_t *shader;
ref_shader_t *shader;
if( r_viewCluster == -1 )
return;
@ -434,13 +435,13 @@ void R_DrawPortals( void )
for( i = 0; i < total_meshes && num_meshes; i++, mb++ )
{
R_SHADER_FOR_KEY( mb->shaderKey, shader );
Shader_ForKey( mb->shaderKey, shader );
if( shader->flags & SHADER_PORTAL )
{
num_meshes--;
if( r_fastsky->integer && !( shader->flags & (SHADER_PORTAL_CAPTURE|SHADER_PORTAL_CAPTURE2)))
if( r_fastsky->integer && !( shader->flags & (SHADER_REFLECTION|SHADER_REFRACTION)))
continue;
if( !R_AddPortalSurface( mb ))
@ -463,9 +464,9 @@ void R_DrawPortals( void )
{
for( i = 0, mb = Ref.meshlist->meshbuffer_opaque; i < Ref.meshlist->num_opaque_meshes; i++, mb++ )
{
R_SHADER_FOR_KEY( mb->shaderKey, shader );
Shader_ForKey( mb->shaderKey, shader );
if( shader->flags & SHADER_SKY )
if( shader->flags & SHADER_SKYPARMS )
{
R_DrawSky( shader );
Ref.params |= RP_NOSKY;
@ -639,7 +640,7 @@ R_AddPortalSurface
*/
static ref_entity_t *r_portal_ent;
static cplane_t r_portal_plane, r_original_portal_plane;
static shader_t *r_portal_shader;
static ref_shader_t *r_portal_shader;
static vec3_t r_portal_mins, r_portal_maxs, r_portal_centre;
static bool R_AddPortalSurface( const meshbuffer_t *mb )
@ -647,7 +648,7 @@ static bool R_AddPortalSurface( const meshbuffer_t *mb )
int i;
float dist;
ref_entity_t *ent;
shader_t *shader;
ref_shader_t *shader;
msurface_t *surf;
cplane_t plane, oplane;
rb_mesh_t *mesh;
@ -670,7 +671,7 @@ static bool R_AddPortalSurface( const meshbuffer_t *mb )
if( !surf || !( mesh = surf->mesh ) || !mesh->points )
return false;
R_SHADER_FOR_KEY( mb->shaderKey, shader );
Shader_ForKey( mb->shaderKey, shader );
VectorCopy( mesh->points[mesh->indexes[0]], v[0] );
VectorCopy( mesh->points[mesh->indexes[1]], v[1] );
@ -696,7 +697,7 @@ static bool R_AddPortalSurface( const meshbuffer_t *mb )
if(( dist = PlaneDiff( Ref.vieworg, &plane )) <= BACKFACE_EPSILON )
{
if(!( shader->flags & SHADER_PORTAL_CAPTURE2 ))
if(!( shader->flags & SHADER_REFRACTION ))
return true;
}
@ -704,9 +705,9 @@ static bool R_AddPortalSurface( const meshbuffer_t *mb )
// by an alphagen portal stage
for( i = 0; i < shader->numStages; i++ )
{
if( shader->stages[i]->alphaGen.type == ALPHAGEN_PORTAL )
if( shader->stages[i]->alphaGen.type == ALPHAGEN_ONEMINUSFADE )
{
if( dist > ( 1.0 / shader->stages[i]->alphaGen.params[0] ))
if( dist > ( 1.0f / shader->stages[i]->alphaGen.params[0] ))
return true; // completely alpha'ed out
}
}
@ -781,7 +782,7 @@ static bool R_DrawPortalSurface( void )
vec3_t origin, angles;
ref_entity_t *ent;
cplane_t *portal_plane = &r_portal_plane, *original_plane = &r_original_portal_plane;
shader_t *shader = r_portal_shader;
ref_shader_t *shader = r_portal_shader;
bool mirror, refraction = false;
texture_t **captureTexture;
int captureTextureID;
@ -790,7 +791,7 @@ static bool R_DrawPortalSurface( void )
if( !r_portal_shader ) return false;
doReflection = doRefraction = true;
if( shader->flags & SHADER_PORTAL_CAPTURE )
if( shader->flags & SHADER_REFLECTION )
{
shaderStage_t *stage;
@ -821,7 +822,7 @@ static bool R_DrawPortalSurface( void )
if(( dist = PlaneDiff( Ref.vieworg, portal_plane )) <= BACKFACE_EPSILON || !doReflection )
{
if(!( shader->flags & SHADER_PORTAL_CAPTURE2 ) || !doRefraction )
if(!( shader->flags & SHADER_REFRACTION ) || !doRefraction )
return false;
// even if we're behind the portal, we still need to capture
@ -1002,10 +1003,10 @@ setup_and_render:
GL_SelectTexture( GL_TEXTURE0 );
GL_BindTexture( *captureTexture );
pglCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, Ref.refdef.rect.x, Ref.refdef.rect.y, (*captureTexture)->width, (*captureTexture)->height );
Ref.params |= ( refraction ? RP_PORTALCAPTURED2 : RP_PORTALCAPTURED );
Ref.params |= ( refraction ? RP_REFRACTED : RP_REFLECTED );
}
if( doRefraction && !refraction && ( shader->flags & SHADER_PORTAL_CAPTURE2 ))
if( doRefraction && !refraction && ( shader->flags & RP_REFRACTED ))
{
refraction = true;
captureTexture = &r_portaltexture2;
@ -1035,7 +1036,7 @@ void R_DrawSkyPortal( skyportal_t *skyportal, vec3_t mins, vec3_t maxs )
Mem_Copy( &saveRef, &oldRef, sizeof( ref_state_t ));
Mem_Copy( &oldRef, &Ref, sizeof( ref_state_t ));
Ref.params = ( Ref.params | RP_SKYPORTALVIEW ) & ~(RP_OLDVIEWCLUSTER|RP_PORTALCAPTURED|RP_PORTALCAPTURED2);
Ref.params = ( Ref.params | RP_SKYPORTALVIEW ) & ~(RP_OLDVIEWCLUSTER|RP_REFLECTED|RP_REFRACTED);
VectorCopy( skyportal->vieworg, Ref.pvsOrigin );
Ref.clipFlags = 15;

16
render/r_model.c
View File

@ -12,10 +12,10 @@
typedef struct
{
string name;
int flags;
int shaderType;
shader_t *shader;
string name;
int flags;
int shaderType;
ref_shader_t *shader;
} mipRef_t;
typedef struct loadmodel_s
@ -608,7 +608,7 @@ static rb_mesh_t *Mod_CreateMeshForSurface( const dsurface_t *in, msurface_t *ou
byte *buffer;
size_t bufSize;
if(( mapConfig.deluxeMappingEnabled && !(LittleLong( in->lmapNum[0] ) < 0 || in->lStyles[0] == 255) ) || ( out->shader->flags & SHADER_PORTAL_CAPTURE2 ))
if(( mapConfig.deluxeMappingEnabled && !(LittleLong( in->lmapNum[0] ) < 0 || in->lStyles[0] == 255) ) || ( out->shader->flags & SHADER_REFRACTION ))
createSTverts = true;
else createSTverts = false;
@ -904,7 +904,7 @@ static void Mod_LoadSurfaceCommon( const dsurface_t *in, msurface_t *out )
if( fognum != -1 && ( fognum < m_pLoadBmodel->numFogs ))
{
fog = m_pLoadBmodel->fogs + fognum;
if( fog->shader && fog->shader->fog_dist )
if( fog->shader && fog->shader->fogDist )
out->fog = fog;
}
@ -1368,7 +1368,7 @@ static void Mod_Finish( const lump_t *faces, vec3_t gridSize, vec3_t ambient )
{
if( globalFog && surf->mesh && surf->fog != testFog )
{
if(!( surf->shader->flags & SHADER_SKY ) && !surf->shader->fog_dist )
if(!( surf->shader->flags & SHADER_SKYPARMS ) && !surf->shader->fogDist )
globalFog = false;
}
@ -1452,7 +1452,7 @@ needs only for more smooth moving of "loading" progress bar
bool Mod_RegisterShader( const char *unused, int index )
{
mipRef_t *in;
shader_t *out;
ref_shader_t *out;
// nothing to load
//if( !r_worldBrushModel )

4
render/r_opengl.c
View File

@ -150,7 +150,7 @@ bool R_SetPixelformat( void )
savedGamma = FS_LoadFile( "config/gamma.rc", &gamma_size );
if( !savedGamma || gamma_size != sizeof( gl_state.stateRamp ))
{
// saved gamma not found or correupted file
// saved gamma not found or corrupted file
FS_WriteFile( "config/gamma.rc", gl_state.stateRamp, sizeof(gl_state.stateRamp));
Msg( "gamma.rc initialized\n" );
}
@ -200,7 +200,7 @@ bool R_SetPixelformat( void )
}
else
{
// current gamma unset by other application, we can restore it here
// current gamma broken by other application, we can restore it here
MsgDev( D_NOTE, "R_SetPixelformat: restore original gamma after crash\n" );
Mem_Copy( gl_state.stateRamp, savedGamma, sizeof( gl_state.gammaRamp ));
}

2
render/r_opengl.h
View File

@ -1060,7 +1060,7 @@ BOOL ( WINAPI * pwglSwapIntervalEXT)( int interval );
BOOL ( WINAPI * pwglGetDeviceGammaRampEXT ) ( unsigned char *pRed, unsigned char *pGreen, unsigned char *pBlue );
BOOL ( WINAPI * pwglSetDeviceGammaRampEXT ) ( const unsigned char *pRed, const unsigned char *pGreen, const unsigned char *pBlue );
// XashGL defines
#define GL_TEXTURE0 0
#define GL_TEXTURE1 1
#define GL_TEXTURE2 2

9
render/r_poly.c
View File

@ -20,10 +20,10 @@ void R_PushPoly( const meshbuffer_t *mb )
{
int i, j;
poly_t *p;
shader_t *shader;
ref_shader_t *shader;
int features;
R_SHADER_FOR_KEY( mb->shaderKey, shader );
Shader_ForKey( mb->shaderKey, shader );
features = shader->features|MF_TRIFAN;
@ -55,7 +55,7 @@ void R_AddPolysToList( void )
poly_t *p;
mfog_t *fog, *lastFog = NULL;
meshbuffer_t *mb = NULL;
shader_t *shader;
ref_shader_t *shader;
vec3_t lastNormal = { 0, 0, 0 };
Ref.m_pCurrentEntity = r_worldEntity;
@ -74,8 +74,7 @@ void R_AddPolysToList( void )
else fog = r_worldBrushModel->fogs + fognum - 1;
// we ignore SHADER_ENTITY_MERGABLE here because polys are just regular trifans
if( !mb || mb->shaderKey != (int)shader->sortKey || lastFog != fog || nverts + p->numverts > MAX_ARRAY_VERTS
|| (( shader->flags & SHADER_MATERIAL ) && !VectorCompare( p->normal, lastNormal )))
if( !mb || mb->shaderKey != (int)shader->sortKey || lastFog != fog || nverts + p->numverts > MAX_ARRAY_VERTS )
{
nverts = 0;
lastFog = fog;

249
render/r_shader.c
View File

@ -10,7 +10,6 @@
#define SHADERS_HASHSIZE 256
#define Shader_Malloc( size ) Mem_Alloc( r_shaderpool, size )
#define Shader_Free( data ) Mem_Free( data )
#define Shader_Sortkey( shader, sort ) ((( sort )<<26 )|((shader)->shaderNum))
typedef struct
{
@ -29,15 +28,15 @@ typedef struct shaderScript_s
char script[1]; // variable sized
} shaderScript_t;
static shader_t r_parseShader;
static ref_shader_t r_parseShader;
static shaderStage_t r_parseShaderStages[SHADER_MAX_STAGES];
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 ref_shader_t *r_shadersHash[SHADERS_HASHSIZE];
static texture_t *r_internalMiptex;
shader_t *r_shaders[MAX_SHADERS];
ref_shader_t *r_shaders[MAX_SHADERS];
skydome_t *r_skydomes[MAX_SHADERS];
int r_numShaders = 0;
byte *r_shaderpool;
@ -47,11 +46,11 @@ static bool r_shaderNoCompress;
static bool r_shaderHasDlightPass;
// builtin shaders
shader_t *r_defaultShader;
shader_t *r_lightmapShader;
shader_t *r_waterCausticsShader;
shader_t *r_slimeCausticsShader;
shader_t *r_lavaCausticsShader;
ref_shader_t *r_defaultShader;
ref_shader_t *r_lightmapShader;
ref_shader_t *r_waterCausticsShader;
ref_shader_t *r_slimeCausticsShader;
ref_shader_t *r_lavaCausticsShader;
shaderParm_t infoParms[] =
{
@ -109,7 +108,7 @@ SHADER PARSING
R_ParseWaveFunc
=================
*/
static bool R_ParseWaveFunc( shader_t *shader, waveFunc_t *func, char **script )
static bool R_ParseWaveFunc( ref_shader_t *shader, waveFunc_t *func, char **script )
{
char *tok;
int i;
@ -118,7 +117,7 @@ static bool R_ParseWaveFunc( shader_t *shader, waveFunc_t *func, char **script )
if( !tok[0] )
return false;
if(Com_MatchToken( "sin" )) func->type = WAVEFORM_SIN;
if(Com_MatchToken( "sin" )) func->type = WAVEFORM_SINE;
else if(Com_MatchToken( "triangle" )) func->type = WAVEFORM_TRIANGLE;
else if(Com_MatchToken( "square" )) func->type = WAVEFORM_SQUARE;
else if(Com_MatchToken( "sawtooth" )) func->type = WAVEFORM_SAWTOOTH;
@ -127,7 +126,7 @@ static bool R_ParseWaveFunc( shader_t *shader, waveFunc_t *func, char **script )
else
{
MsgDev( D_WARN, "unknown waveform '%s' in shader '%s', defaulting to sin\n", tok, shader->name );
func->type = WAVEFORM_SIN;
func->type = WAVEFORM_SINE;
}
for( i = 0; i < 4; i++ )
@ -144,7 +143,7 @@ static bool R_ParseWaveFunc( shader_t *shader, waveFunc_t *func, char **script )
R_ParseHeightToNormal
=================
*/
static bool R_ParseHeightToNormal( shader_t *shader, char *heightMap, int heightMapLen, float *bumpScale, char **script )
static bool R_ParseHeightToNormal( ref_shader_t *shader, char *heightMap, int heightMapLen, float *bumpScale, char **script )
{
char *tok;
@ -192,7 +191,7 @@ static bool R_ParseHeightToNormal( shader_t *shader, char *heightMap, int height
R_ParseGeneralSurfaceParm
=================
*/
static bool R_ParseGeneralSurfaceParm( shader_t *shader, char **script )
static bool R_ParseGeneralSurfaceParm( ref_shader_t *shader, char **script )
{
char *tok;
int i, numInfoParms = sizeof(infoParms) / sizeof(infoParms[0]);
@ -238,7 +237,7 @@ static bool R_ParseGeneralSurfaceParm( shader_t *shader, char **script )
R_ParseGeneralNoMipmaps
=================
*/
static bool R_ParseGeneralNoMipmaps( shader_t *shader, char **script )
static bool R_ParseGeneralNoMipmaps( ref_shader_t *shader, char **script )
{
r_shaderNoMipMaps = r_shaderNoPicMip = true;
return true;
@ -249,7 +248,7 @@ static bool R_ParseGeneralNoMipmaps( shader_t *shader, char **script )
R_ParseGeneralNoPicmip
=================
*/
static bool R_ParseGeneralNoPicmip( shader_t *shader, char **script )
static bool R_ParseGeneralNoPicmip( ref_shader_t *shader, char **script )
{
r_shaderNoPicMip = true;
return true;
@ -260,7 +259,7 @@ static bool R_ParseGeneralNoPicmip( shader_t *shader, char **script )
R_ParseGeneralNoCompress
=================
*/
static bool R_ParseGeneralNoCompress( shader_t *shader, char **script )
static bool R_ParseGeneralNoCompress( ref_shader_t *shader, char **script )
{
r_shaderNoCompress = true;
return true;
@ -271,7 +270,7 @@ static bool R_ParseGeneralNoCompress( shader_t *shader, char **script )
R_ParseGeneralEntityMergable
=================
*/
static bool R_ParseGeneralEntityMergable( shader_t *shader, char **script )
static bool R_ParseGeneralEntityMergable( ref_shader_t *shader, char **script )
{
shader->flags |= SHADER_ENTITYMERGABLE;
return true;
@ -282,7 +281,7 @@ static bool R_ParseGeneralEntityMergable( shader_t *shader, char **script )
R_ParseGeneralPolygonOffset
=================
*/
static bool R_ParseGeneralPolygonOffset( shader_t *shader, char **script )
static bool R_ParseGeneralPolygonOffset( ref_shader_t *shader, char **script )
{
shader->flags |= SHADER_POLYGONOFFSET;
return true;
@ -293,7 +292,7 @@ static bool R_ParseGeneralPolygonOffset( shader_t *shader, char **script )
R_ParseGeneralCull
=================
*/
static bool R_ParseGeneralCull( shader_t *shader, char **script )
static bool R_ParseGeneralCull( ref_shader_t *shader, char **script )
{
char *tok;
@ -321,7 +320,7 @@ static bool R_ParseGeneralCull( shader_t *shader, char **script )
R_ParseGeneralSort
=================
*/
static bool R_ParseGeneralSort( shader_t *shader, char **script )
static bool R_ParseGeneralSort( ref_shader_t *shader, char **script )
{
char *tok;
@ -360,13 +359,13 @@ static bool R_ParseGeneralSort( shader_t *shader, char **script )
R_ParseGeneralSkyParms
=================
*/
static bool R_ParseGeneralSkyParms( shader_t *shader, char **script )
static bool R_ParseGeneralSkyParms( ref_shader_t *shader, char **script )
{
string name;
char *tok;
int i;
if( shader->shaderType != SHADER_SKY )
if( shader->shaderType != SHADER_SKYDOME )
{
MsgDev( D_WARN, "'skyParms' not allowed in shader '%s'\n", shader->name );
return false;
@ -444,18 +443,18 @@ static bool R_ParseGeneralSkyParms( shader_t *shader, char **script )
R_ParseGeneralDeformVertexes
=================
*/
static bool R_ParseGeneralDeformVertexes( shader_t *shader, char **script )
static bool R_ParseGeneralDeformVertexes( ref_shader_t *shader, char **script )
{
deformVerts_t *deformVertexes;
char *tok;
int i;
if( shader->deformVertexesNum == SHADER_MAX_DEFORMVERTEXES )
if( shader->deformVertsNum == SHADER_MAX_DEFORMVERTS )
{
MsgDev( D_WARN, "SHADER_MAX_DEFORMVERTEXES hit in shader '%s'\n", shader->name );
MsgDev( D_WARN, "SHADER_MAX_DEFORMVERTS hit in shader '%s'\n", shader->name );
return false;
}
deformVertexes = &shader->deformVertexes[shader->deformVertexesNum++];
deformVertexes = &shader->deformVerts[shader->deformVertsNum++];
tok = Com_ParseToken( script, false );
if( !tok[0] )
@ -537,7 +536,7 @@ static bool R_ParseGeneralDeformVertexes( shader_t *shader, char **script )
R_ParseStageRequires
=================
*/
static bool R_ParseStageRequires( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageRequires( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
MsgDev( D_WARN, "'requires' is not the first command in the stage in shader '%s'\n", shader->name );
return false;
@ -548,10 +547,10 @@ static bool R_ParseStageRequires( shader_t *shader, shaderStage_t *stage, char *
R_ParseStageNoMipmaps
=================
*/
static bool R_ParseStageNoMipmaps( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageNoMipmaps( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
bundle->flags |= (STAGEBUNDLE_NOMIPMAPS|STAGEBUNDLE_NOPICMIP);
bundle->texFlags |= (TF_NOMIPMAP|TF_NOPICMIP);
return true;
}
@ -560,10 +559,10 @@ static bool R_ParseStageNoMipmaps( shader_t *shader, shaderStage_t *stage, char
R_ParseStageNoPicmip
=================
*/
static bool R_ParseStageNoPicmip( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageNoPicmip( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
bundle->flags |= STAGEBUNDLE_NOPICMIP;
bundle->flags |= TF_NOPICMIP;
return true;
}
@ -572,10 +571,10 @@ static bool R_ParseStageNoPicmip( shader_t *shader, shaderStage_t *stage, char *
R_ParseStageNoCompress
=================
*/
static bool R_ParseStageNoCompress( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageNoCompress( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
bundle->flags |= STAGEBUNDLE_NOCOMPRESS;
bundle->texFlags &= ~TF_COMPRESS;
return true;
}
@ -584,10 +583,10 @@ static bool R_ParseStageNoCompress( shader_t *shader, shaderStage_t *stage, char
R_ParseStageClampTexCoords
=================
*/
static bool R_ParseStageClampTexCoords( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageClampTexCoords( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
bundle->flags |= STAGEBUNDLE_CLAMPTEXCOORDS;
bundle->texFlags |= TF_CLAMP;
return true;
}
@ -596,7 +595,7 @@ static bool R_ParseStageClampTexCoords( shader_t *shader, shaderStage_t *stage,
R_ParseStageAnimFrequency
=================
*/
static bool R_ParseStageAnimFrequency( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageAnimFrequency( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
char *tok;
@ -619,10 +618,9 @@ static bool R_ParseStageAnimFrequency( shader_t *shader, shaderStage_t *stage, c
R_ParseStageMap
=================
*/
static bool R_ParseStageMap( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageMap( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
unsigned flags = 0;
char *tok;
if( bundle->numTextures )
@ -699,12 +697,12 @@ static bool R_ParseStageMap( shader_t *shader, shaderStage_t *stage, char **scri
return false;
}
bundle->texType = TEX_PORTAL;
bundle->texType = TEX_RENDERVIEW;
bundle->tcGen.type = TCGEN_PROJECTION;
bundle->flags |= STAGEBUNDLE_MAP;
if(( shader->flags & SHADER_PORTAL ) && ( shader->sort == SORT_PORTAL ))
shader->sort = 0; // reset sorting so we can figure it out later. FIXME?
shader->flags |= SHADER_PORTAL|( r_portalmaps->integer ? SHADER_PORTAL_CAPTURE : 0 );
shader->flags |= SHADER_PORTAL|( r_portalmaps->integer ? RP_REFLECTED : 0 );
return true;
}
if( Com_MatchToken( "$white" )) bundle->textures[bundle->numTextures++] = r_whiteTexture;
@ -712,17 +710,12 @@ static bool R_ParseStageMap( shader_t *shader, shaderStage_t *stage, char **scri
else if( Com_MatchToken( "$internal")) bundle->textures[bundle->numTextures++] = r_internalMiptex;
else
{
if( r_shaderNoMipMaps || bundle->flags & STAGEBUNDLE_NOMIPMAPS )
flags |= TF_NOMIPMAP;
if( r_shaderNoPicMip || bundle->flags & STAGEBUNDLE_NOPICMIP )
flags |= TF_NOPICMIP;
if( !r_shaderNoCompress && !(bundle->flags & STAGEBUNDLE_NOCOMPRESS))
flags |= TF_COMPRESS;
// apply global shader texflags
if( r_shaderNoMipMaps ) bundle->texFlags |= TF_NOMIPMAP;
if( r_shaderNoPicMip ) bundle->texFlags |= TF_NOPICMIP;
if( !r_shaderNoCompress ) bundle->texFlags |= TF_COMPRESS;
if( bundle->flags & STAGEBUNDLE_CLAMPTEXCOORDS )
flags |= TF_CLAMP;
bundle->textures[bundle->numTextures] = R_FindTexture( tok, NULL, 0, flags, 0 );
bundle->textures[bundle->numTextures] = R_FindTexture( tok, NULL, 0, bundle->texFlags, 0 );
if( !bundle->textures[bundle->numTextures])
{
MsgDev( D_WARN, "couldn't find texture '%s' in shader '%s'\n", tok, shader->name );
@ -741,10 +734,9 @@ static bool R_ParseStageMap( shader_t *shader, shaderStage_t *stage, char **scri
R_ParseStageBumpMap
=================
*/
static bool R_ParseStageBumpMap( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageBumpMap( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
uint flags = TF_NORMALMAP;
char heightMap[MAX_QPATH];
float bumpScale;
char *tok;
@ -781,22 +773,18 @@ static bool R_ParseStageBumpMap( shader_t *shader, shaderStage_t *stage, char **
return false;
}
if( r_shaderNoMipMaps || bundle->flags & STAGEBUNDLE_NOMIPMAPS )
flags |= TF_NOMIPMAP;
if( r_shaderNoPicMip || bundle->flags & STAGEBUNDLE_NOPICMIP )
flags |= TF_NOPICMIP;
if( !r_shaderNoCompress && !( bundle->flags & STAGEBUNDLE_NOCOMPRESS ))
flags |= TF_COMPRESS;
if(bundle->flags & STAGEBUNDLE_CLAMPTEXCOORDS)
flags |= TF_CLAMP;
// apply texflags
bundle->texFlags |= TF_NORMALMAP;
if( r_shaderNoMipMaps ) bundle->texFlags |= TF_NOMIPMAP;
if( r_shaderNoPicMip ) bundle->texFlags |= TF_NOPICMIP;
if( !r_shaderNoCompress ) bundle->texFlags |= TF_COMPRESS;
if(Com_MatchToken( "heightToNormal"))
{
if(!R_ParseHeightToNormal( shader, heightMap, sizeof(heightMap), &bumpScale, script ))
return false;
bundle->textures[bundle->numTextures] = R_FindTexture(heightMap, NULL, 0, flags|TF_HEIGHTMAP, bumpScale );
bundle->textures[bundle->numTextures] = R_FindTexture(heightMap, NULL, 0, bundle->texFlags|TF_HEIGHTMAP, bumpScale );
if( !bundle->textures[bundle->numTextures] )
{
MsgDev( D_WARN, "couldn't find texture '%s' in shader '%s'\n", heightMap, shader->name );
@ -806,7 +794,7 @@ static bool R_ParseStageBumpMap( shader_t *shader, shaderStage_t *stage, char **
}
else
{
bundle->textures[bundle->numTextures] = R_FindTexture( tok, NULL, 0, flags, 0 );
bundle->textures[bundle->numTextures] = R_FindTexture( tok, NULL, 0, bundle->texFlags, 0 );
if( !bundle->textures[bundle->numTextures] )
{
MsgDev( D_WARN, "couldn't find texture '%s' in shader '%s'\n", tok, shader->name );
@ -825,11 +813,10 @@ static bool R_ParseStageBumpMap( shader_t *shader, shaderStage_t *stage, char **
R_ParseStageCubeMap
=================
*/
static bool R_ParseStageCubeMap( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageCubeMap( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
unsigned flags = TF_CLAMP | TF_CUBEMAP;
char *tok;
char *tok;
if( !GL_Support( R_TEXTURECUBEMAP_EXT ))
{
@ -881,17 +868,13 @@ static bool R_ParseStageCubeMap( shader_t *shader, shaderStage_t *stage, char **
}
else
{
if( r_shaderNoMipMaps || bundle->flags & STAGEBUNDLE_NOMIPMAPS )
flags |= TF_NOMIPMAP;
if( r_shaderNoPicMip || bundle->flags & STAGEBUNDLE_NOPICMIP )
flags |= TF_NOPICMIP;
if( !r_shaderNoCompress && !(bundle->flags & STAGEBUNDLE_NOCOMPRESS))
flags |= TF_COMPRESS;
// apply texFlags
bundle->texFlags |= TF_CLAMP|TF_CUBEMAP;
if( r_shaderNoMipMaps ) bundle->texFlags |= TF_NOMIPMAP;
if( r_shaderNoPicMip ) bundle->texFlags |= TF_NOPICMIP;
if( !r_shaderNoCompress ) bundle->texFlags |= TF_COMPRESS;
if(bundle->flags & STAGEBUNDLE_CLAMPTEXCOORDS)
flags |= TF_CLAMP;
bundle->textures[bundle->numTextures] = R_FindCubeMapTexture( tok, flags, 0 );
bundle->textures[bundle->numTextures] = R_FindCubeMapTexture( tok, bundle->texFlags, 0 );
if( !bundle->textures[bundle->numTextures] )
{
MsgDev( D_WARN, "couldn't find texture '%s' in shader '%s'\n", tok, shader->name );
@ -910,7 +893,7 @@ static bool R_ParseStageCubeMap( shader_t *shader, shaderStage_t *stage, char **
R_ParseStageVideoMap
=================
*/
static bool R_ParseStageVideoMap( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageVideoMap( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
char *tok;
@ -952,7 +935,7 @@ static bool R_ParseStageVideoMap( shader_t *shader, shaderStage_t *stage, char *
R_ParseStageTexEnvCombine
=================
*/
static bool R_ParseStageTexEnvCombine( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageTexEnvCombine( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
int numArgs;
@ -1488,7 +1471,7 @@ static bool R_ParseStageTexEnvCombine( shader_t *shader, shaderStage_t *stage, c
R_ParseStageTcGen
=================
*/
static bool R_ParseStageTcGen( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageTcGen( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
char *tok;
@ -1573,7 +1556,7 @@ static bool R_ParseStageTcGen( shader_t *shader, shaderStage_t *stage, char **sc
R_ParseStageTcMod
=================
*/
static bool R_ParseStageTcMod( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageTcMod( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle = stage->bundles[stage->numBundles - 1];
tcMod_t *tcMod;
@ -1658,7 +1641,7 @@ static bool R_ParseStageTcMod( shader_t *shader, shaderStage_t *stage, char **sc
}
else if (Com_MatchToken( "turb" ))
{
tcMod->func.type = WAVEFORM_SIN;
tcMod->func.type = WAVEFORM_SINE;
for( i = 0; i < 4; i++ )
{
@ -1701,7 +1684,7 @@ static bool R_ParseStageTcMod( shader_t *shader, shaderStage_t *stage, char **sc
R_ParseStageNextBundle
=================
*/
static bool R_ParseStageNextBundle( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageNextBundle( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
stageBundle_t *bundle;
char *tok;
@ -1846,7 +1829,7 @@ static bool R_ParseStageNextBundle( shader_t *shader, shaderStage_t *stage, char
R_ParseStageAlphaFunc
=================
*/
static bool R_ParseStageAlphaFunc( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageAlphaFunc( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
char *tok;
@ -1920,7 +1903,7 @@ static bool R_ParseStageAlphaFunc( shader_t *shader, shaderStage_t *stage, char
R_ParseStageBlendFunc
=================
*/
static bool R_ParseStageBlendFunc( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageBlendFunc( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
char *tok;
@ -2017,7 +2000,7 @@ static bool R_ParseStageBlendFunc( shader_t *shader, shaderStage_t *stage, char
R_ParseStageDepthFunc
=================
*/
static bool R_ParseStageDepthFunc( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageDepthFunc( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
char *tok;
@ -2053,7 +2036,7 @@ static bool R_ParseStageDepthFunc( shader_t *shader, shaderStage_t *stage, char
R_ParseStageDepthWrite
=================
*/
static bool R_ParseStageDepthWrite( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageDepthWrite( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
if( stage->flags & SHADERSTAGE_NEXTBUNDLE )
{
@ -2069,7 +2052,7 @@ static bool R_ParseStageDepthWrite( shader_t *shader, shaderStage_t *stage, char
R_ParseStageDetail
=================
*/
static bool R_ParseStageDetail( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageDetail( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
if( stage->flags & SHADERSTAGE_NEXTBUNDLE )
{
@ -2086,7 +2069,7 @@ static bool R_ParseStageDetail( shader_t *shader, shaderStage_t *stage, char **s
R_ParseStageRgbGen
=================
*/
static bool R_ParseStageRgbGen( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageRgbGen( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
char *tok;
int i;
@ -2158,7 +2141,7 @@ static bool R_ParseStageRgbGen( shader_t *shader, shaderStage_t *stage, char **s
R_ParseStageAlphaGen
=================
*/
static bool R_ParseStageAlphaGen( shader_t *shader, shaderStage_t *stage, char **script )
static bool R_ParseStageAlphaGen( ref_shader_t *shader, shaderStage_t *stage, char **script )
{
char *tok;
@ -2331,13 +2314,13 @@ static bool R_ParseStageAlphaGen( shader_t *shader, shaderStage_t *stage, char *
typedef struct
{
const char *name;
bool (*parseFunc)( shader_t *shader, char **script );
bool (*parseFunc)( ref_shader_t *shader, char **script );
} shaderGeneralCmd_t;
typedef struct
{
const char *name;
bool (*parseFunc)( shader_t *shader, shaderStage_t *stage, char **script );
bool (*parseFunc)( ref_shader_t *shader, shaderStage_t *stage, char **script );
} shaderStageCmd_t;
static shaderGeneralCmd_t r_shaderGeneralCmds[] =
@ -2386,7 +2369,7 @@ static shaderStageCmd_t r_shaderStageCmds[] =
R_ParseShaderCommand
=================
*/
static bool R_ParseShaderCommand( shader_t *shader, char **script, char *command )
static bool R_ParseShaderCommand( ref_shader_t *shader, char **script, char *command )
{
shaderGeneralCmd_t *cmd;
@ -2407,7 +2390,7 @@ static bool R_ParseShaderCommand( shader_t *shader, char **script, char *command
R_ParseShaderStageCommand
=================
*/
static bool R_ParseShaderStageCommand( shader_t *shader, shaderStage_t *stage, char **script, char *command )
static bool R_ParseShaderStageCommand( ref_shader_t *shader, shaderStage_t *stage, char **script, char *command )
{
shaderStageCmd_t *cmd;
@ -2425,7 +2408,7 @@ static bool R_ParseShaderStageCommand( shader_t *shader, shaderStage_t *stage, c
R_EvaluateRequires
=================
*/
static bool R_EvaluateRequires( shader_t *shader, char **script )
static bool R_EvaluateRequires( ref_shader_t *shader, char **script )
{
bool results[SHADER_MAX_EXPRESSIONS];
bool logicAnd = false, logicOr = false;
@ -2595,7 +2578,7 @@ static bool R_EvaluateRequires( shader_t *shader, char **script )
R_SkipShaderStage
=================
*/
static bool R_SkipShaderStage( shader_t *shader, char **script )
static bool R_SkipShaderStage( ref_shader_t *shader, char **script )
{
char *tok;
@ -2624,7 +2607,7 @@ static bool R_SkipShaderStage( shader_t *shader, char **script )
R_ParseShader
=================
*/
static bool R_ParseShader( shader_t *shader, char *script )
static bool R_ParseShader( ref_shader_t *shader, char *script )
{
shaderStage_t *stage;
char *tok;
@ -2790,13 +2773,13 @@ static void R_ParseShaderFile( char *buffer, int size )
R_NewShader
=================
*/
static shader_t *R_NewShader( void )
static ref_shader_t *R_NewShader( void )
{
shader_t *shader;
ref_shader_t *shader;
int i, j;
shader = &r_parseShader;
memset( shader, 0, sizeof( shader_t ));
memset( shader, 0, sizeof( ref_shader_t ));
for( i = 0; i < SHADER_MAX_STAGES; i++ )
{
@ -2817,9 +2800,9 @@ static shader_t *R_NewShader( void )
R_CreateShader
=================
*/
static shader_t *R_CreateShader( const char *name, shaderType_t shaderType, uint surfaceParm, char *script )
static ref_shader_t *R_CreateShader( const char *name, shaderType_t shaderType, uint surfaceParm, char *script )
{
shader_t *shader;
ref_shader_t *shader;
shaderStage_t *stage;
stageBundle_t *bundle;
int i, j;
@ -2885,9 +2868,9 @@ static shader_t *R_CreateShader( const char *name, shaderType_t shaderType, uint
R_CreateDefaultShader
=================
*/
static shader_t *R_CreateDefaultShader( const char *name, shaderType_t shaderType, uint surfaceParm )
static ref_shader_t *R_CreateDefaultShader( const char *name, shaderType_t shaderType, uint surfaceParm )
{
shader_t *shader;
ref_shader_t *shader;
const byte *buffer = NULL; // default image buffer
size_t bufsize = 0;
int i;
@ -2903,7 +2886,7 @@ static shader_t *R_CreateDefaultShader( const char *name, shaderType_t shaderTyp
switch( shader->shaderType )
{
case SHADER_SKY:
case SHADER_SKYDOME:
shader->flags |= SHADER_SKYPARMS;
for( i = 0; i < 6; i++ )
@ -3071,7 +3054,7 @@ static shader_t *R_CreateDefaultShader( const char *name, shaderType_t shaderTyp
R_FinishShader
=================
*/
static void R_FinishShader( shader_t *shader )
static void R_FinishShader( ref_shader_t *shader )
{
shaderStage_t *stage;
stageBundle_t *bundle;
@ -3106,7 +3089,7 @@ static void R_FinishShader( shader_t *shader )
}
// make sure sky shaders have a cloudHeight value
if( shader->shaderType == SHADER_SKY )
if( shader->shaderType == SHADER_SKYDOME )
{
if(!(shader->flags & SHADER_SKYPARMS))
{
@ -3121,9 +3104,9 @@ static void R_FinishShader( shader_t *shader )
if( shader->flags & SHADER_DEFORMVERTEXES )
{
shader->flags &= ~SHADER_DEFORMVERTEXES;
for( i = 0; i < shader->deformVertexesNum; i++ )
memset( &shader->deformVertexes[i], 0, sizeof( deformVerts_t ));
shader->deformVertexesNum = 0;
for( i = 0; i < shader->deformVertsNum; i++ )
Mem_Set( &shader->deformVerts[i], 0, sizeof( deformVerts_t ));
shader->deformVertsNum = 0;
}
}
@ -3213,7 +3196,7 @@ static void R_FinishShader( shader_t *shader )
stage->flags |= SHADERSTAGE_DEPTHWRITE;
// remove depthWrite from sky and 2D shaders
if( shader->shaderType == SHADER_SKY || shader->shaderType == SHADER_NOMIP )
if( shader->shaderType == SHADER_SKYDOME || shader->shaderType == SHADER_NOMIP )
stage->flags &= ~SHADERSTAGE_DEPTHWRITE;
// ignore detail stages if detail textures are disabled
@ -3228,7 +3211,7 @@ static void R_FinishShader( shader_t *shader )
{
switch( shader->shaderType )
{
case SHADER_SKY:
case SHADER_SKYDOME:
stage->rgbGen.type = RGBGEN_IDENTITY;
break;
case SHADER_SURFACE:
@ -3260,7 +3243,7 @@ static void R_FinishShader( shader_t *shader )
{
switch( shader->shaderType )
{
case SHADER_SKY:
case SHADER_SKYDOME:
stage->alphaGen.type = ALPHAGEN_IDENTITY;
break;
case SHADER_SURFACE:
@ -3354,7 +3337,7 @@ static void R_FinishShader( shader_t *shader )
// set sort if unset
if( !(shader->flags & SHADER_SORT ))
{
if( shader->shaderType == SHADER_SKY )
if( shader->shaderType == SHADER_SKYDOME )
shader->sort = SORT_SKY;
else
{
@ -3436,7 +3419,7 @@ static bool R_MergeShaderStages( shaderStage_t *stage1, shaderStage_t *stage2 )
R_OptimizeShader
=================
*/
static void R_OptimizeShader( shader_t *shader )
static void R_OptimizeShader( ref_shader_t *shader )
{
shaderStage_t *curStage, *prevStage = NULL;
int i;
@ -3478,18 +3461,18 @@ static void R_OptimizeShader( shader_t *shader )
}
}
void R_DeformVertexesBBoxForShader( const shader_t *shader, vec3_t ebbox )
void R_DeformVertexesBBoxForShader( const ref_shader_t *shader, vec3_t ebbox )
{
int dv;
float dvmax;
if( !shader ) return;
for( dv = 0; dv < shader->deformVertexesNum; dv++ )
for( dv = 0; dv < shader->deformVertsNum; dv++ )
{
switch( shader->deformVertexes[dv].type )
switch( shader->deformVerts[dv].type )
{
case DEFORMVERTEXES_WAVE:
dvmax = fabs( shader->deformVertexes[dv].func.params[1] ) + shader->deformVertexes[dv].func.params[0];
dvmax = fabs( shader->deformVerts[dv].func.params[1] ) + shader->deformVerts[dv].func.params[0];
ebbox[0] = max( ebbox[0], dvmax );
ebbox[1] = ebbox[0];
ebbox[2] = ebbox[0];
@ -3505,16 +3488,16 @@ void R_DeformVertexesBBoxForShader( const shader_t *shader, vec3_t ebbox )
R_LoadShader
=================
*/
shader_t *R_LoadShader( shader_t *newShader )
ref_shader_t *R_LoadShader( ref_shader_t *newShader )
{
shader_t *shader;
ref_shader_t *shader;
uint hashKey;
int i, j;
if( r_numShaders == MAX_SHADERS )
Host_Error( "R_LoadShader: MAX_SHADERS limit exceeded\n" );
r_shaders[r_numShaders++] = shader = Shader_Malloc( sizeof( shader_t ));
r_shaders[r_numShaders++] = shader = Shader_Malloc( sizeof( ref_shader_t ));
// make sure the shader is valid and set all the unset parameters
R_FinishShader( newShader );
@ -3523,7 +3506,7 @@ shader_t *R_LoadShader( shader_t *newShader )
R_OptimizeShader( newShader );
// copy the shader
Mem_Copy( shader, newShader, sizeof( shader_t ));
Mem_Copy( shader, newShader, sizeof( ref_shader_t ));
shader->numStages = 0;
// allocate and copy the stages
@ -3560,9 +3543,9 @@ shader_t *R_LoadShader( shader_t *newShader )
R_FindShader
=================
*/
shader_t *R_FindShader( const char *name, shaderType_t shaderType, uint surfaceParm )
ref_shader_t *R_FindShader( const char *name, shaderType_t shaderType, uint surfaceParm )
{
shader_t *shader;
ref_shader_t *shader;
shaderScript_t *shaderScript;
char *script = NULL;
uint hashKey;
@ -3618,7 +3601,7 @@ void R_SetInternalMap( texture_t *mipTex )
R_RegisterShader
=================
*/
shader_t *R_RegisterShader( const char *name )
ref_shader_t *R_RegisterShader( const char *name )
{
return R_FindShader( name, SHADER_GENERIC, 0 );
}
@ -3628,7 +3611,7 @@ shader_t *R_RegisterShader( const char *name )
R_RegisterShaderSkin
=================
*/
shader_t *R_RegisterShaderSkin( const char *name )
ref_shader_t *R_RegisterShaderSkin( const char *name )
{
return R_FindShader( name, SHADER_STUDIO, 0 );
}
@ -3638,7 +3621,7 @@ shader_t *R_RegisterShaderSkin( const char *name )
R_RegisterShaderNoMip
=================
*/
shader_t *R_RegisterShaderNoMip( const char *name )
ref_shader_t *R_RegisterShaderNoMip( const char *name )
{
return R_FindShader( name, SHADER_NOMIP, 0 );
}
@ -3650,7 +3633,7 @@ R_ShaderRegisterImages
many many included cycles ...
=================
*/
void R_ShaderRegisterImages( shader_t *shader )
void R_ShaderRegisterImages( ref_shader_t *shader )
{
int i, j, k;
shaderStage_t *stage;
@ -3684,7 +3667,7 @@ R_CreateBuiltInShaders
*/
static void R_CreateBuiltInShaders( void )
{
shader_t *shader;
ref_shader_t *shader;
// default shader
shader = R_NewShader();
@ -3721,7 +3704,7 @@ R_ShaderList_f
*/
void R_ShaderList_f( void )
{
shader_t *shader;
ref_shader_t *shader;
int i, j;
int passes;
@ -3738,7 +3721,7 @@ void R_ShaderList_f( void )
switch( shader->shaderType )
{
case SHADER_SKY:
case SHADER_SKYDOME:
Msg( "sky " );
break;
case SHADER_SURFACE:
@ -3816,7 +3799,7 @@ R_ShutdownShaders
*/
void R_ShutdownShaders( void )
{
shader_t *shader;
ref_shader_t *shader;
shaderStage_t *stage;
stageBundle_t *bundle;
int i, j, k;

392
render/r_shader.h Normal file
View File

@ -0,0 +1,392 @@
//=======================================================================
// Copyright XashXT Group 2008 ©
// r_shader.h - render shader language
//=======================================================================
#ifndef R_SHADER_H
#define R_SHADER_H
#define MAX_SHADERS 1024 // can be blindly increased
#define Shader_ForKey( num, s ) ((s) = r_shaders[((num) & 0xFFF)]) // returns shader ptr
#define Shader_Sortkey( shader, sort ) ((( sort )<<26 )|((shader)->shaderNum)) // returns shader->sortKey
/*
=======================================================================
SHADERS
=======================================================================
*/
#define SHADER_MAX_EXPRESSIONS 32
#define SHADER_MAX_STAGES 8
#define SHADER_MAX_TEXTURES 16 // max animation frames (increase if need)
#define SHADER_MAX_DEFORMVERTS 8
#define SHADER_MAX_TCMOD 8
// shader types used for shader loading
typedef enum
{
SHADER_GENERIC = 0, // internal system shader
SHADER_SURFACE, // lightmapped bsp surface
SHADER_VERTEX,
SHADER_SKYDOME, // skydome or skybox shader
SHADER_STUDIO, // studio meshes
SHADER_SPRITE, // sprites
SHADER_NOMIP, // 2d images
} shaderType_t;
// shader global flags
#define SHADER_EXTERNAL (1<<0) // shader have external script
#define SHADER_LIGHTMAP (1<<1) // shaderType should be equal SHADER_SURFACE
#define SHADER_NOSHADOWS (1<<2) // ignore shadows for this surface
#define SHADER_NODLIGHTS (1<<3) // ignore dynamic lights for this surface
#define SHADER_NOMARKS (1<<4) // ignore decals for this surface
#define SHADER_ENTITYMERGABLE (1<<5) // cl.entity can change color, alpha and frame
#define SHADER_POLYGONOFFSET (1<<6) // surface using POLYGON_OFFSET_FILL
#define SHADER_CULL (1<<7) // set GL_CullFace
#define SHADER_SORT (1<<8) // sort surface in 3d-mode
#define SHADER_AMMODISPLAY (1<<9) // special case for draw ammo counters on viewmodel
#define SHADER_TESSSIZE (1<<10) // patches custom subdivision level only
#define SHADER_DEFORMVERTEXES (1<<11) // CPU realtime vertex deformation
#define SHADER_SKYPARMS (1<<12) // shaderType should be equal SHADER_SKYDOME
#define SHADER_AUTOSPRITE (1<<13) // autosprites draw both faces
#define SHADER_FLARE (1<<14) // specail case for flare shaders
#define SHADER_PORTAL (1<<15) // shader rendering portal effects (portal, screen, mirror etc)
#define SHADER_REFLECTION (1<<16) // do reflection (glsl using)
#define SHADER_REFRACTION (1<<17) // do refraction (glsl using)
// shader stage flags
#define SHADERSTAGE_NEXTBUNDLE (1<<0) // for two stages blended with GL_TEXENV_COMBINE
#define SHADERSTAGE_PROGRAM (1<<1) // stage have a glsl program
#define SHADERSTAGE_ALPHAFUNC (1<<2) // stage have glAlphaFunc
#define SHADERSTAGE_BLENDFUNC (1<<3) // stage have glBlendFunc
#define SHADERSTAGE_DEPTHFUNC (1<<4) // stage have glDepthFunc
#define SHADERSTAGE_DEPTHWRITE (1<<5) // write depth
#define SHADERSTAGE_RGBGEN (1<<6) // generate color
#define SHADERSTAGE_ALPHAGEN (1<<7) // generate alpha
#define SHADERSTAGE_DETAIL (1<<8) // currently not used
// KILLME
#define SHADERSTAGE_NOCOLORARRAY (1<<9)
#define SHADERSTAGE_DLIGHT (1<<10)
#define SHADERSTAGE_STENCILSHADOW (1<<11)
// stage bundle flags
#define STAGEBUNDLE_ANIMFREQUENCY (1<<0) // if not set and have bit ENTITYMERGABLE can switch frames manually
#define STAGEBUNDLE_TEXENVCOMBINE (1<<1) // if set bit NEXTBUNDLE blends previous and surrent frames
#define STAGEBUNDLE_TCGEN (1<<2) // generate texCoords
#define STAGEBUNDLE_TCMOD (1<<3) // rotate, move, deform texCoords
#define STAGEBUNDLE_MAP (1<<4) // "map"
#define STAGEBUNDLE_BUMPMAP (1<<5) // "bumpMap"
#define STAGEBUNDLE_CUBEMAP (1<<6) // "cubeMap"
#define STAGEBUNDLE_VIDEOMAP (1<<7) // "videoMap"
#define STAGEBUNDLE_ANGLEMAP (1<<8) // frame = ((viewangles[1] - ent->angles[1]) / 360 * 8 + 0.5 - 4) & 7;
#define STAGEBUNDLE_NORMALMAP (1<<9) // currently not used
typedef enum
{
WAVEFORM_NONE = 0, // --------
WAVEFORM_SINE,
WAVEFORM_TRIANGLE, // triangle approximation "Super Sand Castle"
WAVEFORM_SQUARE, // pure meander
WAVEFORM_SAWTOOTH,
WAVEFORM_INVERSESAWTOOTH,
WAVEFORM_NOISE,
WAVEFORM_CONSTANT
} waveForm_t;
typedef enum
{
SORT_NONE = 0,
SORT_PORTAL,
SORT_SKY,
SORT_OPAQUE,
SORT_DECAL,
SORT_ALPHATEST,
SORT_BANNER,
SORT_UNDERWATER,
SORT_WATER,
SORT_INNERBLEND,
SORT_BLEND1,
SORT_BLEND2,
SORT_BLEND3,
SORT_BLEND4,
SORT_OUTERBLEND,
SORT_ADDITIVE,
SORT_NEAREST
} sort_t;
typedef enum
{
AMMODISPLAY_DIGIT1,
AMMODISPLAY_DIGIT2,
AMMODISPLAY_DIGIT3,
AMMODISPLAY_WARNING
} ammoDisplayType_t;
typedef enum
{
DEFORMVERTEXES_NONE = 0,
DEFORMVERTEXES_WAVE, // using waveForm_t
DEFORMVERTEXES_MOVE,
DEFORMVERTEXES_BULGE,
DEFORMVERTEXES_NORMAL,
DEFORMVERTEXES_AUTOSPRITE,
DEFORMVERTEXES_AUTOSPRITE2,
DEFORMVERTEXES_AUTOPARTICLE, // used for particelShader
DEFORMVERTEXES_PROJECTION_SHADOW // currently not used
} deformVertsType_t;
typedef enum
{
TCGEN_BASE = 0, // use original texCoords as default
TCGEN_LIGHTMAP, // use lightMap texCoords (for TEX_LIGHTMAP)
TCGEN_ENVIRONMENT, // simple EnvMapping
TCGEN_FOG,
TCGEN_VECTOR, // const vector specified in shader
TCGEN_LIGHTVECTOR, // vector == LightDir
TCGEN_WARP, // q1/q2 warp surfaces (water, slime, lava)
TCGEN_HALFANGLE, // halfAngle = lightVector + eyeVector;
TCGEN_REFLECTION, // enable GL_REFLECTION_MAP_ARB
TCGEN_PROJECTION, // project view onto plane (PORTAL used)
TCGEN_NORMAL,
TCGEN_SVECTORS, // using sVectors array instead texCoordArray
TCGEN_PROJECTION_SHADOW // currently not used
} tcGenType_t;
typedef enum
{
TCMOD_NONE = 0,
TCMOD_TRANSLATE, // same as glTranslate
TCMOD_SCALE, // same as glScale
TCMOD_SCROLL,
TCMOD_ROTATE, // same as glRotate
TCMOD_STRETCH, // proporcional scaling
TCMOD_TURB, // warp tubulence
TCMOD_TRANSFORM
} tcModType_t;
typedef enum
{
RGBGEN_IDENTITY = 0, // glColor( 1.0, 1.0f, 1.0f )
RGBGEN_IDENTITYLIGHTING, // rgb = 1.0f / pow( 2.0f, max( 0, floor( r_overbrightbits )))
RGBGEN_WAVE, // using waveForm_t
RGBGEN_CONST, // RGB values from shader
RGBGEN_COLORWAVE, // normalize RGBwave with RGB values from shader
RGBGEN_VERTEX, // get color from bsp vertexes or deformVertexes
RGBGEN_EXACTVERTEX,
RGBGEN_ONEMINUSVERTEX, // 1.0 - vertexColor
RGBGEN_ENTITY, // ent->renderColor (need ENTITYMERGABLE bit)
RGBGEN_ONEMINUSENTITY, // 1.0 - ent->renderColor (need ENTITYMERGABLE bit)
RGBGEN_LIGHTINGAMBIENT, // ambient LightColor
RGBGEN_LIGHTINGDIFFUSE, // diffuse LightColor
RGBGEN_LIGHTINGDIFFUSE_ONLY, // ignore ambientColor
RGBGEN_LIGHTINGAMBIENT_ONLY, // ignore diffuseColor
RGBGEN_ENVIRONMENT, // simple EnvColorMapping
RGBGEN_FOG
} rgbGenType_t;
typedef enum
{
ALPHAGEN_IDENTITY = 0, // glAlpha( 1.0 )
ALPHAGEN_CONST, // get alpha from shader
ALPHAGEN_WAVE, // using waveForm_t
ALPHAGEN_ALPHAWAVE, // normalize alphawave with alpha value from shader
ALPHAGEN_VERTEX, // get alpha from bsp vertexes or deformVerts
ALPHAGEN_ONEMINUSVERTEX, // 1.0 - vertexAlpha
ALPHAGEN_ENTITY, // ent->renderAmt (need ENTITYMERGABLE bit)
ALPHAGEN_ONEMINUSENTITY, // 1.0 - ent->renderAmt (need ENTITYMERGABLE bit)
ALPHAGEN_SPECULAR, // p = (vieworg - ent->origin) - vertex
ALPHAGEN_DOT, // v = DotProduct( vforward, normal )
ALPHAGEN_ONEMINUSDOT, // v = 1.0 - DotProduct( vforward, normal )
ALPHAGEN_FADE, // alpha = dist( ent->origin, vieworg ) * maxDist
ALPHAGEN_ONEMINUSFADE, // alpha = (1.0 - ALPHAGEN_FADE) (another name - ALPHAGEN_PORTAL)
} alphaGenType_t;
typedef enum
{
TEX_GENERIC, // vertexArray, texCoordArray
TEX_LIGHTMAP, // vertexArray, lmCoordArray
TEX_CINEMATIC, // RoQ frame
TEX_RENDERVIEW, // scene from another point (portals, mirrors etc)
TEX_DLIGHT // currently not used
} texType_t;
typedef struct
{
waveForm_t type;
float params[4];
} waveFunc_t;
typedef struct
{
GLenum mode;
} cullFunc_t;
typedef struct
{
ammoDisplayType_t type;
int lowAmmo; // threshold before change color of digits
string shader[3]; // remap shaders
} ammoDisplay_t;
typedef struct
{
texture_t *farBox[6];
float cloudHeight;
texture_t *nearBox[6];
} skyParms_t;
typedef struct
{
deformVertsType_t type;
waveFunc_t func;
float params[3];
} deformVerts_t;
typedef struct
{
GLint rgbCombine;
GLint rgbSource[3];
GLint rgbOperand[3];
GLint rgbScale;
GLint alphaCombine;
GLint alphaSource[3];
GLint alphaOperand[3];
GLint alphaScale;
GLfloat constColor[4];
} texEnvCombine_t;
typedef struct
{
tcGenType_t type;
float params[8];
} tcGen_t;
typedef struct
{
tcModType_t type;
waveFunc_t func;
float params[6];
} tcMod_t;
typedef struct
{
GLenum func;
GLclampf ref;
} alphaFunc_t;
typedef struct
{
GLenum src;
GLenum dst;
} blendFunc_t;
typedef struct
{
GLenum func;
} depthFunc_t;
typedef struct
{
rgbGenType_t type;
waveFunc_t func;
float params[4];
} rgbGen_t;
typedef struct
{
alphaGenType_t type;
waveFunc_t func;
float params[3];
} alphaGen_t;
typedef struct
{
texType_t texType;
uint texFlags; // TF_* flags
uint flags;
texture_t *textures[SHADER_MAX_TEXTURES];
uint numTextures;
float animFrequency;
video_t cinematicHandle;
GLint texEnv;
texEnvCombine_t texEnvCombine;
tcGen_t tcGen;
tcMod_t tcMod[SHADER_MAX_TCMOD];
uint tcModNum;
} stageBundle_t;
typedef struct
{
bool ignore; // this stage ignored for some reasons (disabled, not needed etc)
uint flags;
stageBundle_t *bundles[MAX_TEXTURE_UNITS];
uint numBundles;
const char *program; // GLSL program
progType_t progType;
alphaFunc_t alphaFunc;
blendFunc_t blendFunc;
depthFunc_t depthFunc;
rgbGen_t rgbGen;
alphaGen_t alphaGen;
} shaderStage_t;
typedef struct ref_shader_s
{
string name;
int shaderNum; // shader_t handle
shaderType_t shaderType;
uint surfaceParm; // dshader->surfaceFlags
uint contentFlags; // dshader->contentFlags
uint features; // renderMesh flags
uint flags; // shader flags
cullFunc_t cull;
sort_t sort;
ammoDisplay_t ammoDisplay; // only for SHADER_STUDIO type
uint tessSize; // bsp patch subdivision level
skyParms_t skyParms; // for realtime change sky
float fogDist; // generic fog stuff
float fogClearDist;
vec4_t fogColor;
deformVerts_t deformVerts[SHADER_MAX_DEFORMVERTS];
uint deformVertsNum;
shaderStage_t *stages[SHADER_MAX_STAGES];
uint numStages;
// link stuff
uint sortKey;
struct ref_shader_s *nextHash;
} ref_shader_t;
extern ref_shader_t *r_shaders[MAX_SHADERS];
extern int r_numShaders;
// built-in shaders
extern ref_shader_t *r_defaultShader;
extern ref_shader_t *r_lightmapShader;
ref_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);
#endif//R_SHADER_H

19
render/r_sky.c
View File

@ -81,7 +81,7 @@ static void Gen_Box( skydome_t *skydome, float skyheight );
R_CreateSkydome
==============
*/
skydome_t *R_CreateSkydome( float skyheight, shader_t **farboxShaders, shader_t **nearboxShaders )
skydome_t *R_CreateSkydome( float skyheight, ref_shader_t **farboxShaders, ref_shader_t **nearboxShaders )
{
int i, size;
rb_mesh_t *mesh;
@ -93,8 +93,8 @@ skydome_t *R_CreateSkydome( float skyheight, shader_t **farboxShaders, shader_t
buffer = Mem_Alloc( r_shaderpool, size );
skydome = ( skydome_t * )buffer;
Mem_Copy( skydome->farboxShaders, farboxShaders, sizeof(shader_t *) * 6 );
Mem_Copy( skydome->nearboxShaders, nearboxShaders, sizeof(shader_t *) * 6 );
Mem_Copy( skydome->farboxShaders, farboxShaders, sizeof(ref_shader_t *) * 6 );
Mem_Copy( skydome->nearboxShaders, nearboxShaders, sizeof(ref_shader_t *) * 6 );
buffer += sizeof( skydome_t );
skydome->meshes = ( rb_mesh_t * )buffer;
@ -255,7 +255,7 @@ static void Gen_BoxSide( skydome_t *skydome, int side, vec3_t orig, vec3_t drow,
R_DrawSkySide
==============
*/
static void R_DrawSkySide( skydome_t *skydome, int side, shader_t *shader, int features )
static void R_DrawSkySide( skydome_t *skydome, int side, ref_shader_t *shader, int features )
{
meshbuffer_t *mbuffer = &r_skydome_mbuffer;
@ -276,7 +276,7 @@ static void R_DrawSkySide( skydome_t *skydome, int side, shader_t *shader, int f
R_DrawSkyBox
==============
*/
static void R_DrawSkyBox( skydome_t *skydome, shader_t **shaders )
static void R_DrawSkyBox( skydome_t *skydome, ref_shader_t **shaders )
{
int i, features;
@ -298,7 +298,7 @@ Draw dummy skybox side to prevent the HOM effect
static void R_DrawBlackBottom( skydome_t *skydome )
{
int features;
shader_t *shader;
ref_shader_t *shader;
// FIXME: register another shader instead maybe?
shader = R_OcclusionShader();
@ -306,13 +306,8 @@ static void R_DrawBlackBottom( skydome_t *skydome )
features = shader->features;
if( r_shownormals->integer ) features |= MF_NORMALS;
// HACK HACK HACK
// skies ought not to write to depth buffer
shader->flags &= ~SHADER_DEPTHWRITE;
shader->stages[0]->flags &= ~SHADERSTAGE_DEPTHWRITE;
R_DrawSkySide( skydome, 5, shader, features );
shader->stages[0]->flags |= SHADERSTAGE_DEPTHWRITE;
shader->flags |= SHADER_DEPTHWRITE;
}
/*
@ -320,7 +315,7 @@ static void R_DrawBlackBottom( skydome_t *skydome )
R_DrawSky
==============
*/
void R_DrawSky( shader_t *shader )
void R_DrawSky( ref_shader_t *shader )
{
vec3_t mins, maxs;
matrix4x4 m, oldm;

4
render/r_sprite.c
View File

@ -19,7 +19,7 @@ string frame_prefix;
byte *spr_palette;
static byte pal[256][4];
uint surfaceParm;
shader_t *frames;
ref_shader_t *frames;
/*
====================
@ -35,7 +35,7 @@ dframetype_t *R_SpriteLoadFrame( rmodel_t *mod, void *pin, mspriteframe_t **ppfr
rgbdata_t *spr_frame;
texture_t *image;
string name;
shader_t *out;
ref_shader_t *out;
pinframe = (dframe_t *)pin;

5
render/r_studio.c
View File

@ -218,7 +218,8 @@ dstudiohdr_t *R_StudioLoadHeader( rmodel_t *mod, const uint *buffer )
{
R_SetInternalMap( R_StudioLoadTexture( mod, &ptexture[i], pin ));
mod->shaders[i] = R_FindShader( ptexture[i].name, SHADER_STUDIO, surfaceParm );
ptexture[i].index = mod->numShaders++; // internal shader index, not gl_texturenum
ptexture[i].shader = mod->shaders[i]->shaderNum;
mod->numShaders++;
}
}
return (dstudiohdr_t *)buffer;
@ -1419,7 +1420,7 @@ void R_StudioDrawMeshes( dstudiotexture_t * ptexture, short *pskinref, int pass
//GL_BindTexture( Ref.m_pCurrentModel->textures[ptexture[pskinref[pmesh->skinref]].index].image );
// FIXME: test
Ref.m_pCurrentShader = Ref.m_pCurrentModel->shaders[ptexture[pskinref[pmesh->skinref]].index];
Ref.m_pCurrentShader = r_shaders[ptexture[pskinref[pmesh->skinref]].shader];
while( i = *(ptricmds++))
{

8
render/r_surface.c
View File

@ -55,9 +55,9 @@ R_CullSurface
*/
bool R_CullSurface( msurface_t *surf, uint clipflags )
{
shader_t *shader = surf->shader;
ref_shader_t *shader = surf->shader;
if(( shader->flags & SHADER_SKY ) && r_fastsky->integer )
if(( shader->flags & SHADER_SKYPARMS ) && r_fastsky->integer )
return true;
if( r_nocull->integer )
return false;
@ -124,14 +124,14 @@ R_AddSurfaceToList
*/
static meshbuffer_t *R_AddSurfaceToList( msurface_t *surf, uint clipflags )
{
shader_t *shader;
ref_shader_t *shader;
meshbuffer_t *mb;
if( R_CullSurface( surf, clipflags ))
return NULL;
shader = ((r_drawworld->integer == 2) ? R_OcclusionShader() : surf->shader);
if( shader->flags & SHADER_SKY )
if( shader->flags & SHADER_SKYPARMS )
{
bool vis = R_AddSkySurface( surf );
if( ( Ref.params & RP_NOSKY ) && vis )

3
todo.log
View File

@ -18,6 +18,9 @@ fopen
GLOBAL: Достигнуть уровня xash 0.45 к очередному релизу
операция "Имплементация рендера от q2e_068"
0. имплементация backend
операция "Отладка: bsp 48
0. отладка qbsp3
1. починить подсчет строк для Com_GetToken OK