mirror of
https://github.com/Q3Rally-Team/q3rally.git
synced 2024-11-26 22:01:50 +00:00
96a9e2a9aa
This updates from SDL 2.0.4 to SDL 2.0.8. Fix nullptr dereference in front of nullptr check in FS_CheckPak0 Fix undefined behaviour due to shifting signed in snd_mem.c Fix shifting bits out of byte in tr_font.c Fix shift into sign in cl_cin.c Fix signed bit operations in MSG_ReadBits Add missing address operator in cm_polylib.c OpenGL1: Decay float[8] to float * in tr_marks.c Avoid srcList[-1] in snd_openal.c Fix the behaviour of CVAR_LATCH|CVAR_CHEAT cvars Maximize cURL buffer size Fix mouse grab after toggling fullscreen Fix q3history buffer not cleared between mods and OOB-access Revert "Removed "Color Depth" from q3_ui system settings, it didn't control anything." Fix displayed color/depth/stencil bits values Restore setting r_colorbits in q3_ui Make setting r_stencilbits more consistent in Team Arena UI Fix map list in Team Arena start server menu after entering SP menu Support SDL audio devices that require float32 samples. sdl_snd.c should just initialize SDL audio without checking SDL_WasInit(). There's no need to SDL_PauseAudio(1) before calling SDL_CloseAudio(). Added audio capture support to SDL backend. Use the SDL2 audio device interface instead of the legacy 1.2 API. Disable SDL audio capture until prebuilt SDL libraries are updated to 2.0.8. Update SDL2 to 2.0.8 Add SDL 2.0.1 headers for macOS PPC Make macOS Universal Bundle target 10.6 for x86 and x86_64 Fix possible bot goal state NULL pointer dereference Fix uninitialized bot_goal_t fields Remove unnecessary NULL pointer check in Cmd_RemoveCommand Make UI_DrawProportionalString handle NULL string Fix compiling against macOS system OpenAL and SDL2 frameworks Fix array index in CanDamage() function - discovered by MARTY Fix compiling Makefile (broke in macOS frameworks commit) Fix clearing keys for control in Team Arena UI Make s_useOpenAL be CVAR_LATCH Improvements for dedicated camera followers (team follow1/2) Fix not closing description.txt and fix path seperator Fix duplicate bots displayed in Team Arena ingame add bot menu OpenGL2: Fix parsing specularScale in shaders Don't allow SDL audio capture using pulseaudio Isolate the Altivec code so non-Altivec PPC targets can use the same binary. Limit -maltivec to specific source files on OpenBSD too (untested) Use SDL 2.0.1 headers for macOS ppc64 Fix console offset while Team Arena voiceMenu is open OpenGL2: Readd r_deluxeSpecular. Fix client kicked as unpure when missing the latest cgame/ui pk3s Don't create multiple windows when GL context creation fails Require OpenGL 1.2 for GL_CLAMP_TO_EDGE Fix Linux uninstaller requiring Bash Fix Linux uninstaller redirecting stderr to stdout in preuninstall.sh Reported by @illwieckz. Fix in_restart causing fatal error while video is shutdown Allow pkg-config binary to be overridden with PKG_CONFIG Make testgun command without argument disable test gun model Remove unused renderer_buffer variable Don't upload 8 bit grayscale images as 16 bit luminance OpenGL1: Use RE_UploadCinematic() instead of duplicate code Don't load non-core GL functions for OpenGL 3.2 core context Load OpenGL ES 2.0 function procs Don't check fixed function GL extensions when using shader pipeline OpenGL2: Fix world VAO cache drawing when glIndex_t is unsigned short OpenGL2: Misc fixes and cleanup Fix IQM root joint backlerp when joint number is more than 0 Improve IQM loading Improve IQM CPU vertex skinning performance OpenGL2: Add GPU vertex skinning for IQM models
1679 lines
42 KiB
C
1679 lines
42 KiB
C
/*
|
|
===========================================================================
|
|
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.c
|
|
|
|
#include "tr_local.h"
|
|
|
|
/*
|
|
|
|
THIS ENTIRE FILE IS BACK END
|
|
|
|
This file deals with applying shaders to surface data in the tess struct.
|
|
*/
|
|
|
|
|
|
/*
|
|
==================
|
|
R_DrawElements
|
|
|
|
==================
|
|
*/
|
|
|
|
void R_DrawElements( int numIndexes, int firstIndex )
|
|
{
|
|
qglDrawElements(GL_TRIANGLES, numIndexes, GL_INDEX_TYPE, BUFFER_OFFSET(firstIndex * sizeof(glIndex_t)));
|
|
}
|
|
|
|
|
|
/*
|
|
=============================================================
|
|
|
|
SURFACE SHADERS
|
|
|
|
=============================================================
|
|
*/
|
|
|
|
shaderCommands_t tess;
|
|
|
|
|
|
/*
|
|
=================
|
|
R_BindAnimatedImageToTMU
|
|
|
|
=================
|
|
*/
|
|
static void R_BindAnimatedImageToTMU( textureBundle_t *bundle, int tmu ) {
|
|
int64_t index;
|
|
|
|
if ( bundle->isVideoMap ) {
|
|
ri.CIN_RunCinematic(bundle->videoMapHandle);
|
|
ri.CIN_UploadCinematic(bundle->videoMapHandle);
|
|
GL_BindToTMU(tr.scratchImage[bundle->videoMapHandle], tmu);
|
|
return;
|
|
}
|
|
|
|
if ( bundle->numImageAnimations <= 1 ) {
|
|
GL_BindToTMU( bundle->image[0], tmu);
|
|
return;
|
|
}
|
|
|
|
// it is necessary to do this messy calc to make sure animations line up
|
|
// exactly with waveforms of the same frequency
|
|
index = tess.shaderTime * bundle->imageAnimationSpeed * FUNCTABLE_SIZE;
|
|
index >>= FUNCTABLE_SIZE2;
|
|
|
|
if ( index < 0 ) {
|
|
index = 0; // may happen with shader time offsets
|
|
}
|
|
|
|
// Windows x86 doesn't load renderer DLL with 64 bit modulus
|
|
//index %= bundle->numImageAnimations;
|
|
while ( index >= bundle->numImageAnimations ) {
|
|
index -= bundle->numImageAnimations;
|
|
}
|
|
|
|
GL_BindToTMU( bundle->image[ index ], tmu );
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
DrawTris
|
|
|
|
Draws triangle outlines for debugging
|
|
================
|
|
*/
|
|
static void DrawTris (shaderCommands_t *input) {
|
|
GL_BindToTMU( tr.whiteImage, TB_COLORMAP );
|
|
|
|
GL_State( GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE );
|
|
qglDepthRange( 0, 0 );
|
|
|
|
{
|
|
shaderProgram_t *sp = &tr.textureColorShader;
|
|
vec4_t color;
|
|
|
|
GLSL_BindProgram(sp);
|
|
|
|
GLSL_SetUniformMat4(sp, UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
|
|
VectorSet4(color, 1, 1, 1, 1);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_COLOR, color);
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHATEST, 0);
|
|
|
|
R_DrawElements(input->numIndexes, input->firstIndex);
|
|
}
|
|
|
|
qglDepthRange( 0, 1 );
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
DrawNormals
|
|
|
|
Draws vertex normals for debugging
|
|
================
|
|
*/
|
|
static void DrawNormals (shaderCommands_t *input) {
|
|
//FIXME: implement this
|
|
}
|
|
|
|
/*
|
|
==============
|
|
RB_BeginSurface
|
|
|
|
We must set some things up before beginning any tesselation,
|
|
because a surface may be forced to perform a RB_End due
|
|
to overflow.
|
|
==============
|
|
*/
|
|
void RB_BeginSurface( shader_t *shader, int fogNum, int cubemapIndex ) {
|
|
|
|
shader_t *state = (shader->remappedShader) ? shader->remappedShader : shader;
|
|
|
|
tess.numIndexes = 0;
|
|
tess.firstIndex = 0;
|
|
tess.numVertexes = 0;
|
|
tess.shader = state;
|
|
tess.fogNum = fogNum;
|
|
tess.cubemapIndex = cubemapIndex;
|
|
tess.dlightBits = 0; // will be OR'd in by surface functions
|
|
tess.pshadowBits = 0; // will be OR'd in by surface functions
|
|
tess.xstages = state->stages;
|
|
tess.numPasses = state->numUnfoggedPasses;
|
|
tess.currentStageIteratorFunc = state->optimalStageIteratorFunc;
|
|
tess.useInternalVao = qtrue;
|
|
tess.useCacheVao = qfalse;
|
|
|
|
tess.shaderTime = backEnd.refdef.floatTime - tess.shader->timeOffset;
|
|
if (tess.shader->clampTime && tess.shaderTime >= tess.shader->clampTime) {
|
|
tess.shaderTime = tess.shader->clampTime;
|
|
}
|
|
|
|
if (backEnd.viewParms.flags & VPF_SHADOWMAP)
|
|
{
|
|
tess.currentStageIteratorFunc = RB_StageIteratorGeneric;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
extern float EvalWaveForm( const waveForm_t *wf );
|
|
extern float EvalWaveFormClamped( const waveForm_t *wf );
|
|
|
|
|
|
static void ComputeTexMods( shaderStage_t *pStage, int bundleNum, float *outMatrix, float *outOffTurb)
|
|
{
|
|
int tm;
|
|
float matrix[6], currentmatrix[6];
|
|
textureBundle_t *bundle = &pStage->bundle[bundleNum];
|
|
|
|
matrix[0] = 1.0f; matrix[2] = 0.0f; matrix[4] = 0.0f;
|
|
matrix[1] = 0.0f; matrix[3] = 1.0f; matrix[5] = 0.0f;
|
|
|
|
currentmatrix[0] = 1.0f; currentmatrix[2] = 0.0f; currentmatrix[4] = 0.0f;
|
|
currentmatrix[1] = 0.0f; currentmatrix[3] = 1.0f; currentmatrix[5] = 0.0f;
|
|
|
|
outMatrix[0] = 1.0f; outMatrix[2] = 0.0f;
|
|
outMatrix[1] = 0.0f; outMatrix[3] = 1.0f;
|
|
|
|
outOffTurb[0] = 0.0f; outOffTurb[1] = 0.0f; outOffTurb[2] = 0.0f; outOffTurb[3] = 0.0f;
|
|
|
|
for ( tm = 0; tm < bundle->numTexMods ; tm++ ) {
|
|
switch ( bundle->texMods[tm].type )
|
|
{
|
|
|
|
case TMOD_NONE:
|
|
tm = TR_MAX_TEXMODS; // break out of for loop
|
|
break;
|
|
|
|
case TMOD_TURBULENT:
|
|
RB_CalcTurbulentFactors(&bundle->texMods[tm].wave, &outOffTurb[2], &outOffTurb[3]);
|
|
break;
|
|
|
|
case TMOD_ENTITY_TRANSLATE:
|
|
RB_CalcScrollTexMatrix( backEnd.currentEntity->e.shaderTexCoord, matrix );
|
|
break;
|
|
|
|
case TMOD_SCROLL:
|
|
RB_CalcScrollTexMatrix( bundle->texMods[tm].scroll,
|
|
matrix );
|
|
break;
|
|
|
|
case TMOD_SCALE:
|
|
RB_CalcScaleTexMatrix( bundle->texMods[tm].scale,
|
|
matrix );
|
|
break;
|
|
|
|
case TMOD_STRETCH:
|
|
RB_CalcStretchTexMatrix( &bundle->texMods[tm].wave,
|
|
matrix );
|
|
break;
|
|
|
|
case TMOD_TRANSFORM:
|
|
RB_CalcTransformTexMatrix( &bundle->texMods[tm],
|
|
matrix );
|
|
break;
|
|
|
|
case TMOD_ROTATE:
|
|
RB_CalcRotateTexMatrix( bundle->texMods[tm].rotateSpeed,
|
|
matrix );
|
|
break;
|
|
|
|
default:
|
|
ri.Error( ERR_DROP, "ERROR: unknown texmod '%d' in shader '%s'", bundle->texMods[tm].type, tess.shader->name );
|
|
break;
|
|
}
|
|
|
|
switch ( bundle->texMods[tm].type )
|
|
{
|
|
case TMOD_NONE:
|
|
case TMOD_TURBULENT:
|
|
default:
|
|
break;
|
|
|
|
case TMOD_ENTITY_TRANSLATE:
|
|
case TMOD_SCROLL:
|
|
case TMOD_SCALE:
|
|
case TMOD_STRETCH:
|
|
case TMOD_TRANSFORM:
|
|
case TMOD_ROTATE:
|
|
outMatrix[0] = matrix[0] * currentmatrix[0] + matrix[2] * currentmatrix[1];
|
|
outMatrix[1] = matrix[1] * currentmatrix[0] + matrix[3] * currentmatrix[1];
|
|
|
|
outMatrix[2] = matrix[0] * currentmatrix[2] + matrix[2] * currentmatrix[3];
|
|
outMatrix[3] = matrix[1] * currentmatrix[2] + matrix[3] * currentmatrix[3];
|
|
|
|
outOffTurb[0] = matrix[0] * currentmatrix[4] + matrix[2] * currentmatrix[5] + matrix[4];
|
|
outOffTurb[1] = matrix[1] * currentmatrix[4] + matrix[3] * currentmatrix[5] + matrix[5];
|
|
|
|
currentmatrix[0] = outMatrix[0];
|
|
currentmatrix[1] = outMatrix[1];
|
|
currentmatrix[2] = outMatrix[2];
|
|
currentmatrix[3] = outMatrix[3];
|
|
currentmatrix[4] = outOffTurb[0];
|
|
currentmatrix[5] = outOffTurb[1];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void ComputeDeformValues(int *deformGen, vec5_t deformParams)
|
|
{
|
|
// u_DeformGen
|
|
*deformGen = DGEN_NONE;
|
|
if(!ShaderRequiresCPUDeforms(tess.shader))
|
|
{
|
|
deformStage_t *ds;
|
|
|
|
// only support the first one
|
|
ds = &tess.shader->deforms[0];
|
|
|
|
switch (ds->deformation)
|
|
{
|
|
case DEFORM_WAVE:
|
|
*deformGen = ds->deformationWave.func;
|
|
|
|
deformParams[0] = ds->deformationWave.base;
|
|
deformParams[1] = ds->deformationWave.amplitude;
|
|
deformParams[2] = ds->deformationWave.phase;
|
|
deformParams[3] = ds->deformationWave.frequency;
|
|
deformParams[4] = ds->deformationSpread;
|
|
break;
|
|
|
|
case DEFORM_BULGE:
|
|
*deformGen = DGEN_BULGE;
|
|
|
|
deformParams[0] = 0;
|
|
deformParams[1] = ds->bulgeHeight; // amplitude
|
|
deformParams[2] = ds->bulgeWidth; // phase
|
|
deformParams[3] = ds->bulgeSpeed; // frequency
|
|
deformParams[4] = 0;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void ProjectDlightTexture( void ) {
|
|
int l;
|
|
vec3_t origin;
|
|
float scale;
|
|
float radius;
|
|
int deformGen;
|
|
vec5_t deformParams;
|
|
|
|
if ( !backEnd.refdef.num_dlights ) {
|
|
return;
|
|
}
|
|
|
|
ComputeDeformValues(&deformGen, deformParams);
|
|
|
|
for ( l = 0 ; l < backEnd.refdef.num_dlights ; l++ ) {
|
|
dlight_t *dl;
|
|
shaderProgram_t *sp;
|
|
vec4_t vector;
|
|
|
|
if ( !( tess.dlightBits & ( 1 << l ) ) ) {
|
|
continue; // this surface definitely doesn't have any of this light
|
|
}
|
|
|
|
dl = &backEnd.refdef.dlights[l];
|
|
VectorCopy( dl->transformed, origin );
|
|
radius = dl->radius;
|
|
scale = 1.0f / radius;
|
|
|
|
sp = &tr.dlightShader[deformGen == DGEN_NONE ? 0 : 1];
|
|
|
|
backEnd.pc.c_dlightDraws++;
|
|
|
|
GLSL_BindProgram(sp);
|
|
|
|
GLSL_SetUniformMat4(sp, UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
|
|
|
|
GLSL_SetUniformFloat(sp, UNIFORM_VERTEXLERP, glState.vertexAttribsInterpolation);
|
|
|
|
GLSL_SetUniformInt(sp, UNIFORM_DEFORMGEN, deformGen);
|
|
if (deformGen != DGEN_NONE)
|
|
{
|
|
GLSL_SetUniformFloat5(sp, UNIFORM_DEFORMPARAMS, deformParams);
|
|
GLSL_SetUniformFloat(sp, UNIFORM_TIME, tess.shaderTime);
|
|
}
|
|
|
|
vector[0] = dl->color[0];
|
|
vector[1] = dl->color[1];
|
|
vector[2] = dl->color[2];
|
|
vector[3] = 1.0f;
|
|
GLSL_SetUniformVec4(sp, UNIFORM_COLOR, vector);
|
|
|
|
vector[0] = origin[0];
|
|
vector[1] = origin[1];
|
|
vector[2] = origin[2];
|
|
vector[3] = scale;
|
|
GLSL_SetUniformVec4(sp, UNIFORM_DLIGHTINFO, vector);
|
|
|
|
GL_BindToTMU( tr.dlightImage, TB_COLORMAP );
|
|
|
|
// include GLS_DEPTHFUNC_EQUAL so alpha tested surfaces don't add light
|
|
// where they aren't rendered
|
|
if ( dl->additive ) {
|
|
GL_State( GLS_ATEST_GT_0 | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
|
|
}
|
|
else {
|
|
GL_State( GLS_ATEST_GT_0 | GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
|
|
}
|
|
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHATEST, 1);
|
|
|
|
R_DrawElements(tess.numIndexes, tess.firstIndex);
|
|
|
|
backEnd.pc.c_totalIndexes += tess.numIndexes;
|
|
backEnd.pc.c_dlightIndexes += tess.numIndexes;
|
|
backEnd.pc.c_dlightVertexes += tess.numVertexes;
|
|
}
|
|
}
|
|
|
|
|
|
static void ComputeShaderColors( shaderStage_t *pStage, vec4_t baseColor, vec4_t vertColor, int blend )
|
|
{
|
|
qboolean isBlend = ((blend & GLS_SRCBLEND_BITS) == GLS_SRCBLEND_DST_COLOR)
|
|
|| ((blend & GLS_SRCBLEND_BITS) == GLS_SRCBLEND_ONE_MINUS_DST_COLOR)
|
|
|| ((blend & GLS_DSTBLEND_BITS) == GLS_DSTBLEND_SRC_COLOR)
|
|
|| ((blend & GLS_DSTBLEND_BITS) == GLS_DSTBLEND_ONE_MINUS_SRC_COLOR);
|
|
|
|
qboolean is2DDraw = backEnd.currentEntity == &backEnd.entity2D;
|
|
|
|
float overbright = (isBlend || is2DDraw) ? 1.0f : (float)(1 << tr.overbrightBits);
|
|
|
|
fog_t *fog;
|
|
|
|
baseColor[0] =
|
|
baseColor[1] =
|
|
baseColor[2] =
|
|
baseColor[3] = 1.0f;
|
|
|
|
vertColor[0] =
|
|
vertColor[1] =
|
|
vertColor[2] =
|
|
vertColor[3] = 0.0f;
|
|
|
|
//
|
|
// rgbGen
|
|
//
|
|
switch ( pStage->rgbGen )
|
|
{
|
|
case CGEN_EXACT_VERTEX:
|
|
case CGEN_EXACT_VERTEX_LIT:
|
|
baseColor[0] =
|
|
baseColor[1] =
|
|
baseColor[2] =
|
|
baseColor[3] = 0.0f;
|
|
|
|
vertColor[0] =
|
|
vertColor[1] =
|
|
vertColor[2] = overbright;
|
|
vertColor[3] = 1.0f;
|
|
break;
|
|
case CGEN_CONST:
|
|
baseColor[0] = pStage->constantColor[0] / 255.0f;
|
|
baseColor[1] = pStage->constantColor[1] / 255.0f;
|
|
baseColor[2] = pStage->constantColor[2] / 255.0f;
|
|
baseColor[3] = pStage->constantColor[3] / 255.0f;
|
|
break;
|
|
case CGEN_VERTEX:
|
|
case CGEN_VERTEX_LIT:
|
|
baseColor[0] =
|
|
baseColor[1] =
|
|
baseColor[2] =
|
|
baseColor[3] = 0.0f;
|
|
|
|
vertColor[0] =
|
|
vertColor[1] =
|
|
vertColor[2] =
|
|
vertColor[3] = 1.0f;
|
|
break;
|
|
case CGEN_ONE_MINUS_VERTEX:
|
|
baseColor[0] =
|
|
baseColor[1] =
|
|
baseColor[2] = 1.0f;
|
|
|
|
vertColor[0] =
|
|
vertColor[1] =
|
|
vertColor[2] = -1.0f;
|
|
break;
|
|
case CGEN_FOG:
|
|
fog = tr.world->fogs + tess.fogNum;
|
|
|
|
baseColor[0] = ((unsigned char *)(&fog->colorInt))[0] / 255.0f;
|
|
baseColor[1] = ((unsigned char *)(&fog->colorInt))[1] / 255.0f;
|
|
baseColor[2] = ((unsigned char *)(&fog->colorInt))[2] / 255.0f;
|
|
baseColor[3] = ((unsigned char *)(&fog->colorInt))[3] / 255.0f;
|
|
break;
|
|
case CGEN_WAVEFORM:
|
|
baseColor[0] =
|
|
baseColor[1] =
|
|
baseColor[2] = RB_CalcWaveColorSingle( &pStage->rgbWave );
|
|
break;
|
|
case CGEN_ENTITY:
|
|
if (backEnd.currentEntity)
|
|
{
|
|
baseColor[0] = ((unsigned char *)backEnd.currentEntity->e.shaderRGBA)[0] / 255.0f;
|
|
baseColor[1] = ((unsigned char *)backEnd.currentEntity->e.shaderRGBA)[1] / 255.0f;
|
|
baseColor[2] = ((unsigned char *)backEnd.currentEntity->e.shaderRGBA)[2] / 255.0f;
|
|
baseColor[3] = ((unsigned char *)backEnd.currentEntity->e.shaderRGBA)[3] / 255.0f;
|
|
}
|
|
break;
|
|
case CGEN_ONE_MINUS_ENTITY:
|
|
if (backEnd.currentEntity)
|
|
{
|
|
baseColor[0] = 1.0f - ((unsigned char *)backEnd.currentEntity->e.shaderRGBA)[0] / 255.0f;
|
|
baseColor[1] = 1.0f - ((unsigned char *)backEnd.currentEntity->e.shaderRGBA)[1] / 255.0f;
|
|
baseColor[2] = 1.0f - ((unsigned char *)backEnd.currentEntity->e.shaderRGBA)[2] / 255.0f;
|
|
baseColor[3] = 1.0f - ((unsigned char *)backEnd.currentEntity->e.shaderRGBA)[3] / 255.0f;
|
|
}
|
|
break;
|
|
case CGEN_IDENTITY:
|
|
case CGEN_LIGHTING_DIFFUSE:
|
|
baseColor[0] =
|
|
baseColor[1] =
|
|
baseColor[2] = overbright;
|
|
break;
|
|
case CGEN_IDENTITY_LIGHTING:
|
|
case CGEN_BAD:
|
|
break;
|
|
}
|
|
|
|
//
|
|
// alphaGen
|
|
//
|
|
switch ( pStage->alphaGen )
|
|
{
|
|
case AGEN_SKIP:
|
|
break;
|
|
case AGEN_CONST:
|
|
baseColor[3] = pStage->constantColor[3] / 255.0f;
|
|
vertColor[3] = 0.0f;
|
|
break;
|
|
case AGEN_WAVEFORM:
|
|
baseColor[3] = RB_CalcWaveAlphaSingle( &pStage->alphaWave );
|
|
vertColor[3] = 0.0f;
|
|
break;
|
|
case AGEN_ENTITY:
|
|
if (backEnd.currentEntity)
|
|
{
|
|
baseColor[3] = ((unsigned char *)backEnd.currentEntity->e.shaderRGBA)[3] / 255.0f;
|
|
}
|
|
vertColor[3] = 0.0f;
|
|
break;
|
|
case AGEN_ONE_MINUS_ENTITY:
|
|
if (backEnd.currentEntity)
|
|
{
|
|
baseColor[3] = 1.0f - ((unsigned char *)backEnd.currentEntity->e.shaderRGBA)[3] / 255.0f;
|
|
}
|
|
vertColor[3] = 0.0f;
|
|
break;
|
|
case AGEN_VERTEX:
|
|
baseColor[3] = 0.0f;
|
|
vertColor[3] = 1.0f;
|
|
break;
|
|
case AGEN_ONE_MINUS_VERTEX:
|
|
baseColor[3] = 1.0f;
|
|
vertColor[3] = -1.0f;
|
|
break;
|
|
case AGEN_IDENTITY:
|
|
case AGEN_LIGHTING_SPECULAR:
|
|
case AGEN_PORTAL:
|
|
// Done entirely in vertex program
|
|
baseColor[3] = 1.0f;
|
|
vertColor[3] = 0.0f;
|
|
break;
|
|
}
|
|
|
|
// FIXME: find some way to implement this.
|
|
#if 0
|
|
// if in greyscale rendering mode turn all color values into greyscale.
|
|
if(r_greyscale->integer)
|
|
{
|
|
int scale;
|
|
|
|
for(i = 0; i < tess.numVertexes; i++)
|
|
{
|
|
scale = (tess.svars.colors[i][0] + tess.svars.colors[i][1] + tess.svars.colors[i][2]) / 3;
|
|
tess.svars.colors[i][0] = tess.svars.colors[i][1] = tess.svars.colors[i][2] = scale;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
static void ComputeFogValues(vec4_t fogDistanceVector, vec4_t fogDepthVector, float *eyeT)
|
|
{
|
|
// from RB_CalcFogTexCoords()
|
|
fog_t *fog;
|
|
vec3_t local;
|
|
|
|
if (!tess.fogNum)
|
|
return;
|
|
|
|
fog = tr.world->fogs + tess.fogNum;
|
|
|
|
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
|
|
VectorScale4(fogDistanceVector, fog->tcScale, fogDistanceVector);
|
|
|
|
// 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
|
|
}
|
|
}
|
|
|
|
|
|
static void ComputeFogColorMask( shaderStage_t *pStage, vec4_t fogColorMask )
|
|
{
|
|
switch(pStage->adjustColorsForFog)
|
|
{
|
|
case ACFF_MODULATE_RGB:
|
|
fogColorMask[0] =
|
|
fogColorMask[1] =
|
|
fogColorMask[2] = 1.0f;
|
|
fogColorMask[3] = 0.0f;
|
|
break;
|
|
case ACFF_MODULATE_ALPHA:
|
|
fogColorMask[0] =
|
|
fogColorMask[1] =
|
|
fogColorMask[2] = 0.0f;
|
|
fogColorMask[3] = 1.0f;
|
|
break;
|
|
case ACFF_MODULATE_RGBA:
|
|
fogColorMask[0] =
|
|
fogColorMask[1] =
|
|
fogColorMask[2] =
|
|
fogColorMask[3] = 1.0f;
|
|
break;
|
|
default:
|
|
fogColorMask[0] =
|
|
fogColorMask[1] =
|
|
fogColorMask[2] =
|
|
fogColorMask[3] = 0.0f;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static void ForwardDlight( void ) {
|
|
int l;
|
|
//vec3_t origin;
|
|
//float scale;
|
|
float radius;
|
|
|
|
int deformGen;
|
|
vec5_t deformParams;
|
|
|
|
vec4_t fogDistanceVector, fogDepthVector = {0, 0, 0, 0};
|
|
float eyeT = 0;
|
|
|
|
shaderCommands_t *input = &tess;
|
|
shaderStage_t *pStage = tess.xstages[0];
|
|
|
|
if ( !backEnd.refdef.num_dlights ) {
|
|
return;
|
|
}
|
|
|
|
ComputeDeformValues(&deformGen, deformParams);
|
|
|
|
ComputeFogValues(fogDistanceVector, fogDepthVector, &eyeT);
|
|
|
|
for ( l = 0 ; l < backEnd.refdef.num_dlights ; l++ ) {
|
|
dlight_t *dl;
|
|
shaderProgram_t *sp;
|
|
vec4_t vector;
|
|
vec4_t texMatrix;
|
|
vec4_t texOffTurb;
|
|
|
|
if ( !( tess.dlightBits & ( 1 << l ) ) ) {
|
|
continue; // this surface definitely doesn't have any of this light
|
|
}
|
|
|
|
dl = &backEnd.refdef.dlights[l];
|
|
//VectorCopy( dl->transformed, origin );
|
|
radius = dl->radius;
|
|
//scale = 1.0f / radius;
|
|
|
|
//if (pStage->glslShaderGroup == tr.lightallShader)
|
|
{
|
|
int index = pStage->glslShaderIndex;
|
|
|
|
index &= ~LIGHTDEF_LIGHTTYPE_MASK;
|
|
index |= LIGHTDEF_USE_LIGHT_VECTOR;
|
|
|
|
sp = &tr.lightallShader[index];
|
|
}
|
|
|
|
backEnd.pc.c_lightallDraws++;
|
|
|
|
GLSL_BindProgram(sp);
|
|
|
|
GLSL_SetUniformMat4(sp, UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_VIEWORIGIN, backEnd.viewParms.or.origin);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_LOCALVIEWORIGIN, backEnd.or.viewOrigin);
|
|
|
|
GLSL_SetUniformFloat(sp, UNIFORM_VERTEXLERP, glState.vertexAttribsInterpolation);
|
|
|
|
GLSL_SetUniformInt(sp, UNIFORM_DEFORMGEN, deformGen);
|
|
if (deformGen != DGEN_NONE)
|
|
{
|
|
GLSL_SetUniformFloat5(sp, UNIFORM_DEFORMPARAMS, deformParams);
|
|
GLSL_SetUniformFloat(sp, UNIFORM_TIME, tess.shaderTime);
|
|
}
|
|
|
|
if ( input->fogNum ) {
|
|
vec4_t fogColorMask;
|
|
|
|
GLSL_SetUniformVec4(sp, UNIFORM_FOGDISTANCE, fogDistanceVector);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_FOGDEPTH, fogDepthVector);
|
|
GLSL_SetUniformFloat(sp, UNIFORM_FOGEYET, eyeT);
|
|
|
|
ComputeFogColorMask(pStage, fogColorMask);
|
|
|
|
GLSL_SetUniformVec4(sp, UNIFORM_FOGCOLORMASK, fogColorMask);
|
|
}
|
|
|
|
{
|
|
vec4_t baseColor;
|
|
vec4_t vertColor;
|
|
|
|
ComputeShaderColors(pStage, baseColor, vertColor, GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE);
|
|
|
|
GLSL_SetUniformVec4(sp, UNIFORM_BASECOLOR, baseColor);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_VERTCOLOR, vertColor);
|
|
}
|
|
|
|
if (pStage->alphaGen == AGEN_PORTAL)
|
|
{
|
|
GLSL_SetUniformFloat(sp, UNIFORM_PORTALRANGE, tess.shader->portalRange);
|
|
}
|
|
|
|
GLSL_SetUniformInt(sp, UNIFORM_COLORGEN, pStage->rgbGen);
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHAGEN, pStage->alphaGen);
|
|
|
|
GLSL_SetUniformVec3(sp, UNIFORM_DIRECTEDLIGHT, dl->color);
|
|
|
|
VectorSet(vector, 0, 0, 0);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_AMBIENTLIGHT, vector);
|
|
|
|
VectorCopy(dl->origin, vector);
|
|
vector[3] = 1.0f;
|
|
GLSL_SetUniformVec4(sp, UNIFORM_LIGHTORIGIN, vector);
|
|
|
|
GLSL_SetUniformFloat(sp, UNIFORM_LIGHTRADIUS, radius);
|
|
|
|
GLSL_SetUniformVec4(sp, UNIFORM_NORMALSCALE, pStage->normalScale);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_SPECULARSCALE, pStage->specularScale);
|
|
|
|
// include GLS_DEPTHFUNC_EQUAL so alpha tested surfaces don't add light
|
|
// where they aren't rendered
|
|
GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHATEST, 0);
|
|
|
|
GLSL_SetUniformMat4(sp, UNIFORM_MODELMATRIX, backEnd.or.transformMatrix);
|
|
|
|
if (pStage->bundle[TB_DIFFUSEMAP].image[0])
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[TB_DIFFUSEMAP], TB_DIFFUSEMAP);
|
|
|
|
// bind textures that are sampled and used in the glsl shader, and
|
|
// bind whiteImage to textures that are sampled but zeroed in the glsl shader
|
|
//
|
|
// alternatives:
|
|
// - use the last bound texture
|
|
// -> costs more to sample a higher res texture then throw out the result
|
|
// - disable texture sampling in glsl shader with #ifdefs, as before
|
|
// -> increases the number of shaders that must be compiled
|
|
//
|
|
|
|
if (pStage->bundle[TB_NORMALMAP].image[0])
|
|
{
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[TB_NORMALMAP], TB_NORMALMAP);
|
|
}
|
|
else if (r_normalMapping->integer)
|
|
GL_BindToTMU( tr.whiteImage, TB_NORMALMAP );
|
|
|
|
if (pStage->bundle[TB_SPECULARMAP].image[0])
|
|
{
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[TB_SPECULARMAP], TB_SPECULARMAP);
|
|
}
|
|
else if (r_specularMapping->integer)
|
|
GL_BindToTMU( tr.whiteImage, TB_SPECULARMAP );
|
|
|
|
{
|
|
vec4_t enableTextures;
|
|
|
|
VectorSet4(enableTextures, 0.0f, 0.0f, 0.0f, 0.0f);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_ENABLETEXTURES, enableTextures);
|
|
}
|
|
|
|
if (r_dlightMode->integer >= 2)
|
|
GL_BindToTMU(tr.shadowCubemaps[l], TB_SHADOWMAP);
|
|
|
|
ComputeTexMods( pStage, TB_DIFFUSEMAP, texMatrix, texOffTurb );
|
|
GLSL_SetUniformVec4(sp, UNIFORM_DIFFUSETEXMATRIX, texMatrix);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_DIFFUSETEXOFFTURB, texOffTurb);
|
|
|
|
GLSL_SetUniformInt(sp, UNIFORM_TCGEN0, pStage->bundle[0].tcGen);
|
|
|
|
//
|
|
// draw
|
|
//
|
|
|
|
R_DrawElements(input->numIndexes, input->firstIndex);
|
|
|
|
backEnd.pc.c_totalIndexes += tess.numIndexes;
|
|
backEnd.pc.c_dlightIndexes += tess.numIndexes;
|
|
backEnd.pc.c_dlightVertexes += tess.numVertexes;
|
|
}
|
|
}
|
|
|
|
|
|
static void ProjectPshadowVBOGLSL( void ) {
|
|
int l;
|
|
vec3_t origin;
|
|
float radius;
|
|
|
|
int deformGen;
|
|
vec5_t deformParams;
|
|
|
|
shaderCommands_t *input = &tess;
|
|
|
|
if ( !backEnd.refdef.num_pshadows ) {
|
|
return;
|
|
}
|
|
|
|
ComputeDeformValues(&deformGen, deformParams);
|
|
|
|
for ( l = 0 ; l < backEnd.refdef.num_pshadows ; l++ ) {
|
|
pshadow_t *ps;
|
|
shaderProgram_t *sp;
|
|
vec4_t vector;
|
|
|
|
if ( !( tess.pshadowBits & ( 1 << l ) ) ) {
|
|
continue; // this surface definitely doesn't have any of this shadow
|
|
}
|
|
|
|
ps = &backEnd.refdef.pshadows[l];
|
|
VectorCopy( ps->lightOrigin, origin );
|
|
radius = ps->lightRadius;
|
|
|
|
sp = &tr.pshadowShader;
|
|
|
|
GLSL_BindProgram(sp);
|
|
|
|
GLSL_SetUniformMat4(sp, UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
|
|
|
|
VectorCopy(origin, vector);
|
|
vector[3] = 1.0f;
|
|
GLSL_SetUniformVec4(sp, UNIFORM_LIGHTORIGIN, vector);
|
|
|
|
VectorScale(ps->lightViewAxis[0], 1.0f / ps->viewRadius, vector);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_LIGHTFORWARD, vector);
|
|
|
|
VectorScale(ps->lightViewAxis[1], 1.0f / ps->viewRadius, vector);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_LIGHTRIGHT, vector);
|
|
|
|
VectorScale(ps->lightViewAxis[2], 1.0f / ps->viewRadius, vector);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_LIGHTUP, vector);
|
|
|
|
GLSL_SetUniformFloat(sp, UNIFORM_LIGHTRADIUS, radius);
|
|
|
|
// include GLS_DEPTHFUNC_EQUAL so alpha tested surfaces don't add light
|
|
// where they aren't rendered
|
|
GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHFUNC_EQUAL );
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHATEST, 0);
|
|
|
|
GL_BindToTMU( tr.pshadowMaps[l], TB_DIFFUSEMAP );
|
|
|
|
//
|
|
// draw
|
|
//
|
|
|
|
R_DrawElements(input->numIndexes, input->firstIndex);
|
|
|
|
backEnd.pc.c_totalIndexes += tess.numIndexes;
|
|
//backEnd.pc.c_dlightIndexes += tess.numIndexes;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===================
|
|
RB_FogPass
|
|
|
|
Blends a fog texture on top of everything else
|
|
===================
|
|
*/
|
|
static void RB_FogPass( void ) {
|
|
fog_t *fog;
|
|
vec4_t color;
|
|
vec4_t fogDistanceVector, fogDepthVector = {0, 0, 0, 0};
|
|
float eyeT = 0;
|
|
shaderProgram_t *sp;
|
|
|
|
int deformGen;
|
|
vec5_t deformParams;
|
|
|
|
ComputeDeformValues(&deformGen, deformParams);
|
|
|
|
{
|
|
int index = 0;
|
|
|
|
if (deformGen != DGEN_NONE)
|
|
index |= FOGDEF_USE_DEFORM_VERTEXES;
|
|
|
|
if (glState.vertexAnimation)
|
|
index |= FOGDEF_USE_VERTEX_ANIMATION;
|
|
else if (glState.boneAnimation)
|
|
index |= FOGDEF_USE_BONE_ANIMATION;
|
|
|
|
sp = &tr.fogShader[index];
|
|
}
|
|
|
|
backEnd.pc.c_fogDraws++;
|
|
|
|
GLSL_BindProgram(sp);
|
|
|
|
fog = tr.world->fogs + tess.fogNum;
|
|
|
|
GLSL_SetUniformMat4(sp, UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
|
|
|
|
GLSL_SetUniformFloat(sp, UNIFORM_VERTEXLERP, glState.vertexAttribsInterpolation);
|
|
|
|
if (glState.boneAnimation)
|
|
{
|
|
GLSL_SetUniformMat4BoneMatrix(sp, UNIFORM_BONEMATRIX, glState.boneMatrix, glState.boneAnimation);
|
|
}
|
|
|
|
GLSL_SetUniformInt(sp, UNIFORM_DEFORMGEN, deformGen);
|
|
if (deformGen != DGEN_NONE)
|
|
{
|
|
GLSL_SetUniformFloat5(sp, UNIFORM_DEFORMPARAMS, deformParams);
|
|
GLSL_SetUniformFloat(sp, UNIFORM_TIME, tess.shaderTime);
|
|
}
|
|
|
|
color[0] = ((unsigned char *)(&fog->colorInt))[0] / 255.0f;
|
|
color[1] = ((unsigned char *)(&fog->colorInt))[1] / 255.0f;
|
|
color[2] = ((unsigned char *)(&fog->colorInt))[2] / 255.0f;
|
|
color[3] = ((unsigned char *)(&fog->colorInt))[3] / 255.0f;
|
|
GLSL_SetUniformVec4(sp, UNIFORM_COLOR, color);
|
|
|
|
ComputeFogValues(fogDistanceVector, fogDepthVector, &eyeT);
|
|
|
|
GLSL_SetUniformVec4(sp, UNIFORM_FOGDISTANCE, fogDistanceVector);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_FOGDEPTH, fogDepthVector);
|
|
GLSL_SetUniformFloat(sp, UNIFORM_FOGEYET, eyeT);
|
|
|
|
if ( tess.shader->fogPass == FP_EQUAL ) {
|
|
GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHFUNC_EQUAL );
|
|
} else {
|
|
GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
|
|
}
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHATEST, 0);
|
|
|
|
R_DrawElements(tess.numIndexes, tess.firstIndex);
|
|
}
|
|
|
|
|
|
static unsigned int RB_CalcShaderVertexAttribs( shaderCommands_t *input )
|
|
{
|
|
unsigned int vertexAttribs = input->shader->vertexAttribs;
|
|
|
|
if(glState.vertexAnimation)
|
|
{
|
|
vertexAttribs |= ATTR_POSITION2;
|
|
if (vertexAttribs & ATTR_NORMAL)
|
|
{
|
|
vertexAttribs |= ATTR_NORMAL2;
|
|
vertexAttribs |= ATTR_TANGENT2;
|
|
}
|
|
}
|
|
|
|
return vertexAttribs;
|
|
}
|
|
|
|
static void RB_IterateStagesGeneric( shaderCommands_t *input )
|
|
{
|
|
int stage;
|
|
|
|
vec4_t fogDistanceVector, fogDepthVector = {0, 0, 0, 0};
|
|
float eyeT = 0;
|
|
|
|
int deformGen;
|
|
vec5_t deformParams;
|
|
|
|
qboolean renderToCubemap = tr.renderCubeFbo && glState.currentFBO == tr.renderCubeFbo;
|
|
|
|
ComputeDeformValues(&deformGen, deformParams);
|
|
|
|
ComputeFogValues(fogDistanceVector, fogDepthVector, &eyeT);
|
|
|
|
for ( stage = 0; stage < MAX_SHADER_STAGES; stage++ )
|
|
{
|
|
shaderStage_t *pStage = input->xstages[stage];
|
|
shaderProgram_t *sp;
|
|
vec4_t texMatrix;
|
|
vec4_t texOffTurb;
|
|
|
|
if ( !pStage )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (backEnd.depthFill)
|
|
{
|
|
if (pStage->glslShaderGroup == tr.lightallShader)
|
|
{
|
|
int index = 0;
|
|
|
|
if (backEnd.currentEntity && backEnd.currentEntity != &tr.worldEntity)
|
|
{
|
|
if (glState.boneAnimation)
|
|
{
|
|
index |= LIGHTDEF_ENTITY_BONE_ANIMATION;
|
|
}
|
|
else
|
|
{
|
|
index |= LIGHTDEF_ENTITY_VERTEX_ANIMATION;
|
|
}
|
|
}
|
|
|
|
if (pStage->stateBits & GLS_ATEST_BITS)
|
|
{
|
|
index |= LIGHTDEF_USE_TCGEN_AND_TCMOD;
|
|
}
|
|
|
|
sp = &pStage->glslShaderGroup[index];
|
|
}
|
|
else
|
|
{
|
|
int shaderAttribs = 0;
|
|
|
|
if (tess.shader->numDeforms && !ShaderRequiresCPUDeforms(tess.shader))
|
|
{
|
|
shaderAttribs |= GENERICDEF_USE_DEFORM_VERTEXES;
|
|
}
|
|
|
|
if (glState.vertexAnimation)
|
|
{
|
|
shaderAttribs |= GENERICDEF_USE_VERTEX_ANIMATION;
|
|
}
|
|
else if (glState.boneAnimation)
|
|
{
|
|
shaderAttribs |= GENERICDEF_USE_BONE_ANIMATION;
|
|
}
|
|
|
|
if (pStage->stateBits & GLS_ATEST_BITS)
|
|
{
|
|
shaderAttribs |= GENERICDEF_USE_TCGEN_AND_TCMOD;
|
|
}
|
|
|
|
sp = &tr.genericShader[shaderAttribs];
|
|
}
|
|
}
|
|
else if (pStage->glslShaderGroup == tr.lightallShader)
|
|
{
|
|
int index = pStage->glslShaderIndex;
|
|
|
|
if (backEnd.currentEntity && backEnd.currentEntity != &tr.worldEntity)
|
|
{
|
|
if (glState.boneAnimation)
|
|
{
|
|
index |= LIGHTDEF_ENTITY_BONE_ANIMATION;
|
|
}
|
|
else
|
|
{
|
|
index |= LIGHTDEF_ENTITY_VERTEX_ANIMATION;
|
|
}
|
|
}
|
|
|
|
if (r_sunlightMode->integer && (backEnd.viewParms.flags & VPF_USESUNLIGHT) && (index & LIGHTDEF_LIGHTTYPE_MASK))
|
|
{
|
|
index |= LIGHTDEF_USE_SHADOWMAP;
|
|
}
|
|
|
|
if (r_lightmap->integer && ((index & LIGHTDEF_LIGHTTYPE_MASK) == LIGHTDEF_USE_LIGHTMAP))
|
|
{
|
|
index = LIGHTDEF_USE_TCGEN_AND_TCMOD;
|
|
}
|
|
|
|
sp = &pStage->glslShaderGroup[index];
|
|
|
|
backEnd.pc.c_lightallDraws++;
|
|
}
|
|
else
|
|
{
|
|
sp = GLSL_GetGenericShaderProgram(stage);
|
|
|
|
backEnd.pc.c_genericDraws++;
|
|
}
|
|
|
|
GLSL_BindProgram(sp);
|
|
|
|
GLSL_SetUniformMat4(sp, UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_VIEWORIGIN, backEnd.viewParms.or.origin);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_LOCALVIEWORIGIN, backEnd.or.viewOrigin);
|
|
|
|
GLSL_SetUniformFloat(sp, UNIFORM_VERTEXLERP, glState.vertexAttribsInterpolation);
|
|
|
|
if (glState.boneAnimation)
|
|
{
|
|
GLSL_SetUniformMat4BoneMatrix(sp, UNIFORM_BONEMATRIX, glState.boneMatrix, glState.boneAnimation);
|
|
}
|
|
|
|
GLSL_SetUniformInt(sp, UNIFORM_DEFORMGEN, deformGen);
|
|
if (deformGen != DGEN_NONE)
|
|
{
|
|
GLSL_SetUniformFloat5(sp, UNIFORM_DEFORMPARAMS, deformParams);
|
|
GLSL_SetUniformFloat(sp, UNIFORM_TIME, tess.shaderTime);
|
|
}
|
|
|
|
if ( input->fogNum ) {
|
|
GLSL_SetUniformVec4(sp, UNIFORM_FOGDISTANCE, fogDistanceVector);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_FOGDEPTH, fogDepthVector);
|
|
GLSL_SetUniformFloat(sp, UNIFORM_FOGEYET, eyeT);
|
|
}
|
|
|
|
GL_State( pStage->stateBits );
|
|
if ((pStage->stateBits & GLS_ATEST_BITS) == GLS_ATEST_GT_0)
|
|
{
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHATEST, 1);
|
|
}
|
|
else if ((pStage->stateBits & GLS_ATEST_BITS) == GLS_ATEST_LT_80)
|
|
{
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHATEST, 2);
|
|
}
|
|
else if ((pStage->stateBits & GLS_ATEST_BITS) == GLS_ATEST_GE_80)
|
|
{
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHATEST, 3);
|
|
}
|
|
else
|
|
{
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHATEST, 0);
|
|
}
|
|
|
|
|
|
{
|
|
vec4_t baseColor;
|
|
vec4_t vertColor;
|
|
|
|
ComputeShaderColors(pStage, baseColor, vertColor, pStage->stateBits);
|
|
|
|
GLSL_SetUniformVec4(sp, UNIFORM_BASECOLOR, baseColor);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_VERTCOLOR, vertColor);
|
|
}
|
|
|
|
if (pStage->rgbGen == CGEN_LIGHTING_DIFFUSE)
|
|
{
|
|
vec4_t vec;
|
|
|
|
VectorScale(backEnd.currentEntity->ambientLight, 1.0f / 255.0f, vec);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_AMBIENTLIGHT, vec);
|
|
|
|
VectorScale(backEnd.currentEntity->directedLight, 1.0f / 255.0f, vec);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_DIRECTEDLIGHT, vec);
|
|
|
|
VectorCopy(backEnd.currentEntity->lightDir, vec);
|
|
vec[3] = 0.0f;
|
|
GLSL_SetUniformVec4(sp, UNIFORM_LIGHTORIGIN, vec);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_MODELLIGHTDIR, backEnd.currentEntity->modelLightDir);
|
|
|
|
GLSL_SetUniformFloat(sp, UNIFORM_LIGHTRADIUS, 0.0f);
|
|
}
|
|
|
|
if (pStage->alphaGen == AGEN_PORTAL)
|
|
{
|
|
GLSL_SetUniformFloat(sp, UNIFORM_PORTALRANGE, tess.shader->portalRange);
|
|
}
|
|
|
|
GLSL_SetUniformInt(sp, UNIFORM_COLORGEN, pStage->rgbGen);
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHAGEN, pStage->alphaGen);
|
|
|
|
if ( input->fogNum )
|
|
{
|
|
vec4_t fogColorMask;
|
|
|
|
ComputeFogColorMask(pStage, fogColorMask);
|
|
|
|
GLSL_SetUniformVec4(sp, UNIFORM_FOGCOLORMASK, fogColorMask);
|
|
}
|
|
|
|
if (r_lightmap->integer)
|
|
{
|
|
vec4_t v;
|
|
VectorSet4(v, 1.0f, 0.0f, 0.0f, 1.0f);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_DIFFUSETEXMATRIX, v);
|
|
VectorSet4(v, 0.0f, 0.0f, 0.0f, 0.0f);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_DIFFUSETEXOFFTURB, v);
|
|
|
|
GLSL_SetUniformInt(sp, UNIFORM_TCGEN0, TCGEN_LIGHTMAP);
|
|
}
|
|
else
|
|
{
|
|
ComputeTexMods(pStage, TB_DIFFUSEMAP, texMatrix, texOffTurb);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_DIFFUSETEXMATRIX, texMatrix);
|
|
GLSL_SetUniformVec4(sp, UNIFORM_DIFFUSETEXOFFTURB, texOffTurb);
|
|
|
|
GLSL_SetUniformInt(sp, UNIFORM_TCGEN0, pStage->bundle[0].tcGen);
|
|
if (pStage->bundle[0].tcGen == TCGEN_VECTOR)
|
|
{
|
|
vec3_t vec;
|
|
|
|
VectorCopy(pStage->bundle[0].tcGenVectors[0], vec);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_TCGEN0VECTOR0, vec);
|
|
VectorCopy(pStage->bundle[0].tcGenVectors[1], vec);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_TCGEN0VECTOR1, vec);
|
|
}
|
|
}
|
|
|
|
GLSL_SetUniformMat4(sp, UNIFORM_MODELMATRIX, backEnd.or.transformMatrix);
|
|
|
|
GLSL_SetUniformVec4(sp, UNIFORM_NORMALSCALE, pStage->normalScale);
|
|
|
|
{
|
|
vec4_t specularScale;
|
|
Vector4Copy(pStage->specularScale, specularScale);
|
|
|
|
if (renderToCubemap)
|
|
{
|
|
// force specular to nonmetal if rendering cubemaps
|
|
if (r_pbr->integer)
|
|
specularScale[1] = 0.0f;
|
|
}
|
|
|
|
GLSL_SetUniformVec4(sp, UNIFORM_SPECULARSCALE, specularScale);
|
|
}
|
|
|
|
//GLSL_SetUniformFloat(sp, UNIFORM_MAPLIGHTSCALE, backEnd.refdef.mapLightScale);
|
|
|
|
//
|
|
// do multitexture
|
|
//
|
|
if ( backEnd.depthFill )
|
|
{
|
|
if (!(pStage->stateBits & GLS_ATEST_BITS))
|
|
GL_BindToTMU( tr.whiteImage, TB_COLORMAP );
|
|
else if ( pStage->bundle[TB_COLORMAP].image[0] != 0 )
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[TB_COLORMAP], TB_COLORMAP );
|
|
}
|
|
else if ( pStage->glslShaderGroup == tr.lightallShader )
|
|
{
|
|
int i;
|
|
vec4_t enableTextures;
|
|
|
|
if (r_sunlightMode->integer && (backEnd.viewParms.flags & VPF_USESUNLIGHT) && (pStage->glslShaderIndex & LIGHTDEF_LIGHTTYPE_MASK))
|
|
{
|
|
// FIXME: screenShadowImage is NULL if no framebuffers
|
|
if (tr.screenShadowImage)
|
|
GL_BindToTMU(tr.screenShadowImage, TB_SHADOWMAP);
|
|
GLSL_SetUniformVec3(sp, UNIFORM_PRIMARYLIGHTAMBIENT, backEnd.refdef.sunAmbCol);
|
|
if (r_pbr->integer)
|
|
{
|
|
vec3_t color;
|
|
|
|
color[0] = backEnd.refdef.sunCol[0] * backEnd.refdef.sunCol[0];
|
|
color[1] = backEnd.refdef.sunCol[1] * backEnd.refdef.sunCol[1];
|
|
color[2] = backEnd.refdef.sunCol[2] * backEnd.refdef.sunCol[2];
|
|
GLSL_SetUniformVec3(sp, UNIFORM_PRIMARYLIGHTCOLOR, color);
|
|
}
|
|
else
|
|
{
|
|
GLSL_SetUniformVec3(sp, UNIFORM_PRIMARYLIGHTCOLOR, backEnd.refdef.sunCol);
|
|
}
|
|
GLSL_SetUniformVec4(sp, UNIFORM_PRIMARYLIGHTORIGIN, backEnd.refdef.sunDir);
|
|
}
|
|
|
|
VectorSet4(enableTextures, 0, 0, 0, 0);
|
|
if ((r_lightmap->integer == 1 || r_lightmap->integer == 2) && pStage->bundle[TB_LIGHTMAP].image[0])
|
|
{
|
|
for (i = 0; i < NUM_TEXTURE_BUNDLES; i++)
|
|
{
|
|
if (i == TB_COLORMAP)
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[TB_LIGHTMAP], i);
|
|
else
|
|
GL_BindToTMU( tr.whiteImage, i );
|
|
}
|
|
}
|
|
else if (r_lightmap->integer == 3 && pStage->bundle[TB_DELUXEMAP].image[0])
|
|
{
|
|
for (i = 0; i < NUM_TEXTURE_BUNDLES; i++)
|
|
{
|
|
if (i == TB_COLORMAP)
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[TB_DELUXEMAP], i);
|
|
else
|
|
GL_BindToTMU( tr.whiteImage, i );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qboolean light = (pStage->glslShaderIndex & LIGHTDEF_LIGHTTYPE_MASK) != 0;
|
|
qboolean fastLight = !(r_normalMapping->integer || r_specularMapping->integer);
|
|
|
|
if (pStage->bundle[TB_DIFFUSEMAP].image[0])
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[TB_DIFFUSEMAP], TB_DIFFUSEMAP);
|
|
|
|
if (pStage->bundle[TB_LIGHTMAP].image[0])
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[TB_LIGHTMAP], TB_LIGHTMAP);
|
|
|
|
// bind textures that are sampled and used in the glsl shader, and
|
|
// bind whiteImage to textures that are sampled but zeroed in the glsl shader
|
|
//
|
|
// alternatives:
|
|
// - use the last bound texture
|
|
// -> costs more to sample a higher res texture then throw out the result
|
|
// - disable texture sampling in glsl shader with #ifdefs, as before
|
|
// -> increases the number of shaders that must be compiled
|
|
//
|
|
if (light && !fastLight)
|
|
{
|
|
if (pStage->bundle[TB_NORMALMAP].image[0])
|
|
{
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[TB_NORMALMAP], TB_NORMALMAP);
|
|
enableTextures[0] = 1.0f;
|
|
}
|
|
else if (r_normalMapping->integer)
|
|
GL_BindToTMU( tr.whiteImage, TB_NORMALMAP );
|
|
|
|
if (pStage->bundle[TB_DELUXEMAP].image[0])
|
|
{
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[TB_DELUXEMAP], TB_DELUXEMAP);
|
|
enableTextures[1] = 1.0f;
|
|
}
|
|
else if (r_deluxeMapping->integer)
|
|
GL_BindToTMU( tr.whiteImage, TB_DELUXEMAP );
|
|
|
|
if (pStage->bundle[TB_SPECULARMAP].image[0])
|
|
{
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[TB_SPECULARMAP], TB_SPECULARMAP);
|
|
enableTextures[2] = 1.0f;
|
|
}
|
|
else if (r_specularMapping->integer)
|
|
GL_BindToTMU( tr.whiteImage, TB_SPECULARMAP );
|
|
}
|
|
|
|
enableTextures[3] = (r_cubeMapping->integer && !(tr.viewParms.flags & VPF_NOCUBEMAPS) && input->cubemapIndex) ? 1.0f : 0.0f;
|
|
}
|
|
|
|
GLSL_SetUniformVec4(sp, UNIFORM_ENABLETEXTURES, enableTextures);
|
|
}
|
|
else if ( pStage->bundle[1].image[0] != 0 )
|
|
{
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[0], 0 );
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[1], 1 );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// set state
|
|
//
|
|
R_BindAnimatedImageToTMU( &pStage->bundle[0], 0 );
|
|
}
|
|
|
|
//
|
|
// testing cube map
|
|
//
|
|
if (!(tr.viewParms.flags & VPF_NOCUBEMAPS) && input->cubemapIndex && r_cubeMapping->integer)
|
|
{
|
|
vec4_t vec;
|
|
cubemap_t *cubemap = &tr.cubemaps[input->cubemapIndex - 1];
|
|
|
|
// FIXME: cubemap image could be NULL if cubemap isn't renderer or loaded
|
|
if (cubemap->image)
|
|
GL_BindToTMU( cubemap->image, TB_CUBEMAP);
|
|
|
|
VectorSubtract(cubemap->origin, backEnd.viewParms.or.origin, vec);
|
|
vec[3] = 1.0f;
|
|
|
|
VectorScale4(vec, 1.0f / cubemap->parallaxRadius, vec);
|
|
|
|
GLSL_SetUniformVec4(sp, UNIFORM_CUBEMAPINFO, vec);
|
|
}
|
|
|
|
//
|
|
// draw
|
|
//
|
|
R_DrawElements(input->numIndexes, input->firstIndex);
|
|
|
|
// allow skipping out to show just lightmaps during development
|
|
if ( r_lightmap->integer && ( pStage->bundle[0].isLightmap || pStage->bundle[1].isLightmap ) )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (backEnd.depthFill)
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static void RB_RenderShadowmap( shaderCommands_t *input )
|
|
{
|
|
int deformGen;
|
|
vec5_t deformParams;
|
|
|
|
ComputeDeformValues(&deformGen, deformParams);
|
|
|
|
{
|
|
shaderProgram_t *sp = &tr.shadowmapShader[0];
|
|
|
|
if (glState.vertexAnimation)
|
|
{
|
|
sp = &tr.shadowmapShader[SHADOWMAPDEF_USE_VERTEX_ANIMATION];
|
|
}
|
|
else if (glState.boneAnimation)
|
|
{
|
|
sp = &tr.shadowmapShader[SHADOWMAPDEF_USE_BONE_ANIMATION];
|
|
}
|
|
|
|
vec4_t vector;
|
|
|
|
GLSL_BindProgram(sp);
|
|
|
|
GLSL_SetUniformMat4(sp, UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
|
|
|
|
GLSL_SetUniformMat4(sp, UNIFORM_MODELMATRIX, backEnd.or.transformMatrix);
|
|
|
|
GLSL_SetUniformFloat(sp, UNIFORM_VERTEXLERP, glState.vertexAttribsInterpolation);
|
|
|
|
if (glState.boneAnimation)
|
|
{
|
|
GLSL_SetUniformMat4BoneMatrix(sp, UNIFORM_BONEMATRIX, glState.boneMatrix, glState.boneAnimation);
|
|
}
|
|
|
|
GLSL_SetUniformInt(sp, UNIFORM_DEFORMGEN, deformGen);
|
|
if (deformGen != DGEN_NONE)
|
|
{
|
|
GLSL_SetUniformFloat5(sp, UNIFORM_DEFORMPARAMS, deformParams);
|
|
GLSL_SetUniformFloat(sp, UNIFORM_TIME, tess.shaderTime);
|
|
}
|
|
|
|
VectorCopy(backEnd.viewParms.or.origin, vector);
|
|
vector[3] = 1.0f;
|
|
GLSL_SetUniformVec4(sp, UNIFORM_LIGHTORIGIN, vector);
|
|
GLSL_SetUniformFloat(sp, UNIFORM_LIGHTRADIUS, backEnd.viewParms.zFar);
|
|
|
|
GL_State( 0 );
|
|
GLSL_SetUniformInt(sp, UNIFORM_ALPHATEST, 0);
|
|
|
|
//
|
|
// do multitexture
|
|
//
|
|
//if ( pStage->glslShaderGroup )
|
|
{
|
|
//
|
|
// draw
|
|
//
|
|
|
|
R_DrawElements(input->numIndexes, input->firstIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
** RB_StageIteratorGeneric
|
|
*/
|
|
void RB_StageIteratorGeneric( void )
|
|
{
|
|
shaderCommands_t *input;
|
|
unsigned int vertexAttribs = 0;
|
|
|
|
input = &tess;
|
|
|
|
if (!input->numVertexes || !input->numIndexes)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (tess.useInternalVao)
|
|
{
|
|
RB_DeformTessGeometry();
|
|
}
|
|
|
|
vertexAttribs = RB_CalcShaderVertexAttribs( input );
|
|
|
|
if (tess.useInternalVao)
|
|
{
|
|
RB_UpdateTessVao(vertexAttribs);
|
|
}
|
|
else
|
|
{
|
|
backEnd.pc.c_staticVaoDraws++;
|
|
}
|
|
|
|
//
|
|
// log this call
|
|
//
|
|
if ( r_logFile->integer )
|
|
{
|
|
// don't just call LogComment, or we will get
|
|
// a call to va() every frame!
|
|
GLimp_LogComment( va("--- RB_StageIteratorGeneric( %s ) ---\n", tess.shader->name) );
|
|
}
|
|
|
|
//
|
|
// set face culling appropriately
|
|
//
|
|
if (input->shader->cullType == CT_TWO_SIDED)
|
|
{
|
|
GL_Cull( CT_TWO_SIDED );
|
|
}
|
|
else
|
|
{
|
|
qboolean cullFront = (input->shader->cullType == CT_FRONT_SIDED);
|
|
|
|
if ( backEnd.viewParms.flags & VPF_DEPTHSHADOW )
|
|
cullFront = !cullFront;
|
|
|
|
if ( backEnd.viewParms.isMirror )
|
|
cullFront = !cullFront;
|
|
|
|
if ( backEnd.currentEntity && backEnd.currentEntity->mirrored )
|
|
cullFront = !cullFront;
|
|
|
|
if (cullFront)
|
|
GL_Cull( CT_FRONT_SIDED );
|
|
else
|
|
GL_Cull( CT_BACK_SIDED );
|
|
}
|
|
|
|
// set polygon offset if necessary
|
|
if ( input->shader->polygonOffset )
|
|
{
|
|
qglEnable( GL_POLYGON_OFFSET_FILL );
|
|
}
|
|
|
|
//
|
|
// render depth if in depthfill mode
|
|
//
|
|
if (backEnd.depthFill)
|
|
{
|
|
RB_IterateStagesGeneric( input );
|
|
|
|
//
|
|
// reset polygon offset
|
|
//
|
|
if ( input->shader->polygonOffset )
|
|
{
|
|
qglDisable( GL_POLYGON_OFFSET_FILL );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// render shadowmap if in shadowmap mode
|
|
//
|
|
if (backEnd.viewParms.flags & VPF_SHADOWMAP)
|
|
{
|
|
if ( input->shader->sort == SS_OPAQUE )
|
|
{
|
|
RB_RenderShadowmap( input );
|
|
}
|
|
//
|
|
// reset polygon offset
|
|
//
|
|
if ( input->shader->polygonOffset )
|
|
{
|
|
qglDisable( GL_POLYGON_OFFSET_FILL );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
//
|
|
// call shader function
|
|
//
|
|
RB_IterateStagesGeneric( input );
|
|
|
|
//
|
|
// pshadows!
|
|
//
|
|
if (glRefConfig.framebufferObject && r_shadows->integer == 4 && tess.pshadowBits
|
|
&& tess.shader->sort <= SS_OPAQUE && !(tess.shader->surfaceFlags & (SURF_NODLIGHT | SURF_SKY) ) ) {
|
|
ProjectPshadowVBOGLSL();
|
|
}
|
|
|
|
|
|
//
|
|
// now do any dynamic lighting needed
|
|
//
|
|
if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE && r_lightmap->integer == 0
|
|
&& !(tess.shader->surfaceFlags & (SURF_NODLIGHT | SURF_SKY) ) ) {
|
|
if (tess.shader->numUnfoggedPasses == 1 && tess.xstages[0]->glslShaderGroup == tr.lightallShader
|
|
&& (tess.xstages[0]->glslShaderIndex & LIGHTDEF_LIGHTTYPE_MASK) && r_dlightMode->integer)
|
|
{
|
|
ForwardDlight();
|
|
}
|
|
else
|
|
{
|
|
ProjectDlightTexture();
|
|
}
|
|
}
|
|
|
|
//
|
|
// now do fog
|
|
//
|
|
if ( tess.fogNum && tess.shader->fogPass ) {
|
|
RB_FogPass();
|
|
}
|
|
|
|
//
|
|
// reset polygon offset
|
|
//
|
|
if ( input->shader->polygonOffset )
|
|
{
|
|
qglDisable( GL_POLYGON_OFFSET_FILL );
|
|
}
|
|
}
|
|
|
|
/*
|
|
** RB_EndSurface
|
|
*/
|
|
void RB_EndSurface( void ) {
|
|
shaderCommands_t *input;
|
|
|
|
input = &tess;
|
|
|
|
if (input->numIndexes == 0 || input->numVertexes == 0) {
|
|
return;
|
|
}
|
|
|
|
if (input->indexes[SHADER_MAX_INDEXES-1] != 0) {
|
|
ri.Error (ERR_DROP, "RB_EndSurface() - SHADER_MAX_INDEXES hit");
|
|
}
|
|
if (input->xyz[SHADER_MAX_VERTEXES-1][0] != 0) {
|
|
ri.Error (ERR_DROP, "RB_EndSurface() - SHADER_MAX_VERTEXES hit");
|
|
}
|
|
|
|
if ( tess.shader == tr.shadowShader ) {
|
|
RB_ShadowTessEnd();
|
|
return;
|
|
}
|
|
|
|
// for debugging of sort order issues, stop rendering after a given sort value
|
|
if ( r_debugSort->integer && r_debugSort->integer < tess.shader->sort ) {
|
|
return;
|
|
}
|
|
|
|
if (tess.useCacheVao)
|
|
{
|
|
// upload indexes now
|
|
VaoCache_Commit();
|
|
}
|
|
|
|
//
|
|
// update performance counters
|
|
//
|
|
backEnd.pc.c_shaders++;
|
|
backEnd.pc.c_vertexes += tess.numVertexes;
|
|
backEnd.pc.c_indexes += tess.numIndexes;
|
|
backEnd.pc.c_totalIndexes += tess.numIndexes * tess.numPasses;
|
|
|
|
//
|
|
// call off to shader specific tess end function
|
|
//
|
|
tess.currentStageIteratorFunc();
|
|
|
|
//
|
|
// draw debugging stuff
|
|
//
|
|
if ( r_showtris->integer ) {
|
|
DrawTris (input);
|
|
}
|
|
if ( r_shownormals->integer ) {
|
|
DrawNormals (input);
|
|
}
|
|
// clear shader so we can tell we don't have any unclosed surfaces
|
|
tess.numIndexes = 0;
|
|
tess.numVertexes = 0;
|
|
tess.firstIndex = 0;
|
|
|
|
GLimp_LogComment( "----------\n" );
|
|
}
|