/* =========================================================================== Copyright (C) 1999-2005 Id Software, Inc. This file is part of Quake III Arena source code. Quake III Arena source code is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. Quake III Arena source code is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Quake III Arena source code; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA =========================================================================== */ // tr_shade_calc.c #include "tr_local.h" #if idppc_altivec && !defined(MACOS_X) #include <altivec.h> #endif #define WAVEVALUE( table, base, amplitude, phase, freq ) ((base) + table[ ri.ftol( ( ( (phase) + tess.shaderTime * (freq) ) * FUNCTABLE_SIZE ) ) & FUNCTABLE_MASK ] * (amplitude)) static float *TableForFunc( genFunc_t func ) { switch ( func ) { case GF_SIN: return tr.sinTable; case GF_TRIANGLE: return tr.triangleTable; case GF_SQUARE: return tr.squareTable; case GF_SAWTOOTH: return tr.sawToothTable; case GF_INVERSE_SAWTOOTH: return tr.inverseSawToothTable; case GF_NONE: default: break; } ri.Error( ERR_DROP, "TableForFunc called with invalid function '%d' in shader '%s'", func, tess.shader->name ); return NULL; } /* ** EvalWaveForm ** ** Evaluates a given waveForm_t, referencing backEnd.refdef.time directly */ static float EvalWaveForm( const waveForm_t *wf ) { float *table; table = TableForFunc( wf->func ); return WAVEVALUE( table, wf->base, wf->amplitude, wf->phase, wf->frequency ); } static float EvalWaveFormClamped( const waveForm_t *wf ) { float glow = EvalWaveForm( wf ); if ( glow < 0 ) { return 0; } if ( glow > 1 ) { return 1; } return glow; } /* ** RB_CalcStretchTexCoords */ void RB_CalcStretchTexCoords( const waveForm_t *wf, float *st ) { float p; texModInfo_t tmi; p = 1.0f / EvalWaveForm( wf ); tmi.matrix[0][0] = p; tmi.matrix[1][0] = 0; tmi.translate[0] = 0.5f - 0.5f * p; tmi.matrix[0][1] = 0; tmi.matrix[1][1] = p; tmi.translate[1] = 0.5f - 0.5f * p; RB_CalcTransformTexCoords( &tmi, st ); } void RB_CalcStretchTexMatrix( const waveForm_t *wf, float *matrix ) { float p; texModInfo_t tmi; p = 1.0f / EvalWaveForm( wf ); tmi.matrix[0][0] = p; tmi.matrix[1][0] = 0; tmi.translate[0] = 0.5f - 0.5f * p; tmi.matrix[0][1] = 0; tmi.matrix[1][1] = p; tmi.translate[1] = 0.5f - 0.5f * p; RB_CalcTransformTexMatrix( &tmi, matrix ); } /* ==================================================================== DEFORMATIONS ==================================================================== */ /* ======================== RB_CalcDeformVertexes ======================== */ void RB_CalcDeformVertexes( deformStage_t *ds ) { 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]; } } } /* ========================= RB_CalcDeformNormals Wiggle the normals for wavy environment mapping ========================= */ void RB_CalcDeformNormals( deformStage_t *ds ) { 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 ); } } /* ======================== RB_CalcBulgeVertexes ======================== */ void RB_CalcBulgeVertexes( deformStage_t *ds ) { 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; } } /* ====================== RB_CalcMoveVertexes A deformation that can move an entire surface along a wave path ====================== */ void RB_CalcMoveVertexes( deformStage_t *ds ) { int i; float *xyz; float *table; float scale; vec3_t offset; table = TableForFunc( ds->deformationWave.func ); scale = WAVEVALUE( table, ds->deformationWave.base, ds->deformationWave.amplitude, ds->deformationWave.phase, ds->deformationWave.frequency ); VectorScale( ds->moveVector, scale, offset ); xyz = ( float * ) tess.xyz; for ( i = 0; i < tess.numVertexes; i++, xyz += 4 ) { VectorAdd( xyz, offset, xyz ); } } /* ============= DeformText Change a polygon into a bunch of text polygons ============= */ void DeformText( const char *text ) { int i; vec3_t origin, width, height; int len; int ch; float 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; tess.firstIndex = 0; color[0] = color[1] = color[2] = color[3] = 1.0f; // 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 ); } } /* ================== GlobalVectorToLocal ================== */ static void GlobalVectorToLocal( const vec3_t in, vec3_t out ) { out[0] = DotProduct( in, backEnd.or.axis[0] ); out[1] = DotProduct( in, backEnd.or.axis[1] ); out[2] = DotProduct( in, backEnd.or.axis[2] ); } /* ===================== AutospriteDeform Assuming all the triangles for this shader are independant quads, rebuild them as forward facing sprites ===================== */ static void AutospriteDeform( void ) { 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\n", tess.shader->name ); } if ( tess.numIndexes != ( tess.numVertexes >> 2 ) * 6 ) { ri.Printf( PRINT_WARNING, "Autosprite shader %s had odd index count\n", tess.shader->name ); } oldVerts = tess.numVertexes; tess.numVertexes = 0; tess.numIndexes = 0; tess.firstIndex = 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] ); } } /* ===================== Autosprite2Deform Autosprite2 will pivot a rectangular quad along the center of its long axis ===================== */ int edgeVerts[6][2] = { { 0, 1 }, { 0, 2 }, { 0, 3 }, { 1, 2 }, { 1, 3 }, { 2, 3 } }; static void Autosprite2Deform( void ) { 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 ); } } } } /* ===================== RB_DeformTessGeometry ===================== */ void RB_DeformTessGeometry( void ) { int i; deformStage_t *ds; if(!ShaderRequiresCPUDeforms(tess.shader)) { // we don't need the following CPU deforms return; } for ( i = 0 ; i < tess.shader->numDeforms ; i++ ) { ds = &tess.shader->deforms[ i ]; switch ( ds->deformation ) { case DEFORM_NONE: break; case DEFORM_NORMALS: RB_CalcDeformNormals( ds ); break; case DEFORM_WAVE: RB_CalcDeformVertexes( ds ); break; case DEFORM_BULGE: RB_CalcBulgeVertexes( ds ); break; case DEFORM_MOVE: RB_CalcMoveVertexes( ds ); break; case DEFORM_PROJECTION_SHADOW: RB_ProjectionShadowDeform(); break; case DEFORM_AUTOSPRITE: AutospriteDeform(); break; case DEFORM_AUTOSPRITE2: Autosprite2Deform(); break; case DEFORM_TEXT0: case DEFORM_TEXT1: case DEFORM_TEXT2: case DEFORM_TEXT3: case DEFORM_TEXT4: case DEFORM_TEXT5: case DEFORM_TEXT6: case DEFORM_TEXT7: DeformText( backEnd.refdef.text[ds->deformation - DEFORM_TEXT0] ); break; } } } /* ==================================================================== COLORS ==================================================================== */ /* ** RB_CalcColorFromEntity */ void RB_CalcColorFromEntity( unsigned char *dstColors ) { 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; } } /* ** RB_CalcColorFromOneMinusEntity */ void RB_CalcColorFromOneMinusEntity( unsigned char *dstColors ) { int i; int *pColors = ( int * ) dstColors; unsigned char invModulate[4]; 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 = c; } } /* ** RB_CalcAlphaFromEntity */ void RB_CalcAlphaFromEntity( unsigned char *dstColors ) { int i; if ( !backEnd.currentEntity ) return; dstColors += 3; for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 ) { *dstColors = backEnd.currentEntity->e.shaderRGBA[3]; } } /* ** RB_CalcAlphaFromOneMinusEntity */ void RB_CalcAlphaFromOneMinusEntity( unsigned char *dstColors ) { int i; if ( !backEnd.currentEntity ) return; dstColors += 3; for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 ) { *dstColors = 0xff - backEnd.currentEntity->e.shaderRGBA[3]; } } /* ** RB_CalcWaveColorSingle */ float RB_CalcWaveColorSingle( const waveForm_t *wf ) { float glow; if ( wf->func == GF_NOISE ) { glow = wf->base + R_NoiseGet4f( 0, 0, 0, ( tess.shaderTime + wf->phase ) * wf->frequency ) * wf->amplitude; } else { glow = EvalWaveForm( wf ) * tr.identityLight; } if ( glow < 0 ) { glow = 0; } else if ( glow > 1 ) { glow = 1; } return glow; } /* ** RB_CalcWaveColor */ void RB_CalcWaveColor( const waveForm_t *wf, unsigned char *dstColors ) { int i; int v; float glow; int *colors = ( int * ) dstColors; byte color[4]; glow = RB_CalcWaveColorSingle( wf ); v = ri.ftol(255 * glow); color[0] = color[1] = color[2] = v; color[3] = 255; v = *(int *)color; for ( i = 0; i < tess.numVertexes; i++, colors++ ) { *colors = v; } } /* ** RB_CalcWaveAlphaSingle */ float RB_CalcWaveAlphaSingle( const waveForm_t *wf ) { return EvalWaveFormClamped( wf ); } /* ** RB_CalcWaveAlpha */ void RB_CalcWaveAlpha( const waveForm_t *wf, unsigned char *dstColors ) { int i; int v; float glow; glow = EvalWaveFormClamped( wf ); v = 255 * glow; for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 ) { dstColors[3] = v; } } /* ** RB_CalcModulateColorsByFog */ void RB_CalcModulateColorsByFog( unsigned char *colors ) { 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; } } /* ** RB_CalcModulateAlphasByFog */ void RB_CalcModulateAlphasByFog( unsigned char *colors ) { 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; } } /* ** RB_CalcModulateRGBAsByFog */ void RB_CalcModulateRGBAsByFog( unsigned char *colors ) { 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; } } /* ==================================================================== TEX COORDS ==================================================================== */ /* ======================== RB_CalcFogTexCoords To do the clipped fog plane really correctly, we should use projected textures, but I don't trust the drivers and it doesn't fit our shader data. ======================== */ void RB_CalcFogTexCoords( float *st ) { int i; float *v; float s, t; float eyeT; qboolean eyeOutside; fog_t *fog; vec3_t local; vec4_t fogDistanceVector, fogDepthVector = {0, 0, 0, 0}; 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; } } /* ** RB_CalcEnvironmentTexCoords */ void RB_CalcEnvironmentTexCoords( float *st ) { 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; } } /* ** RB_CalcTurbulentTexCoords */ void RB_CalcTurbulentTexCoords( const waveForm_t *wf, float *st ) { int i; float now; now = ( wf->phase + tess.shaderTime * wf->frequency ); for ( i = 0; i < tess.numVertexes; i++, st += 2 ) { float s = st[0]; float t = st[1]; st[0] = s + tr.sinTable[ ( ( int ) ( ( ( tess.xyz[i][0] + tess.xyz[i][2] )* 1.0/128 * 0.125 + now ) * FUNCTABLE_SIZE ) ) & ( FUNCTABLE_MASK ) ] * wf->amplitude; st[1] = t + tr.sinTable[ ( ( int ) ( ( tess.xyz[i][1] * 1.0/128 * 0.125 + now ) * FUNCTABLE_SIZE ) ) & ( FUNCTABLE_MASK ) ] * wf->amplitude; } } void RB_CalcTurbulentTexMatrix( const waveForm_t *wf, matrix_t matrix ) { float now; now = ( wf->phase + tess.shaderTime * wf->frequency ); // bit of a hack here, hide amplitude and now in the matrix // the vertex program will extract them and perform a turbulent pass last if it's nonzero matrix[ 0] = 1.0f; matrix[ 4] = 0.0f; matrix[ 8] = 0.0f; matrix[12] = wf->amplitude; matrix[ 1] = 0.0f; matrix[ 5] = 1.0f; matrix[ 9] = 0.0f; matrix[13] = now; matrix[ 2] = 0.0f; matrix[ 6] = 0.0f; matrix[10] = 1.0f; matrix[14] = 0.0f; matrix[ 3] = 0.0f; matrix[ 7] = 0.0f; matrix[11] = 0.0f; matrix[15] = 1.0f; } /* ** RB_CalcScaleTexCoords */ void RB_CalcScaleTexCoords( const float scale[2], float *st ) { int i; for ( i = 0; i < tess.numVertexes; i++, st += 2 ) { st[0] *= scale[0]; st[1] *= scale[1]; } } void RB_CalcScaleTexMatrix( const float scale[2], float *matrix ) { matrix[ 0] = scale[0]; matrix[ 4] = 0.0f; matrix[ 8] = 0.0f; matrix[12] = 0.0f; matrix[ 1] = 0.0f; matrix[ 5] = scale[1]; matrix[ 9] = 0.0f; matrix[13] = 0.0f; matrix[ 2] = 0.0f; matrix[ 6] = 0.0f; matrix[10] = 1.0f; matrix[14] = 0.0f; matrix[ 3] = 0.0f; matrix[ 7] = 0.0f; matrix[11] = 0.0f; matrix[15] = 1.0f; } /* ** RB_CalcScrollTexCoords */ void RB_CalcScrollTexCoords( const float scrollSpeed[2], float *st ) { int i; float timeScale = tess.shaderTime; float adjustedScrollS, adjustedScrollT; adjustedScrollS = scrollSpeed[0] * timeScale; adjustedScrollT = scrollSpeed[1] * timeScale; // clamp so coordinates don't continuously get larger, causing problems // with hardware limits adjustedScrollS = adjustedScrollS - floor( adjustedScrollS ); adjustedScrollT = adjustedScrollT - floor( adjustedScrollT ); for ( i = 0; i < tess.numVertexes; i++, st += 2 ) { st[0] += adjustedScrollS; st[1] += adjustedScrollT; } } void RB_CalcScrollTexMatrix( const float scrollSpeed[2], float *matrix ) { float timeScale = tess.shaderTime; float adjustedScrollS, adjustedScrollT; adjustedScrollS = scrollSpeed[0] * timeScale; adjustedScrollT = scrollSpeed[1] * timeScale; // clamp so coordinates don't continuously get larger, causing problems // with hardware limits adjustedScrollS = adjustedScrollS - floor( adjustedScrollS ); adjustedScrollT = adjustedScrollT - floor( adjustedScrollT ); matrix[ 0] = 1.0f; matrix[ 4] = 0.0f; matrix[ 8] = adjustedScrollS; matrix[12] = 0.0f; matrix[ 1] = 0.0f; matrix[ 5] = 1.0f; matrix[ 9] = adjustedScrollT; matrix[13] = 0.0f; matrix[ 2] = 0.0f; matrix[ 6] = 0.0f; matrix[10] = 1.0f; matrix[14] = 0.0f; matrix[ 3] = 0.0f; matrix[ 7] = 0.0f; matrix[11] = 0.0f; matrix[15] = 1.0f; } /* ** RB_CalcTransformTexCoords */ void RB_CalcTransformTexCoords( const texModInfo_t *tmi, float *st ) { int i; for ( i = 0; i < tess.numVertexes; i++, st += 2 ) { float s = st[0]; float t = st[1]; st[0] = s * tmi->matrix[0][0] + t * tmi->matrix[1][0] + tmi->translate[0]; st[1] = s * tmi->matrix[0][1] + t * tmi->matrix[1][1] + tmi->translate[1]; } } void RB_CalcTransformTexMatrix( const texModInfo_t *tmi, float *matrix ) { matrix[ 0] = tmi->matrix[0][0]; matrix[ 4] = tmi->matrix[1][0]; matrix[ 8] = tmi->translate[0]; matrix[12] = 0.0f; matrix[ 1] = tmi->matrix[0][1]; matrix[ 5] = tmi->matrix[1][1]; matrix[ 9] = tmi->translate[1]; matrix[13] = 0.0f; matrix[ 2] = 0.0f; matrix[ 6] = 0.0f; matrix[10] = 1.0f; matrix[14] = 0.0f; matrix[ 3] = 0.0f; matrix[ 7] = 0.0f; matrix[11] = 0.0f; matrix[15] = 1.0f; } /* ** RB_CalcRotateTexCoords */ void RB_CalcRotateTexCoords( float degsPerSecond, float *st ) { float timeScale = tess.shaderTime; float degs; int index; float sinValue, cosValue; texModInfo_t tmi; degs = -degsPerSecond * timeScale; index = degs * ( FUNCTABLE_SIZE / 360.0f ); sinValue = tr.sinTable[ index & FUNCTABLE_MASK ]; cosValue = tr.sinTable[ ( index + FUNCTABLE_SIZE / 4 ) & FUNCTABLE_MASK ]; tmi.matrix[0][0] = cosValue; tmi.matrix[1][0] = -sinValue; tmi.translate[0] = 0.5 - 0.5 * cosValue + 0.5 * sinValue; tmi.matrix[0][1] = sinValue; tmi.matrix[1][1] = cosValue; tmi.translate[1] = 0.5 - 0.5 * sinValue - 0.5 * cosValue; RB_CalcTransformTexCoords( &tmi, st ); } void RB_CalcRotateTexMatrix( float degsPerSecond, float *matrix ) { float timeScale = tess.shaderTime; float degs; int index; float sinValue, cosValue; texModInfo_t tmi; degs = -degsPerSecond * timeScale; index = degs * ( FUNCTABLE_SIZE / 360.0f ); sinValue = tr.sinTable[ index & FUNCTABLE_MASK ]; cosValue = tr.sinTable[ ( index + FUNCTABLE_SIZE / 4 ) & FUNCTABLE_MASK ]; tmi.matrix[0][0] = cosValue; tmi.matrix[1][0] = -sinValue; tmi.translate[0] = 0.5 - 0.5 * cosValue + 0.5 * sinValue; tmi.matrix[0][1] = sinValue; tmi.matrix[1][1] = cosValue; tmi.translate[1] = 0.5 - 0.5 * sinValue - 0.5 * cosValue; RB_CalcTransformTexMatrix( &tmi, matrix ); } /* ** RB_CalcSpecularAlpha ** ** Calculates specular coefficient and places it in the alpha channel */ vec3_t lightOrigin = { -960, 1980, 96 }; // FIXME: track dynamically void RB_CalcSpecularAlpha( unsigned char *alphas ) { int i; float *v, *normal; vec3_t viewer, reflected; float l, d; int b; vec3_t lightDir; int numVertexes; v = tess.xyz[0]; normal = tess.normal[0]; alphas += 3; numVertexes = tess.numVertexes; for (i = 0 ; i < numVertexes ; i++, v += 4, normal += 4, alphas += 4) { float ilength; VectorSubtract( lightOrigin, v, lightDir ); // ilength = Q_rsqrt( DotProduct( lightDir, lightDir ) ); VectorNormalizeFast( lightDir ); // calculate the specular color d = DotProduct (normal, lightDir); // d *= ilength; // we don't optimize for the d < 0 case since this tends to // cause visual artifacts such as faceted "snapping" reflected[0] = normal[0]*2*d - lightDir[0]; reflected[1] = normal[1]*2*d - lightDir[1]; reflected[2] = normal[2]*2*d - lightDir[2]; VectorSubtract (backEnd.or.viewOrigin, v, viewer); ilength = Q_rsqrt( DotProduct( viewer, viewer ) ); l = DotProduct (reflected, viewer); l *= ilength; if (l < 0) { b = 0; } else { l = l*l; l = l*l; b = l * 255; if (b > 255) { b = 255; } } *alphas = b; } } /* ** RB_CalcDiffuseColor ** ** The basic vertex lighting calc */ #if idppc_altivec static void RB_CalcDiffuseColor_altivec( unsigned char *colors ) { int i; float *v, *normal; trRefEntity_t *ent; int ambientLightInt; vec3_t lightDir; int numVertexes; vector unsigned char vSel = VECCONST_UINT8(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; ent = backEnd.currentEntity; ambientLightInt = ent->ambientLightInt; // 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 ); v = tess.xyz[0]; normal = tess.normal[0]; normalPerm = vec_lvsl(0,normal); numVertexes = tess.numVertexes; for (i = 0 ; i < numVertexes ; i++, v += 4, normal += 4) { 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 } } #endif static void RB_CalcDiffuseColor_scalar( unsigned char *colors ) { int i, j; float *v, *normal; float incoming; trRefEntity_t *ent; int ambientLightInt; vec3_t ambientLight; vec3_t lightDir; vec3_t directedLight; int numVertexes; ent = backEnd.currentEntity; ambientLightInt = ent->ambientLightInt; VectorCopy( ent->ambientLight, ambientLight ); VectorCopy( ent->directedLight, directedLight ); VectorCopy( ent->lightDir, lightDir ); v = tess.xyz[0]; normal = tess.normal[0]; numVertexes = tess.numVertexes; for (i = 0 ; i < numVertexes ; i++, v += 4, normal += 4) { incoming = DotProduct (normal, lightDir); if ( incoming <= 0 ) { *(int *)&colors[i*4] = ambientLightInt; continue; } j = ri.ftol(ambientLight[0] + incoming * directedLight[0]); if ( j > 255 ) { j = 255; } colors[i*4+0] = j; j = ri.ftol(ambientLight[1] + incoming * directedLight[1]); if ( j > 255 ) { j = 255; } colors[i*4+1] = j; j = ri.ftol(ambientLight[2] + incoming * directedLight[2]); if ( j > 255 ) { j = 255; } colors[i*4+2] = j; colors[i*4+3] = 255; } } void RB_CalcDiffuseColor( unsigned char *colors ) { #if idppc_altivec if (com_altivec->integer) { // must be in a seperate function or G3 systems will crash. RB_CalcDiffuseColor_altivec( colors ); return; } #endif RB_CalcDiffuseColor_scalar( colors ); }