tr_shade_calc.c File Reference

#include "tr_local.h"

Include dependency graph for tr_shade_calc.c:

Go to the source code of this file.

Defines
#define	WAVEVALUE(table, base, amplitude, phase, freq)   ((base) + table[ myftol( ( ( (phase) + tess.shaderTime * (freq) ) * FUNCTABLE_SIZE ) ) & FUNCTABLE_MASK ] * (amplitude))
Functions
void	Autosprite2Deform (void)
void	AutospriteDeform (void)
void	DeformText (const char *text)
float	EvalWaveForm (const waveForm_t *wf)
float	EvalWaveFormClamped (const waveForm_t *wf)
void	GlobalVectorToLocal (const vec3_t in, vec3_t out)
void	RB_CalcAlphaFromEntity (unsigned char *dstColors)
void	RB_CalcAlphaFromOneMinusEntity (unsigned char *dstColors)
void	RB_CalcBulgeVertexes (deformStage_t *ds)
void	RB_CalcColorFromEntity (unsigned char *dstColors)
void	RB_CalcColorFromOneMinusEntity (unsigned char *dstColors)
void	RB_CalcDeformNormals (deformStage_t *ds)
void	RB_CalcDeformVertexes (deformStage_t *ds)
void	RB_CalcDiffuseColor (unsigned char *colors)
void	RB_CalcEnvironmentTexCoords (float *st)
void	RB_CalcFogTexCoords (float *st)
void	RB_CalcModulateAlphasByFog (unsigned char *colors)
void	RB_CalcModulateColorsByFog (unsigned char *colors)
void	RB_CalcModulateRGBAsByFog (unsigned char *colors)
void	RB_CalcMoveVertexes (deformStage_t *ds)
void	RB_CalcRotateTexCoords (float degsPerSecond, float *st)
void	RB_CalcScaleTexCoords (const float scale[2], float *st)
void	RB_CalcScrollTexCoords (const float scrollSpeed[2], float *st)
void	RB_CalcSpecularAlpha (unsigned char *alphas)
void	RB_CalcStretchTexCoords (const waveForm_t *wf, float *st)
void	RB_CalcTransformTexCoords (const texModInfo_t *tmi, float *st)
void	RB_CalcTurbulentTexCoords (const waveForm_t *wf, float *st)
void	RB_CalcWaveAlpha (const waveForm_t *wf, unsigned char *dstColors)
void	RB_CalcWaveColor (const waveForm_t *wf, unsigned char *dstColors)
void	RB_DeformTessGeometry (void)
float *	TableForFunc (genFunc_t func)
Variables
int	edgeVerts [6][2]
vec3_t	lightOrigin = { -960, 1980, 96 }

---

Define Documentation

#define WAVEVALUE (  table, base, amplitude, phase, freq   )     ((base) + table[ myftol( ( ( (phase) + tess.shaderTime * (freq) ) * FUNCTABLE_SIZE ) ) & FUNCTABLE_MASK ] * (amplitude))

Definition at line 27 of file tr_shade_calc.c. Referenced by EvalWaveForm(), RB_CalcDeformVertexes(), and RB_CalcMoveVertexes().

---

Function Documentation

void Autosprite2Deform (  void   )  [static]

Definition at line 429 of file tr_shade_calc.c. References orientationr_t::axis, backEnd, CrossProduct(), backEndState_t::currentEntity, DotProduct, edgeVerts, GlobalVectorToLocal(), i, shaderCommands_s::indexes, j, k, l, shader_s::name, shaderCommands_s::numIndexes, shaderCommands_s::numVertexes, viewParms_t::or, PRINT_WARNING, ri, shaderCommands_s::shader, sqrt(), tess, tr, v1, v2, vec3_t, VectorCopy, VectorMA, VectorNormalize(), VectorSubtract, backEndState_t::viewParms, trGlobals_t::worldEntity, and shaderCommands_s::xyz. Referenced by RB_DeformTessGeometry(). { int i, j, k; int indexes; float *xyz; vec3_t forward; if ( tess.numVertexes & 3 ) { ri.Printf( PRINT_WARNING, "Autosprite2 shader %s had odd vertex count", tess.shader->name ); } if ( tess.numIndexes != ( tess.numVertexes >> 2 ) * 6 ) { ri.Printf( PRINT_WARNING, "Autosprite2 shader %s had odd index count", tess.shader->name ); } if ( backEnd.currentEntity != &tr.worldEntity ) { GlobalVectorToLocal( backEnd.viewParms.or.axis[0], forward ); } else { VectorCopy( backEnd.viewParms.or.axis[0], forward ); } // this is a lot of work for two triangles... // we could precalculate a lot of it is an issue, but it would mess up // the shader abstraction for ( i = 0, indexes = 0 ; i < tess.numVertexes ; i+=4, indexes+=6 ) { float lengths[2]; int nums[2]; vec3_t mid[2]; vec3_t major, minor; float *v1, *v2; // find the midpoint xyz = tess.xyz[i]; // identify the two shortest edges nums[0] = nums[1] = 0; lengths[0] = lengths[1] = 999999; for ( j = 0 ; j < 6 ; j++ ) { float l; vec3_t temp; v1 = xyz + 4 * edgeVerts[j][0]; v2 = xyz + 4 * edgeVerts[j][1]; VectorSubtract( v1, v2, temp ); l = DotProduct( temp, temp ); if ( l < lengths[0] ) { nums[1] = nums[0]; lengths[1] = lengths[0]; nums[0] = j; lengths[0] = l; } else if ( l < lengths[1] ) { nums[1] = j; lengths[1] = l; } } for ( j = 0 ; j < 2 ; j++ ) { v1 = xyz + 4 * edgeVerts[nums[j]][0]; v2 = xyz + 4 * edgeVerts[nums[j]][1]; mid[j][0] = 0.5f * (v1[0] + v2[0]); mid[j][1] = 0.5f * (v1[1] + v2[1]); mid[j][2] = 0.5f * (v1[2] + v2[2]); } // find the vector of the major axis VectorSubtract( mid[1], mid[0], major ); // cross this with the view direction to get minor axis CrossProduct( major, forward, minor ); VectorNormalize( minor ); // re-project the points for ( j = 0 ; j < 2 ; j++ ) { float l; v1 = xyz + 4 * edgeVerts[nums[j]][0]; v2 = xyz + 4 * edgeVerts[nums[j]][1]; l = 0.5 * sqrt( lengths[j] ); // we need to see which direction this edge // is used to determine direction of projection for ( k = 0 ; k < 5 ; k++ ) { if ( tess.indexes[ indexes + k ] == i + edgeVerts[nums[j]][0] && tess.indexes[ indexes + k + 1 ] == i + edgeVerts[nums[j]][1] ) { break; } } if ( k == 5 ) { VectorMA( mid[j], l, minor, v1 ); VectorMA( mid[j], -l, minor, v2 ); } else { VectorMA( mid[j], -l, minor, v1 ); VectorMA( mid[j], l, minor, v2 ); } } } }

Here is the call graph for this function:

void AutospriteDeform (  void   )  [static]

Definition at line 349 of file tr_shade_calc.c. References refEntity_t::axis, orientationr_t::axis, backEnd, backEndState_t::currentEntity, trRefEntity_t::e, GlobalVectorToLocal(), i, viewParms_t::isMirror, shader_s::name, refEntity_t::nonNormalizedAxes, shaderCommands_s::numIndexes, shaderCommands_s::numVertexes, viewParms_t::or, PRINT_WARNING, RB_AddQuadStamp(), ri, shaderCommands_s::shader, tess, tr, up, vec3_origin, vec3_t, VectorCopy, VectorLength(), VectorScale, VectorSubtract, shaderCommands_s::vertexColors, backEndState_t::viewParms, trGlobals_t::worldEntity, and shaderCommands_s::xyz. Referenced by RB_DeformTessGeometry(). { int i; int oldVerts; float *xyz; vec3_t mid, delta; float radius; vec3_t left, up; vec3_t leftDir, upDir; if ( tess.numVertexes & 3 ) { ri.Printf( PRINT_WARNING, "Autosprite shader %s had odd vertex count", tess.shader->name ); } if ( tess.numIndexes != ( tess.numVertexes >> 2 ) * 6 ) { ri.Printf( PRINT_WARNING, "Autosprite shader %s had odd index count", tess.shader->name ); } oldVerts = tess.numVertexes; tess.numVertexes = 0; tess.numIndexes = 0; if ( backEnd.currentEntity != &tr.worldEntity ) { GlobalVectorToLocal( backEnd.viewParms.or.axis[1], leftDir ); GlobalVectorToLocal( backEnd.viewParms.or.axis[2], upDir ); } else { VectorCopy( backEnd.viewParms.or.axis[1], leftDir ); VectorCopy( backEnd.viewParms.or.axis[2], upDir ); } for ( i = 0 ; i < oldVerts ; i+=4 ) { // find the midpoint xyz = tess.xyz[i]; mid[0] = 0.25f * (xyz[0] + xyz[4] + xyz[8] + xyz[12]); mid[1] = 0.25f * (xyz[1] + xyz[5] + xyz[9] + xyz[13]); mid[2] = 0.25f * (xyz[2] + xyz[6] + xyz[10] + xyz[14]); VectorSubtract( xyz, mid, delta ); radius = VectorLength( delta ) * 0.707f; // / sqrt(2) VectorScale( leftDir, radius, left ); VectorScale( upDir, radius, up ); if ( backEnd.viewParms.isMirror ) { VectorSubtract( vec3_origin, left, left ); } // compensate for scale in the axes if necessary if ( backEnd.currentEntity->e.nonNormalizedAxes ) { float axisLength; axisLength = VectorLength( backEnd.currentEntity->e.axis[0] ); if ( !axisLength ) { axisLength = 0; } else { axisLength = 1.0f / axisLength; } VectorScale(left, axisLength, left); VectorScale(up, axisLength, up); } RB_AddQuadStamp( mid, left, up, tess.vertexColors[i] ); } }

Here is the call graph for this function:

void DeformText (  const char *  text  )

Definition at line 262 of file tr_shade_calc.c. References bottom, byte, ch, col, CrossProduct(), f, height, i, shaderCommands_s::normal, shaderCommands_s::numIndexes, shaderCommands_s::numVertexes, RB_AddQuadStampExt(), strlen(), tess, top, vec3_t, VectorAdd, VectorClear, VectorMA, VectorScale, width, and shaderCommands_s::xyz. Referenced by RB_DeformTessGeometry(). { int i; vec3_t origin, width, height; int len; int ch; byte color[4]; float bottom, top; vec3_t mid; height[0] = 0; height[1] = 0; height[2] = -1; CrossProduct( tess.normal[0], height, width ); // find the midpoint of the box VectorClear( mid ); bottom = 999999; top = -999999; for ( i = 0 ; i < 4 ; i++ ) { VectorAdd( tess.xyz[i], mid, mid ); if ( tess.xyz[i][2] < bottom ) { bottom = tess.xyz[i][2]; } if ( tess.xyz[i][2] > top ) { top = tess.xyz[i][2]; } } VectorScale( mid, 0.25f, origin ); // determine the individual character size height[0] = 0; height[1] = 0; height[2] = ( top - bottom ) * 0.5f; VectorScale( width, height[2] * -0.75f, width ); // determine the starting position len = strlen( text ); VectorMA( origin, (len-1), width, origin ); // clear the shader indexes tess.numIndexes = 0; tess.numVertexes = 0; color[0] = color[1] = color[2] = color[3] = 255; // draw each character for ( i = 0 ; i < len ; i++ ) { ch = text[i]; ch &= 255; if ( ch != ' ' ) { int row, col; float frow, fcol, size; row = ch>>4; col = ch&15; frow = row*0.0625f; fcol = col*0.0625f; size = 0.0625f; RB_AddQuadStampExt( origin, width, height, color, fcol, frow, fcol + size, frow + size ); } VectorMA( origin, -2, width, origin ); } }

Here is the call graph for this function:

float EvalWaveForm (  const waveForm_t *  wf  )  [static]

Definition at line 57 of file tr_shade_calc.c. References waveForm_t::amplitude, waveForm_t::base, waveForm_t::frequency, waveForm_t::func, waveForm_t::phase, table, TableForFunc(), and WAVEVALUE. Referenced by EvalWaveFormClamped(), RB_CalcDeformVertexes(), RB_CalcStretchTexCoords(), and RB_CalcWaveColor(). { float *table; table = TableForFunc( wf->func ); return WAVEVALUE( table, wf->base, wf->amplitude, wf->phase, wf->frequency ); }

Here is the call graph for this function:

float EvalWaveFormClamped (  const waveForm_t *  wf  )  [static]

Definition at line 66 of file tr_shade_calc.c. References EvalWaveForm(). Referenced by RB_CalcWaveAlpha(). { float glow = EvalWaveForm( wf ); if ( glow < 0 ) { return 0; } if ( glow > 1 ) { return 1; } return glow; }

Here is the call graph for this function:

void GlobalVectorToLocal (  const vec3_t  in, vec3_t  out )  [static]

Definition at line 335 of file tr_shade_calc.c. References orientationr_t::axis, backEnd, DotProduct, in, and backEndState_t::or. Referenced by Autosprite2Deform(), and AutospriteDeform(). { out[0] = DotProduct( in, backEnd.or.axis[0] ); out[1] = DotProduct( in, backEnd.or.axis[1] ); out[2] = DotProduct( in, backEnd.or.axis[2] ); }

void RB_CalcAlphaFromEntity (  unsigned char *  dstColors  )

Definition at line 641 of file tr_shade_calc.c. References backEnd, backEndState_t::currentEntity, trRefEntity_t::e, i, shaderCommands_s::numVertexes, refEntity_t::shaderRGBA, and tess. Referenced by ComputeColors(). { int i; if ( !backEnd.currentEntity ) return; dstColors += 3; for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 ) { *dstColors = backEnd.currentEntity->e.shaderRGBA[3]; } }

void RB_CalcAlphaFromOneMinusEntity (  unsigned char *  dstColors  )

Definition at line 659 of file tr_shade_calc.c. References backEnd, backEndState_t::currentEntity, trRefEntity_t::e, i, shaderCommands_s::numVertexes, refEntity_t::shaderRGBA, and tess. Referenced by ComputeColors(). { int i; if ( !backEnd.currentEntity ) return; dstColors += 3; for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 ) { *dstColors = 0xff - backEnd.currentEntity->e.shaderRGBA[3]; } }

void RB_CalcBulgeVertexes (  deformStage_t *  ds  )

Definition at line 201 of file tr_shade_calc.c. References backEnd, deformStage_t::bulgeHeight, deformStage_t::bulgeSpeed, deformStage_t::bulgeWidth, FUNCTABLE_SIZE, i, M_PI, shaderCommands_s::normal, shaderCommands_s::numVertexes, backEndState_t::refdef, trGlobals_t::sinTable, tess, shaderCommands_s::texCoords, trRefdef_t::time, tr, and shaderCommands_s::xyz. Referenced by RB_DeformTessGeometry(). { int i; const float *st = ( const float * ) tess.texCoords[0]; float *xyz = ( float * ) tess.xyz; float *normal = ( float * ) tess.normal; float now; now = backEnd.refdef.time * ds->bulgeSpeed * 0.001f; for ( i = 0; i < tess.numVertexes; i++, xyz += 4, st += 4, normal += 4 ) { int off; float scale; off = (float)( FUNCTABLE_SIZE / (M_PI*2) ) * ( st[0] * ds->bulgeWidth + now ); scale = tr.sinTable[ off & FUNCTABLE_MASK ] * ds->bulgeHeight; xyz[0] += normal[0] * scale; xyz[1] += normal[1] * scale; xyz[2] += normal[2] * scale; } }

void RB_CalcColorFromEntity (  unsigned char *  dstColors  )

Definition at line 595 of file tr_shade_calc.c. References backEnd, c, backEndState_t::currentEntity, trRefEntity_t::e, i, shaderCommands_s::numVertexes, refEntity_t::shaderRGBA, and tess. Referenced by ComputeColors(). { int i; int *pColors = ( int * ) dstColors; int c; if ( !backEnd.currentEntity ) return; c = * ( int * ) backEnd.currentEntity->e.shaderRGBA; for ( i = 0; i < tess.numVertexes; i++, pColors++ ) { *pColors = c; } }

void RB_CalcColorFromOneMinusEntity (  unsigned char *  dstColors  )

Definition at line 615 of file tr_shade_calc.c. References backEnd, c, backEndState_t::currentEntity, trRefEntity_t::e, i, shaderCommands_s::numVertexes, refEntity_t::shaderRGBA, and tess. Referenced by ComputeColors(). { int i; int *pColors = ( int * ) dstColors; unsigned char invModulate[3]; int c; if ( !backEnd.currentEntity ) return; invModulate[0] = 255 - backEnd.currentEntity->e.shaderRGBA[0]; invModulate[1] = 255 - backEnd.currentEntity->e.shaderRGBA[1]; invModulate[2] = 255 - backEnd.currentEntity->e.shaderRGBA[2]; invModulate[3] = 255 - backEnd.currentEntity->e.shaderRGBA[3]; // this trashes alpha, but the AGEN block fixes it c = * ( int * ) invModulate; for ( i = 0; i < tess.numVertexes; i++, pColors++ ) { *pColors = * ( int * ) invModulate; } }

void RB_CalcDeformNormals (  deformStage_t *  ds  )

Definition at line 169 of file tr_shade_calc.c. References waveForm_t::amplitude, deformStage_t::deformationWave, waveForm_t::frequency, i, shaderCommands_s::normal, shaderCommands_s::numVertexes, R_NoiseGet4f(), shaderCommands_s::shaderTime, tess, VectorNormalizeFast(), and shaderCommands_s::xyz. Referenced by RB_DeformTessGeometry(). { int i; float scale; float *xyz = ( float * ) tess.xyz; float *normal = ( float * ) tess.normal; for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 ) { scale = 0.98f; scale = R_NoiseGet4f( xyz[0] * scale, xyz[1] * scale, xyz[2] * scale, tess.shaderTime * ds->deformationWave.frequency ); normal[ 0 ] += ds->deformationWave.amplitude * scale; scale = 0.98f; scale = R_NoiseGet4f( 100 + xyz[0] * scale, xyz[1] * scale, xyz[2] * scale, tess.shaderTime * ds->deformationWave.frequency ); normal[ 1 ] += ds->deformationWave.amplitude * scale; scale = 0.98f; scale = R_NoiseGet4f( 200 + xyz[0] * scale, xyz[1] * scale, xyz[2] * scale, tess.shaderTime * ds->deformationWave.frequency ); normal[ 2 ] += ds->deformationWave.amplitude * scale; VectorNormalizeFast( normal ); } }

Here is the call graph for this function:

void RB_CalcDeformVertexes (  deformStage_t *  ds  )

Definition at line 118 of file tr_shade_calc.c. References waveForm_t::amplitude, waveForm_t::base, deformStage_t::deformationSpread, deformStage_t::deformationWave, EvalWaveForm(), waveForm_t::frequency, waveForm_t::func, i, shaderCommands_s::normal, shaderCommands_s::numVertexes, offset, waveForm_t::phase, table, TableForFunc(), tess, vec3_t, VectorScale, WAVEVALUE, and shaderCommands_s::xyz. Referenced by RB_DeformTessGeometry(). { int i; vec3_t offset; float scale; float *xyz = ( float * ) tess.xyz; float *normal = ( float * ) tess.normal; float *table; if ( ds->deformationWave.frequency == 0 ) { scale = EvalWaveForm( &ds->deformationWave ); for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 ) { VectorScale( normal, scale, offset ); xyz[0] += offset[0]; xyz[1] += offset[1]; xyz[2] += offset[2]; } } else { table = TableForFunc( ds->deformationWave.func ); for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 ) { float off = ( xyz[0] + xyz[1] + xyz[2] ) * ds->deformationSpread; scale = WAVEVALUE( table, ds->deformationWave.base, ds->deformationWave.amplitude, ds->deformationWave.phase + off, ds->deformationWave.frequency ); VectorScale( normal, scale, offset ); xyz[0] += offset[0]; xyz[1] += offset[1]; xyz[2] += offset[2]; } } }

Here is the call graph for this function:

void RB_CalcDiffuseColor (  unsigned char *  colors  )

Definition at line 1097 of file tr_shade_calc.c. References trRefEntity_t::ambientLight, trRefEntity_t::ambientLightInt, backEnd, backEndState_t::currentEntity, trRefEntity_t::directedLight, DotProduct, i, j, trRefEntity_t::lightDir, myftol, shaderCommands_s::normal, shaderCommands_s::numVertexes, tess, v, vec3_t, VectorCopy, shaderCommands_s::xyz, and zero(). Referenced by ComputeColors(), and RB_StageIteratorVertexLitTexture(). { int i, j; float *v, *normal; float incoming; trRefEntity_t *ent; int ambientLightInt; vec3_t ambientLight; vec3_t lightDir; vec3_t directedLight; int numVertexes; #if idppc_altivec vector unsigned char vSel = (vector unsigned char)(0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff); vector float ambientLightVec; vector float directedLightVec; vector float lightDirVec; vector float normalVec0, normalVec1; vector float incomingVec0, incomingVec1, incomingVec2; vector float zero, jVec; vector signed int jVecInt; vector signed short jVecShort; vector unsigned char jVecChar, normalPerm; #endif ent = backEnd.currentEntity; ambientLightInt = ent->ambientLightInt; #if idppc_altivec // A lot of this could be simplified if we made sure // entities light info was 16-byte aligned. jVecChar = vec_lvsl(0, ent->ambientLight); ambientLightVec = vec_ld(0, (vector float *)ent->ambientLight); jVec = vec_ld(11, (vector float *)ent->ambientLight); ambientLightVec = vec_perm(ambientLightVec,jVec,jVecChar); jVecChar = vec_lvsl(0, ent->directedLight); directedLightVec = vec_ld(0,(vector float *)ent->directedLight); jVec = vec_ld(11,(vector float *)ent->directedLight); directedLightVec = vec_perm(directedLightVec,jVec,jVecChar); jVecChar = vec_lvsl(0, ent->lightDir); lightDirVec = vec_ld(0,(vector float *)ent->lightDir); jVec = vec_ld(11,(vector float *)ent->lightDir); lightDirVec = vec_perm(lightDirVec,jVec,jVecChar); zero = (vector float)vec_splat_s8(0); VectorCopy( ent->lightDir, lightDir ); #else VectorCopy( ent->ambientLight, ambientLight ); VectorCopy( ent->directedLight, directedLight ); VectorCopy( ent->lightDir, lightDir ); #endif v = tess.xyz[0]; normal = tess.normal[0]; #if idppc_altivec normalPerm = vec_lvsl(0,normal); #endif numVertexes = tess.numVertexes; for (i = 0 ; i < numVertexes ; i++, v += 4, normal += 4) { #if idppc_altivec normalVec0 = vec_ld(0,(vector float *)normal); normalVec1 = vec_ld(11,(vector float *)normal); normalVec0 = vec_perm(normalVec0,normalVec1,normalPerm); incomingVec0 = vec_madd(normalVec0, lightDirVec, zero); incomingVec1 = vec_sld(incomingVec0,incomingVec0,4); incomingVec2 = vec_add(incomingVec0,incomingVec1); incomingVec1 = vec_sld(incomingVec1,incomingVec1,4); incomingVec2 = vec_add(incomingVec2,incomingVec1); incomingVec0 = vec_splat(incomingVec2,0); incomingVec0 = vec_max(incomingVec0,zero); normalPerm = vec_lvsl(12,normal); jVec = vec_madd(incomingVec0, directedLightVec, ambientLightVec); jVecInt = vec_cts(jVec,0); // RGBx jVecShort = vec_pack(jVecInt,jVecInt); // RGBxRGBx jVecChar = vec_packsu(jVecShort,jVecShort); // RGBxRGBxRGBxRGBx jVecChar = vec_sel(jVecChar,vSel,vSel); // RGBARGBARGBARGBA replace alpha with 255 vec_ste((vector unsigned int)jVecChar,0,(unsigned int *)&colors[i*4]); // store color #else incoming = DotProduct (normal, lightDir); if ( incoming <= 0 ) { *(int *)&colors[i*4] = ambientLightInt; continue; } j = myftol( ambientLight[0] + incoming * directedLight[0] ); if ( j > 255 ) { j = 255; } colors[i*4+0] = j; j = myftol( ambientLight[1] + incoming * directedLight[1] ); if ( j > 255 ) { j = 255; } colors[i*4+1] = j; j = myftol( ambientLight[2] + incoming * directedLight[2] ); if ( j > 255 ) { j = 255; } colors[i*4+2] = j; colors[i*4+3] = 255; #endif } }

Here is the call graph for this function:

void RB_CalcEnvironmentTexCoords (  float *  st  )

Definition at line 888 of file tr_shade_calc.c. References backEnd, d, DotProduct, i, shaderCommands_s::normal, shaderCommands_s::numVertexes, backEndState_t::or, tess, v, vec3_t, VectorNormalizeFast(), VectorSubtract, orientationr_t::viewOrigin, and shaderCommands_s::xyz. Referenced by ComputeTexCoords(). { int i; float *v, *normal; vec3_t viewer, reflected; float d; v = tess.xyz[0]; normal = tess.normal[0]; for (i = 0 ; i < tess.numVertexes ; i++, v += 4, normal += 4, st += 2 ) { VectorSubtract (backEnd.or.viewOrigin, v, viewer); VectorNormalizeFast (viewer); d = DotProduct (normal, viewer); reflected[0] = normal[0]*2*d - viewer[0]; reflected[1] = normal[1]*2*d - viewer[1]; reflected[2] = normal[2]*2*d - viewer[2]; st[0] = 0.5 + reflected[1] * 0.5; st[1] = 0.5 - reflected[2] * 0.5; } }

Here is the call graph for this function:

void RB_CalcFogTexCoords (  float *  st  )

Definition at line 805 of file tr_shade_calc.c. References orientationr_t::axis, backEnd, DotProduct, shaderCommands_s::fogNum, world_t::fogs, fog_t::hasSurface, i, orientationr_t::modelMatrix, shaderCommands_s::numVertexes, viewParms_t::or, backEndState_t::or, orientationr_t::origin, qboolean, s, fog_t::surface, t, fog_t::tcScale, tess, tr, v, vec3_t, VectorSubtract, orientationr_t::viewOrigin, backEndState_t::viewParms, trGlobals_t::world, and shaderCommands_s::xyz. Referenced by ComputeTexCoords(), RB_CalcModulateAlphasByFog(), RB_CalcModulateColorsByFog(), RB_CalcModulateRGBAsByFog(), and RB_FogPass(). { int i; float *v; float s, t; float eyeT; qboolean eyeOutside; fog_t *fog; vec3_t local; vec4_t fogDistanceVector, fogDepthVector; fog = tr.world->fogs + tess.fogNum; // all fogging distance is based on world Z units VectorSubtract( backEnd.or.origin, backEnd.viewParms.or.origin, local ); fogDistanceVector[0] = -backEnd.or.modelMatrix[2]; fogDistanceVector[1] = -backEnd.or.modelMatrix[6]; fogDistanceVector[2] = -backEnd.or.modelMatrix[10]; fogDistanceVector[3] = DotProduct( local, backEnd.viewParms.or.axis[0] ); // scale the fog vectors based on the fog's thickness fogDistanceVector[0] *= fog->tcScale; fogDistanceVector[1] *= fog->tcScale; fogDistanceVector[2] *= fog->tcScale; fogDistanceVector[3] *= fog->tcScale; // rotate the gradient vector for this orientation if ( fog->hasSurface ) { fogDepthVector[0] = fog->surface[0] * backEnd.or.axis[0][0] + fog->surface[1] * backEnd.or.axis[0][1] + fog->surface[2] * backEnd.or.axis[0][2]; fogDepthVector[1] = fog->surface[0] * backEnd.or.axis[1][0] + fog->surface[1] * backEnd.or.axis[1][1] + fog->surface[2] * backEnd.or.axis[1][2]; fogDepthVector[2] = fog->surface[0] * backEnd.or.axis[2][0] + fog->surface[1] * backEnd.or.axis[2][1] + fog->surface[2] * backEnd.or.axis[2][2]; fogDepthVector[3] = -fog->surface[3] + DotProduct( backEnd.or.origin, fog->surface ); eyeT = DotProduct( backEnd.or.viewOrigin, fogDepthVector ) + fogDepthVector[3]; } else { eyeT = 1; // non-surface fog always has eye inside } // see if the viewpoint is outside // this is needed for clipping distance even for constant fog if ( eyeT < 0 ) { eyeOutside = qtrue; } else { eyeOutside = qfalse; } fogDistanceVector[3] += 1.0/512; // calculate density for each point for (i = 0, v = tess.xyz[0] ; i < tess.numVertexes ; i++, v += 4) { // calculate the length in fog s = DotProduct( v, fogDistanceVector ) + fogDistanceVector[3]; t = DotProduct( v, fogDepthVector ) + fogDepthVector[3]; // partially clipped fogs use the T axis if ( eyeOutside ) { if ( t < 1.0 ) { t = 1.0/32; // point is outside, so no fogging } else { t = 1.0/32 + 30.0/32 * t / ( t - eyeT ); // cut the distance at the fog plane } } else { if ( t < 0 ) { t = 1.0/32; // point is outside, so no fogging } else { t = 31.0/32; } } st[0] = s; st[1] = t; st += 2; } }

void RB_CalcModulateAlphasByFog (  unsigned char *  colors  )

Definition at line 751 of file tr_shade_calc.c. References f, i, shaderCommands_s::numVertexes, R_FogFactor(), RB_CalcFogTexCoords(), and tess. Referenced by ComputeColors(). { int i; float texCoords[SHADER_MAX_VERTEXES][2]; // calculate texcoords so we can derive density // this is not wasted, because it would only have // been previously called if the surface was opaque RB_CalcFogTexCoords( texCoords[0] ); for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) { float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] ); colors[3] *= f; } }

Here is the call graph for this function:

void RB_CalcModulateColorsByFog (  unsigned char *  colors  )

Definition at line 731 of file tr_shade_calc.c. References f, i, shaderCommands_s::numVertexes, R_FogFactor(), RB_CalcFogTexCoords(), and tess. Referenced by ComputeColors(). { int i; float texCoords[SHADER_MAX_VERTEXES][2]; // calculate texcoords so we can derive density // this is not wasted, because it would only have // been previously called if the surface was opaque RB_CalcFogTexCoords( texCoords[0] ); for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) { float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] ); colors[0] *= f; colors[1] *= f; colors[2] *= f; } }

Here is the call graph for this function:

void RB_CalcModulateRGBAsByFog (  unsigned char *  colors  )

Definition at line 769 of file tr_shade_calc.c. References f, i, shaderCommands_s::numVertexes, R_FogFactor(), RB_CalcFogTexCoords(), and tess. Referenced by ComputeColors(). { int i; float texCoords[SHADER_MAX_VERTEXES][2]; // calculate texcoords so we can derive density // this is not wasted, because it would only have // been previously called if the surface was opaque RB_CalcFogTexCoords( texCoords[0] ); for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) { float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] ); colors[0] *= f; colors[1] *= f; colors[2] *= f; colors[3] *= f; } }

Here is the call graph for this function:

void RB_CalcMoveVertexes (  deformStage_t *  ds  )

Definition at line 232 of file tr_shade_calc.c. References waveForm_t::amplitude, waveForm_t::base, deformStage_t::deformationWave, waveForm_t::frequency, waveForm_t::func, i, deformStage_t::moveVector, shaderCommands_s::numVertexes, offset, waveForm_t::phase, table, TableForFunc(), tess,