30 Jul 2009
This commit is contained in:
parent
f21653cc9b
commit
b0e1800966
|
@ -1,16 +0,0 @@
|
|||
<html>
|
||||
<body>
|
||||
<pre>
|
||||
<h1>Build Log</h1>
|
||||
<h3>
|
||||
--------------------Configuration: engine - Win32 Debug--------------------
|
||||
</h3>
|
||||
<h3>Command Lines</h3>
|
||||
|
||||
|
||||
|
||||
<h3>Results</h3>
|
||||
engine.dll - 0 error(s), 0 warning(s)
|
||||
</pre>
|
||||
</body>
|
||||
</html>
|
|
@ -511,11 +511,12 @@ void IBSP_LoadBrushSides( lump_t *l )
|
|||
}
|
||||
}
|
||||
|
||||
void RBSP_LoadBrushSides( lump_t *l )
|
||||
static void RBSP_LoadBrushSides( lump_t *l, bool raven_bsp )
|
||||
{
|
||||
dbrushsider_t *in;
|
||||
cbrushside_t *out;
|
||||
int i, j, num,count;
|
||||
csurface_t *surf;
|
||||
int i, j, shadernum, count;
|
||||
|
||||
in = (void *)(cms.base + l->fileofs);
|
||||
if( l->filelen % sizeof( *in )) Host_Error( "BSP_LoadBrushSides: funny lump size\n" );
|
||||
|
@ -526,15 +527,29 @@ void RBSP_LoadBrushSides( lump_t *l )
|
|||
|
||||
for ( i = 0; i < count; i++, in++, out++)
|
||||
{
|
||||
num = LittleLong( in->planenum );
|
||||
out->plane = cm.planes + num;
|
||||
j = LittleLong( in->shadernum );
|
||||
j = bound( 0, j, cm.numshaders - 1 );
|
||||
out->shader = cm.shaders + j;
|
||||
out->plane = cm.planes + LittleLong( in->planenum );
|
||||
shadernum = bound( 0, LittleLong( in->shadernum ), cm.numshaders - 1 );
|
||||
out->shader = cm.shaders + shadernum;
|
||||
|
||||
if( raven_bsp )
|
||||
{
|
||||
j = LittleLong( in->surfacenum );
|
||||
j = bound( 0, j, cm.numsurfaces - 1 );
|
||||
out->surface = cm.surfaces + j;
|
||||
}
|
||||
else
|
||||
{
|
||||
for( j = 0, surf = cm.surfaces; j < cm.numsurfaces; j++, surf++ )
|
||||
{
|
||||
if( surf->shadernum == shadernum )
|
||||
{
|
||||
// HACKHACK: only name matched, not vertices
|
||||
out->surface = surf;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -1257,7 +1272,7 @@ cmodel_t *CM_BeginRegistration( const char *name, bool clientload, uint *checksu
|
|||
else Host_Error( "CM_LoadMap: %s has wrong version number (%i should be %i)\n", name, hdr->version, RFIDBSP_VERSION );
|
||||
break;
|
||||
case IDBSPMODHEADER:
|
||||
if( hdr->version == Q3IDBSP_VERSION || hdr->version == RTCWBSP_VERSION )
|
||||
if( hdr->version == Q3IDBSP_VERSION || hdr->version == RTCWBSP_VERSION || hdr->version == IGIDBSP_VERSION )
|
||||
extended = false;
|
||||
else Host_Error( "CM_LoadMap: %s has wrong version number (%i should be %i)\n", name, hdr->version, Q3IDBSP_VERSION );
|
||||
break;
|
||||
|
@ -1276,13 +1291,16 @@ cmodel_t *CM_BeginRegistration( const char *name, bool clientload, uint *checksu
|
|||
{
|
||||
RBSP_LoadVertexes( &hdr->lumps[LUMP_VERTEXES] );
|
||||
RBSP_LoadSurfaces( &hdr->lumps[LUMP_SURFACES] ); // used only for generate NewtonCollisionTree
|
||||
RBSP_LoadBrushSides( &hdr->lumps[LUMP_BRUSHSIDES] );
|
||||
RBSP_LoadBrushSides( &hdr->lumps[LUMP_BRUSHSIDES], true );
|
||||
}
|
||||
else
|
||||
{
|
||||
IBSP_LoadVertexes( &hdr->lumps[LUMP_VERTEXES] );
|
||||
IBSP_LoadSurfaces( &hdr->lumps[LUMP_SURFACES] ); // used only for generate NewtonCollisionTree
|
||||
IBSP_LoadBrushSides( &hdr->lumps[LUMP_BRUSHSIDES] );
|
||||
|
||||
if( hdr->version == IGIDBSP_VERSION )
|
||||
RBSP_LoadBrushSides( &hdr->lumps[LUMP_BRUSHSIDES], false );
|
||||
else IBSP_LoadBrushSides( &hdr->lumps[LUMP_BRUSHSIDES] );
|
||||
}
|
||||
BSP_LoadBrushes( &hdr->lumps[LUMP_BRUSHES] );
|
||||
BSP_LoadLeafBrushes( &hdr->lumps[LUMP_LEAFBRUSHES] );
|
||||
|
|
|
@ -165,6 +165,7 @@ BRUSH MODELS
|
|||
// header
|
||||
#define Q3IDBSP_VERSION 46
|
||||
#define RTCWBSP_VERSION 47
|
||||
#define IGIDBSP_VERSION 48 // extended brushides
|
||||
#define RFIDBSP_VERSION 1 // both raven bsp and qfusion bsp
|
||||
|
||||
#define IDBSPMODHEADER (('P'<<24)+('S'<<16)+('B'<<8)+'I') // little-endian "IBSP"
|
||||
|
@ -364,7 +365,12 @@ typedef struct
|
|||
{
|
||||
int planenum; // facing out of the leaf
|
||||
int shadernum; // surface description
|
||||
|
||||
union
|
||||
{
|
||||
int surfacenum;
|
||||
int surfaceflags;
|
||||
};
|
||||
} dbrushsider_t;
|
||||
|
||||
typedef struct
|
||||
|
|
|
@ -783,10 +783,8 @@ static void R_DrawAliasFrameLerp( const meshbuffer_t *mb, float backlerp )
|
|||
{
|
||||
if( ( features & MF_SVECTORS ) || r_shownormals->integer )
|
||||
features |= MF_NORMALS;
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
if( e->outlineHeight )
|
||||
features |= MF_NORMALS|(GL_Support( R_SHADER_GLSL100_EXT ) ? MF_ENABLENORMALS : 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
calcNormals = calcSTVectors = false;
|
||||
|
|
|
@ -88,12 +88,8 @@ static const mfog_t *r_texFog, *r_colorFog;
|
|||
static ref_stage_t r_dlightsPass, r_fogPass;
|
||||
static float r_lightmapPassesArgs[MAX_TEXTURE_UNITS+1][3];
|
||||
static ref_stage_t r_lightmapPasses[MAX_TEXTURE_UNITS+1];
|
||||
|
||||
static ref_stage_t r_GLSLpasses[4]; // dlights and base
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
static ref_stage_t r_GLSLpassOutline;
|
||||
#endif
|
||||
|
||||
static ref_stage_t *r_accumPasses[MAX_TEXTURE_UNITS];
|
||||
static int r_numAccumPasses;
|
||||
|
@ -170,55 +166,59 @@ void R_BackendInit( void )
|
|||
|
||||
// init dynamic lights pass
|
||||
memset( &r_dlightsPass, 0, sizeof( ref_stage_t ) );
|
||||
r_dlightsPass.flags = SHADERSTAGE_DLIGHT|GLSTATE_DEPTHFUNC_EQ|GLSTATE_SRCBLEND_DST_COLOR|GLSTATE_DSTBLEND_ONE;
|
||||
r_dlightsPass.flags = SHADERSTAGE_DLIGHT;
|
||||
r_dlightsPass.glState = GLSTATE_DEPTHFUNC_EQ|GLSTATE_SRCBLEND_DST_COLOR|GLSTATE_DSTBLEND_ONE;
|
||||
|
||||
// init fog pass
|
||||
memset( &r_fogPass, 0, sizeof( ref_stage_t ) );
|
||||
r_fogPass.tcgen = TCGEN_FOG;
|
||||
r_fogPass.rgbgen.type = RGBGEN_FOG;
|
||||
r_fogPass.alphagen.type = ALPHAGEN_IDENTITY;
|
||||
r_fogPass.flags = SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_DECAL|GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA;
|
||||
r_fogPass.rgbGen.type = RGBGEN_FOG;
|
||||
r_fogPass.alphaGen.type = ALPHAGEN_IDENTITY;
|
||||
r_fogPass.flags = SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_DECAL;
|
||||
r_fogPass.glState = GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA;
|
||||
|
||||
// the very first lightmap pass is reserved for GL_REPLACE or GL_MODULATE
|
||||
memset( r_lightmapPasses, 0, sizeof( r_lightmapPasses ) );
|
||||
r_lightmapPasses[0].rgbgen.args = r_lightmapPassesArgs[0];
|
||||
Mem_Set( r_lightmapPasses, 0, sizeof( r_lightmapPasses ));
|
||||
r_lightmapPasses[0].rgbGen.args = r_lightmapPassesArgs[0];
|
||||
|
||||
// the rest are GL_ADD
|
||||
for( i = 1; i < MAX_TEXTURE_UNITS+1; i++ )
|
||||
{
|
||||
r_lightmapPasses[i].flags = SHADERSTAGE_LIGHTMAP|SHADERSTAGE_NOCOLORARRAY|GLSTATE_DEPTHFUNC_EQ
|
||||
|SHADERSTAGE_BLEND_ADD|GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ONE;
|
||||
r_lightmapPasses[i].flags = SHADERSTAGE_LIGHTMAP|SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_ADD;
|
||||
r_lightmapPasses[i].glState = GLSTATE_DEPTHFUNC_EQ|GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ONE;
|
||||
r_lightmapPasses[i].tcgen = TCGEN_LIGHTMAP;
|
||||
r_lightmapPasses[i].alphagen.type = ALPHAGEN_IDENTITY;
|
||||
r_lightmapPasses[i].rgbgen.args = r_lightmapPassesArgs[i];
|
||||
r_lightmapPasses[i].alphaGen.type = ALPHAGEN_IDENTITY;
|
||||
r_lightmapPasses[i].rgbGen.args = r_lightmapPassesArgs[i];
|
||||
}
|
||||
|
||||
// init optional GLSL program passes
|
||||
memset( r_GLSLpasses, 0, sizeof( r_GLSLpasses ) );
|
||||
r_GLSLpasses[0].flags = SHADERSTAGE_DLIGHT|GLSTATE_DEPTHFUNC_EQ|SHADERSTAGE_BLEND_ADD|GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ONE;
|
||||
r_GLSLpasses[0].flags = SHADERSTAGE_DLIGHT|SHADERSTAGE_BLEND_ADD;
|
||||
r_GLSLpasses[0].glState = GLSTATE_DEPTHFUNC_EQ|GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ONE;
|
||||
|
||||
r_GLSLpasses[1].flags = SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_MODULATE|GLSTATE_SRCBLEND_ZERO|GLSTATE_DSTBLEND_SRC_COLOR;
|
||||
r_GLSLpasses[1].flags = SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_MODULATE;
|
||||
r_GLSLpasses[1].glState = GLSTATE_SRCBLEND_ZERO|GLSTATE_DSTBLEND_SRC_COLOR;
|
||||
r_GLSLpasses[1].tcgen = TCGEN_BASE;
|
||||
r_GLSLpasses[1].rgbgen.type = RGBGEN_IDENTITY;
|
||||
r_GLSLpasses[1].alphagen.type = ALPHAGEN_IDENTITY;
|
||||
memcpy( &r_GLSLpasses[2], &r_GLSLpasses[1], sizeof( ref_stage_t ) );
|
||||
r_GLSLpasses[1].rgbGen.type = RGBGEN_IDENTITY;
|
||||
r_GLSLpasses[1].alphaGen.type = ALPHAGEN_IDENTITY;
|
||||
Mem_Copy( &r_GLSLpasses[2], &r_GLSLpasses[1], sizeof( ref_stage_t ) );
|
||||
|
||||
r_GLSLpasses[3].flags = SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_MODULATE|GLSTATE_DEPTHFUNC_EQ /*|GLSTATE_OFFSET_FILL*/|GLSTATE_SRCBLEND_ZERO|GLSTATE_DSTBLEND_SRC_COLOR;
|
||||
r_GLSLpasses[3].flags = SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_MODULATE;
|
||||
r_GLSLpasses[3].glState = GLSTATE_DEPTHFUNC_EQ /*|GLSTATE_OFFSET_FILL*/|GLSTATE_SRCBLEND_ZERO|GLSTATE_DSTBLEND_SRC_COLOR;
|
||||
r_GLSLpasses[3].tcgen = TCGEN_PROJECTION_SHADOW;
|
||||
r_GLSLpasses[3].rgbgen.type = RGBGEN_IDENTITY;
|
||||
r_GLSLpasses[3].alphagen.type = ALPHAGEN_IDENTITY;
|
||||
r_GLSLpasses[3].rgbGen.type = RGBGEN_IDENTITY;
|
||||
r_GLSLpasses[3].alphaGen.type = ALPHAGEN_IDENTITY;
|
||||
r_GLSLpasses[3].program = DEFAULT_GLSL_SHADOWMAP_PROGRAM;
|
||||
r_GLSLpasses[3].program_type = PROGRAM_TYPE_SHADOWMAP;
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
memset( &r_GLSLpassOutline, 0, sizeof( r_GLSLpassOutline ) );
|
||||
r_GLSLpassOutline.flags = SHADERSTAGE_NOCOLORARRAY|GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ZERO|SHADERSTAGE_BLEND_MODULATE|GLSTATE_DEPTHWRITE;
|
||||
r_GLSLpassOutline.rgbgen.type = RGBGEN_OUTLINE;
|
||||
r_GLSLpassOutline.alphagen.type = ALPHAGEN_OUTLINE;
|
||||
Mem_Set( &r_GLSLpassOutline, 0, sizeof( r_GLSLpassOutline ) );
|
||||
r_GLSLpassOutline.flags = SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_MODULATE;
|
||||
r_GLSLpassOutline.glState = GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ZERO|GLSTATE_DEPTHWRITE;
|
||||
r_GLSLpassOutline.rgbGen.type = RGBGEN_OUTLINE;
|
||||
r_GLSLpassOutline.alphaGen.type = ALPHAGEN_OUTLINE;
|
||||
r_GLSLpassOutline.tcgen = TCGEN_NONE;
|
||||
r_GLSLpassOutline.program = DEFAULT_GLSL_OUTLINE_PROGRAM;
|
||||
r_GLSLpassOutline.program_type = PROGRAM_TYPE_OUTLINE;
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -567,15 +567,15 @@ R_DeformVertices
|
|||
*/
|
||||
void R_DeformVertices( void )
|
||||
{
|
||||
unsigned int i, j, k;
|
||||
uint i, j, k;
|
||||
double args[4], temp;
|
||||
float deflect, *quad[4];
|
||||
const float *table;
|
||||
const deformv_t *deformv;
|
||||
const deform_t *deformv;
|
||||
vec3_t tv, rot_centre;
|
||||
|
||||
deformv = &r_currentShader->deforms[0];
|
||||
for( i = 0; i < r_currentShader->numdeforms; i++, deformv++ )
|
||||
for( i = 0; i < r_currentShader->numDeforms; i++, deformv++ )
|
||||
{
|
||||
switch( deformv->type )
|
||||
{
|
||||
|
@ -904,16 +904,12 @@ void R_DeformVertices( void )
|
|||
}
|
||||
}
|
||||
break;
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
case DEFORM_OUTLINE:
|
||||
// Deflect vertex along its normal by outline amount
|
||||
deflect = RI.currententity->outlineHeight * r_outlines_scale->value;
|
||||
for( j = 0; j < r_backacc.numVerts; j++ )
|
||||
VectorMA( inVertsArray[j], deflect, inNormalsArray[j], inVertsArray[j] );
|
||||
break;
|
||||
#endif
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
@ -1189,9 +1185,9 @@ static void R_ApplyTCMods( const ref_stage_t *pass, mat4x4_t result )
|
|||
const float *table;
|
||||
double t1, t2, sint, cost;
|
||||
mat4x4_t m1, m2;
|
||||
const tcmod_t *tcmod;
|
||||
const tcMod_t *tcmod;
|
||||
|
||||
for( i = 0, tcmod = pass->tcmods; i < pass->numtcmods; i++, tcmod++ )
|
||||
for( i = 0, tcmod = pass->tcMods; i < pass->numtcMods; i++, tcmod++ )
|
||||
{
|
||||
switch( tcmod->type )
|
||||
{
|
||||
|
@ -1278,7 +1274,7 @@ static void R_BindShaderpass( const ref_stage_t *pass, texture_t *tex, int unit
|
|||
|
||||
identityMatrix = R_VertexTCBase( pass, unit, result );
|
||||
|
||||
if( pass->numtcmods )
|
||||
if( pass->numtcMods )
|
||||
{
|
||||
identityMatrix = false;
|
||||
R_ApplyTCMods( pass, result );
|
||||
|
@ -1306,7 +1302,7 @@ R_ModifyColor
|
|||
*/
|
||||
void R_ModifyColor( const ref_stage_t *pass )
|
||||
{
|
||||
unsigned int i;
|
||||
uint i;
|
||||
int c, bits;
|
||||
double temp;
|
||||
float *table, a;
|
||||
|
@ -1322,12 +1318,12 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
bArray = colorArray[0];
|
||||
inArray = inColorsArray[0][0];
|
||||
|
||||
if( pass->rgbgen.type == RGBGEN_IDENTITY_LIGHTING )
|
||||
if( pass->rgbGen.type == RGBGEN_IDENTITY_LIGHTING )
|
||||
{
|
||||
entityAlpha = identityAlpha = false;
|
||||
memset( bArray, r_identityLighting, sizeof( rgba_t ) * r_backacc.numColors );
|
||||
}
|
||||
else if( pass->rgbgen.type == RGBGEN_EXACT_VERTEX )
|
||||
else if( pass->rgbGen.type == RGBGEN_EXACT_VERTEX )
|
||||
{
|
||||
entityAlpha = identityAlpha = false;
|
||||
memcpy( bArray, inArray, sizeof( rgba_t ) * r_backacc.numColors );
|
||||
|
@ -1338,20 +1334,20 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
identityAlpha = true;
|
||||
memset( bArray, 255, sizeof( rgba_t ) * r_backacc.numColors );
|
||||
|
||||
switch( pass->rgbgen.type )
|
||||
switch( pass->rgbGen.type )
|
||||
{
|
||||
case RGBGEN_IDENTITY:
|
||||
break;
|
||||
case RGBGEN_CONST:
|
||||
rgba[0] = R_FloatToByte( pass->rgbgen.args[0] );
|
||||
rgba[1] = R_FloatToByte( pass->rgbgen.args[1] );
|
||||
rgba[2] = R_FloatToByte( pass->rgbgen.args[2] );
|
||||
rgba[0] = R_FloatToByte( pass->rgbGen.args[0] );
|
||||
rgba[1] = R_FloatToByte( pass->rgbGen.args[1] );
|
||||
rgba[2] = R_FloatToByte( pass->rgbGen.args[2] );
|
||||
|
||||
for( i = 0, c = *(int *)rgba; i < r_backacc.numColors; i++, bArray += 4 )
|
||||
*(int *)bArray = c;
|
||||
break;
|
||||
case RGBGEN_WAVE:
|
||||
rgbgenfunc = pass->rgbgen.func;
|
||||
rgbgenfunc = pass->rgbGen.func;
|
||||
if( rgbgenfunc->type == WAVEFORM_NOISE )
|
||||
{
|
||||
temp = R_BackendGetNoiseValue( 0, 0, 0, ( r_currentShaderTime + rgbgenfunc->args[2] ) * rgbgenfunc->args[3] );
|
||||
|
@ -1364,9 +1360,9 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
}
|
||||
|
||||
temp = temp * rgbgenfunc->args[1] + rgbgenfunc->args[0];
|
||||
a = pass->rgbgen.args[0] * temp; rgba[0] = a <= 0 ? 0 : R_FloatToByte( a );
|
||||
a = pass->rgbgen.args[1] * temp; rgba[1] = a <= 0 ? 0 : R_FloatToByte( a );
|
||||
a = pass->rgbgen.args[2] * temp; rgba[2] = a <= 0 ? 0 : R_FloatToByte( a );
|
||||
a = pass->rgbGen.args[0] * temp; rgba[0] = a <= 0 ? 0 : R_FloatToByte( a );
|
||||
a = pass->rgbGen.args[1] * temp; rgba[1] = a <= 0 ? 0 : R_FloatToByte( a );
|
||||
a = pass->rgbGen.args[2] * temp; rgba[2] = a <= 0 ? 0 : R_FloatToByte( a );
|
||||
|
||||
for( i = 0, c = *(int *)rgba; i < r_backacc.numColors; i++, bArray += 4 )
|
||||
*(int *)bArray = c;
|
||||
|
@ -1378,14 +1374,12 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
for( i = 0, c = *(int *)RI.currententity->color; i < r_backacc.numColors; i++, bArray += 4 )
|
||||
*(int *)bArray = c;
|
||||
break;
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
case RGBGEN_OUTLINE:
|
||||
identityAlpha = ( RI.currententity->outlineColor[3] == 255 );
|
||||
|
||||
for( i = 0, c = *(int *)RI.currententity->outlineColor; i < r_backacc.numColors; i++, bArray += 4 )
|
||||
*(int *)bArray = c;
|
||||
break;
|
||||
#endif
|
||||
case RGBGEN_ONE_MINUS_ENTITY:
|
||||
rgba[0] = 255 - RI.currententity->color[0];
|
||||
rgba[1] = 255 - RI.currententity->color[1];
|
||||
|
@ -1497,7 +1491,7 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
*(int *)bArray = c;
|
||||
break;
|
||||
case RGBGEN_CUSTOM:
|
||||
c = (int)pass->rgbgen.args[0];
|
||||
c = (int)pass->rgbGen.args[0];
|
||||
for( i = 0, c = R_GetCustomColor( c ); i < r_backacc.numColors; i++, bArray += 4 )
|
||||
*(int *)bArray = c;
|
||||
break;
|
||||
|
@ -1513,7 +1507,7 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
bArray = colorArray[0];
|
||||
inArray = inColorsArray[0][0];
|
||||
|
||||
switch( pass->alphagen.type )
|
||||
switch( pass->alphaGen.type )
|
||||
{
|
||||
case ALPHAGEN_IDENTITY:
|
||||
if( identityAlpha )
|
||||
|
@ -1522,12 +1516,12 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
bArray[3] = 255;
|
||||
break;
|
||||
case ALPHAGEN_CONST:
|
||||
c = R_FloatToByte( pass->alphagen.args[0] );
|
||||
c = R_FloatToByte( pass->alphaGen.args[0] );
|
||||
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
|
||||
bArray[3] = c;
|
||||
break;
|
||||
case ALPHAGEN_WAVE:
|
||||
alphagenfunc = pass->alphagen.func;
|
||||
alphagenfunc = pass->alphaGen.func;
|
||||
if( alphagenfunc->type == WAVEFORM_NOISE )
|
||||
{
|
||||
a = R_BackendGetNoiseValue( 0, 0, 0, ( r_currentShaderTime + alphagenfunc->args[2] ) * alphagenfunc->args[3] );
|
||||
|
@ -1548,7 +1542,7 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
case ALPHAGEN_PORTAL:
|
||||
VectorAdd( vertsArray[0], RI.currententity->origin, v );
|
||||
VectorSubtract( RI.viewOrigin, v, t );
|
||||
a = VectorLength( t ) * pass->alphagen.args[0];
|
||||
a = VectorLength( t ) * pass->alphaGen.args[0];
|
||||
a = bound( 0.0f, a, 1.0f );
|
||||
c = R_FloatToByte( a );
|
||||
|
||||
|
@ -1569,12 +1563,10 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
|
||||
bArray[3] = RI.currententity->color[3];
|
||||
break;
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
case ALPHAGEN_OUTLINE:
|
||||
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
|
||||
bArray[3] = RI.currententity->outlineColor[3];
|
||||
break;
|
||||
#endif
|
||||
case ALPHAGEN_SPECULAR:
|
||||
VectorSubtract( RI.viewOrigin, RI.currententity->origin, t );
|
||||
if( !Matrix_Compare( RI.currententity->axis, axis_identity ) )
|
||||
|
@ -1587,7 +1579,7 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
VectorSubtract( v, vertsArray[i], t );
|
||||
c = VectorLength( t );
|
||||
a = DotProduct( t, normalsArray[i] ) / max( 0.1, c );
|
||||
a = pow( a, pass->alphagen.args[0] );
|
||||
a = pow( a, pass->alphaGen.args[0] );
|
||||
bArray[3] = a <= 0 ? 0 : R_FloatToByte( a );
|
||||
}
|
||||
break;
|
||||
|
@ -1600,7 +1592,7 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
|
||||
{
|
||||
a = DotProduct( v, inNormalsArray[i] ); if( a < 0 ) a = -a;
|
||||
bArray[3] = R_FloatToByte( bound( pass->alphagen.args[0], a, pass->alphagen.args[1] ) );
|
||||
bArray[3] = R_FloatToByte( bound( pass->alphaGen.args[0], a, pass->alphaGen.args[1] ) );
|
||||
}
|
||||
break;
|
||||
case ALPHAGEN_ONE_MINUS_DOT:
|
||||
|
@ -1612,7 +1604,7 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
|
||||
{
|
||||
a = DotProduct( v, inNormalsArray[i] ); if( a < 0 ) a = -a;a = 1.0f - a;
|
||||
bArray[3] = R_FloatToByte( bound( pass->alphagen.args[0], a, pass->alphagen.args[1] ) );
|
||||
bArray[3] = R_FloatToByte( bound( pass->alphaGen.args[0], a, pass->alphaGen.args[1] ) );
|
||||
}
|
||||
default:
|
||||
break;
|
||||
|
@ -1629,13 +1621,11 @@ void R_ModifyColor( const ref_stage_t *pass )
|
|||
bool alphaFog;
|
||||
int blendsrc, blenddst;
|
||||
|
||||
blendsrc = pass->flags & GLSTATE_SRCBLEND_MASK;
|
||||
blenddst = pass->flags & GLSTATE_DSTBLEND_MASK;
|
||||
if( ( blendsrc != GLSTATE_SRCBLEND_SRC_ALPHA && blenddst != GLSTATE_DSTBLEND_SRC_ALPHA ) &&
|
||||
( blendsrc != GLSTATE_SRCBLEND_ONE_MINUS_SRC_ALPHA && blenddst != GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA ) )
|
||||
blendsrc = pass->glState & GLSTATE_SRCBLEND_MASK;
|
||||
blenddst = pass->glState & GLSTATE_DSTBLEND_MASK;
|
||||
if(( blendsrc != GLSTATE_SRCBLEND_SRC_ALPHA && blenddst != GLSTATE_DSTBLEND_SRC_ALPHA ) && ( blendsrc != GLSTATE_SRCBLEND_ONE_MINUS_SRC_ALPHA && blenddst != GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA ))
|
||||
alphaFog = false;
|
||||
else
|
||||
alphaFog = true;
|
||||
else alphaFog = true;
|
||||
|
||||
fogPlane = r_colorFog->visibleplane;
|
||||
fogShaderDistScale = 1.0 / (r_colorFog->shader->fog_dist - r_colorFog->shader->fog_clearDist);
|
||||
|
@ -1743,14 +1733,13 @@ static void R_SetShaderState( void )
|
|||
int state;
|
||||
|
||||
// Face culling
|
||||
if( !gl_cull->integer || ( r_features & MF_NOCULL ) )
|
||||
if( !gl_cull->integer || ( r_features & MF_NOCULL ))
|
||||
GL_Cull( 0 );
|
||||
else if( r_currentShader->flags & SHADER_CULL_FRONT )
|
||||
GL_Cull( GL_FRONT );
|
||||
else if( r_currentShader->flags & SHADER_CULL_BACK )
|
||||
GL_Cull( GL_BACK );
|
||||
else
|
||||
GL_Cull( 0 );
|
||||
else GL_Cull( 0 );
|
||||
|
||||
state = 0;
|
||||
if( r_currentShader->flags & SHADER_POLYGONOFFSET || RI.params & RP_SHADOWMAPVIEW )
|
||||
|
@ -1776,7 +1765,7 @@ void R_RenderMeshGeneric( void )
|
|||
GL_TexEnv( GL_REPLACE );
|
||||
else
|
||||
GL_TexEnv( GL_MODULATE );
|
||||
GL_SetState( r_currentShaderState | ( pass->flags & r_currentShaderPassMask ) );
|
||||
GL_SetState( r_currentShaderState | ( pass->glState & r_currentShaderPassMask ));
|
||||
|
||||
R_FlushArrays();
|
||||
}
|
||||
|
@ -1795,7 +1784,7 @@ void R_RenderMeshMultitextured( void )
|
|||
R_ModifyColor( pass );
|
||||
|
||||
GL_TexEnv( GL_MODULATE );
|
||||
GL_SetState( r_currentShaderState | ( pass->flags & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX );
|
||||
GL_SetState( r_currentShaderState | ( pass->glState & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX );
|
||||
|
||||
for( i = 1; i < r_numAccumPasses; i++ )
|
||||
{
|
||||
|
@ -1821,14 +1810,14 @@ void R_RenderMeshCombined( void )
|
|||
R_ModifyColor( pass );
|
||||
|
||||
GL_TexEnv( GL_MODULATE );
|
||||
GL_SetState( r_currentShaderState | ( pass->flags & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX );
|
||||
GL_SetState( r_currentShaderState | ( pass->glState & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX );
|
||||
|
||||
for( i = 1; i < r_numAccumPasses; i++ )
|
||||
{
|
||||
pass = r_accumPasses[i];
|
||||
R_BindShaderpass( pass, NULL, i );
|
||||
|
||||
if( pass->flags & ( SHADERSTAGE_BLEND_REPLACE|SHADERSTAGE_BLEND_MODULATE ) )
|
||||
if( pass->flags & ( SHADERSTAGE_BLEND_REPLACE|SHADERSTAGE_BLEND_MODULATE ))
|
||||
{
|
||||
GL_TexEnv( GL_MODULATE );
|
||||
}
|
||||
|
@ -1909,9 +1898,12 @@ static void R_RenderMeshGLSL_Material( void )
|
|||
programFeatures |= PROGRAM_APPLY_CLIPPING;
|
||||
|
||||
if( r_currentMeshBuffer->infokey > 0 )
|
||||
{ // world surface
|
||||
int srcAlpha = (pass->flags & (SHADERSTAGE_BLEND_DECAL|GLSTATE_ALPHAFUNC
|
||||
|GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_SRCBLEND_ONE_MINUS_SRC_ALPHA|GLSTATE_DSTBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA));
|
||||
{
|
||||
// world surface
|
||||
int srcAlpha = (pass->flags & SHADERSTAGE_BLEND_DECAL);
|
||||
|
||||
// CHECKTHIS: this is right ?
|
||||
srcAlpha |= (pass->glState & (GLSTATE_ALPHAFUNC|GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_SRCBLEND_ONE_MINUS_SRC_ALPHA|GLSTATE_DSTBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA));
|
||||
|
||||
if( !( r_offsetmapping->integer & 1 ) )
|
||||
offsetmappingScale = 0;
|
||||
|
@ -1930,18 +1922,18 @@ static void R_RenderMeshGLSL_Material( void )
|
|||
{
|
||||
breakIntoPasses = true;
|
||||
r_GLSLpasses[1] = *pass;
|
||||
r_GLSLpasses[1].flags = ( pass->flags & SHADERSTAGE_NOCOLORARRAY )|((pass->flags & GLSTATE_ALPHAFUNC) ? GLSTATE_DEPTHFUNC_EQ : 0)
|
||||
|SHADERSTAGE_BLEND_MODULATE|GLSTATE_SRCBLEND_ZERO|GLSTATE_DSTBLEND_SRC_COLOR;
|
||||
r_GLSLpasses[1].flags = ( pass->flags & SHADERSTAGE_NOCOLORARRAY )|SHADERSTAGE_BLEND_MODULATE;
|
||||
r_GLSLpasses[1].glState = GLSTATE_SRCBLEND_ZERO|GLSTATE_DSTBLEND_SRC_COLOR|((pass->glState & GLSTATE_ALPHAFUNC) ? GLSTATE_DEPTHFUNC_EQ : 0);
|
||||
|
||||
// decal
|
||||
if( decalmap )
|
||||
{
|
||||
r_GLSLpasses[1].rgbgen.type = RGBGEN_IDENTITY;
|
||||
r_GLSLpasses[1].alphagen.type = ALPHAGEN_IDENTITY;
|
||||
r_GLSLpasses[1].rgbGen.type = RGBGEN_IDENTITY;
|
||||
r_GLSLpasses[1].alphaGen.type = ALPHAGEN_IDENTITY;
|
||||
|
||||
r_GLSLpasses[2] = *pass;
|
||||
r_GLSLpasses[2].flags = ( pass->flags & SHADERSTAGE_NOCOLORARRAY )|((pass->flags & GLSTATE_ALPHAFUNC) ? GLSTATE_DEPTHFUNC_EQ : 0)
|
||||
|SHADERSTAGE_BLEND_DECAL|GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA;
|
||||
r_GLSLpasses[2].flags = ( pass->flags & SHADERSTAGE_NOCOLORARRAY )|SHADERSTAGE_BLEND_DECAL;
|
||||
r_GLSLpasses[2].glState = GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA|((pass->glState & GLSTATE_ALPHAFUNC) ? GLSTATE_DEPTHFUNC_EQ : 0);
|
||||
r_GLSLpasses[2].textures[0] = decalmap;
|
||||
}
|
||||
|
||||
|
@ -1954,7 +1946,7 @@ static void R_RenderMeshGLSL_Material( void )
|
|||
{
|
||||
r_GLSLpasses[1].textures[2] = r_GLSLpasses[2].textures[2] = NULL; // no specular
|
||||
r_GLSLpasses[1].textures[3] = r_GLSLpasses[2].textures[3] = NULL; // no decal
|
||||
r_GLSLpasses[1].textures[6] = r_GLSLpasses[6].textures[2] = ((texture_t *)1); // no ambient (HACK HACK HACK)
|
||||
r_GLSLpasses[1].textures[6] = r_GLSLpasses[6].textures[2] = ((texture_t *)1); // HACKHACK no ambient
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1976,7 +1968,8 @@ static void R_RenderMeshGLSL_Material( void )
|
|||
pass->tcgen = TCGEN_BASE;
|
||||
R_BindShaderpass( pass, base, 0 );
|
||||
if( !breakIntoPasses )
|
||||
{ // calculate the fragment color
|
||||
{
|
||||
// calculate the fragment color
|
||||
R_ModifyColor( pass );
|
||||
}
|
||||
else
|
||||
|
@ -1986,7 +1979,7 @@ static void R_RenderMeshGLSL_Material( void )
|
|||
}
|
||||
|
||||
// set shaderpass state (blending, depthwrite, etc)
|
||||
state = r_currentShaderState | ( pass->flags & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX;
|
||||
state = r_currentShaderState | ( pass->glState & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX;
|
||||
GL_SetState( state );
|
||||
|
||||
// don't waste time on processing GLSL programs with zero colormask
|
||||
|
@ -2177,12 +2170,12 @@ static void R_RenderMeshGLSL_Distortion( void )
|
|||
|
||||
if( frontPlane )
|
||||
{
|
||||
if( pass->alphagen.type != ALPHAGEN_IDENTITY )
|
||||
if( pass->alphaGen.type != ALPHAGEN_IDENTITY )
|
||||
programFeatures |= PROGRAM_APPLY_DISTORTION_ALPHA;
|
||||
}
|
||||
|
||||
// set shaderpass state (blending, depthwrite, etc)
|
||||
state = r_currentShaderState | ( pass->flags & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX;
|
||||
state = r_currentShaderState | ( pass->glState & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX;
|
||||
GL_SetState( state );
|
||||
|
||||
if( pass->textures[1] /* && ( RI.params & RP_PORTALCAPTURED )*/ )
|
||||
|
@ -2255,7 +2248,7 @@ static void R_RenderMeshGLSL_Shadowmap( void )
|
|||
R_ModifyColor( pass );
|
||||
|
||||
// set shaderpass state (blending, depthwrite, etc)
|
||||
state = r_currentShaderState | ( pass->flags & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX;
|
||||
state = r_currentShaderState | ( pass->glState & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX;
|
||||
GL_SetState( state );
|
||||
|
||||
pglUseProgramObjectARB( object );
|
||||
|
@ -2272,7 +2265,6 @@ static void R_RenderMeshGLSL_Shadowmap( void )
|
|||
}
|
||||
}
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
/*
|
||||
================
|
||||
R_RenderMeshGLSL_Outline
|
||||
|
@ -2305,7 +2297,7 @@ static void R_RenderMeshGLSL_Outline( void )
|
|||
R_ModifyColor( pass );
|
||||
|
||||
// set shaderpass state (blending, depthwrite, etc)
|
||||
state = r_currentShaderState | ( pass->flags & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX;
|
||||
state = r_currentShaderState | ( pass->glState & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX;
|
||||
GL_SetState( state );
|
||||
|
||||
pglUseProgramObjectARB( object );
|
||||
|
@ -2319,7 +2311,6 @@ static void R_RenderMeshGLSL_Outline( void )
|
|||
|
||||
GL_Cull( faceCull );
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
================
|
||||
|
@ -2342,9 +2333,7 @@ static void R_RenderMeshGLSLProgrammed( void )
|
|||
R_RenderMeshGLSL_Shadowmap();
|
||||
break;
|
||||
case PROGRAM_TYPE_OUTLINE:
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
R_RenderMeshGLSL_Outline ();
|
||||
#endif
|
||||
break;
|
||||
default:
|
||||
MsgDev( D_WARN, "Unknown GLSL program type %i\n", pass->program_type );
|
||||
|
@ -2372,13 +2361,13 @@ static void R_RenderAccumulatedPasses( void )
|
|||
if( pass->flags & SHADERSTAGE_DLIGHT )
|
||||
{
|
||||
r_numAccumPasses = 0;
|
||||
R_AddDynamicLights( r_currentDlightBits, r_currentShaderState | ( pass->flags & r_currentShaderPassMask ) );
|
||||
R_AddDynamicLights( r_currentDlightBits, r_currentShaderState | ( pass->glState & r_currentShaderPassMask ));
|
||||
return;
|
||||
}
|
||||
if( pass->flags & SHADERSTAGE_STENCILSHADOW )
|
||||
{
|
||||
r_numAccumPasses = 0;
|
||||
R_PlanarShadowPass( r_currentShaderState | ( pass->flags & r_currentShaderPassMask ) );
|
||||
R_PlanarShadowPass( r_currentShaderState | ( pass->glState & r_currentShaderPassMask ));
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -2403,7 +2392,7 @@ static void R_AccumulatePass( ref_stage_t *pass )
|
|||
const ref_stage_t *prevPass;
|
||||
|
||||
// for depth texture we render light's view to, ignore passes that do not write into depth buffer
|
||||
if( ( RI.params & RP_SHADOWMAPVIEW ) && !( pass->flags & GLSTATE_DEPTHWRITE ) )
|
||||
if( ( RI.params & RP_SHADOWMAPVIEW ) && !( pass->glState & GLSTATE_DEPTHWRITE ))
|
||||
return;
|
||||
|
||||
// see if there are any free texture units
|
||||
|
@ -2423,11 +2412,11 @@ static void R_AccumulatePass( ref_stage_t *pass )
|
|||
|
||||
// see if depthfuncs and colors are good
|
||||
if(
|
||||
( ( prevPass->flags ^ pass->flags ) & GLSTATE_DEPTHFUNC_EQ ) ||
|
||||
( pass->flags & GLSTATE_ALPHAFUNC ) ||
|
||||
( pass->rgbgen.type != RGBGEN_IDENTITY ) ||
|
||||
( pass->alphagen.type != ALPHAGEN_IDENTITY ) ||
|
||||
( ( prevPass->flags & GLSTATE_ALPHAFUNC ) && !( pass->flags & GLSTATE_DEPTHFUNC_EQ ) )
|
||||
(( prevPass->glState ^ pass->glState ) & GLSTATE_DEPTHFUNC_EQ ) ||
|
||||
( pass->glState & GLSTATE_ALPHAFUNC ) ||
|
||||
( pass->rgbGen.type != RGBGEN_IDENTITY ) ||
|
||||
( pass->alphaGen.type != ALPHAGEN_IDENTITY ) ||
|
||||
( ( prevPass->glState & GLSTATE_ALPHAFUNC ) && !( pass->glState & GLSTATE_DEPTHFUNC_EQ ))
|
||||
)
|
||||
accumulate = false;
|
||||
|
||||
|
@ -2491,12 +2480,13 @@ R_SetupLightmapMode
|
|||
void R_SetupLightmapMode( void )
|
||||
{
|
||||
r_lightmapPasses[0].tcgen = TCGEN_LIGHTMAP;
|
||||
r_lightmapPasses[0].rgbgen.type = RGBGEN_IDENTITY;
|
||||
r_lightmapPasses[0].alphagen.type = ALPHAGEN_IDENTITY;
|
||||
r_lightmapPasses[0].flags &= ~( SHADERSTAGE_BLENDMODE|SHADERSTAGE_DELUXEMAP|GLSTATE_ALPHAFUNC|GLSTATE_SRCBLEND_MASK|GLSTATE_DSTBLEND_MASK|GLSTATE_DEPTHFUNC_EQ );
|
||||
r_lightmapPasses[0].flags |= SHADERSTAGE_LIGHTMAP|SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_MODULATE /*|GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ZERO*/;
|
||||
if( r_lightmap->integer )
|
||||
r_lightmapPasses[0].flags |= GLSTATE_DEPTHWRITE;
|
||||
r_lightmapPasses[0].rgbGen.type = RGBGEN_IDENTITY;
|
||||
r_lightmapPasses[0].alphaGen.type = ALPHAGEN_IDENTITY;
|
||||
r_lightmapPasses[0].flags &= ~SHADERSTAGE_BLENDMODE;
|
||||
r_lightmapPasses[0].glState &= ~( GLSTATE_ALPHAFUNC|GLSTATE_SRCBLEND_MASK|GLSTATE_DSTBLEND_MASK|GLSTATE_DEPTHFUNC_EQ );
|
||||
r_lightmapPasses[0].flags |= SHADERSTAGE_LIGHTMAP|SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_MODULATE;
|
||||
// r_lightmapPasses[0].glState |= GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ZERO;
|
||||
if( r_lightmap->integer ) r_lightmapPasses[0].glState |= GLSTATE_DEPTHWRITE;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -2543,7 +2533,7 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
|
|||
if( !r_triangleOutlines )
|
||||
R_SetShaderState();
|
||||
|
||||
if( r_currentShader->numdeforms )
|
||||
if( r_currentShader->numDeforms )
|
||||
R_DeformVertices();
|
||||
|
||||
if( r_features & MF_KEEPLOCK )
|
||||
|
@ -2574,7 +2564,7 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
|
|||
|
||||
// can we fog the geometry with alpha texture?
|
||||
r_texFog = ( fog && ( ( r_currentShader->sort <= SORT_ALPHATEST &&
|
||||
( r_currentShader->flags & ( SHADER_DEPTHWRITE|SHADER_SKYPARMS ) ) ) || r_currentShader->fog_dist ) ) ? fog : NULL;
|
||||
( r_currentShader->flags & (SHADER_DEPTHWRITE|SHADER_SKYPARMS))) || r_currentShader->fog_dist ) ) ? fog : NULL;
|
||||
|
||||
// check if the fog volume is present but we can't use alpha texture
|
||||
r_colorFog = ( fog && !r_texFog ) ? fog : NULL;
|
||||
|
@ -2589,7 +2579,7 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
|
|||
R_LockArrays( r_backacc.numVerts );
|
||||
|
||||
// accumulate passes for dynamic merging
|
||||
for( i = 0, pass = r_currentShader->passes; i < r_currentShader->numpasses; i++, pass++ )
|
||||
for( i = 0, pass = r_currentShader->stages; i < r_currentShader->num_stages; i++, pass++ )
|
||||
{
|
||||
if( !pass->program )
|
||||
{
|
||||
|
@ -2602,7 +2592,7 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
|
|||
continue;
|
||||
|
||||
// try to apply lightstyles
|
||||
if( ( !( pass->flags & ( GLSTATE_SRCBLEND_MASK|GLSTATE_DSTBLEND_MASK ) ) || ( pass->flags & SHADERSTAGE_BLEND_MODULATE ) ) && ( pass->rgbgen.type == RGBGEN_IDENTITY ) && ( pass->alphagen.type == ALPHAGEN_IDENTITY ) )
|
||||
if(( !( pass->glState & (GLSTATE_SRCBLEND_MASK|GLSTATE_DSTBLEND_MASK)) || ( pass->flags & SHADERSTAGE_BLEND_MODULATE )) && ( pass->rgbGen.type == RGBGEN_IDENTITY ) && ( pass->alphaGen.type == ALPHAGEN_IDENTITY ))
|
||||
{
|
||||
vec3_t colorSum, color;
|
||||
|
||||
|
@ -2634,7 +2624,7 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
|
|||
|
||||
if( VectorCompare( color, colorWhite ) )
|
||||
{
|
||||
r_lightmapPasses[u].rgbgen.type = RGBGEN_IDENTITY;
|
||||
r_lightmapPasses[u].rgbGen.type = RGBGEN_IDENTITY;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -2643,8 +2633,8 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
|
|||
r_lightmapPasses[0].flags &= ~SHADERSTAGE_BLENDMODE;
|
||||
r_lightmapPasses[0].flags |= SHADERSTAGE_BLEND_MODULATE;
|
||||
}
|
||||
r_lightmapPasses[u].rgbgen.type = RGBGEN_CONST;
|
||||
VectorCopy( color, r_lightmapPasses[u].rgbgen.args );
|
||||
r_lightmapPasses[u].rgbGen.type = RGBGEN_CONST;
|
||||
VectorCopy( color, r_lightmapPasses[u].rgbGen.args );
|
||||
}
|
||||
|
||||
if( r_lightmap->integer && !l )
|
||||
|
@ -2666,13 +2656,13 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
|
|||
}
|
||||
continue;
|
||||
}
|
||||
else if( r_lightmap->integer && ( r_currentShader->flags & SHADER_LIGHTMAP ) )
|
||||
else if( r_lightmap->integer && ( r_currentShader->flags & SHADER_HASLIGHTMAP ))
|
||||
continue;
|
||||
if( ( pass->flags & SHADERSTAGE_PORTALMAP ) && !( RI.params & RP_PORTALCAPTURED ) )
|
||||
if(( pass->flags & SHADERSTAGE_PORTALMAP ) && !( RI.params & RP_PORTALCAPTURED ))
|
||||
continue;
|
||||
if( ( pass->flags & SHADERSTAGE_DETAIL ) && !r_detailtextures->integer )
|
||||
if(( pass->flags & SHADERSTAGE_DETAIL ) && !r_detailtextures->integer )
|
||||
continue;
|
||||
if( ( pass->flags & SHADERSTAGE_DLIGHT ) && !r_currentDlightBits )
|
||||
if(( pass->flags & SHADERSTAGE_DLIGHT ) && !r_currentDlightBits )
|
||||
continue;
|
||||
}
|
||||
|
||||
|
@ -2680,29 +2670,25 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
|
|||
}
|
||||
|
||||
// accumulate dynamic lights pass and fog pass if any
|
||||
if( r_currentDlightBits && !( r_currentShader->flags & SHADER_NO_MODULATIVE_DLIGHTS ) )
|
||||
if( r_currentDlightBits && !( r_currentShader->flags & SHADER_NO_MODULATIVE_DLIGHTS ))
|
||||
{
|
||||
if( !r_lightmap->integer || !( r_currentShader->flags & SHADER_LIGHTMAP ) )
|
||||
if( !r_lightmap->integer || !( r_currentShader->flags & SHADER_HASLIGHTMAP ))
|
||||
R_AccumulatePass( &r_dlightsPass );
|
||||
}
|
||||
|
||||
if( r_currentShadowBits && ( r_currentShader->sort >= SORT_OPAQUE )
|
||||
&& ( r_currentShader->sort <= SORT_ALPHATEST ) )
|
||||
if( r_currentShadowBits && ( r_currentShader->sort >= SORT_OPAQUE ) && ( r_currentShader->sort <= SORT_ALPHATEST ))
|
||||
R_AccumulatePass( &r_GLSLpasses[3] );
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
if( GL_Support( R_SHADER_GLSL100_EXT ) && RI.currententity && RI.currententity->outlineHeight && r_outlines_scale->value > 0
|
||||
&& ( r_currentShader->sort == SORT_OPAQUE ) && ( r_currentShader->flags & SHADER_CULL_FRONT ) )
|
||||
R_AccumulatePass( &r_GLSLpassOutline );
|
||||
#endif
|
||||
|
||||
if( r_texFog && r_texFog->shader )
|
||||
{
|
||||
r_fogPass.textures[0] = tr.fogTexture;
|
||||
if( !r_currentShader->numpasses || r_currentShader->fog_dist || ( r_currentShader->flags & SHADER_SKYPARMS ) )
|
||||
r_fogPass.flags &= ~GLSTATE_DEPTHFUNC_EQ;
|
||||
else
|
||||
r_fogPass.flags |= GLSTATE_DEPTHFUNC_EQ;
|
||||
if( !r_currentShader->num_stages || r_currentShader->fog_dist || ( r_currentShader->flags & SHADER_SKYPARMS ) )
|
||||
r_fogPass.glState &= ~GLSTATE_DEPTHFUNC_EQ;
|
||||
else r_fogPass.glState |= GLSTATE_DEPTHFUNC_EQ;
|
||||
R_AccumulatePass( &r_fogPass );
|
||||
}
|
||||
|
||||
|
|
|
@ -114,34 +114,34 @@ void R_DrawGetParms( int *w, int *h, int *f, int frame, shader_t handle )
|
|||
if( handle < 0 || handle > MAX_SHADERS || !(shader = &r_shaders[handle]))
|
||||
return;
|
||||
|
||||
if( !shader->numpasses || !shader->passes[0].textures[0] )
|
||||
if( !shader->num_stages || !shader->stages[0].textures[0] )
|
||||
return;
|
||||
|
||||
if( shader->passes[0].textures[0] && shader->passes[0].num_textures && frame > 0 )
|
||||
cur = bound( 0, frame, shader->passes[0].num_textures );
|
||||
if( shader->stages[0].textures[0] && shader->stages[0].num_textures && frame > 0 )
|
||||
cur = bound( 0, frame, shader->stages[0].num_textures );
|
||||
|
||||
if( w ) *w = (int)shader->passes[0].textures[cur]->srcWidth;
|
||||
if( h ) *h = (int)shader->passes[0].textures[cur]->srcHeight;
|
||||
if( f ) *f = (int)shader->passes[0].num_textures;
|
||||
if( w ) *w = (int)shader->stages[0].textures[cur]->srcWidth;
|
||||
if( h ) *h = (int)shader->stages[0].textures[cur]->srcHeight;
|
||||
if( f ) *f = (int)shader->stages[0].num_textures;
|
||||
}
|
||||
|
||||
void R_DrawSetParms( shader_t handle, kRenderMode_t rendermode, int frame )
|
||||
{
|
||||
ref_shader_t *shader;
|
||||
|
||||
if( handle < 0 || handle > MAX_SHADERS || !(shader = &r_shaders[handle]) || !shader->numpasses )
|
||||
if( handle < 0 || handle > MAX_SHADERS || !(shader = &r_shaders[handle]) || !shader->num_stages )
|
||||
return;
|
||||
|
||||
glState.draw_rendermode = rendermode;
|
||||
|
||||
if( !shader->passes[0].num_textures )
|
||||
if( !shader->stages[0].num_textures )
|
||||
return;
|
||||
|
||||
// change frame if need
|
||||
// if( shader->passes[0].flags & SHADERSTAGE_FRAMES )
|
||||
if( shader->stages[0].flags & SHADERSTAGE_FRAMES )
|
||||
{
|
||||
// make sure what frame inbound
|
||||
glState.draw_frame = bound( 0, frame, shader->passes[0].num_textures - 1 );
|
||||
glState.draw_frame = bound( 0, frame, shader->stages[0].num_textures - 1 );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -46,7 +46,7 @@ bool R_SurfPotentiallyLit( msurface_t *surf )
|
|||
return false;
|
||||
|
||||
shader = surf->shader;
|
||||
if( shader->flags & SHADER_SKYPARMS || shader->type == SHADER_FLARE || !shader->numpasses )
|
||||
if( shader->flags & SHADER_SKYPARMS || shader->type == SHADER_FLARE || !shader->num_stages )
|
||||
return false;
|
||||
|
||||
return ( surf->mesh && ( surf->facetype != MST_FLARE ) /* && (surf->facetype != MST_TRISURF)*/ );
|
||||
|
@ -117,7 +117,7 @@ void R_AddDynamicLights( unsigned int dlightbits, int state )
|
|||
if( !GL_Support( R_TEXTURE_3D_EXT ) && !GL_Support( R_ARB_MULTITEXTURE ))
|
||||
return;
|
||||
|
||||
for( i = 0; i < (unsigned)( GL_Support( R_TEXTURE_3D_EXT ) ? 1 : 2 ); i++ )
|
||||
for( i = 0; i < (uint)( GL_Support( R_TEXTURE_3D_EXT ) ? 1 : 2 ); i++ )
|
||||
{
|
||||
GL_SelectTexture( i );
|
||||
GL_TexEnv( GL_MODULATE );
|
||||
|
|
|
@ -21,8 +21,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|||
#ifndef __R_LOCAL_H__
|
||||
#define __R_LOCAL_H__
|
||||
|
||||
#define HARDWARE_OUTLINES
|
||||
|
||||
#include <windows.h>
|
||||
#include "launch_api.h"
|
||||
#include "qfiles_ref.h"
|
||||
|
@ -361,12 +359,9 @@ extern cvar_t *r_bloom_intensity;
|
|||
extern cvar_t *r_bloom_darken;
|
||||
extern cvar_t *r_bloom_sample_size;
|
||||
extern cvar_t *r_bloom_fast_sample;
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
extern cvar_t *r_outlines_world;
|
||||
extern cvar_t *r_outlines_scale;
|
||||
extern cvar_t *r_outlines_cutoff;
|
||||
#endif
|
||||
|
||||
extern cvar_t *r_lodbias;
|
||||
extern cvar_t *r_lodscale;
|
||||
|
@ -462,8 +457,8 @@ enum
|
|||
#define OCCLUSION_QUERIES_ENABLED( RI ) ( GL_Support( R_OCCLUSION_QUERIES_EXT ) && r_occlusion_queries->integer && r_drawentities->integer \
|
||||
&& !((RI).params & RP_NONVIEWERREF) && !((RI).refdef.rdflags & RDF_NOWORLDMODEL) \
|
||||
&& OCCLUSION_QUERIES_CVAR_HACK( RI ) )
|
||||
#define OCCLUSION_OPAQUE_SHADER( s ) ( ((s)->sort == SORT_OPAQUE ) && ((s)->flags & SHADER_DEPTHWRITE ) && !(s)->numdeforms )
|
||||
#define OCCLUSION_TEST_ENTITY( e ) ( ((e)->flags & (RF_OCCLUSIONTEST|RF_WEAPONMODEL)) == RF_OCCLUSIONTEST )
|
||||
#define OCCLUSION_OPAQUE_SHADER( s ) (((s)->sort == SORT_OPAQUE ) && ((s)->flags & SHADER_DEPTHWRITE ) && !(s)->numDeforms )
|
||||
#define OCCLUSION_TEST_ENTITY( e ) (((e)->flags & (RF_OCCLUSIONTEST|RF_WEAPONMODEL)) == RF_OCCLUSIONTEST )
|
||||
|
||||
void R_InitOcclusionQueries( void );
|
||||
void R_BeginOcclusionPass( void );
|
||||
|
@ -575,10 +570,8 @@ void R_InitCustomColors( void );
|
|||
void R_SetCustomColor( int num, int r, int g, int b );
|
||||
int R_GetCustomColor( int num );
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
void R_InitOutlines( void );
|
||||
void R_AddModelMeshOutline( unsigned int modhandle, mfog_t *fog, int meshnum );
|
||||
#endif
|
||||
|
||||
msurface_t *R_TraceLine( trace_t *tr, const vec3_t start, const vec3_t end, int surfumask );
|
||||
|
||||
|
@ -784,9 +777,7 @@ typedef struct
|
|||
int pow2MapOvrbr;
|
||||
|
||||
float ambient[3];
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
rgba_t outlineColor;
|
||||
#endif
|
||||
rgba_t environmentColor;
|
||||
|
||||
bool lightmapsPacking;
|
||||
|
|
|
@ -953,11 +953,7 @@ static void R_ApplySoftwareGamma( void )
|
|||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
|
||||
static ref_shader_t *r_outlineShader;
|
||||
|
||||
/*
|
||||
===============
|
||||
R_InitOutlines
|
||||
|
@ -976,11 +972,8 @@ R_AddModelMeshOutline
|
|||
void R_AddModelMeshOutline( unsigned int modhandle, mfog_t *fog, int meshnum )
|
||||
{
|
||||
meshbuffer_t *mb = R_AddMeshToList( MB_MODEL, fog, r_outlineShader, -( meshnum+1 ) );
|
||||
if( mb )
|
||||
mb->LODModelHandle = modhandle;
|
||||
if( mb ) mb->LODModelHandle = modhandle;
|
||||
}
|
||||
#endif
|
||||
|
||||
//=======================================================================
|
||||
|
||||
/*
|
||||
|
|
|
@ -273,13 +273,11 @@ void R_AddModelMeshToList( unsigned int modhandle, mfog_t *fog, ref_shader_t *sh
|
|||
if( mb )
|
||||
mb->LODModelHandle = modhandle;
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
if( !GL_Support( R_SHADER_GLSL100_EXT ) && RI.currententity->outlineHeight/* && !(RI.params & RP_SHADOWMAPVIEW)*/ )
|
||||
{
|
||||
if( ( shader->sort == SORT_OPAQUE ) && ( shader->flags & SHADER_CULL_FRONT ) )
|
||||
if(( shader->sort == SORT_OPAQUE ) && ( shader->flags & SHADER_CULL_FRONT ))
|
||||
R_AddModelMeshOutline( modhandle, fog, meshnum );
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -329,10 +327,8 @@ static void R_BatchMeshBuffer( const meshbuffer_t *mb, const meshbuffer_t *nextm
|
|||
features = shader->features;
|
||||
if( r_shownormals->integer )
|
||||
features |= MF_NORMALS;
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
if( ent->outlineHeight )
|
||||
features |= (MF_NORMALS|MF_ENABLENORMALS);
|
||||
#endif
|
||||
features |= r_superLightStyles[surf->superLightStyle].features;
|
||||
|
||||
if( features & MF_NONBATCHED )
|
||||
|
@ -760,11 +756,11 @@ static bool R_AddPortalSurface( const meshbuffer_t *mb )
|
|||
|
||||
// check if we are too far away and the portal view is obscured
|
||||
// by an alphagen portal stage
|
||||
for( i = 0; i < shader->numpasses; i++ )
|
||||
for( i = 0; i < shader->num_stages; i++ )
|
||||
{
|
||||
if( shader->passes[i].alphagen.type == ALPHAGEN_PORTAL )
|
||||
if( shader->stages[i].alphaGen.type == ALPHAGEN_PORTAL )
|
||||
{
|
||||
if( dist > ( 1.0/shader->passes[i].alphagen.args[0] ) )
|
||||
if( dist > ( 1.0f / shader->stages[i].alphaGen.args[0] ) )
|
||||
return true; // completely alpha'ed out
|
||||
}
|
||||
}
|
||||
|
@ -857,13 +853,13 @@ static bool R_DrawPortalSurface( void )
|
|||
captureTexture = &tr.portaltexture1;
|
||||
captureTextureID = 1;
|
||||
|
||||
for( i = 0, pass = shader->passes; i < shader->numpasses; i++, pass++ )
|
||||
for( i = 0, pass = shader->stages; i < shader->num_stages; i++, pass++ )
|
||||
{
|
||||
if( pass->program && pass->program_type == PROGRAM_TYPE_DISTORTION )
|
||||
{
|
||||
if( ( pass->alphagen.type == ALPHAGEN_CONST && pass->alphagen.args[0] == 1 ) )
|
||||
if( ( pass->alphaGen.type == ALPHAGEN_CONST && pass->alphaGen.args[0] == 1 ) )
|
||||
doRefraction = false;
|
||||
else if( ( pass->alphagen.type == ALPHAGEN_CONST && pass->alphagen.args[0] == 0 ) )
|
||||
else if( ( pass->alphaGen.type == ALPHAGEN_CONST && pass->alphaGen.args[0] == 0 ) )
|
||||
doReflection = false;
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -72,7 +72,7 @@ typedef struct mesh_s
|
|||
#define MB_NUM2FOG( num, fog ) ( (fog) = r_worldbrushmodel->fogs+(((num)>>2) & 0xFF), (fog) = ( (fog) == r_worldbrushmodel->fogs ? NULL : (fog)-1 ) )
|
||||
|
||||
#define MB_ENTITY2NUM( ent ) ((int)((ent)-r_entities)<<20 )
|
||||
#define MB_NUM2ENTITY( num, ent ) ( ent = r_entities+(((num)>>20)&1023))
|
||||
#define MB_NUM2ENTITY( num, ent ) ( ent = r_entities+(((num)>>20)&MAX_ENTITIES-1))
|
||||
|
||||
#define MB_SHADER2NUM( s ) ( (s)->sort << 26 ) | ((s) - r_shaders )
|
||||
#define MB_NUM2SHADER( num, s ) ( (s) = r_shaders + ((num) & 0xFFF) )
|
||||
|
|
|
@ -33,6 +33,7 @@ enum
|
|||
{
|
||||
BSP_IDBSP = 0,
|
||||
BSP_RAVEN,
|
||||
BSP_IGBSP,
|
||||
};
|
||||
|
||||
typedef struct
|
||||
|
@ -48,6 +49,7 @@ bspFormatDesc_t bspFormats[] =
|
|||
{
|
||||
{ QFBSPMODHEADER, RFIDBSP_VERSION, 512, 512, BSP_RAVEN },
|
||||
{ IDBSPMODHEADER, Q3IDBSP_VERSION, 128, 128, BSP_IDBSP },
|
||||
{ IDBSPMODHEADER, IGIDBSP_VERSION, 128, 128, BSP_IGBSP },
|
||||
{ IDBSPMODHEADER, RTCWBSP_VERSION, 128, 128, BSP_IDBSP },
|
||||
{ RBBSPMODHEADER, RFIDBSP_VERSION, 128, 128, BSP_RAVEN }
|
||||
};
|
||||
|
@ -1110,8 +1112,8 @@ static _inline void Mod_LoadFaceCommon( const dsurfacer_t *in, msurface_t *out )
|
|||
{
|
||||
// some q3a maps specify a lightmap shader for surfaces that do not have a lightmap,
|
||||
// workaround that... see pukka3tourney2 for example
|
||||
if( ( shaderType == SHADER_VERTEX && ( shaderref->shader->flags & SHADER_LIGHTMAP ) &&
|
||||
( shaderref->shader->passes[0].flags & SHADERSTAGE_LIGHTMAP ) ) )
|
||||
if( ( shaderType == SHADER_VERTEX && ( shaderref->shader->flags & SHADER_HASLIGHTMAP ) &&
|
||||
( shaderref->shader->stages[0].flags & SHADERSTAGE_LIGHTMAP )))
|
||||
out->shader = R_LoadShader( shaderref->name, shaderType, false, 0, shaderref->shader->type );
|
||||
else
|
||||
out->shader = shaderref->shader;
|
||||
|
@ -1287,7 +1289,7 @@ static void Mod_LoadFogs( const lump_t *l, const lump_t *brLump, const lump_t *b
|
|||
if( brLump->filelen % sizeof( *inbrushes ) )
|
||||
Host_Error( "Mod_LoadBrushes: funny lump size in %s\n", loadmodel->name );
|
||||
|
||||
if( mod_bspFormat->flags & BSP_RAVEN )
|
||||
if( mod_bspFormat->flags & (BSP_RAVEN|BSP_IGBSP))
|
||||
{
|
||||
inrbrushsides = ( void * )( mod_base + brSidesLump->fileofs );
|
||||
if( brSidesLump->filelen % sizeof( *inrbrushsides ) )
|
||||
|
@ -1324,28 +1326,27 @@ static void Mod_LoadFogs( const lump_t *l, const lump_t *brLump, const lump_t *b
|
|||
continue;
|
||||
}
|
||||
|
||||
if( mod_bspFormat->flags & BSP_RAVEN )
|
||||
if( mod_bspFormat->flags & (BSP_RAVEN|BSP_IGBSP))
|
||||
rbrushside = inrbrushsides + p;
|
||||
else
|
||||
brushside = inbrushsides + p;
|
||||
else brushside = inbrushsides + p;
|
||||
|
||||
p = LittleLong( in->visibleside );
|
||||
out->numplanes = LittleLong( brush->numsides );
|
||||
out->planes = Mod_Malloc( loadmodel, out->numplanes * sizeof( cplane_t ) );
|
||||
|
||||
if( mod_bspFormat->flags & BSP_RAVEN )
|
||||
if( mod_bspFormat->flags & (BSP_RAVEN|BSP_IGBSP))
|
||||
{
|
||||
if( p != -1 )
|
||||
out->visibleplane = loadbmodel->planes + LittleLong( rbrushside[p].planenum );
|
||||
for( j = 0; j < out->numplanes; j++ )
|
||||
out->planes[j] = *( loadbmodel->planes + LittleLong( rbrushside[j].planenum ) );
|
||||
out->planes[j] = *( loadbmodel->planes + LittleLong( rbrushside[j].planenum ));
|
||||
}
|
||||
else
|
||||
{
|
||||
if( p != -1 )
|
||||
out->visibleplane = loadbmodel->planes + LittleLong( brushside[p].planenum );
|
||||
for( j = 0; j < out->numplanes; j++ )
|
||||
out->planes[j] = *( loadbmodel->planes + LittleLong( brushside[j].planenum ) );
|
||||
out->planes[j] = *( loadbmodel->planes + LittleLong( brushside[j].planenum ));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1660,25 +1661,20 @@ static void Mod_LoadEntities( const lump_t *l, vec3_t gridSize, vec3_t ambient,
|
|||
{
|
||||
int n;
|
||||
bool isworld;
|
||||
float celcolorf[3] = { 0, 0, 0 };
|
||||
float gridsizef[3] = { 0, 0, 0 }, colorf[3] = { 0, 0, 0 }, ambientf = 0;
|
||||
char key[MAX_KEY], value[MAX_VALUE];
|
||||
token_t token;
|
||||
script_t *ents;
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
float celcolorf[3] = { 0, 0, 0 };
|
||||
#endif
|
||||
|
||||
Com_Assert( gridSize == NULL );
|
||||
Com_Assert( ambient == NULL );
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
Com_Assert( outline == NULL );
|
||||
#endif
|
||||
|
||||
VectorClear( gridSize );
|
||||
VectorClear( ambient );
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
VectorClear( outline );
|
||||
#endif
|
||||
|
||||
ents = Com_OpenScript( LUMP_ENTITIES, (char *)mod_base + l->fileofs, l->filelen );
|
||||
if( !ents ) return;
|
||||
|
||||
|
@ -1738,7 +1734,6 @@ static void Mod_LoadEntities( const lump_t *l, vec3_t gridSize, vec3_t ambient,
|
|||
VectorCopy( colori, colorf );
|
||||
}
|
||||
}
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
else if( !com.strcmp( key, "_outlinecolor" ) )
|
||||
{
|
||||
n = sscanf( value, "%f %f %f", &celcolorf[0], &celcolorf[1], &celcolorf[2] );
|
||||
|
@ -1749,7 +1744,6 @@ static void Mod_LoadEntities( const lump_t *l, vec3_t gridSize, vec3_t ambient,
|
|||
VectorCopy( celcolori, celcolorf );
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
if( isworld )
|
||||
|
@ -1759,11 +1753,10 @@ static void Mod_LoadEntities( const lump_t *l, vec3_t gridSize, vec3_t ambient,
|
|||
if( VectorCompare( colorf, vec3_origin ))
|
||||
VectorSet( colorf, 1.0, 1.0, 1.0 );
|
||||
VectorScale( colorf, ambientf, ambient );
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
|
||||
if( max( celcolorf[0], max( celcolorf[1], celcolorf[2] ) ) > 1.0f )
|
||||
VectorScale( celcolorf, 1.0f / 255.0f, celcolorf ); // [0..1] RGB -> [0..255] RGB
|
||||
VectorCopy( celcolorf, outline );
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -1860,11 +1853,9 @@ static void Mod_Finish( const lump_t *faces, const lump_t *light, vec3_t gridSiz
|
|||
for( i = 0; i < 3; i++ )
|
||||
mapConfig.ambient[i] = bound( 0, ambient[i]*( (float)( 1 << mapConfig.pow2MapOvrbr )/255.0f ), 1 );
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
for( i = 0; i < 3; i++ )
|
||||
mapConfig.outlineColor[i] = (byte)(bound( 0, outline[i]*255.0f, 255 ));
|
||||
mapConfig.outlineColor[3] = 255;
|
||||
#endif
|
||||
|
||||
R_SortSuperLightStyles();
|
||||
|
||||
|
@ -1992,27 +1983,23 @@ void Mod_LoadBrushModel( ref_model_t *mod, ref_model_t *parent, void *buffer )
|
|||
Mod_LoadEntities( &header->lumps[LUMP_ENTITIES], gridSize, ambient, outline );
|
||||
if( mod_bspFormat->flags & BSP_RAVEN )
|
||||
Mod_LoadVertexes_RBSP( &header->lumps[LUMP_VERTEXES] );
|
||||
else
|
||||
Mod_LoadVertexes( &header->lumps[LUMP_VERTEXES] );
|
||||
else Mod_LoadVertexes( &header->lumps[LUMP_VERTEXES] );
|
||||
Mod_LoadElems( &header->lumps[LUMP_ELEMENTS] );
|
||||
Mod_LoadLighting( &header->lumps[LUMP_LIGHTING], &header->lumps[LUMP_SURFACES] );
|
||||
if( mod_bspFormat->flags & BSP_RAVEN )
|
||||
Mod_LoadLightgrid_RBSP( &header->lumps[LUMP_LIGHTGRID] );
|
||||
else
|
||||
Mod_LoadLightgrid( &header->lumps[LUMP_LIGHTGRID] );
|
||||
else Mod_LoadLightgrid( &header->lumps[LUMP_LIGHTGRID] );
|
||||
Mod_LoadShaderrefs( &header->lumps[LUMP_SHADERS] );
|
||||
Mod_LoadPlanes( &header->lumps[LUMP_PLANES] );
|
||||
Mod_LoadFogs( &header->lumps[LUMP_FOGS], &header->lumps[LUMP_BRUSHES], &header->lumps[LUMP_BRUSHSIDES] );
|
||||
if( mod_bspFormat->flags & BSP_RAVEN )
|
||||
if( mod_bspFormat->flags & (BSP_RAVEN|BSP_IGBSP))
|
||||
Mod_LoadFaces_RBSP( &header->lumps[LUMP_SURFACES] );
|
||||
else
|
||||
Mod_LoadFaces( &header->lumps[LUMP_SURFACES] );
|
||||
else Mod_LoadFaces( &header->lumps[LUMP_SURFACES] );
|
||||
Mod_LoadLeafs( &header->lumps[LUMP_LEAFS], &header->lumps[LUMP_LEAFSURFACES] );
|
||||
Mod_LoadNodes( &header->lumps[LUMP_NODES] );
|
||||
if( mod_bspFormat->flags & BSP_RAVEN )
|
||||
Mod_LoadLightArray_RBSP( &header->lumps[LUMP_LIGHTARRAY] );
|
||||
else
|
||||
Mod_LoadLightArray();
|
||||
else Mod_LoadLightArray();
|
||||
|
||||
Mod_Finish( &header->lumps[LUMP_SURFACES], &header->lumps[LUMP_LIGHTING], gridSize, ambient, outline );
|
||||
|
||||
|
@ -2027,7 +2014,7 @@ void Mod_LoadBrushModel( ref_model_t *mod, ref_model_t *parent, void *buffer )
|
|||
bmodel = ( mbrushmodel_t * )starmod->extradata;
|
||||
|
||||
memcpy( starmod, mod, sizeof( ref_model_t ) );
|
||||
memcpy( bmodel, mod->extradata, sizeof( mbrushmodel_t ) );
|
||||
memcpy( bmodel, mod->extradata, sizeof( mbrushmodel_t ));
|
||||
|
||||
bmodel->firstmodelsurface = bmodel->surfaces + bm->firstface;
|
||||
bmodel->nummodelsurfaces = bm->numfaces;
|
||||
|
@ -2118,9 +2105,7 @@ void R_BeginRegistration( const char *mapname, const dvis_t *visData )
|
|||
mapConfig.deluxeMappingEnabled = false;
|
||||
|
||||
VectorClear( mapConfig.ambient );
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
VectorClear( mapConfig.outlineColor );
|
||||
#endif
|
||||
|
||||
com.sprintf( fullname, "maps/%s.bsp", mapname );
|
||||
|
||||
|
@ -2131,7 +2116,7 @@ void R_BeginRegistration( const char *mapname, const dvis_t *visData )
|
|||
|
||||
mapConfig.lightmapsPacking = true;
|
||||
|
||||
com.strncpy( lightmapsPath, fullname, sizeof( lightmapsPath ) );
|
||||
com.strncpy( lightmapsPath, fullname, sizeof( lightmapsPath ));
|
||||
p = com.strrchr( lightmapsPath, '.' );
|
||||
if( p )
|
||||
{
|
||||
|
|
|
@ -35,35 +35,29 @@ typedef struct
|
|||
typedef struct
|
||||
{
|
||||
char *name;
|
||||
unsigned int features;
|
||||
uint features;
|
||||
const char *string;
|
||||
|
||||
int object;
|
||||
int vertexShader;
|
||||
int fragmentShader;
|
||||
|
||||
int locEyeOrigin,
|
||||
locLightDir,
|
||||
locLightOrigin,
|
||||
locLightAmbient,
|
||||
locLightDiffuse,
|
||||
|
||||
locGlossIntensity,
|
||||
locGlossExponent,
|
||||
|
||||
locOffsetMappingScale,
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
locOutlineHeight,
|
||||
locOutlineCutOff,
|
||||
#endif
|
||||
locFrontPlane,
|
||||
locTextureWidth,
|
||||
locTextureHeight,
|
||||
locProjDistance,
|
||||
|
||||
locDeluxemapOffset[LM_STYLES],
|
||||
loclsColor[LM_STYLES]
|
||||
;
|
||||
int locEyeOrigin;
|
||||
int locLightDir;
|
||||
int locLightOrigin;
|
||||
int locLightAmbient;
|
||||
int locLightDiffuse;
|
||||
int locGlossIntensity;
|
||||
int locGlossExponent;
|
||||
int locOffsetMappingScale;
|
||||
int locOutlineHeight;
|
||||
int locOutlineCutOff;
|
||||
int locFrontPlane;
|
||||
int locTextureWidth;
|
||||
int locTextureHeight;
|
||||
int locProjDistance;
|
||||
int locDeluxemapOffset[LM_STYLES];
|
||||
int loclsColor[LM_STYLES];
|
||||
} glsl_program_t;
|
||||
|
||||
static glsl_program_t r_glslprograms[MAX_GLSL_PROGRAMS];
|
||||
|
@ -74,9 +68,7 @@ static void R_GetProgramUniformLocations( glsl_program_t *program );
|
|||
static const char *r_defaultGLSLProgram;
|
||||
static const char *r_defaultDistortionGLSLProgram;
|
||||
static const char *r_defaultShadowmapGLSLProgram;
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
static const char *r_defaultOutlineGLSLProgram;
|
||||
#endif
|
||||
|
||||
/*
|
||||
================
|
||||
|
@ -114,9 +106,7 @@ void R_InitGLSLPrograms( void )
|
|||
|
||||
R_RegisterGLSLProgram( DEFAULT_GLSL_SHADOWMAP_PROGRAM, r_defaultShadowmapGLSLProgram, 0|features );
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
R_RegisterGLSLProgram( DEFAULT_GLSL_OUTLINE_PROGRAM, r_defaultOutlineGLSLProgram, 0|features );
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -788,7 +778,6 @@ static const char *r_defaultShadowmapGLSLProgram =
|
|||
"#endif // FRAGMENT_SHADER\n"
|
||||
"\n";
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
static const char *r_defaultOutlineGLSLProgram =
|
||||
"// " APPLICATION " GLSL shader\n"
|
||||
"\n"
|
||||
|
@ -837,7 +826,6 @@ static const char *r_defaultOutlineGLSLProgram =
|
|||
"\n"
|
||||
"#endif // FRAGMENT_SHADER\n"
|
||||
"\n";
|
||||
#endif
|
||||
|
||||
/*
|
||||
================
|
||||
|
@ -1050,9 +1038,7 @@ void R_ProgramDump_f( void )
|
|||
DUMP_PROGRAM( defaultGLSLProgram );
|
||||
DUMP_PROGRAM( defaultDistortionGLSLProgram );
|
||||
DUMP_PROGRAM( defaultShadowmapGLSLProgram );
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
DUMP_PROGRAM( defaultOutlineGLSLProgram );
|
||||
#endif
|
||||
}
|
||||
#undef DUMP_PROGRAM
|
||||
|
||||
|
@ -1061,10 +1047,8 @@ void R_ProgramDump_f( void )
|
|||
R_UpdateProgramUniforms
|
||||
================
|
||||
*/
|
||||
void R_UpdateProgramUniforms( int elem, vec3_t eyeOrigin,
|
||||
vec3_t lightOrigin, vec3_t lightDir, vec4_t ambient, vec4_t diffuse,
|
||||
superLightStyle_t *superLightStyle, bool frontPlane, int TexWidth, int TexHeight,
|
||||
float projDistance, float offsetmappingScale )
|
||||
void R_UpdateProgramUniforms( int elem, vec3_t eyeOrigin, vec3_t lightOrigin, vec3_t lightDir, vec4_t ambient, vec4_t diffuse,
|
||||
superLightStyle_t *superLightStyle, bool frontPlane, int TexWidth, int TexHeight, float projDistance, float offsetmappingScale )
|
||||
{
|
||||
glsl_program_t *program = r_glslprograms + elem - 1;
|
||||
|
||||
|
@ -1089,12 +1073,10 @@ void R_UpdateProgramUniforms( int elem, vec3_t eyeOrigin,
|
|||
if( program->locOffsetMappingScale >= 0 )
|
||||
pglUniform1fARB( program->locOffsetMappingScale, offsetmappingScale );
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
if( program->locOutlineHeight >= 0 )
|
||||
pglUniform1fARB( program->locOutlineHeight, projDistance );
|
||||
if( program->locOutlineCutOff >= 0 )
|
||||
pglUniform1fARB( program->locOutlineCutOff, max( 0, r_outlines_cutoff->value ) );
|
||||
#endif
|
||||
|
||||
if( program->locFrontPlane >= 0 )
|
||||
pglUniform1fARB( program->locFrontPlane, frontPlane ? 1 : -1 );
|
||||
|
@ -1182,10 +1164,8 @@ static void R_GetProgramUniformLocations( glsl_program_t *program )
|
|||
|
||||
program->locOffsetMappingScale = pglGetUniformLocationARB( program->object, "OffsetMappingScale" );
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
program->locOutlineHeight = pglGetUniformLocationARB( program->object, "OutlineHeight" );
|
||||
program->locOutlineCutOff = pglGetUniformLocationARB( program->object, "OutlineCutOff" );
|
||||
#endif
|
||||
|
||||
program->locFrontPlane = pglGetUniformLocationARB( program->object, "FrontPlane" );
|
||||
|
||||
|
|
|
@ -160,14 +160,12 @@ typedef struct entity_s
|
|||
float radius; // used as RT_SPRITE's radius
|
||||
float rotation;
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
float outlineHeight;
|
||||
union
|
||||
{
|
||||
rgba_t outlineColor;
|
||||
rgba_t outlineRGBA;
|
||||
};
|
||||
#endif
|
||||
} ref_entity_t;
|
||||
|
||||
void R_ModelBounds( const struct ref_model_s *model, vec3_t mins, vec3_t maxs );
|
||||
|
|
|
@ -582,11 +582,9 @@ void GL_InitCommands( void )
|
|||
r_shadows_pcf = Cvar_Get( "r_shadows_pcf", "0", CVAR_ARCHIVE, "allow pcf filtration" );
|
||||
r_shadows_self_shadow = Cvar_Get( "r_shadows_self_shadow", "0", CVAR_ARCHIVE, "allow self-shadowing" );
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
r_outlines_world = Cvar_Get( "r_outlines_world", "1.8", CVAR_ARCHIVE, "cel-shading world outline thinkness" );
|
||||
r_outlines_scale = Cvar_Get( "r_outlines_scale", "1", CVAR_ARCHIVE, "outilines scale" );
|
||||
r_outlines_cutoff = Cvar_Get( "r_outlines_cutoff", "712", CVAR_ARCHIVE, "cutoff factor" );
|
||||
#endif
|
||||
|
||||
r_lodbias = Cvar_Get( "r_lodbias", "0", CVAR_ARCHIVE, "md3 or skm lod bias" );
|
||||
r_lodscale = Cvar_Get( "r_lodscale", "5.0", CVAR_ARCHIVE, "md3 or skm LOD scale factor" );
|
||||
|
@ -1053,16 +1051,14 @@ static void R_InitMedia( void )
|
|||
R_InitGLSLPrograms();
|
||||
R_InitImages();
|
||||
R_InitCinematics ();
|
||||
R_InitShaders((glw_state.developer <= 3));
|
||||
R_InitShaders();
|
||||
R_InitModels();
|
||||
R_InitSkinFiles();
|
||||
R_InitCoronas();
|
||||
R_InitShadows();
|
||||
R_InitOcclusionQueries();
|
||||
R_InitCustomColors ();
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
R_InitOutlines ();
|
||||
#endif
|
||||
|
||||
GL_SetDefaultTexState ();
|
||||
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -21,11 +21,15 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|||
#define __R_SHADER_H__
|
||||
|
||||
#define MAX_SHADERS 4096
|
||||
#define SHADERS_HASH_SIZE 256
|
||||
#define MAX_STAGE_TEXTURES 256 // same as MAX_SPRITE_FRAMES
|
||||
#define MAX_SHADER_STAGES 8
|
||||
#define MAX_SHADER_DEFORMS 8
|
||||
#define MAX_STAGE_TEXTURES 256
|
||||
#define MAX_SHADER_TCMODS 8
|
||||
|
||||
#define MAX_TABLES 4096
|
||||
#define TABLES_HASH_SIZE 1024
|
||||
|
||||
// shader types
|
||||
#define SHADER_INVALID -1
|
||||
#define SHADER_UNKNOWN 0
|
||||
|
@ -41,33 +45,55 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|||
#define SHADER_NEARBOX 10
|
||||
#define SHADER_PLANAR_SHADOW 11
|
||||
#define SHADER_OPAQUE_OCCLUDER 12
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
#define SHADER_OUTLINE 13
|
||||
#endif
|
||||
|
||||
// shader flags
|
||||
typedef enum
|
||||
{
|
||||
SHADER_STATIC = BIT(0), // never freed by R_ShaderFreeUnused
|
||||
SHADER_DEPTHWRITE = BIT(1),
|
||||
SHADER_SKYPARMS = BIT(2),
|
||||
SHADER_SURFACEPARM = BIT(3), // shader has surface and contents parms
|
||||
SHADER_POLYGONOFFSET = BIT(4),
|
||||
SHADER_CULL_FRONT = BIT(5),
|
||||
SHADER_CULL_BACK = BIT(6),
|
||||
SHADER_VIDEOMAP = BIT(7),
|
||||
SHADER_MATERIAL = BIT(8),
|
||||
SHADER_DEFORM_NORMAL = BIT(9),
|
||||
SHADER_ENTITY_MERGABLE = BIT(10),
|
||||
SHADER_AUTOSPRITE = BIT(11),
|
||||
SHADER_NO_MODULATIVE_DLIGHTS = BIT(12),
|
||||
SHADER_HASLIGHTMAP = BIT(13),
|
||||
SHADER_PORTAL = BIT(14),
|
||||
SHADER_PORTAL_CAPTURE1 = BIT(15),
|
||||
SHADER_PORTAL_CAPTURE2 = BIT(16),
|
||||
SHADER_RENDERMODE = BIT(17),
|
||||
SHADER_PORTAL_CAPTURE = (SHADER_PORTAL_CAPTURE1|SHADER_PORTAL_CAPTURE1),
|
||||
SHADER_CULL = (SHADER_CULL_FRONT|SHADER_CULL_BACK)
|
||||
} shaderFlags_t;
|
||||
|
||||
// shaderstage flags
|
||||
enum
|
||||
{
|
||||
SHADER_DEPTHWRITE = BIT(0),
|
||||
SHADER_SKYPARMS = BIT(1),
|
||||
SHADER_POLYGONOFFSET = BIT(2),
|
||||
SHADER_CULL_FRONT = BIT(3),
|
||||
SHADER_CULL_BACK = BIT(4),
|
||||
SHADER_VIDEOMAP = BIT(5),
|
||||
SHADER_MATERIAL = BIT(6),
|
||||
SHADER_DEFORM_NORMAL = BIT(7),
|
||||
SHADER_ENTITY_MERGABLE = BIT(8),
|
||||
SHADER_AUTOSPRITE = BIT(9),
|
||||
SHADER_NO_MODULATIVE_DLIGHTS = BIT(10),
|
||||
SHADER_LIGHTMAP = BIT(11),
|
||||
SHADER_PORTAL = BIT(12),
|
||||
SHADER_PORTAL_CAPTURE1 = BIT(13),
|
||||
SHADER_PORTAL_CAPTURE2 = BIT(14),
|
||||
SHADER_PORTAL_CAPTURE = SHADER_PORTAL_CAPTURE1|SHADER_PORTAL_CAPTURE1,
|
||||
};
|
||||
SHADERSTAGE_ANIMFREQUENCY = BIT(0), // auto-animate value
|
||||
SHADERSTAGE_FRAMES = BIT(1), // bundle have anim frames, thats can be switching manually
|
||||
SHADERSTAGE_ANGLEDMAP = BIT(2), // doom1 eight angle-aligned ( 360 / 8 ) textures
|
||||
SHADERSTAGE_LIGHTMAP = BIT(3),
|
||||
SHADERSTAGE_DETAIL = BIT(4),
|
||||
SHADERSTAGE_NOCOLORARRAY = BIT(5),
|
||||
SHADERSTAGE_DLIGHT = BIT(6),
|
||||
SHADERSTAGE_PORTALMAP = BIT(7),
|
||||
SHADERSTAGE_STENCILSHADOW = BIT(8),
|
||||
SHADERSTAGE_BLEND_REPLACE = BIT(9),
|
||||
SHADERSTAGE_BLEND_MODULATE = BIT(10),
|
||||
SHADERSTAGE_BLEND_ADD = BIT(11),
|
||||
SHADERSTAGE_BLEND_DECAL = BIT(12)
|
||||
} stageFlags_t;
|
||||
|
||||
#define SHADERSTAGE_BLENDMODE (SHADERSTAGE_BLEND_REPLACE|SHADERSTAGE_BLEND_MODULATE|SHADERSTAGE_BLEND_ADD|SHADERSTAGE_BLEND_DECAL)
|
||||
|
||||
// sorting
|
||||
enum
|
||||
typedef enum
|
||||
{
|
||||
SORT_NONE = 0,
|
||||
SORT_PORTAL = 1,
|
||||
|
@ -76,51 +102,34 @@ enum
|
|||
SORT_DECAL = 4,
|
||||
SORT_ALPHATEST = 5,
|
||||
SORT_BANNER = 6,
|
||||
SORT_UNDERWATER = 8,
|
||||
SORT_UNDERWATER = 7,
|
||||
SORT_WATER = 8,
|
||||
SORT_ADDITIVE = 9,
|
||||
SORT_NEAREST = 16
|
||||
};
|
||||
|
||||
// shaderpass flags
|
||||
#define SHADERSTAGE_MARK_BEGIN 0x10000 // same as GLSTATE_MARK_END
|
||||
enum
|
||||
{
|
||||
SHADERSTAGE_LIGHTMAP = SHADERSTAGE_MARK_BEGIN,
|
||||
SHADERSTAGE_DETAIL = SHADERSTAGE_MARK_BEGIN << 1,
|
||||
SHADERSTAGE_NOCOLORARRAY = SHADERSTAGE_MARK_BEGIN << 2,
|
||||
SHADERSTAGE_DLIGHT = SHADERSTAGE_MARK_BEGIN << 3,
|
||||
SHADERSTAGE_DELUXEMAP = SHADERSTAGE_MARK_BEGIN << 4,
|
||||
SHADERSTAGE_PORTALMAP = SHADERSTAGE_MARK_BEGIN << 5,
|
||||
SHADERSTAGE_STENCILSHADOW = SHADERSTAGE_MARK_BEGIN << 6,
|
||||
|
||||
SHADERSTAGE_BLEND_REPLACE = SHADERSTAGE_MARK_BEGIN << 7,
|
||||
SHADERSTAGE_BLEND_MODULATE = SHADERSTAGE_MARK_BEGIN << 8,
|
||||
SHADERSTAGE_BLEND_ADD = SHADERSTAGE_MARK_BEGIN << 9,
|
||||
SHADERSTAGE_BLEND_DECAL = SHADERSTAGE_MARK_BEGIN << 10
|
||||
};
|
||||
|
||||
#define SHADERSTAGE_BLENDMODE (SHADERSTAGE_BLEND_REPLACE|SHADERSTAGE_BLEND_MODULATE|SHADERSTAGE_BLEND_ADD|SHADERSTAGE_BLEND_DECAL)
|
||||
} sort_t;
|
||||
|
||||
// transform functions
|
||||
typedef enum
|
||||
{
|
||||
WAVEFORM_SIN = 1,
|
||||
WAVEFORM_TRIANGLE = 2,
|
||||
WAVEFORM_SQUARE = 3,
|
||||
WAVEFORM_SAWTOOTH = 4,
|
||||
WAVEFORM_INVERSESAWTOOTH = 5,
|
||||
WAVEFORM_NOISE = 6,
|
||||
WAVEFORM_CONSTANT = 7
|
||||
WAVEFORM_NONE = 0,
|
||||
WAVEFORM_SIN,
|
||||
WAVEFORM_TRIANGLE,
|
||||
WAVEFORM_SQUARE,
|
||||
WAVEFORM_SAWTOOTH,
|
||||
WAVEFORM_INVERSESAWTOOTH,
|
||||
WAVEFORM_NOISE,
|
||||
WAVEFORM_CONSTANT
|
||||
} waveForm_t;
|
||||
|
||||
// RGB colors generation
|
||||
enum
|
||||
typedef enum
|
||||
{
|
||||
RGBGEN_UNKNOWN,
|
||||
RGBGEN_UNKNOWN = 0,
|
||||
RGBGEN_IDENTITY,
|
||||
RGBGEN_IDENTITY_LIGHTING,
|
||||
RGBGEN_CONST,
|
||||
RGBGEN_WAVE,
|
||||
RGBGEN_COLORWAVE,
|
||||
RGBGEN_ENTITY,
|
||||
RGBGEN_ONE_MINUS_ENTITY,
|
||||
RGBGEN_VERTEX,
|
||||
|
@ -131,63 +140,69 @@ enum
|
|||
RGBGEN_LIGHTING_AMBIENT_ONLY,
|
||||
RGBGEN_FOG,
|
||||
RGBGEN_CUSTOM,
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
RGBGEN_OUTLINE,
|
||||
#endif
|
||||
RGBGEN_ENVIRONMENT,
|
||||
};
|
||||
RGBGEN_ENVIRONMENT
|
||||
} rgbGenType_t;
|
||||
|
||||
// alpha channel generation
|
||||
enum
|
||||
typedef enum
|
||||
{
|
||||
ALPHAGEN_UNKNOWN,
|
||||
ALPHAGEN_UNKNOWN = 0,
|
||||
ALPHAGEN_IDENTITY,
|
||||
ALPHAGEN_CONST,
|
||||
ALPHAGEN_PORTAL,
|
||||
ALPHAGEN_VERTEX,
|
||||
ALPHAGEN_ONE_MINUS_VERTEX,
|
||||
ALPHAGEN_ENTITY,
|
||||
ALPHAGEN_ONE_MINUS_ENTITY,
|
||||
ALPHAGEN_SPECULAR,
|
||||
ALPHAGEN_WAVE,
|
||||
ALPHAGEN_ALPHAWAVE,
|
||||
ALPHAGEN_FADE, // same as portal but for other things
|
||||
ALPHAGEN_ONE_MINUS_FADE,
|
||||
ALPHAGEN_DOT,
|
||||
ALPHAGEN_ONE_MINUS_DOT,
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
ALPHAGEN_OUTLINE
|
||||
#endif
|
||||
};
|
||||
} alphaGenType_t;
|
||||
|
||||
// texture coordinates generation
|
||||
enum
|
||||
typedef enum
|
||||
{
|
||||
TCGEN_NONE,
|
||||
TCGEN_NONE = 0,
|
||||
TCGEN_BASE,
|
||||
TCGEN_LIGHTMAP,
|
||||
TCGEN_ENVIRONMENT,
|
||||
TCGEN_VECTOR,
|
||||
TCGEN_LIGHTVECTOR,
|
||||
TCGEN_HALFANGLE,
|
||||
TCGEN_WARP,
|
||||
TCGEN_REFLECTION,
|
||||
TCGEN_FOG,
|
||||
TCGEN_REFLECTION_CELLSHADE,
|
||||
TCGEN_SVECTORS,
|
||||
TCGEN_PROJECTION,
|
||||
TCGEN_PROJECTION_SHADOW
|
||||
};
|
||||
TCGEN_PROJECTION_SHADOW,
|
||||
TCGEN_NORMAL
|
||||
} tcGenType_t;
|
||||
|
||||
// tcmod functions
|
||||
enum
|
||||
typedef enum
|
||||
{
|
||||
TCMOD_NONE,
|
||||
TCMOD_NONE = 0,
|
||||
TCMOD_TRANSLATE,
|
||||
TCMOD_SCALE,
|
||||
TCMOD_SCROLL,
|
||||
TCMOD_ROTATE,
|
||||
TCMOD_STRETCH,
|
||||
TCMOD_TRANSFORM,
|
||||
TCMOD_TURB,
|
||||
TCMOD_STRETCH
|
||||
};
|
||||
TCMOD_CONVEYOR // same as TCMOD_SCROLL, but can be controlled by entity
|
||||
} tcModType_t;
|
||||
|
||||
// vertices deformation
|
||||
enum
|
||||
typedef enum
|
||||
{
|
||||
DEFORM_NONE,
|
||||
DEFORM_NONE = 0,
|
||||
DEFORM_WAVE,
|
||||
DEFORM_NORMAL,
|
||||
DEFORM_BULGE,
|
||||
|
@ -196,10 +211,25 @@ enum
|
|||
DEFORM_AUTOSPRITE2,
|
||||
DEFORM_PROJECTION_SHADOW,
|
||||
DEFORM_AUTOPARTICLE,
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
DEFORM_OUTLINE
|
||||
#endif
|
||||
};
|
||||
} deformType_t;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
TABLE_SNAP = BIT(0),
|
||||
TABLE_CLAMP = BIT(1)
|
||||
} tableFlags_t;
|
||||
|
||||
typedef struct table_s
|
||||
{
|
||||
char *name; // table name
|
||||
int index;
|
||||
tableFlags_t flags;
|
||||
|
||||
int size;
|
||||
float *values; // float[]
|
||||
struct table_s *nextHash;
|
||||
} table_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
@ -209,40 +239,47 @@ typedef struct
|
|||
|
||||
typedef struct
|
||||
{
|
||||
word type;
|
||||
tcModType_t type;
|
||||
float args[6];
|
||||
} tcmod_t;
|
||||
} tcMod_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
word type;
|
||||
rgbGenType_t type;
|
||||
float *args;
|
||||
waveFunc_t *func;
|
||||
} colorgen_t;
|
||||
} rgbGen_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
word type;
|
||||
alphaGenType_t type;
|
||||
float *args;
|
||||
waveFunc_t *func;
|
||||
} alphaGen_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
deformType_t type;
|
||||
float args[4];
|
||||
waveFunc_t func;
|
||||
} deformv_t;
|
||||
} deform_t;
|
||||
|
||||
// Per-pass rendering state information
|
||||
typedef struct ref_stage_s
|
||||
{
|
||||
uint flags;
|
||||
uint glstate; // GLSTATE_ flags
|
||||
uint glState; // GLSTATE_ flags
|
||||
|
||||
colorgen_t rgbgen;
|
||||
colorgen_t alphagen;
|
||||
rgbGen_t rgbGen;
|
||||
alphaGen_t alphaGen;
|
||||
|
||||
word tcgen;
|
||||
vec_t *tcgenVec;
|
||||
|
||||
word numtcmods;
|
||||
tcmod_t *tcmods;
|
||||
word numtcMods;
|
||||
tcMod_t *tcMods;
|
||||
|
||||
uint cin;
|
||||
uint cinHandle;
|
||||
|
||||
const char *program;
|
||||
word program_type;
|
||||
|
@ -256,53 +293,48 @@ typedef struct ref_stage_s
|
|||
typedef struct ref_shader_s
|
||||
{
|
||||
char *name;
|
||||
word type;
|
||||
|
||||
word flags;
|
||||
uint flags;
|
||||
word features;
|
||||
uint sort;
|
||||
sort_t sort;
|
||||
sort_t realsort; // member original sort type until rendermode is reset
|
||||
uint sortkey;
|
||||
uint touchFrame; // 0 = free
|
||||
|
||||
int type;
|
||||
word num_stages;
|
||||
ref_stage_t *stages;
|
||||
|
||||
word numpasses;
|
||||
ref_stage_t *passes;
|
||||
|
||||
word numdeforms;
|
||||
deformv_t *deforms;
|
||||
word numDeforms;
|
||||
deform_t *deforms;
|
||||
|
||||
skydome_t *skyParms;
|
||||
rgba_t fog_color;
|
||||
float fog_dist, fog_clearDist;
|
||||
float fog_dist;
|
||||
float fog_clearDist;
|
||||
|
||||
float offsetmapping_scale;
|
||||
|
||||
struct ref_shader_s *hash_next;
|
||||
struct ref_shader_s *nextHash;
|
||||
} ref_shader_t;
|
||||
|
||||
// memory management
|
||||
extern byte *r_shadersmempool;
|
||||
|
||||
extern ref_shader_t r_shaders[MAX_SHADERS];
|
||||
extern int r_numShaders;
|
||||
extern skydome_t *r_skydomes[MAX_SHADERS];
|
||||
|
||||
#define Shader_Sortkey( shader, sort ) ((( sort )<<26 )|( shader - r_shaders ))
|
||||
#define Shader_Malloc( size ) Mem_Alloc( r_shadersmempool, size )
|
||||
#define Shader_Free( data ) Mem_Free( data )
|
||||
#define Shader_Sortkey( shader, sort ) ( ( ( sort )<<26 )|( shader-r_shaders ) )
|
||||
|
||||
void R_InitShaders( bool silent );
|
||||
|
||||
void R_InitShaders( void );
|
||||
void R_ShutdownShaders( void );
|
||||
|
||||
void R_UploadCinematicShader( const ref_shader_t *shader );
|
||||
|
||||
void R_DeformvBBoxForShader( const ref_shader_t *shader, vec3_t ebbox );
|
||||
|
||||
ref_shader_t *R_LoadShader( const char *name, int type, bool forceDefault, int addFlags, int ignoreType );
|
||||
|
||||
ref_shader_t *R_RegisterPic( const char *name );
|
||||
ref_shader_t *R_RegisterShader( const char *name );
|
||||
ref_shader_t *R_RegisterSkin( const char *name );
|
||||
|
||||
void R_ShaderList_f( void );
|
||||
void R_ShaderDump_f( void );
|
||||
ref_shader_t *R_LoadShader( const char *name, int type, bool forceDefault, int addFlags, int ignoreType );
|
||||
|
||||
|
||||
#endif /*__R_SHADER_H__*/
|
||||
|
|
|
@ -1072,10 +1072,8 @@ static void R_DrawBonesFrameLerp( const meshbuffer_t *mb, float backlerp )
|
|||
{
|
||||
if( ( features & MF_SVECTORS ) || r_shownormals->integer )
|
||||
features |= MF_NORMALS;
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
if( e->outlineHeight )
|
||||
features |= MF_NORMALS|(GL_Support( R_SHADER_GLSL100_EXT ) ? MF_ENABLENORMALS : 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
// not sure if it's really needed
|
||||
|
|
|
@ -265,12 +265,11 @@ static void R_DrawBlackBottom( skydome_t *skydome )
|
|||
if( r_shownormals->integer )
|
||||
features |= MF_NORMALS;
|
||||
|
||||
// HACK HACK HACK
|
||||
// skies ought not to write to depth buffer
|
||||
// HACKHACK skies ought not to write to depth buffer
|
||||
shader->flags &= ~SHADER_DEPTHWRITE;
|
||||
shader->passes[0].flags &= ~GLSTATE_DEPTHWRITE;
|
||||
shader->stages[0].glState &= ~GLSTATE_DEPTHWRITE;
|
||||
R_DrawSkySide( skydome, 5, shader, features );
|
||||
shader->passes[0].flags |= GLSTATE_DEPTHWRITE;
|
||||
shader->stages[0].glState |= GLSTATE_DEPTHWRITE;
|
||||
shader->flags |= SHADER_DEPTHWRITE;
|
||||
}
|
||||
|
||||
|
@ -365,7 +364,7 @@ void R_DrawSky( ref_shader_t *shader )
|
|||
else
|
||||
R_DrawBlackBottom( skydome );
|
||||
|
||||
if( shader->numpasses )
|
||||
if( shader->num_stages )
|
||||
{
|
||||
bool flush = false;
|
||||
int features = shader->features;
|
||||
|
|
|
@ -97,19 +97,16 @@ bool R_CullSurface( msurface_t *surf, unsigned int clipflags )
|
|||
return true;
|
||||
}
|
||||
|
||||
if( surf->facetype == MST_PLANAR && r_faceplanecull->integer
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
&& !RI.currententity->outlineHeight
|
||||
#endif
|
||||
&& ( shader->flags & ( SHADER_CULL_FRONT|SHADER_CULL_BACK ) ) )
|
||||
if( surf->facetype == MST_PLANAR && r_faceplanecull->integer &&
|
||||
!RI.currententity->outlineHeight && ( shader->flags & (SHADER_CULL_FRONT|SHADER_CULL_BACK)))
|
||||
{
|
||||
// Vic: I hate q3map2. I really do.
|
||||
if( !VectorCompare( surf->plane->normal, vec3_origin ) )
|
||||
if( !VectorCompare( surf->plane->normal, vec3_origin ))
|
||||
{
|
||||
float dist;
|
||||
|
||||
dist = PlaneDiff( modelorg, surf->plane );
|
||||
if( ( shader->flags & SHADER_CULL_FRONT ) || ( RI.params & RP_MIRRORVIEW ) )
|
||||
if( ( shader->flags & SHADER_CULL_FRONT ) || ( RI.params & RP_MIRRORVIEW ))
|
||||
{
|
||||
if( dist <= BACKFACE_EPSILON )
|
||||
return true;
|
||||
|
@ -121,8 +118,7 @@ bool R_CullSurface( msurface_t *surf, unsigned int clipflags )
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ( clipflags && R_CullBox( surf->mins, surf->maxs, clipflags ) );
|
||||
return ( clipflags && R_CullBox( surf->mins, surf->maxs, clipflags ));
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -224,18 +220,16 @@ R_AddBrushModelToList
|
|||
*/
|
||||
void R_AddBrushModelToList( ref_entity_t *e )
|
||||
{
|
||||
unsigned int i;
|
||||
uint i;
|
||||
bool rotated;
|
||||
ref_model_t *model = e->model;
|
||||
mbrushmodel_t *bmodel = ( mbrushmodel_t * )model->extradata;
|
||||
msurface_t *psurf;
|
||||
unsigned int dlightbits;
|
||||
uint dlightbits;
|
||||
meshbuffer_t *mb;
|
||||
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
e->outlineHeight = r_worldent->outlineHeight;
|
||||
Vector4Copy( r_worldent->outlineRGBA, e->outlineColor );
|
||||
#endif
|
||||
|
||||
rotated = !Matrix_Compare( e->axis, axis_identity );
|
||||
VectorSubtract( RI.refdef.vieworg, e->origin, modelorg );
|
||||
|
@ -577,18 +571,16 @@ void R_DrawWorld( void )
|
|||
RI.previousentity = NULL;
|
||||
RI.currententity = r_worldent;
|
||||
RI.currentmodel = RI.currententity->model;
|
||||
#ifdef HARDWARE_OUTLINES
|
||||
if( (RI.refdef.rdflags & RDF_WORLDOUTLINES) && (r_viewcluster != -1) )
|
||||
|
||||
if( (RI.refdef.rdflags & RDF_WORLDOUTLINES) && (r_viewcluster != -1))
|
||||
RI.currententity->outlineHeight = max( 0.0f, r_outlines_world->value );
|
||||
else
|
||||
RI.currententity->outlineHeight = 0.0f;
|
||||
else RI.currententity->outlineHeight = 0.0f;
|
||||
Vector4Copy( mapConfig.outlineColor, RI.currententity->outlineColor );
|
||||
#endif
|
||||
|
||||
if( !( RI.params & RP_SHADOWMAPVIEW ) )
|
||||
{
|
||||
R_AllocMeshbufPointers( &RI );
|
||||
memset( RI.surfmbuffers, 0, r_worldbrushmodel->numsurfaces * sizeof( meshbuffer_t * ) );
|
||||
Mem_Set( RI.surfmbuffers, 0, r_worldbrushmodel->numsurfaces * sizeof( meshbuffer_t * ));
|
||||
|
||||
R_CalcDistancesToFogVolumes();
|
||||
}
|
||||
|
|
|
@ -6,6 +6,52 @@
|
|||
--------------------Configuration: render - Win32 Debug--------------------
|
||||
</h3>
|
||||
<h3>Command Lines</h3>
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP39A.tmp" with contents
|
||||
[
|
||||
/nologo /MDd /W3 /Gm /Gi /GX /ZI /Od /I "../public" /I "../common" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FR"..\temp\render\!debug/" /Fo"..\temp\render\!debug/" /Fd"..\temp\render\!debug/" /FD /c
|
||||
"D:\Xash3D\src_main\render\r_shader.c"
|
||||
]
|
||||
Creating command line "cl.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP39A.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP39B.tmp" with contents
|
||||
[
|
||||
msvcrtd.lib user32.lib gdi32.lib /nologo /subsystem:windows /dll /incremental:yes /pdb:"..\temp\render\!debug/render.pdb" /debug /machine:I386 /nodefaultlib:"msvcrt.lib" /out:"..\temp\render\!debug/render.dll" /implib:"..\temp\render\!debug/render.lib" /pdbtype:sept
|
||||
"\Xash3D\src_main\temp\render\!debug\cin.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_alias.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_backend.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_bloom.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_cin.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_cull.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_draw.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_image.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_light.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_main.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_math.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_mesh.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_model.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_opengl.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_poly.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_program.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_register.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_shader.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_shadow.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_skin.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_skm.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_sky.obj"
|
||||
"\Xash3D\src_main\temp\render\!debug\r_surf.obj"
|
||||
]
|
||||
Creating command line "link.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP39B.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP39C.bat" with contents
|
||||
[
|
||||
@echo off
|
||||
copy \Xash3D\src_main\temp\render\!debug\render.dll "D:\Xash3D\bin\render.dll"
|
||||
]
|
||||
Creating command line "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP39C.bat"
|
||||
Compiling...
|
||||
r_shader.c
|
||||
Linking...
|
||||
<h3>Output Window</h3>
|
||||
Performing Custom Build Step on \Xash3D\src_main\temp\render\!debug\render.dll
|
||||
‘ª®¯¨à®¢ ® ä ©«®¢: 1.
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -1,100 +0,0 @@
|
|||
<html>
|
||||
<body>
|
||||
<pre>
|
||||
<h1>Build Log</h1>
|
||||
<h3>
|
||||
--------------------Configuration: server - Win32 Debug--------------------
|
||||
</h3>
|
||||
<h3>Command Lines</h3>
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP271.tmp" with contents
|
||||
[
|
||||
/nologo /MDd /W3 /Gm /Gi /GX /ZI /Od /I "./" /I "ents" /I "game" /I "global" /I "monsters" /I "../common" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FR"..\temp\server\!debug/" /Fo"..\temp\server\!debug/" /Fd"..\temp\server\!debug/" /FD /c
|
||||
"D:\Xash3D\src_main\server\monsters\player.cpp"
|
||||
]
|
||||
Creating command line "cl.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP271.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP272.tmp" with contents
|
||||
[
|
||||
msvcrtd.lib /nologo /subsystem:windows /dll /incremental:yes /pdb:"..\temp\server\!debug/server.pdb" /debug /machine:I386 /nodefaultlib:"libc.lib" /def:".\server.def" /out:"..\temp\server\!debug/server.dll" /implib:"..\temp\server\!debug/server.lib" /pdbtype:sept
|
||||
"\Xash3D\src_main\temp\server\!debug\ai_sound.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\animating.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\animation.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\apache.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\barnacle.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\barney.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\basebrush.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\baseentity.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\basefunc.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\basefx.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\baseinfo.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\baseitem.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\baselogic.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\basemonster.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\basemover.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\baseother.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\basepath.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\basephys.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\baserockets.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\basetank.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\basetrigger.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\baseutil.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\baseweapon.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\baseworld.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\client.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\combat.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\decals.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\defaultai.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\dll_int.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\flyingmonster.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\game.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\gamerules.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\generic.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\globals.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\gman.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\hassassin.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\headcrab.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\hgrunt.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\leech.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\legacy.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\lights.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\multiplay_gamerules.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\nodes.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\osprey.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\parent.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\player.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\rat.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\roach.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\saverestore.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\scientist.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\scripted.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\sfx.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\singleplay_gamerules.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\sound.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\squadmonster.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\talkmonster.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\teamplay_gamerules.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\turret.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\utils.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\weapon_generic.obj"
|
||||
"\Xash3D\src_main\temp\server\!debug\zombie.obj"
|
||||
]
|
||||
Creating command line "link.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP272.tmp"
|
||||
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP273.bat" with contents
|
||||
[
|
||||
@echo off
|
||||
copy \Xash3D\src_main\temp\server\!debug\server.dll "D:\Xash3D\bin\server.dll"
|
||||
]
|
||||
Creating command line "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP273.bat"
|
||||
Compiling...
|
||||
player.cpp
|
||||
Linking...
|
||||
<h3>Output Window</h3>
|
||||
Performing Custom Build Step on \Xash3D\src_main\temp\server\!debug\server.dll
|
||||
‘ª®¯¨à®¢ ® ä ©«®¢: 1.
|
||||
|
||||
|
||||
|
||||
<h3>Results</h3>
|
||||
server.dll - 0 error(s), 0 warning(s)
|
||||
</pre>
|
||||
</body>
|
||||
</html>
|
Reference in New Issue