mirror of
https://github.com/openmoh/openmohaa.git
synced 2025-04-29 14:17:57 +03:00
3683 lines
117 KiB
C++
3683 lines
117 KiB
C++
|
/*
|
||
|
|
===========================================================================
|
||
|
|
Copyright (C) 2010-2011 Robert Beckebans <trebor_7@users.sourceforge.net>
|
||
|
|
|
||
|
|
This file is part of XreaL source code.
|
||
|
|
|
||
|
|
XreaL 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.
|
||
|
|
|
||
|
|
XreaL 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 XreaL source code; if not, write to the Free Software
|
||
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||
|
|
===========================================================================
|
||
|
|
*/
|
||
|
|
// gl_shader.cpp -- GLSL shader handling
|
||
|
|
|
||
|
|
#include "gl_shader.h"
|
||
|
|
|
||
|
|
// *INDENT-OFF*
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_generic* gl_genericShader = NULL;
|
||
|
|
GLShader_lightMapping* gl_lightMappingShader = NULL;
|
||
|
|
GLShader_vertexLighting_DBS_entity* gl_vertexLightingShader_DBS_entity = NULL;
|
||
|
|
GLShader_vertexLighting_DBS_world* gl_vertexLightingShader_DBS_world = NULL;
|
||
|
|
GLShader_forwardLighting_omniXYZ* gl_forwardLightingShader_omniXYZ = NULL;
|
||
|
|
GLShader_forwardLighting_projXYZ* gl_forwardLightingShader_projXYZ = NULL;
|
||
|
|
GLShader_forwardLighting_directionalSun* gl_forwardLightingShader_directionalSun = NULL;
|
||
|
|
GLShader_deferredLighting_omniXYZ* gl_deferredLightingShader_omniXYZ = NULL;
|
||
|
|
GLShader_deferredLighting_projXYZ* gl_deferredLightingShader_projXYZ = NULL;
|
||
|
|
GLShader_deferredLighting_directionalSun* gl_deferredLightingShader_directionalSun = NULL;
|
||
|
|
GLShader_geometricFill* gl_geometricFillShader = NULL;
|
||
|
|
GLShader_shadowFill* gl_shadowFillShader = NULL;
|
||
|
|
GLShader_reflection* gl_reflectionShader = NULL;
|
||
|
|
GLShader_skybox* gl_skyboxShader = NULL;
|
||
|
|
GLShader_fogQuake3* gl_fogQuake3Shader = NULL;
|
||
|
|
GLShader_fogGlobal* gl_fogGlobalShader = NULL;
|
||
|
|
GLShader_heatHaze* gl_heatHazeShader = NULL;
|
||
|
|
GLShader_screen* gl_screenShader = NULL;
|
||
|
|
GLShader_portal* gl_portalShader = NULL;
|
||
|
|
GLShader_toneMapping* gl_toneMappingShader = NULL;
|
||
|
|
GLShader_contrast* gl_contrastShader = NULL;
|
||
|
|
GLShader_cameraEffects* gl_cameraEffectsShader = NULL;
|
||
|
|
GLShader_blurX* gl_blurXShader = NULL;
|
||
|
|
GLShader_blurY* gl_blurYShader = NULL;
|
||
|
|
GLShader_debugShadowMap* gl_debugShadowMapShader = NULL;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
bool GLCompileMacro_USE_VERTEX_SKINNING::HasConflictingMacros(int permutation, const std::vector<GLCompileMacro*>& macros) const
|
||
|
|
{
|
||
|
|
for(size_t i = 0; i < macros.size(); i++)
|
||
|
|
{
|
||
|
|
GLCompileMacro* macro = macros[i];
|
||
|
|
|
||
|
|
//if(GLCompileMacro_USE_VERTEX_ANIMATION* m = dynamic_cast<GLCompileMacro_USE_VERTEX_ANIMATION*>(macro))
|
||
|
|
if((permutation & macro->GetBit()) != 0 && macro->GetType() == USE_VERTEX_ANIMATION)
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "conflicting macro! canceling '%s' vs. '%s' \n", GetName(), macro->GetName());
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool GLCompileMacro_USE_VERTEX_SKINNING::MissesRequiredMacros(int permutation, const std::vector<GLCompileMacro*>& macros) const
|
||
|
|
{
|
||
|
|
return !glConfig2.vboVertexSkinningAvailable;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
bool GLCompileMacro_USE_VERTEX_ANIMATION::HasConflictingMacros(int permutation, const std::vector<GLCompileMacro*>& macros) const
|
||
|
|
{
|
||
|
|
#if 1
|
||
|
|
for(size_t i = 0; i < macros.size(); i++)
|
||
|
|
{
|
||
|
|
GLCompileMacro* macro = macros[i];
|
||
|
|
|
||
|
|
if((permutation & macro->GetBit()) != 0 && macro->GetType() == USE_VERTEX_SKINNING)
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "conflicting macro! canceling '%s' vs. '%s' \n", GetName(), macro->GetName());
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint32_t GLCompileMacro_USE_VERTEX_ANIMATION::GetRequiredVertexAttributes() const
|
||
|
|
{
|
||
|
|
uint32_t attribs = ATTR_NORMAL | ATTR_POSITION2 | ATTR_NORMAL2;
|
||
|
|
|
||
|
|
if(r_normalMapping->integer)
|
||
|
|
{
|
||
|
|
attribs |= ATTR_TANGENT2 | ATTR_BINORMAL2;
|
||
|
|
}
|
||
|
|
|
||
|
|
return attribs;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
bool GLCompileMacro_USE_DEFORM_VERTEXES::HasConflictingMacros(int permutation, const std::vector<GLCompileMacro*>& macros) const
|
||
|
|
{
|
||
|
|
return (glConfig.driverType != GLDRV_OPENGL3 || !r_vboDeformVertexes->integer);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool GLCompileMacro_USE_PARALLAX_MAPPING::MissesRequiredMacros(int permutation, const std::vector<GLCompileMacro*>& macros) const
|
||
|
|
{
|
||
|
|
bool foundUSE_NORMAL_MAPPING = false;
|
||
|
|
for(size_t i = 0; i < macros.size(); i++)
|
||
|
|
{
|
||
|
|
GLCompileMacro* macro = macros[i];
|
||
|
|
|
||
|
|
if((permutation & macro->GetBit()) != 0 && macro->GetType() == USE_NORMAL_MAPPING)
|
||
|
|
{
|
||
|
|
foundUSE_NORMAL_MAPPING = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(!foundUSE_NORMAL_MAPPING)
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "missing macro! canceling '%s' <= '%s' \n", GetName(), "USE_NORMAL_MAPPING");
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool GLCompileMacro_USE_REFLECTIVE_SPECULAR::MissesRequiredMacros(int permutation, const std::vector<GLCompileMacro*>& macros) const
|
||
|
|
{
|
||
|
|
bool foundUSE_NORMAL_MAPPING = false;
|
||
|
|
for(size_t i = 0; i < macros.size(); i++)
|
||
|
|
{
|
||
|
|
GLCompileMacro* macro = macros[i];
|
||
|
|
|
||
|
|
if((permutation & macro->GetBit()) != 0 && macro->GetType() == USE_NORMAL_MAPPING)
|
||
|
|
{
|
||
|
|
foundUSE_NORMAL_MAPPING = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(!foundUSE_NORMAL_MAPPING)
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "missing macro! canceling '%s' <= '%s' \n", GetName(), "USE_NORMAL_MAPPING");
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
bool GLShader::GetCompileMacrosString(int permutation, std::string& compileMacrosOut) const
|
||
|
|
{
|
||
|
|
compileMacrosOut = "";
|
||
|
|
for(size_t j = 0; j < _compileMacros.size(); j++)
|
||
|
|
{
|
||
|
|
GLCompileMacro* macro = _compileMacros[j];
|
||
|
|
|
||
|
|
if(permutation & macro->GetBit())
|
||
|
|
{
|
||
|
|
if(macro->HasConflictingMacros(permutation, _compileMacros))
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "conflicting macro! canceling '%s'\n", macro->GetName());
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(macro->MissesRequiredMacros(permutation, _compileMacros))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
compileMacrosOut += macro->GetName();
|
||
|
|
compileMacrosOut += " ";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void GLShader::UpdateShaderProgramUniformLocations(shaderProgram_t *shaderProgram) const
|
||
|
|
{
|
||
|
|
for(size_t j = 0; j < _uniforms.size(); j++)
|
||
|
|
{
|
||
|
|
GLUniform* uniform = _uniforms[j];
|
||
|
|
|
||
|
|
uniform->UpdateShaderProgramUniformLocation(shaderProgram);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string GLShader::BuildGPUShaderText( const char *mainShaderName,
|
||
|
|
const char *libShaderNames,
|
||
|
|
GLenum shaderType) const
|
||
|
|
{
|
||
|
|
char filename[MAX_QPATH];
|
||
|
|
GLcharARB *mainBuffer = NULL;
|
||
|
|
int mainSize;
|
||
|
|
char *token;
|
||
|
|
|
||
|
|
int libsSize;
|
||
|
|
char *libsBuffer; // all libs concatenated
|
||
|
|
|
||
|
|
char **libs = (char **) &libShaderNames;
|
||
|
|
|
||
|
|
std::string shaderText;
|
||
|
|
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
// load libs
|
||
|
|
libsSize = 0;
|
||
|
|
libsBuffer = NULL;
|
||
|
|
while(1)
|
||
|
|
{
|
||
|
|
int libSize;
|
||
|
|
char *libBuffer; // single extra lib file
|
||
|
|
|
||
|
|
token = COM_ParseExt(libs, qfalse);
|
||
|
|
if(!token[0])
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(shaderType == GL_VERTEX_SHADER_ARB)
|
||
|
|
{
|
||
|
|
Com_sprintf(filename, sizeof(filename), "glsl/%s_vp.glsl", token);
|
||
|
|
ri.Printf(PRINT_ALL, "...loading vertex shader '%s'\n", filename);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Com_sprintf(filename, sizeof(filename), "glsl/%s_fp.glsl", token);
|
||
|
|
ri.Printf(PRINT_ALL, "...loading vertex shader '%s'\n", filename);
|
||
|
|
}
|
||
|
|
|
||
|
|
libSize = ri.FS_ReadFile(filename, (void **)&libBuffer);
|
||
|
|
if(!libBuffer)
|
||
|
|
{
|
||
|
|
ri.Error(ERR_DROP, "Couldn't load %s", filename);
|
||
|
|
}
|
||
|
|
|
||
|
|
// append it to the libsBuffer
|
||
|
|
libsBuffer = (char* ) realloc(libsBuffer, libsSize + libSize);
|
||
|
|
|
||
|
|
memset(libsBuffer + libsSize, 0, libSize);
|
||
|
|
libsSize += libSize;
|
||
|
|
|
||
|
|
Q_strcat(libsBuffer, libsSize, libBuffer);
|
||
|
|
//Q_strncpyz(libsBuffer + libsSize, libBuffer, libSize -1);
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
ri.FS_FreeFile(libBuffer);
|
||
|
|
}
|
||
|
|
|
||
|
|
// load main() program
|
||
|
|
if(shaderType == GL_VERTEX_SHADER_ARB)
|
||
|
|
{
|
||
|
|
Com_sprintf(filename, sizeof(filename), "glsl/%s_vp.glsl", mainShaderName);
|
||
|
|
ri.Printf(PRINT_ALL, "...loading vertex main() shader '%s'\n", filename);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Com_sprintf(filename, sizeof(filename), "glsl/%s_fp.glsl", mainShaderName);
|
||
|
|
ri.Printf(PRINT_ALL, "...loading fragment main() shader '%s'\n", filename);
|
||
|
|
}
|
||
|
|
|
||
|
|
mainSize = ri.FS_ReadFile(filename, (void **)&mainBuffer);
|
||
|
|
if(!mainBuffer)
|
||
|
|
{
|
||
|
|
ri.Error(ERR_DROP, "Couldn't load %s", filename);
|
||
|
|
}
|
||
|
|
|
||
|
|
{
|
||
|
|
static char bufferExtra[32000];
|
||
|
|
int sizeExtra;
|
||
|
|
|
||
|
|
char *bufferFinal = NULL;
|
||
|
|
int sizeFinal;
|
||
|
|
|
||
|
|
float fbufWidthScale, fbufHeightScale;
|
||
|
|
float npotWidthScale, npotHeightScale;
|
||
|
|
|
||
|
|
Com_Memset(bufferExtra, 0, sizeof(bufferExtra));
|
||
|
|
|
||
|
|
#if defined(COMPAT_Q3A) || defined(COMPAT_ET)
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef COMPAT_Q3A\n#define COMPAT_Q3A 1\n#endif\n");
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if defined(COMPAT_ET)
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef COMPAT_ET\n#define COMPAT_ET 1\n#endif\n");
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
// HACK: add some macros to avoid extra uniforms and save speed and code maintenance
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_SpecularExponent\n#define r_SpecularExponent %f\n#endif\n", r_specularExponent->value));
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_SpecularExponent2\n#define r_SpecularExponent2 %f\n#endif\n", r_specularExponent2->value));
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_SpecularScale\n#define r_SpecularScale %f\n#endif\n", r_specularScale->value));
|
||
|
|
//Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
// va("#ifndef r_NormalScale\n#define r_NormalScale %f\n#endif\n", r_normalScale->value));
|
||
|
|
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef M_PI\n#define M_PI 3.14159265358979323846f\n#endif\n");
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), va("#ifndef MAX_SHADOWMAPS\n#define MAX_SHADOWMAPS %i\n#endif\n", MAX_SHADOWMAPS));
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), va("#ifndef MAX_SHADER_DEFORM_PARMS\n#define MAX_SHADER_DEFORM_PARMS %i\n#endif\n", MAX_SHADER_DEFORM_PARMS));
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef deform_t\n"
|
||
|
|
"#define deform_t\n"
|
||
|
|
"#define DEFORM_WAVE %i\n"
|
||
|
|
"#define DEFORM_BULGE %i\n"
|
||
|
|
"#define DEFORM_MOVE %i\n"
|
||
|
|
"#endif\n",
|
||
|
|
DEFORM_WAVE,
|
||
|
|
DEFORM_BULGE,
|
||
|
|
DEFORM_MOVE));
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef genFunc_t\n"
|
||
|
|
"#define genFunc_t\n"
|
||
|
|
"#define GF_NONE %1.1f\n"
|
||
|
|
"#define GF_SIN %1.1f\n"
|
||
|
|
"#define GF_SQUARE %1.1f\n"
|
||
|
|
"#define GF_TRIANGLE %1.1f\n"
|
||
|
|
"#define GF_SAWTOOTH %1.1f\n"
|
||
|
|
"#define GF_INVERSE_SAWTOOTH %1.1f\n"
|
||
|
|
"#define GF_NOISE %1.1f\n"
|
||
|
|
"#endif\n",
|
||
|
|
(float)GF_NONE,
|
||
|
|
(float)GF_SIN,
|
||
|
|
(float)GF_SQUARE,
|
||
|
|
(float)GF_TRIANGLE,
|
||
|
|
(float)GF_SAWTOOTH,
|
||
|
|
(float)GF_INVERSE_SAWTOOTH,
|
||
|
|
(float)GF_NOISE));
|
||
|
|
|
||
|
|
/*
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef deformGen_t\n"
|
||
|
|
"#define deformGen_t\n"
|
||
|
|
"#define DGEN_WAVE_SIN %1.1f\n"
|
||
|
|
"#define DGEN_WAVE_SQUARE %1.1f\n"
|
||
|
|
"#define DGEN_WAVE_TRIANGLE %1.1f\n"
|
||
|
|
"#define DGEN_WAVE_SAWTOOTH %1.1f\n"
|
||
|
|
"#define DGEN_WAVE_INVERSE_SAWTOOTH %1.1f\n"
|
||
|
|
"#define DGEN_BULGE %i\n"
|
||
|
|
"#define DGEN_MOVE %i\n"
|
||
|
|
"#endif\n",
|
||
|
|
(float)DGEN_WAVE_SIN,
|
||
|
|
(float)DGEN_WAVE_SQUARE,
|
||
|
|
(float)DGEN_WAVE_TRIANGLE,
|
||
|
|
(float)DGEN_WAVE_SAWTOOTH,
|
||
|
|
(float)DGEN_WAVE_INVERSE_SAWTOOTH,
|
||
|
|
DGEN_BULGE,
|
||
|
|
DGEN_MOVE));
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef colorGen_t\n"
|
||
|
|
"#define colorGen_t\n"
|
||
|
|
"#define CGEN_VERTEX %i\n"
|
||
|
|
"#define CGEN_ONE_MINUS_VERTEX %i\n"
|
||
|
|
"#endif\n",
|
||
|
|
CGEN_VERTEX,
|
||
|
|
CGEN_ONE_MINUS_VERTEX));
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef alphaGen_t\n"
|
||
|
|
"#define alphaGen_t\n"
|
||
|
|
"#define AGEN_VERTEX %i\n"
|
||
|
|
"#define AGEN_ONE_MINUS_VERTEX %i\n"
|
||
|
|
"#endif\n",
|
||
|
|
AGEN_VERTEX,
|
||
|
|
AGEN_ONE_MINUS_VERTEX));
|
||
|
|
*/
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef alphaTest_t\n"
|
||
|
|
"#define alphaTest_t\n"
|
||
|
|
"#define ATEST_GT_0 %i\n"
|
||
|
|
"#define ATEST_LT_128 %i\n"
|
||
|
|
"#define ATEST_GE_128 %i\n"
|
||
|
|
"#endif\n",
|
||
|
|
ATEST_GT_0,
|
||
|
|
ATEST_LT_128,
|
||
|
|
ATEST_GE_128));
|
||
|
|
|
||
|
|
fbufWidthScale = Q_rsqrt((float)glConfig.vidWidth);
|
||
|
|
fbufHeightScale = Q_rsqrt((float)glConfig.vidHeight);
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_FBufScale\n#define r_FBufScale vec2(%f, %f)\n#endif\n", fbufWidthScale, fbufHeightScale));
|
||
|
|
|
||
|
|
if(glConfig2.textureNPOTAvailable)
|
||
|
|
{
|
||
|
|
npotWidthScale = 1;
|
||
|
|
npotHeightScale = 1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
npotWidthScale = (float)glConfig.vidWidth / (float)NearestPowerOfTwo(glConfig.vidWidth);
|
||
|
|
npotHeightScale = (float)glConfig.vidHeight / (float)NearestPowerOfTwo(glConfig.vidHeight);
|
||
|
|
}
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_NPOTScale\n#define r_NPOTScale vec2(%f, %f)\n#endif\n", npotWidthScale, npotHeightScale));
|
||
|
|
|
||
|
|
if(glConfig.driverType == GLDRV_MESA)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef GLDRV_MESA\n#define GLDRV_MESA 1\n#endif\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
if(glConfig.hardwareType == GLHW_ATI)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef GLHW_ATI\n#define GLHW_ATI 1\n#endif\n");
|
||
|
|
}
|
||
|
|
else if(glConfig.hardwareType == GLHW_ATI_DX10)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef GLHW_ATI_DX10\n#define GLHW_ATI_DX10 1\n#endif\n");
|
||
|
|
}
|
||
|
|
else if(glConfig.hardwareType == GLHW_NV_DX10)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef GLHW_NV_DX10\n#define GLHW_NV_DX10 1\n#endif\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_shadows->integer >= SHADOWING_ESM16 && glConfig2.textureFloatAvailable && glConfig2.framebufferObjectAvailable)
|
||
|
|
{
|
||
|
|
if(r_shadows->integer == SHADOWING_ESM16 || r_shadows->integer == SHADOWING_ESM32)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef ESM\n#define ESM 1\n#endif\n");
|
||
|
|
}
|
||
|
|
else if(r_shadows->integer == SHADOWING_EVSM32)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef EVSM\n#define EVSM 1\n#endif\n");
|
||
|
|
|
||
|
|
// The exponents for the EVSM techniques should be less than ln(FLT_MAX/FILTER_SIZE)/2 {ln(FLT_MAX/1)/2 ~44.3}
|
||
|
|
// 42.9 is the maximum possible value for FILTER_SIZE=15
|
||
|
|
// 42.0 is the truncated value that we pass into the sample
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_EVSMExponents\n#define r_EVSMExponents vec2(%f, %f)\n#endif\n", 42.0f, 42.0f));
|
||
|
|
|
||
|
|
if(r_evsmPostProcess->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_EVSMPostProcess\n#define r_EVSMPostProcess 1\n#endif\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef VSM\n#define VSM 1\n#endif\n");
|
||
|
|
|
||
|
|
if(glConfig.hardwareType == GLHW_ATI)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef VSM_CLAMP\n#define VSM_CLAMP 1\n#endif\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if((glConfig.hardwareType == GLHW_NV_DX10 || glConfig.hardwareType == GLHW_ATI_DX10) && r_shadows->integer == SHADOWING_VSM32)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef VSM_EPSILON\n#define VSM_EPSILON 0.000001\n#endif\n");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef VSM_EPSILON\n#define VSM_EPSILON 0.0001\n#endif\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_lightBleedReduction->value)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_LightBleedReduction\n#define r_LightBleedReduction %f\n#endif\n",
|
||
|
|
r_lightBleedReduction->value));
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_overDarkeningFactor->value)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_OverDarkeningFactor\n#define r_OverDarkeningFactor %f\n#endif\n",
|
||
|
|
r_overDarkeningFactor->value));
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_shadowMapDepthScale->value)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_ShadowMapDepthScale\n#define r_ShadowMapDepthScale %f\n#endif\n",
|
||
|
|
r_shadowMapDepthScale->value));
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_debugShadowMaps->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_DebugShadowMaps\n#define r_DebugShadowMaps %i\n#endif\n", r_debugShadowMaps->integer));
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
if(r_softShadows->integer == 1)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef PCF_2X2\n#define PCF_2X2 1\n#endif\n");
|
||
|
|
}
|
||
|
|
else if(r_softShadows->integer == 2)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef PCF_3X3\n#define PCF_3X3 1\n#endif\n");
|
||
|
|
}
|
||
|
|
else if(r_softShadows->integer == 3)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef PCF_4X4\n#define PCF_4X4 1\n#endif\n");
|
||
|
|
}
|
||
|
|
else if(r_softShadows->integer == 4)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef PCF_5X5\n#define PCF_5X5 1\n#endif\n");
|
||
|
|
}
|
||
|
|
else if(r_softShadows->integer == 5)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef PCF_6X6\n#define PCF_6X6 1\n#endif\n");
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
if(r_softShadows->integer == 6)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef PCSS\n#define PCSS 1\n#endif\n");
|
||
|
|
}
|
||
|
|
else if(r_softShadows->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_PCFSamples\n#define r_PCFSamples %1.1f\n#endif\n", r_softShadows->value + 1.0f));
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_parallelShadowSplits->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_ParallelShadowSplits_%i\n#define r_ParallelShadowSplits_%i\n#endif\n", r_parallelShadowSplits->integer, r_parallelShadowSplits->integer));
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_showParallelShadowSplits->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_ShowParallelShadowSplits\n#define r_ShowParallelShadowSplits 1\n#endif\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_deferredShading->integer && glConfig2.maxColorAttachments >= 4 && glConfig2.textureFloatAvailable &&
|
||
|
|
glConfig2.drawBuffersAvailable && glConfig2.maxDrawBuffers >= 4)
|
||
|
|
{
|
||
|
|
|
||
|
|
if(r_deferredShading->integer == DS_STANDARD)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_DeferredShading\n#define r_DeferredShading 1\n#endif\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_hdrRendering->integer && glConfig2.framebufferObjectAvailable && glConfig2.textureFloatAvailable)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_HDRRendering\n#define r_HDRRendering 1\n#endif\n");
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_HDRContrastThreshold\n#define r_HDRContrastThreshold %f\n#endif\n",
|
||
|
|
r_hdrContrastThreshold->value));
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_HDRContrastOffset\n#define r_HDRContrastOffset %f\n#endif\n",
|
||
|
|
r_hdrContrastOffset->value));
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_HDRToneMappingOperator\n#define r_HDRToneMappingOperator_%i\n#endif\n",
|
||
|
|
r_hdrToneMappingOperator->integer));
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_HDRGamma\n#define r_HDRGamma %f\n#endif\n",
|
||
|
|
r_hdrGamma->value));
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_precomputedLighting->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
"#ifndef r_precomputedLighting\n#define r_precomputedLighting 1\n#endif\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_heatHazeFix->integer && glConfig2.framebufferBlitAvailable && /*glConfig.hardwareType != GLHW_ATI && glConfig.hardwareType != GLHW_ATI_DX10 &&*/ glConfig.driverType != GLDRV_MESA)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_heatHazeFix\n#define r_heatHazeFix 1\n#endif\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_showLightMaps->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_showLightMaps\n#define r_showLightMaps 1\n#endif\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_showDeluxeMaps->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_showDeluxeMaps\n#define r_showDeluxeMaps 1\n#endif\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef EXPERIMENTAL
|
||
|
|
if(r_screenSpaceAmbientOcclusion->integer)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
static vec3_t jitter[32];
|
||
|
|
static qboolean jitterInit = qfalse;
|
||
|
|
|
||
|
|
if(!jitterInit)
|
||
|
|
{
|
||
|
|
for(i = 0; i < 32; i++)
|
||
|
|
{
|
||
|
|
float *jit = &jitter[i][0];
|
||
|
|
|
||
|
|
float rad = crandom() * 1024.0f; // FIXME radius;
|
||
|
|
float a = crandom() * M_PI * 2;
|
||
|
|
float b = crandom() * M_PI * 2;
|
||
|
|
|
||
|
|
jit[0] = rad * sin(a) * cos(b);
|
||
|
|
jit[1] = rad * sin(a) * sin(b);
|
||
|
|
jit[2] = rad * cos(a);
|
||
|
|
}
|
||
|
|
|
||
|
|
jitterInit = qtrue;
|
||
|
|
}
|
||
|
|
|
||
|
|
// TODO
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
if(glConfig2.vboVertexSkinningAvailable)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_VertexSkinning\n#define r_VertexSkinning 1\n#endif\n");
|
||
|
|
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef MAX_GLSL_BONES\n#define MAX_GLSL_BONES %i\n#endif\n", glConfig2.maxVertexSkinningBones));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef MAX_GLSL_BONES\n#define MAX_GLSL_BONES %i\n#endif\n", 4));
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
if(glConfig.drawBuffersAvailable && glConfig.maxDrawBuffers >= 4)
|
||
|
|
{
|
||
|
|
//Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef GL_ARB_draw_buffers\n#define GL_ARB_draw_buffers 1\n#endif\n");
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#extension GL_ARB_draw_buffers : enable\n");
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
|
||
|
|
if(r_normalMapping->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_NormalMapping\n#define r_NormalMapping 1\n#endif\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
if( /* TODO: check for shader model 3 hardware && */ r_normalMapping->integer && r_parallaxMapping->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_ParallaxMapping\n#define r_ParallaxMapping 1\n#endif\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_wrapAroundLighting->value)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra),
|
||
|
|
va("#ifndef r_WrapAroundLighting\n#define r_WrapAroundLighting %f\n#endif\n",
|
||
|
|
r_wrapAroundLighting->value));
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_halfLambertLighting->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_HalfLambertLighting\n#define r_HalfLambertLighting 1\n#endif\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
if(r_rimLighting->integer)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_RimLighting\n#define r_RimLighting 1\n#endif\n");
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#ifndef r_RimColor\n#define r_RimColor vec4(0.26, 0.19, 0.16, 0.0)\n#endif\n");
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), va("#ifndef r_RimExponent\n#define r_RimExponent %f\n#endif\n",
|
||
|
|
r_rimExponent->value));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// OK we added a lot of stuff but if we do something bad in the GLSL shaders then we want the proper line
|
||
|
|
// so we have to reset the line counting
|
||
|
|
Q_strcat(bufferExtra, sizeof(bufferExtra), "#line 0\n");
|
||
|
|
|
||
|
|
sizeExtra = strlen(bufferExtra);
|
||
|
|
sizeFinal = sizeExtra + mainSize + libsSize;
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_ALL, "GLSL extra: %s\n", bufferExtra);
|
||
|
|
|
||
|
|
bufferFinal = (char *) ri.Malloc(sizeFinal);
|
||
|
|
|
||
|
|
strcpy(bufferFinal, bufferExtra);
|
||
|
|
|
||
|
|
if(libsSize > 0)
|
||
|
|
{
|
||
|
|
Q_strcat(bufferFinal, sizeFinal, libsBuffer);
|
||
|
|
}
|
||
|
|
|
||
|
|
Q_strcat(bufferFinal, sizeFinal, mainBuffer);
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
{
|
||
|
|
static char msgPart[1024];
|
||
|
|
int i;
|
||
|
|
ri.Printf(PRINT_WARNING, "----------------------------------------------------------\n", filename);
|
||
|
|
ri.Printf(PRINT_WARNING, "CONCATENATED shader '%s' ----------\n", filename);
|
||
|
|
ri.Printf(PRINT_WARNING, " BEGIN ---------------------------------------------------\n", filename);
|
||
|
|
|
||
|
|
for(i = 0; i < sizeFinal; i += 1024)
|
||
|
|
{
|
||
|
|
Q_strncpyz(msgPart, bufferFinal + i, sizeof(msgPart));
|
||
|
|
ri.Printf(PRINT_ALL, "%s", msgPart);
|
||
|
|
}
|
||
|
|
|
||
|
|
ri.Printf(PRINT_WARNING, " END-- ---------------------------------------------------\n", filename);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if defined(USE_GLSL_OPTIMIZER)
|
||
|
|
if(glConfig.driverType != GLDRV_OPENGL3 && optimize)
|
||
|
|
{
|
||
|
|
static char msgPart[1024];
|
||
|
|
int length = 0;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
|
||
|
|
glslopt_shader_type glsloptShaderType;
|
||
|
|
|
||
|
|
if(shaderType == GL_FRAGMENT_SHADER_ARB)
|
||
|
|
glsloptShaderType = kGlslOptShaderFragment;
|
||
|
|
else
|
||
|
|
glsloptShaderType = kGlslOptShaderVertex;
|
||
|
|
|
||
|
|
glslopt_shader* shaderOptimized = glslopt_optimize(s_glslOptimizer,
|
||
|
|
glsloptShaderType, bufferFinal, 0);
|
||
|
|
|
||
|
|
if(glslopt_get_status(shaderOptimized))
|
||
|
|
{
|
||
|
|
const char* newSource = glslopt_get_output(shaderOptimized);
|
||
|
|
|
||
|
|
ri.Printf(PRINT_WARNING, "----------------------------------------------------------\n", filename);
|
||
|
|
ri.Printf(PRINT_WARNING, "OPTIMIZED shader '%s' ----------\n", filename);
|
||
|
|
ri.Printf(PRINT_WARNING, " BEGIN ---------------------------------------------------\n", filename);
|
||
|
|
|
||
|
|
length = strlen(newSource);
|
||
|
|
for(i = 0; i < length; i += 1024)
|
||
|
|
{
|
||
|
|
Q_strncpyz(msgPart, newSource + i, sizeof(msgPart));
|
||
|
|
ri.Printf(PRINT_ALL, "%s\n", msgPart);
|
||
|
|
}
|
||
|
|
|
||
|
|
ri.Printf(PRINT_WARNING, " END-- ---------------------------------------------------\n", filename);
|
||
|
|
|
||
|
|
glShaderSourceARB(shader, 1, (const GLcharARB **)&newSource, &length);
|
||
|
|
shaderText = std::string(newSource, length);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
const char* errorLog = glslopt_get_log(shaderOptimized);
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_WARNING, "Couldn't optimize '%s'", filename);
|
||
|
|
|
||
|
|
length = strlen(errorLog);
|
||
|
|
for(i = 0; i < length; i += 1024)
|
||
|
|
{
|
||
|
|
Q_strncpyz(msgPart, errorLog + i, sizeof(msgPart));
|
||
|
|
ri.Printf(PRINT_ALL, "%s\n", msgPart);
|
||
|
|
}
|
||
|
|
|
||
|
|
ri.Error(ERR_FATAL, "Couldn't optimize %s", filename);
|
||
|
|
}
|
||
|
|
|
||
|
|
glslopt_shader_delete(shaderOptimized);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
shaderText = std::string(bufferFinal, sizeFinal);
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
shaderText = std::string(bufferFinal, sizeFinal);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
ri.Free(bufferFinal);
|
||
|
|
}
|
||
|
|
|
||
|
|
ri.FS_FreeFile(mainBuffer);
|
||
|
|
free(libsBuffer);
|
||
|
|
|
||
|
|
return shaderText;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void GLShader::CompileAndLinkGPUShaderProgram( shaderProgram_t * program,
|
||
|
|
const char *programName,
|
||
|
|
const std::string& vertexShaderText,
|
||
|
|
const std::string& fragmentShaderText,
|
||
|
|
const std::string& compileMacros) const
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "------- GPU shader -------\n");
|
||
|
|
|
||
|
|
Q_strncpyz(program->name, programName, sizeof(program->name));
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
if(!compileMacros.empty())
|
||
|
|
{
|
||
|
|
program->compileMacros = (char *) ri.Hunk_Alloc(sizeof(char) * compileMacros.length() + 1, h_low);
|
||
|
|
Q_strncpyz(program->compileMacros, compileMacros.c_str(), compileMacros.length() + 1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
program->compileMacros = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
program->program = glCreateProgramObjectARB();
|
||
|
|
program->attribs = _vertexAttribsRequired;// | _vertexAttribsOptional;
|
||
|
|
|
||
|
|
|
||
|
|
// header of the glsl shader
|
||
|
|
std::string vertexHeader;
|
||
|
|
std::string fragmentHeader;
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3)
|
||
|
|
{
|
||
|
|
// HACK: abuse the GLSL preprocessor to turn GLSL 1.20 shaders into 1.30 ones
|
||
|
|
|
||
|
|
vertexHeader += "#version 130\n";
|
||
|
|
fragmentHeader += "#version 130\n";
|
||
|
|
|
||
|
|
//if(shaderType == GL_VERTEX_SHADER_ARB)
|
||
|
|
{
|
||
|
|
vertexHeader += "#define attribute in\n";
|
||
|
|
vertexHeader += "#define varying out\n";
|
||
|
|
}
|
||
|
|
//else
|
||
|
|
{
|
||
|
|
fragmentHeader += "#define varying in\n";
|
||
|
|
|
||
|
|
fragmentHeader += "out vec4 out_Color;\n";
|
||
|
|
fragmentHeader += "#define gl_FragColor out_Color\n";
|
||
|
|
}
|
||
|
|
|
||
|
|
vertexHeader += "#define textureCube texture\n";
|
||
|
|
fragmentHeader += "#define textureCube texture\n";
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
vertexHeader += "#version 120\n";
|
||
|
|
fragmentHeader += "#version 120\n";
|
||
|
|
}
|
||
|
|
|
||
|
|
// permutation macros
|
||
|
|
std::string macrosString;
|
||
|
|
|
||
|
|
if(!compileMacros.empty())
|
||
|
|
{
|
||
|
|
const char *compileMacros_ = compileMacros.c_str();
|
||
|
|
char **compileMacrosP = (char **) &compileMacros_;
|
||
|
|
char *token;
|
||
|
|
while(1)
|
||
|
|
{
|
||
|
|
token = COM_ParseExt(compileMacrosP, qfalse);
|
||
|
|
if(!token[0])
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
macrosString += va("#ifndef %s\n#define %s 1\n#endif\n", token, token);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// add them
|
||
|
|
std::string vertexShaderTextWithMacros = vertexHeader + macrosString + vertexShaderText;
|
||
|
|
std::string fragmentShaderTextWithMacros = fragmentHeader + macrosString + fragmentShaderText;
|
||
|
|
|
||
|
|
CompileGPUShader(program->program, programName, vertexShaderTextWithMacros.c_str(), vertexShaderTextWithMacros.length(), GL_VERTEX_SHADER_ARB);
|
||
|
|
CompileGPUShader(program->program, programName, fragmentShaderTextWithMacros.c_str(), fragmentShaderTextWithMacros.length(), GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
BindAttribLocations(program->program); //, _vertexAttribsRequired | _vertexAttribsOptional);
|
||
|
|
LinkProgram(program->program);
|
||
|
|
}
|
||
|
|
|
||
|
|
void GLShader::CompileGPUShader(GLhandleARB program, const char* programName, const char *shaderText, int shaderTextSize, GLenum shaderType) const
|
||
|
|
{
|
||
|
|
GLhandleARB shader = glCreateShaderObjectARB(shaderType);
|
||
|
|
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
glShaderSourceARB(shader, 1, (const GLcharARB **)&shaderText, &shaderTextSize);
|
||
|
|
|
||
|
|
// compile shader
|
||
|
|
glCompileShaderARB(shader);
|
||
|
|
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
// check if shader compiled
|
||
|
|
GLint compiled;
|
||
|
|
glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &compiled);
|
||
|
|
if(!compiled)
|
||
|
|
{
|
||
|
|
PrintShaderSource(shader);
|
||
|
|
PrintInfoLog(shader, qfalse);
|
||
|
|
ri.Error(ERR_DROP, "Couldn't compile %s %s", (shaderType == GL_VERTEX_SHADER_ARB ? "vertex shader" : "fragment shader"), programName);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//PrintInfoLog(shader, qtrue);
|
||
|
|
//ri.Printf(PRINT_ALL, "%s\n", GLSL_PrintShaderSource(shader));
|
||
|
|
|
||
|
|
// attach shader to program
|
||
|
|
glAttachObjectARB(program, shader);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
// delete shader, no longer needed
|
||
|
|
glDeleteObjectARB(shader);
|
||
|
|
GL_CheckErrors();
|
||
|
|
}
|
||
|
|
|
||
|
|
void GLShader::PrintShaderText(const std::string& shaderText) const
|
||
|
|
{
|
||
|
|
static char msgPart[1024];
|
||
|
|
|
||
|
|
for(int i = 0; i < shaderText.length(); i += 1024)
|
||
|
|
{
|
||
|
|
Q_strncpyz(msgPart, shaderText.c_str() + i, sizeof(msgPart));
|
||
|
|
ri.Printf(PRINT_ALL, "%s\n", msgPart);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void GLShader::PrintShaderSource(GLhandleARB object) const
|
||
|
|
{
|
||
|
|
char *msg;
|
||
|
|
static char msgPart[1024];
|
||
|
|
int maxLength = 0;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
glGetObjectParameterivARB(object, GL_OBJECT_SHADER_SOURCE_LENGTH_ARB, &maxLength);
|
||
|
|
|
||
|
|
msg = (char *) Com_Allocate(maxLength);
|
||
|
|
|
||
|
|
glGetShaderSourceARB(object, maxLength, &maxLength, msg);
|
||
|
|
|
||
|
|
for(i = 0; i < maxLength; i += 1024)
|
||
|
|
{
|
||
|
|
Q_strncpyz(msgPart, msg + i, sizeof(msgPart));
|
||
|
|
ri.Printf(PRINT_ALL, "%s\n", msgPart);
|
||
|
|
}
|
||
|
|
|
||
|
|
Com_Dealloc(msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
void GLShader::PrintInfoLog(GLhandleARB object, bool developerOnly) const
|
||
|
|
{
|
||
|
|
char *msg;
|
||
|
|
static char msgPart[1024];
|
||
|
|
int maxLength = 0;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
glGetObjectParameterivARB(object, GL_OBJECT_INFO_LOG_LENGTH_ARB, &maxLength);
|
||
|
|
|
||
|
|
msg = (char *) Com_Allocate(maxLength);
|
||
|
|
|
||
|
|
glGetInfoLogARB(object, maxLength, &maxLength, msg);
|
||
|
|
|
||
|
|
if(developerOnly)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_DEVELOPER, "compile log:\n");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "compile log:\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
for(i = 0; i < maxLength; i += 1024)
|
||
|
|
{
|
||
|
|
Q_strncpyz(msgPart, msg + i, sizeof(msgPart));
|
||
|
|
|
||
|
|
if(developerOnly)
|
||
|
|
ri.Printf(PRINT_DEVELOPER, "%s\n", msgPart);
|
||
|
|
else
|
||
|
|
ri.Printf(PRINT_ALL, "%s\n", msgPart);
|
||
|
|
}
|
||
|
|
|
||
|
|
Com_Dealloc(msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
void GLShader::LinkProgram(GLhandleARB program) const
|
||
|
|
{
|
||
|
|
GLint linked;
|
||
|
|
|
||
|
|
glLinkProgramARB(program);
|
||
|
|
|
||
|
|
glGetObjectParameterivARB(program, GL_OBJECT_LINK_STATUS_ARB, &linked);
|
||
|
|
if(!linked)
|
||
|
|
{
|
||
|
|
PrintInfoLog(program, qfalse);
|
||
|
|
ri.Error(ERR_DROP, "Shaders failed to link!!!");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void GLShader::ValidateProgram(GLhandleARB program) const
|
||
|
|
{
|
||
|
|
GLint validated;
|
||
|
|
|
||
|
|
glValidateProgramARB(program);
|
||
|
|
|
||
|
|
glGetObjectParameterivARB(program, GL_OBJECT_VALIDATE_STATUS_ARB, &validated);
|
||
|
|
if(!validated)
|
||
|
|
{
|
||
|
|
PrintInfoLog(program, qfalse);
|
||
|
|
ri.Error(ERR_DROP, "Shaders failed to validate!!!");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void GLShader::ShowProgramUniforms(GLhandleARB program) const
|
||
|
|
{
|
||
|
|
int i, count, size;
|
||
|
|
GLenum type;
|
||
|
|
char uniformName[1000];
|
||
|
|
|
||
|
|
// install the executables in the program object as part of current state.
|
||
|
|
glUseProgramObjectARB(program);
|
||
|
|
|
||
|
|
// check for GL Errors
|
||
|
|
|
||
|
|
// query the number of active uniforms
|
||
|
|
glGetObjectParameterivARB(program, GL_OBJECT_ACTIVE_UNIFORMS_ARB, &count);
|
||
|
|
|
||
|
|
// Loop over each of the active uniforms, and set their value
|
||
|
|
for(i = 0; i < count; i++)
|
||
|
|
{
|
||
|
|
glGetActiveUniformARB(program, i, sizeof(uniformName), NULL, &size, &type, uniformName);
|
||
|
|
|
||
|
|
ri.Printf(PRINT_DEVELOPER, "active uniform: '%s'\n", uniformName);
|
||
|
|
}
|
||
|
|
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
void GLShader::BindAttribLocations(GLhandleARB program) const
|
||
|
|
{
|
||
|
|
//if(attribs & ATTR_POSITION)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_POSITION, "attr_Position");
|
||
|
|
|
||
|
|
//if(attribs & ATTR_TEXCOORD)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_TEXCOORD0, "attr_TexCoord0");
|
||
|
|
|
||
|
|
//if(attribs & ATTR_LIGHTCOORD)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_TEXCOORD1, "attr_TexCoord1");
|
||
|
|
|
||
|
|
// if(attribs & ATTR_TEXCOORD2)
|
||
|
|
// glBindAttribLocationARB(program, ATTR_INDEX_TEXCOORD2, "attr_TexCoord2");
|
||
|
|
|
||
|
|
// if(attribs & ATTR_TEXCOORD3)
|
||
|
|
// glBindAttribLocationARB(program, ATTR_INDEX_TEXCOORD3, "attr_TexCoord3");
|
||
|
|
|
||
|
|
//if(attribs & ATTR_TANGENT)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_TANGENT, "attr_Tangent");
|
||
|
|
|
||
|
|
//if(attribs & ATTR_BINORMAL)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_BINORMAL, "attr_Binormal");
|
||
|
|
|
||
|
|
//if(attribs & ATTR_NORMAL)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_NORMAL, "attr_Normal");
|
||
|
|
|
||
|
|
//if(attribs & ATTR_COLOR)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_COLOR, "attr_Color");
|
||
|
|
|
||
|
|
#if !defined(COMPAT_Q3A) && !defined(COMPAT_ET)
|
||
|
|
//if(attribs & ATTR_PAINTCOLOR)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_PAINTCOLOR, "attr_PaintColor");
|
||
|
|
|
||
|
|
//if(attribs & ATTR_LIGHTDIRECTION)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_LIGHTDIRECTION, "attr_LightDirection");
|
||
|
|
#endif
|
||
|
|
|
||
|
|
//if(glConfig2.vboVertexSkinningAvailable)
|
||
|
|
{
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_BONE_INDEXES, "attr_BoneIndexes");
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_BONE_WEIGHTS, "attr_BoneWeights");
|
||
|
|
}
|
||
|
|
|
||
|
|
//if(attribs & ATTR_POSITION2)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_POSITION2, "attr_Position2");
|
||
|
|
|
||
|
|
//if(attribs & ATTR_TANGENT2)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_TANGENT2, "attr_Tangent2");
|
||
|
|
|
||
|
|
//if(attribs & ATTR_BINORMAL2)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_BINORMAL2, "attr_Binormal2");
|
||
|
|
|
||
|
|
//if(attribs & ATTR_NORMAL2)
|
||
|
|
glBindAttribLocationARB(program, ATTR_INDEX_NORMAL2, "attr_Normal2");
|
||
|
|
}
|
||
|
|
|
||
|
|
void GLShader::SelectProgram()
|
||
|
|
{
|
||
|
|
int index = 0;
|
||
|
|
|
||
|
|
size_t numMacros = _compileMacros.size();
|
||
|
|
for(int i = 0; i < numMacros; i++)
|
||
|
|
{
|
||
|
|
if(_activeMacros & BIT(i))
|
||
|
|
index += BIT(i);
|
||
|
|
}
|
||
|
|
|
||
|
|
_currentProgram = &_shaderPrograms[index];
|
||
|
|
}
|
||
|
|
|
||
|
|
void GLShader::BindProgram()
|
||
|
|
{
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
if(_currentProgram->program == 0)
|
||
|
|
{
|
||
|
|
std::string activeMacros = "";
|
||
|
|
size_t numMacros = _compileMacros.size();
|
||
|
|
for(size_t j = 0; j < numMacros; j++)
|
||
|
|
{
|
||
|
|
GLCompileMacro* macro = _compileMacros[j];
|
||
|
|
|
||
|
|
int bit = macro->GetBit();
|
||
|
|
|
||
|
|
if(IsMacroSet(bit))
|
||
|
|
{
|
||
|
|
activeMacros += macro->GetName();
|
||
|
|
activeMacros += " ";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ri.Error(ERR_FATAL, "Invalid shader configuration: shader = '%s', macros = '%s'", _name.c_str(), activeMacros.c_str());
|
||
|
|
}
|
||
|
|
|
||
|
|
GL_BindProgram(_currentProgram);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void GLShader::SetRequiredVertexPointers()
|
||
|
|
{
|
||
|
|
uint32_t macroVertexAttribs = 0;
|
||
|
|
size_t numMacros = _compileMacros.size();
|
||
|
|
for(size_t j = 0; j < numMacros; j++)
|
||
|
|
{
|
||
|
|
GLCompileMacro* macro = _compileMacros[j];
|
||
|
|
|
||
|
|
int bit = macro->GetBit();
|
||
|
|
|
||
|
|
if(IsMacroSet(bit))
|
||
|
|
{
|
||
|
|
macroVertexAttribs |= macro->GetRequiredVertexAttributes();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
GL_VertexAttribsState((_vertexAttribsRequired | _vertexAttribs | macroVertexAttribs));// & ~_vertexAttribsUnsupported);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_generic::GLShader_generic():
|
||
|
|
GLShader( "generic", ATTR_POSITION | ATTR_TEXCOORD | ATTR_NORMAL),
|
||
|
|
u_ColorMap(this),
|
||
|
|
u_ColorTextureMatrix(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_AlphaTest(this),
|
||
|
|
u_ColorModulate(this),
|
||
|
|
u_Color(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_BoneMatrix(this),
|
||
|
|
u_VertexInterpolation(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_ALPHA_TESTING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_SKINNING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_ANIMATION(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this),
|
||
|
|
GLCompileMacro_USE_TCGEN_ENVIRONMENT(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating generic shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "vertexSkinning vertexAnimation ";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("generic", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("generic", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling generic shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"generic",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
//shaderProgram->u_ColorMap = glGetUniformLocationARB(shaderProgram->program, "u_ColorMap");
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_ALL, "u_ColorMap = %i\n", shaderProgram->u_ColorMap);
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_ColorMap, 0);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i generic shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_lightMapping::GLShader_lightMapping():
|
||
|
|
GLShader("lightMapping", ATTR_POSITION | ATTR_TEXCOORD | ATTR_LIGHTCOORD | ATTR_NORMAL),
|
||
|
|
u_DiffuseTextureMatrix(this),
|
||
|
|
u_NormalTextureMatrix(this),
|
||
|
|
u_SpecularTextureMatrix(this),
|
||
|
|
u_ColorModulate(this),
|
||
|
|
u_Color(this),
|
||
|
|
u_AlphaTest(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
u_DepthScale(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_ALPHA_TESTING(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this),
|
||
|
|
GLCompileMacro_USE_NORMAL_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_PARALLAX_MAPPING(this)//,
|
||
|
|
//GLCompileMacro_TWOSIDED(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating lightMapping shaders -------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("lightMapping", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("lightMapping", "reliefMapping", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling lightMapping shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
compileMacros += "TWOSIDED ";
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"lightMapping",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_DiffuseMap = glGetUniformLocationARB(shaderProgram->program, "u_DiffuseMap");
|
||
|
|
shaderProgram->u_NormalMap = glGetUniformLocationARB(shaderProgram->program, "u_NormalMap");
|
||
|
|
shaderProgram->u_SpecularMap = glGetUniformLocationARB(shaderProgram->program, "u_SpecularMap");
|
||
|
|
shaderProgram->u_LightMap = glGetUniformLocationARB(shaderProgram->program, "u_LightMap");
|
||
|
|
shaderProgram->u_DeluxeMap = glGetUniformLocationARB(shaderProgram->program, "u_DeluxeMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_DiffuseMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 1);
|
||
|
|
glUniform1iARB(shaderProgram->u_SpecularMap, 2);
|
||
|
|
glUniform1iARB(shaderProgram->u_LightMap, 3);
|
||
|
|
glUniform1iARB(shaderProgram->u_DeluxeMap, 4);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i lightMapping shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_vertexLighting_DBS_entity::GLShader_vertexLighting_DBS_entity():
|
||
|
|
GLShader("vertexLighting_DBS_entity", ATTR_POSITION | ATTR_TEXCOORD | ATTR_NORMAL),
|
||
|
|
u_DiffuseTextureMatrix(this),
|
||
|
|
u_NormalTextureMatrix(this),
|
||
|
|
u_SpecularTextureMatrix(this),
|
||
|
|
u_AlphaTest(this),
|
||
|
|
u_AmbientColor(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_LightDir(this),
|
||
|
|
u_LightColor(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_BoneMatrix(this),
|
||
|
|
u_VertexInterpolation(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
u_DepthScale(this),
|
||
|
|
u_EnvironmentInterpolation(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_ALPHA_TESTING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_SKINNING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_ANIMATION(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this),
|
||
|
|
GLCompileMacro_USE_NORMAL_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_PARALLAX_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_REFLECTIVE_SPECULAR(this)//,
|
||
|
|
//GLCompileMacro_TWOSIDED(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating vertexLighting_DBS_entity shaders ------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "vertexSkinning vertexAnimation ";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("vertexLighting_DBS_entity", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("vertexLighting_DBS_entity", "reliefMapping", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling vertexLighting_DBS_entity shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
compileMacros += "TWOSIDED ";
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"vertexLighting_DBS_entity",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_DiffuseMap = glGetUniformLocationARB(shaderProgram->program, "u_DiffuseMap");
|
||
|
|
shaderProgram->u_NormalMap = glGetUniformLocationARB(shaderProgram->program, "u_NormalMap");
|
||
|
|
shaderProgram->u_SpecularMap = glGetUniformLocationARB(shaderProgram->program, "u_SpecularMap");
|
||
|
|
shaderProgram->u_EnvironmentMap0 = glGetUniformLocationARB(shaderProgram->program, "u_EnvironmentMap0");
|
||
|
|
shaderProgram->u_EnvironmentMap1 = glGetUniformLocationARB(shaderProgram->program, "u_EnvironmentMap1");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_DiffuseMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 1);
|
||
|
|
glUniform1iARB(shaderProgram->u_SpecularMap, 2);
|
||
|
|
glUniform1iARB(shaderProgram->u_EnvironmentMap0, 3);
|
||
|
|
glUniform1iARB(shaderProgram->u_EnvironmentMap1, 4);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i vertexLighting_DBS_entity shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_vertexLighting_DBS_world::GLShader_vertexLighting_DBS_world():
|
||
|
|
GLShader( "vertexLighting_DBS_world",
|
||
|
|
ATTR_POSITION | ATTR_TEXCOORD | ATTR_NORMAL | ATTR_COLOR
|
||
|
|
#if !defined(COMPAT_Q3A) && !defined(COMPAT_ET)
|
||
|
|
| ATTR_LIGHTDIRECTION
|
||
|
|
#endif
|
||
|
|
),
|
||
|
|
u_DiffuseTextureMatrix(this),
|
||
|
|
u_NormalTextureMatrix(this),
|
||
|
|
u_SpecularTextureMatrix(this),
|
||
|
|
u_ColorModulate(this),
|
||
|
|
u_Color(this),
|
||
|
|
u_AlphaTest(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
u_DepthScale(this),
|
||
|
|
u_LightWrapAround(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_ALPHA_TESTING(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this),
|
||
|
|
GLCompileMacro_USE_NORMAL_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_PARALLAX_MAPPING(this)//,
|
||
|
|
//GLCompileMacro_TWOSIDED(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating vertexLighting_DBS_world shaders -------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("vertexLighting_DBS_world", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("vertexLighting_DBS_world", "reliefMapping", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling vertexLighting_DBS_world shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
compileMacros += "TWOSIDED ";
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"vertexLighting_DBS_world",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_DiffuseMap = glGetUniformLocationARB(shaderProgram->program, "u_DiffuseMap");
|
||
|
|
shaderProgram->u_NormalMap = glGetUniformLocationARB(shaderProgram->program, "u_NormalMap");
|
||
|
|
shaderProgram->u_SpecularMap = glGetUniformLocationARB(shaderProgram->program, "u_SpecularMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_DiffuseMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 1);
|
||
|
|
glUniform1iARB(shaderProgram->u_SpecularMap, 2);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i vertexLighting_DBS_world shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_forwardLighting_omniXYZ::GLShader_forwardLighting_omniXYZ():
|
||
|
|
GLShader("forwardLighting_omniXYZ", ATTR_POSITION | ATTR_TEXCOORD | ATTR_NORMAL),
|
||
|
|
u_DiffuseTextureMatrix(this),
|
||
|
|
u_NormalTextureMatrix(this),
|
||
|
|
u_SpecularTextureMatrix(this),
|
||
|
|
u_AlphaTest(this),
|
||
|
|
u_ColorModulate(this),
|
||
|
|
u_Color(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_LightOrigin(this),
|
||
|
|
u_LightColor(this),
|
||
|
|
u_LightRadius(this),
|
||
|
|
u_LightScale(this),
|
||
|
|
u_LightWrapAround(this),
|
||
|
|
u_LightAttenuationMatrix(this),
|
||
|
|
u_ShadowTexelSize(this),
|
||
|
|
u_ShadowBlur(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_BoneMatrix(this),
|
||
|
|
u_VertexInterpolation(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
u_DepthScale(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_ALPHA_TESTING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_SKINNING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_ANIMATION(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this),
|
||
|
|
GLCompileMacro_USE_NORMAL_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_PARALLAX_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_SHADOWING(this)//,
|
||
|
|
//GLCompileMacro_TWOSIDED(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating forwardLighting_omniXYZ shaders --------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "vertexSkinning vertexAnimation ";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("forwardLighting", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("forwardLighting", "reliefMapping", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling forwardLighting_omniXYZ shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
compileMacros += "TWOSIDED ";
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"forwardLighting_omniXYZ",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_DiffuseMap = glGetUniformLocationARB(shaderProgram->program, "u_DiffuseMap");
|
||
|
|
shaderProgram->u_NormalMap = glGetUniformLocationARB(shaderProgram->program, "u_NormalMap");
|
||
|
|
shaderProgram->u_SpecularMap = glGetUniformLocationARB(shaderProgram->program, "u_SpecularMap");
|
||
|
|
shaderProgram->u_AttenuationMapXY = glGetUniformLocationARB(shaderProgram->program, "u_AttenuationMapXY");
|
||
|
|
shaderProgram->u_AttenuationMapZ = glGetUniformLocationARB(shaderProgram->program, "u_AttenuationMapZ");
|
||
|
|
//if(r_shadows->integer >= SHADOWING_ESM16)
|
||
|
|
{
|
||
|
|
shaderProgram->u_ShadowMap = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap");
|
||
|
|
}
|
||
|
|
shaderProgram->u_RandomMap = glGetUniformLocationARB(shaderProgram->program, "u_RandomMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_DiffuseMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 1);
|
||
|
|
glUniform1iARB(shaderProgram->u_SpecularMap, 2);
|
||
|
|
glUniform1iARB(shaderProgram->u_AttenuationMapXY, 3);
|
||
|
|
glUniform1iARB(shaderProgram->u_AttenuationMapZ, 4);
|
||
|
|
//if(r_shadows->integer >= SHADOWING_ESM16)
|
||
|
|
{
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap, 5);
|
||
|
|
}
|
||
|
|
glUniform1iARB(shaderProgram->u_RandomMap, 6);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i forwardLighting_omniXYZ shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_forwardLighting_projXYZ::GLShader_forwardLighting_projXYZ():
|
||
|
|
GLShader("forwardLighting_projXYZ", ATTR_POSITION | ATTR_TEXCOORD | ATTR_NORMAL),
|
||
|
|
u_DiffuseTextureMatrix(this),
|
||
|
|
u_NormalTextureMatrix(this),
|
||
|
|
u_SpecularTextureMatrix(this),
|
||
|
|
u_AlphaTest(this),
|
||
|
|
u_ColorModulate(this),
|
||
|
|
u_Color(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_LightOrigin(this),
|
||
|
|
u_LightColor(this),
|
||
|
|
u_LightRadius(this),
|
||
|
|
u_LightScale(this),
|
||
|
|
u_LightWrapAround(this),
|
||
|
|
u_LightAttenuationMatrix(this),
|
||
|
|
u_ShadowTexelSize(this),
|
||
|
|
u_ShadowBlur(this),
|
||
|
|
u_ShadowMatrix(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_BoneMatrix(this),
|
||
|
|
u_VertexInterpolation(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
u_DepthScale(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_ALPHA_TESTING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_SKINNING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_ANIMATION(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this),
|
||
|
|
GLCompileMacro_USE_NORMAL_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_PARALLAX_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_SHADOWING(this)//,
|
||
|
|
//GLCompileMacro_TWOSIDED(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating forwardLighting_projXYZ shaders --------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "vertexSkinning vertexAnimation ";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("forwardLighting", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("forwardLighting", "reliefMapping", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling forwardLighting_projXYZ shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
compileMacros += "LIGHT_PROJ ";
|
||
|
|
compileMacros += "TWOSIDED ";
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_ALL, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"forwardLighting_projXYZ",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_DiffuseMap = glGetUniformLocationARB(shaderProgram->program, "u_DiffuseMap");
|
||
|
|
shaderProgram->u_NormalMap = glGetUniformLocationARB(shaderProgram->program, "u_NormalMap");
|
||
|
|
shaderProgram->u_SpecularMap = glGetUniformLocationARB(shaderProgram->program, "u_SpecularMap");
|
||
|
|
shaderProgram->u_AttenuationMapXY = glGetUniformLocationARB(shaderProgram->program, "u_AttenuationMapXY");
|
||
|
|
shaderProgram->u_AttenuationMapZ = glGetUniformLocationARB(shaderProgram->program, "u_AttenuationMapZ");
|
||
|
|
//if(r_shadows->integer >= SHADOWING_VSM16)
|
||
|
|
{
|
||
|
|
shaderProgram->u_ShadowMap0 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap0");
|
||
|
|
}
|
||
|
|
shaderProgram->u_RandomMap = glGetUniformLocationARB(shaderProgram->program, "u_RandomMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_DiffuseMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 1);
|
||
|
|
glUniform1iARB(shaderProgram->u_SpecularMap, 2);
|
||
|
|
glUniform1iARB(shaderProgram->u_AttenuationMapXY, 3);
|
||
|
|
glUniform1iARB(shaderProgram->u_AttenuationMapZ, 4);
|
||
|
|
//if(r_shadows->integer >= SHADOWING_ESM16)
|
||
|
|
{
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap0, 5);
|
||
|
|
}
|
||
|
|
glUniform1iARB(shaderProgram->u_RandomMap, 6);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i forwardLighting_projXYZ shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_forwardLighting_directionalSun::GLShader_forwardLighting_directionalSun():
|
||
|
|
GLShader("forwardLighting_directionalSun", ATTR_POSITION | ATTR_TEXCOORD | ATTR_NORMAL),
|
||
|
|
u_DiffuseTextureMatrix(this),
|
||
|
|
u_NormalTextureMatrix(this),
|
||
|
|
u_SpecularTextureMatrix(this),
|
||
|
|
u_AlphaTest(this),
|
||
|
|
u_ColorModulate(this),
|
||
|
|
u_Color(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_LightDir(this),
|
||
|
|
u_LightColor(this),
|
||
|
|
u_LightRadius(this),
|
||
|
|
u_LightScale(this),
|
||
|
|
u_LightWrapAround(this),
|
||
|
|
u_LightAttenuationMatrix(this),
|
||
|
|
u_ShadowTexelSize(this),
|
||
|
|
u_ShadowBlur(this),
|
||
|
|
u_ShadowMatrix(this),
|
||
|
|
u_ShadowParallelSplitDistances(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ViewMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_BoneMatrix(this),
|
||
|
|
u_VertexInterpolation(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
u_DepthScale(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_ALPHA_TESTING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_SKINNING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_ANIMATION(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this),
|
||
|
|
GLCompileMacro_USE_NORMAL_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_PARALLAX_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_SHADOWING(this)//,
|
||
|
|
//GLCompileMacro_TWOSIDED(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating forwardLighting_directionalSun shaders -\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "vertexSkinning vertexAnimation ";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("forwardLighting", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("forwardLighting", "reliefMapping", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling forwardLighting_directionalSun shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
compileMacros += "LIGHT_DIRECTIONAL ";
|
||
|
|
compileMacros += "TWOSIDED ";
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"forwardLighting",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_DiffuseMap = glGetUniformLocationARB(shaderProgram->program, "u_DiffuseMap");
|
||
|
|
shaderProgram->u_NormalMap = glGetUniformLocationARB(shaderProgram->program, "u_NormalMap");
|
||
|
|
shaderProgram->u_SpecularMap = glGetUniformLocationARB(shaderProgram->program, "u_SpecularMap");
|
||
|
|
//if(r_shadows->integer >= SHADOWING_ESM16)
|
||
|
|
{
|
||
|
|
shaderProgram->u_ShadowMap0 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap0");
|
||
|
|
shaderProgram->u_ShadowMap1 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap1");
|
||
|
|
shaderProgram->u_ShadowMap2 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap2");
|
||
|
|
shaderProgram->u_ShadowMap3 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap3");
|
||
|
|
shaderProgram->u_ShadowMap4 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap4");
|
||
|
|
}
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_DiffuseMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 1);
|
||
|
|
glUniform1iARB(shaderProgram->u_SpecularMap, 2);
|
||
|
|
//glUniform1iARB(shaderProgram->u_AttenuationMapXY, 3);
|
||
|
|
//glUniform1iARB(shaderProgram->u_AttenuationMapZ, 4);
|
||
|
|
//if(r_shadows->integer >= SHADOWING_ESM16)
|
||
|
|
{
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap0, 5);
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap1, 6);
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap2, 7);
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap3, 8);
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap4, 9);
|
||
|
|
}
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i forwardLighting_directionalSun shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_deferredLighting_omniXYZ::GLShader_deferredLighting_omniXYZ():
|
||
|
|
GLShader("deferredLighting_omniXYZ", ATTR_POSITION),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_LightOrigin(this),
|
||
|
|
u_LightColor(this),
|
||
|
|
u_LightRadius(this),
|
||
|
|
u_LightScale(this),
|
||
|
|
u_LightWrapAround(this),
|
||
|
|
u_LightAttenuationMatrix(this),
|
||
|
|
u_LightFrustum(this),
|
||
|
|
u_ShadowTexelSize(this),
|
||
|
|
u_ShadowBlur(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_UnprojectMatrix(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_FRUSTUM_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_NORMAL_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_SHADOWING(this)//,
|
||
|
|
//GLCompileMacro_TWOSIDED(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating deferredLighting_omniXYZ shaders --------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("deferredLighting", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("deferredLighting", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling deferredLighting_omniXYZ shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
//compileMacros += "TWOSIDED ";
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"deferredLighting_omniXYZ",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_DiffuseMap = glGetUniformLocationARB(shaderProgram->program, "u_DiffuseMap");
|
||
|
|
shaderProgram->u_NormalMap = glGetUniformLocationARB(shaderProgram->program, "u_NormalMap");
|
||
|
|
shaderProgram->u_SpecularMap = glGetUniformLocationARB(shaderProgram->program, "u_SpecularMap");
|
||
|
|
shaderProgram->u_DepthMap = glGetUniformLocationARB(shaderProgram->program, "u_DepthMap");
|
||
|
|
shaderProgram->u_AttenuationMapXY = glGetUniformLocationARB(shaderProgram->program, "u_AttenuationMapXY");
|
||
|
|
shaderProgram->u_AttenuationMapZ = glGetUniformLocationARB(shaderProgram->program, "u_AttenuationMapZ");
|
||
|
|
//if(r_shadows->integer >= SHADOWING_ESM16)
|
||
|
|
{
|
||
|
|
shaderProgram->u_ShadowMap = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap");
|
||
|
|
}
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_DiffuseMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 1);
|
||
|
|
glUniform1iARB(shaderProgram->u_SpecularMap, 2);
|
||
|
|
glUniform1iARB(shaderProgram->u_DepthMap, 3);
|
||
|
|
glUniform1iARB(shaderProgram->u_AttenuationMapXY, 4);
|
||
|
|
glUniform1iARB(shaderProgram->u_AttenuationMapZ, 5);
|
||
|
|
//if(r_shadows->integer >= SHADOWING_ESM16)
|
||
|
|
{
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap, 6);
|
||
|
|
}
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i deferredLighting_omniXYZ shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_deferredLighting_projXYZ::GLShader_deferredLighting_projXYZ():
|
||
|
|
GLShader("deferredLighting_projXYZ", ATTR_POSITION),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_LightOrigin(this),
|
||
|
|
u_LightColor(this),
|
||
|
|
u_LightRadius(this),
|
||
|
|
u_LightScale(this),
|
||
|
|
u_LightWrapAround(this),
|
||
|
|
u_LightAttenuationMatrix(this),
|
||
|
|
u_LightFrustum(this),
|
||
|
|
u_ShadowTexelSize(this),
|
||
|
|
u_ShadowBlur(this),
|
||
|
|
u_ShadowMatrix(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_UnprojectMatrix(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_FRUSTUM_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_NORMAL_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_SHADOWING(this)//,
|
||
|
|
//GLCompileMacro_TWOSIDED(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating deferredLighting_projXYZ shaders --------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("deferredLighting", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("deferredLighting", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling deferredLighting_projXYZ shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
compileMacros += "LIGHT_PROJ ";
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"deferredLighting_projXYZ",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_DiffuseMap = glGetUniformLocationARB(shaderProgram->program, "u_DiffuseMap");
|
||
|
|
shaderProgram->u_NormalMap = glGetUniformLocationARB(shaderProgram->program, "u_NormalMap");
|
||
|
|
shaderProgram->u_SpecularMap = glGetUniformLocationARB(shaderProgram->program, "u_SpecularMap");
|
||
|
|
shaderProgram->u_DepthMap = glGetUniformLocationARB(shaderProgram->program, "u_DepthMap");
|
||
|
|
shaderProgram->u_AttenuationMapXY = glGetUniformLocationARB(shaderProgram->program, "u_AttenuationMapXY");
|
||
|
|
shaderProgram->u_AttenuationMapZ = glGetUniformLocationARB(shaderProgram->program, "u_AttenuationMapZ");
|
||
|
|
//if(r_shadows->integer >= SHADOWING_ESM16)
|
||
|
|
{
|
||
|
|
shaderProgram->u_ShadowMap0 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap0");
|
||
|
|
}
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_DiffuseMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 1);
|
||
|
|
glUniform1iARB(shaderProgram->u_SpecularMap, 2);
|
||
|
|
glUniform1iARB(shaderProgram->u_DepthMap, 3);
|
||
|
|
glUniform1iARB(shaderProgram->u_AttenuationMapXY, 4);
|
||
|
|
glUniform1iARB(shaderProgram->u_AttenuationMapZ, 5);
|
||
|
|
//if(r_shadows->integer >= SHADOWING_ESM16)
|
||
|
|
{
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap0, 6);
|
||
|
|
}
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i deferredLighting_projXYZ shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
GLShader_deferredLighting_directionalSun::GLShader_deferredLighting_directionalSun():
|
||
|
|
GLShader("deferredLighting_directionalSun", ATTR_POSITION),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_LightDir(this),
|
||
|
|
u_LightColor(this),
|
||
|
|
u_LightRadius(this),
|
||
|
|
u_LightScale(this),
|
||
|
|
u_LightWrapAround(this),
|
||
|
|
u_LightAttenuationMatrix(this),
|
||
|
|
u_LightFrustum(this),
|
||
|
|
u_ShadowTexelSize(this),
|
||
|
|
u_ShadowBlur(this),
|
||
|
|
u_ShadowMatrix(this),
|
||
|
|
u_ShadowParallelSplitDistances(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_ViewMatrix(this),
|
||
|
|
u_UnprojectMatrix(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_FRUSTUM_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_NORMAL_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_SHADOWING(this)//,
|
||
|
|
//GLCompileMacro_TWOSIDED(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating deferredLighting_directionalSun shaders --------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("deferredLighting", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("deferredLighting", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling deferredLighting_directionalSun shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
compileMacros += "LIGHT_DIRECTIONAL ";
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"deferredLighting_directionalSun",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_DiffuseMap = glGetUniformLocationARB(shaderProgram->program, "u_DiffuseMap");
|
||
|
|
shaderProgram->u_NormalMap = glGetUniformLocationARB(shaderProgram->program, "u_NormalMap");
|
||
|
|
shaderProgram->u_SpecularMap = glGetUniformLocationARB(shaderProgram->program, "u_SpecularMap");
|
||
|
|
shaderProgram->u_DepthMap = glGetUniformLocationARB(shaderProgram->program, "u_DepthMap");
|
||
|
|
//if(r_shadows->integer >= SHADOWING_ESM16)
|
||
|
|
{
|
||
|
|
shaderProgram->u_ShadowMap0 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap0");
|
||
|
|
shaderProgram->u_ShadowMap1 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap1");
|
||
|
|
shaderProgram->u_ShadowMap2 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap2");
|
||
|
|
shaderProgram->u_ShadowMap3 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap3");
|
||
|
|
shaderProgram->u_ShadowMap4 = glGetUniformLocationARB(shaderProgram->program, "u_ShadowMap4");
|
||
|
|
}
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_DiffuseMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 1);
|
||
|
|
glUniform1iARB(shaderProgram->u_SpecularMap, 2);
|
||
|
|
glUniform1iARB(shaderProgram->u_DepthMap, 3);
|
||
|
|
//glUniform1iARB(shaderProgram->u_AttenuationMapXY, 4);
|
||
|
|
//glUniform1iARB(shaderProgram->u_AttenuationMapZ, 5);
|
||
|
|
//if(r_shadows->integer >= SHADOWING_ESM16)
|
||
|
|
{
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap0, 6);
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap1, 7);
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap2, 8);
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap3, 9);
|
||
|
|
glUniform1iARB(shaderProgram->u_ShadowMap4, 10);
|
||
|
|
}
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i deferredLighting_directionalSun shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_geometricFill::GLShader_geometricFill():
|
||
|
|
GLShader("geometricFill", ATTR_POSITION | ATTR_TEXCOORD | ATTR_NORMAL),
|
||
|
|
u_DiffuseTextureMatrix(this),
|
||
|
|
u_NormalTextureMatrix(this),
|
||
|
|
u_SpecularTextureMatrix(this),
|
||
|
|
u_AlphaTest(this),
|
||
|
|
u_ColorModulate(this),
|
||
|
|
u_Color(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_BoneMatrix(this),
|
||
|
|
u_VertexInterpolation(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
u_DepthScale(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_ALPHA_TESTING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_SKINNING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_ANIMATION(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this),
|
||
|
|
GLCompileMacro_USE_NORMAL_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_PARALLAX_MAPPING(this),
|
||
|
|
GLCompileMacro_USE_REFLECTIVE_SPECULAR(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating geometricFill shaders ---------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "vertexSkinning vertexAnimation ";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("geometricFill", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("geometricFill", "reliefMapping", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling geometricFill shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
compileMacros += "TWOSIDED ";
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_ALL, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"geometricFill",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_DiffuseMap = glGetUniformLocationARB(shaderProgram->program, "u_DiffuseMap");
|
||
|
|
shaderProgram->u_NormalMap = glGetUniformLocationARB(shaderProgram->program, "u_NormalMap");
|
||
|
|
shaderProgram->u_SpecularMap = glGetUniformLocationARB(shaderProgram->program, "u_SpecularMap");
|
||
|
|
shaderProgram->u_EnvironmentMap0 = glGetUniformLocationARB(shaderProgram->program, "u_EnvironmentMap0");
|
||
|
|
shaderProgram->u_EnvironmentMap1 = glGetUniformLocationARB(shaderProgram->program, "u_EnvironmentMap1");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_DiffuseMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 1);
|
||
|
|
glUniform1iARB(shaderProgram->u_SpecularMap, 2);
|
||
|
|
glUniform1iARB(shaderProgram->u_EnvironmentMap0, 3);
|
||
|
|
glUniform1iARB(shaderProgram->u_EnvironmentMap1, 4);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i geometricFill shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_shadowFill::GLShader_shadowFill():
|
||
|
|
GLShader("shadowFill", ATTR_POSITION | ATTR_TEXCOORD | ATTR_NORMAL),
|
||
|
|
u_ColorTextureMatrix(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_AlphaTest(this),
|
||
|
|
u_LightOrigin(this),
|
||
|
|
u_LightRadius(this),
|
||
|
|
u_Color(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_BoneMatrix(this),
|
||
|
|
u_VertexInterpolation(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_ALPHA_TESTING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_SKINNING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_ANIMATION(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this),
|
||
|
|
GLCompileMacro_LIGHT_DIRECTIONAL(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating shadowFill shaders ---------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "vertexSkinning vertexAnimation ";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("shadowFill", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("shadowFill", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling shadowFill shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"shadowFill",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_ColorMap = glGetUniformLocationARB(shaderProgram->program, "u_ColorMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_ColorMap, 0);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i shadowFill shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_reflection::GLShader_reflection():
|
||
|
|
GLShader("reflection", ATTR_POSITION | ATTR_TEXCOORD | ATTR_NORMAL),
|
||
|
|
u_ColorMap(this),
|
||
|
|
u_NormalMap(this),
|
||
|
|
u_NormalTextureMatrix(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_BoneMatrix(this),
|
||
|
|
u_VertexInterpolation(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_SKINNING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_ANIMATION(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this),
|
||
|
|
GLCompileMacro_USE_NORMAL_MAPPING(this)//,
|
||
|
|
//GLCompileMacro_TWOSIDED(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating reflection shaders ---------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "vertexSkinning vertexAnimation ";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("reflection_CB", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("reflection_CB", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling reflection shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
compileMacros += "TWOSIDED ";
|
||
|
|
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"reflection",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_ColorMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 1);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i reflection shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_skybox::GLShader_skybox():
|
||
|
|
GLShader("skybox", ATTR_POSITION),
|
||
|
|
u_ColorMap(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_BoneMatrix(this),
|
||
|
|
u_VertexInterpolation(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating skybox shaders -------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("skybox", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("skybox", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling skybox shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"skybox",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_ColorMap, 0);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i skybox shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_fogQuake3::GLShader_fogQuake3():
|
||
|
|
GLShader("fogQuake3", ATTR_POSITION | ATTR_NORMAL),
|
||
|
|
u_Color(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_BoneMatrix(this),
|
||
|
|
u_VertexInterpolation(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
u_FogDistanceVector(this),
|
||
|
|
u_FogDepthVector(this),
|
||
|
|
u_FogEyeT(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
//GLCompileMacro_USE_ALPHA_TESTING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_SKINNING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_ANIMATION(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this),
|
||
|
|
GLCompileMacro_EYE_OUTSIDE(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating fogQuake3 shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "vertexSkinning vertexAnimation ";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("fogQuake3", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("fogQuake3", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling fogQuake3 shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"fogQuake3",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_ColorMap = glGetUniformLocationARB(shaderProgram->program, "u_ColorMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_ColorMap, 0);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i fogQuake3 shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_fogGlobal::GLShader_fogGlobal():
|
||
|
|
GLShader("fogGlobal", ATTR_POSITION),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
u_Color(this),
|
||
|
|
u_ViewMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_UnprojectMatrix(this),
|
||
|
|
u_FogDistanceVector(this),
|
||
|
|
u_FogDepthVector(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating fogGlobal shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("fogGlobal", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("fogGlobal", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling fogGlobal shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"fogGlobal",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_ColorMap = glGetUniformLocationARB(shaderProgram->program, "u_ColorMap");
|
||
|
|
shaderProgram->u_DepthMap = glGetUniformLocationARB(shaderProgram->program, "u_DepthMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_ColorMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_DepthMap, 1);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i fogQuake3 shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_heatHaze::GLShader_heatHaze():
|
||
|
|
GLShader("heatHaze", ATTR_POSITION | ATTR_TEXCOORD | ATTR_NORMAL),
|
||
|
|
u_NormalTextureMatrix(this),
|
||
|
|
u_ViewOrigin(this),
|
||
|
|
//u_AlphaTest(this),
|
||
|
|
u_DeformMagnitude(this),
|
||
|
|
u_ColorModulate(this),
|
||
|
|
u_Color(this),
|
||
|
|
u_ModelMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_ModelViewMatrixTranspose(this),
|
||
|
|
u_ProjectionMatrixTranspose(this),
|
||
|
|
u_BoneMatrix(this),
|
||
|
|
u_VertexInterpolation(this),
|
||
|
|
u_PortalPlane(this),
|
||
|
|
GLDeformStage(this),
|
||
|
|
GLCompileMacro_USE_PORTAL_CLIPPING(this),
|
||
|
|
//GLCompileMacro_USE_ALPHA_TESTING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_SKINNING(this),
|
||
|
|
GLCompileMacro_USE_VERTEX_ANIMATION(this),
|
||
|
|
GLCompileMacro_USE_DEFORM_VERTEXES(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating heatHaze shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexInlines = "vertexSkinning vertexAnimation ";
|
||
|
|
if(glConfig.driverType == GLDRV_OPENGL3 && r_vboDeformVertexes->integer)
|
||
|
|
{
|
||
|
|
vertexInlines += "deformVertexes ";
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("heatHaze", vertexInlines.c_str(), GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("heatHaze", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling heatHaze shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"heatHaze",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_NormalMap = glGetUniformLocationARB(shaderProgram->program, "u_NormalMap");
|
||
|
|
shaderProgram->u_CurrentMap = glGetUniformLocationARB(shaderProgram->program, "u_CurrentMap");
|
||
|
|
if(r_heatHazeFix->integer && glConfig2.framebufferBlitAvailable && /*glConfig.hardwareType != GLHW_ATI && glConfig.hardwareType != GLHW_ATI_DX10 &&*/ glConfig.driverType != GLDRV_MESA)
|
||
|
|
{
|
||
|
|
shaderProgram->u_ContrastMap = glGetUniformLocationARB(shaderProgram->program, "u_ContrastMap");
|
||
|
|
}
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_NormalMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_CurrentMap, 1);
|
||
|
|
if(r_heatHazeFix->integer && glConfig2.framebufferBlitAvailable && /*glConfig.hardwareType != GLHW_ATI && glConfig.hardwareType != GLHW_ATI_DX10 &&*/ glConfig.driverType != GLDRV_MESA)
|
||
|
|
{
|
||
|
|
glUniform1iARB(shaderProgram->u_ContrastMap, 2);
|
||
|
|
}
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i heatHaze shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_screen::GLShader_screen():
|
||
|
|
GLShader("screen", ATTR_POSITION),
|
||
|
|
u_ModelViewProjectionMatrix(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating screen shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("screen", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("screen", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"screen",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_CurrentMap = glGetUniformLocationARB(shaderProgram->program, "u_CurrentMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_CurrentMap, 0);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i screen shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
GLShader_portal::GLShader_portal():
|
||
|
|
GLShader("portal", ATTR_POSITION),
|
||
|
|
u_ModelViewMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_PortalRange(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating portal shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("portal", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("portal", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"portal",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_CurrentMap = glGetUniformLocationARB(shaderProgram->program, "u_CurrentMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_CurrentMap, 0);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i portal shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_toneMapping::GLShader_toneMapping():
|
||
|
|
GLShader("toneMapping", ATTR_POSITION),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_HDRKey(this),
|
||
|
|
u_HDRAverageLuminance(this),
|
||
|
|
u_HDRMaxLuminance(this),
|
||
|
|
GLCompileMacro_BRIGHTPASS_FILTER(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating toneMapping shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("toneMapping", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("toneMapping", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling toneMapping shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"toneMapping",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_CurrentMap = glGetUniformLocationARB(shaderProgram->program, "u_CurrentMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_CurrentMap, 0);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i toneMapping shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_contrast::GLShader_contrast():
|
||
|
|
GLShader("contrast", ATTR_POSITION),
|
||
|
|
u_ModelViewProjectionMatrix(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating contrast shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("contrast", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("contrast", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling contrast shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"contrast",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_ColorMap = glGetUniformLocationARB(shaderProgram->program, "u_ColorMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_ColorMap, 0);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i contrast shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_cameraEffects::GLShader_cameraEffects():
|
||
|
|
GLShader("cameraEffects", ATTR_POSITION | ATTR_TEXCOORD),
|
||
|
|
u_ColorTextureMatrix(this),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_DeformMagnitude(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating cameraEffects shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("cameraEffects", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("cameraEffects", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling cameraEffects shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"cameraEffects",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_CurrentMap = glGetUniformLocationARB(shaderProgram->program, "u_CurrentMap");
|
||
|
|
shaderProgram->u_GrainMap = glGetUniformLocationARB(shaderProgram->program, "u_GrainMap");
|
||
|
|
shaderProgram->u_VignetteMap = glGetUniformLocationARB(shaderProgram->program, "u_VignetteMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_CurrentMap, 0);
|
||
|
|
glUniform1iARB(shaderProgram->u_GrainMap, 1);
|
||
|
|
glUniform1iARB(shaderProgram->u_VignetteMap, 2);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i cameraEffects shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_blurX::GLShader_blurX():
|
||
|
|
GLShader("blurX", ATTR_POSITION),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_DeformMagnitude(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating blurX shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("blurX", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("blurX", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling blurX shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"blurX",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_ColorMap = glGetUniformLocationARB(shaderProgram->program, "u_ColorMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_ColorMap, 0);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i blurX shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_blurY::GLShader_blurY():
|
||
|
|
GLShader("blurY", ATTR_POSITION),
|
||
|
|
u_ModelViewProjectionMatrix(this),
|
||
|
|
u_DeformMagnitude(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating blurY shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("blurY", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("blurY", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
ri.Printf(PRINT_ALL, "...compiling blurY shaders\n");
|
||
|
|
ri.Printf(PRINT_ALL, "0%% 10 20 30 40 50 60 70 80 90 100%%\n");
|
||
|
|
ri.Printf(PRINT_ALL, "|----|----|----|----|----|----|----|----|----|----|\n");
|
||
|
|
size_t tics = 0;
|
||
|
|
size_t nextTicCount = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
if((i + 1) >= nextTicCount)
|
||
|
|
{
|
||
|
|
size_t ticsNeeded = (size_t)(((double)(i + 1) / numPermutations) * 50.0);
|
||
|
|
|
||
|
|
do { ri.Printf(PRINT_ALL, "*"); } while ( ++tics < ticsNeeded );
|
||
|
|
|
||
|
|
nextTicCount = (size_t)((tics / 50.0) * numPermutations);
|
||
|
|
if(i == (numPermutations - 1))
|
||
|
|
{
|
||
|
|
if(tics < 51)
|
||
|
|
ri.Printf(PRINT_ALL, "*");
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
//ri.Printf(PRINT_ALL, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"blurY",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_ColorMap = glGetUniformLocationARB(shaderProgram->program, "u_ColorMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_ColorMap, 0);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ri.Printf(PRINT_ALL, "\n");
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i blurY shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
GLShader_debugShadowMap::GLShader_debugShadowMap():
|
||
|
|
GLShader("debugShadowMap", ATTR_POSITION),
|
||
|
|
u_ModelViewProjectionMatrix(this)
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_ALL, "/// -------------------------------------------------\n");
|
||
|
|
ri.Printf(PRINT_ALL, "/// creating debugShadowMap shaders ------------------------\n");
|
||
|
|
|
||
|
|
int startTime = ri.Milliseconds();
|
||
|
|
|
||
|
|
_shaderPrograms = std::vector<shaderProgram_t>(1 << _compileMacros.size());
|
||
|
|
|
||
|
|
//Com_Memset(_shaderPrograms, 0, sizeof(_shaderPrograms));
|
||
|
|
|
||
|
|
std::string vertexShaderText = BuildGPUShaderText("debugShadowMap", "", GL_VERTEX_SHADER_ARB);
|
||
|
|
std::string fragmentShaderText = BuildGPUShaderText("debugShadowMap", "", GL_FRAGMENT_SHADER_ARB);
|
||
|
|
|
||
|
|
size_t numPermutations = (1 << _compileMacros.size()); // same as 2^n, n = no. compile macros
|
||
|
|
size_t numCompiled = 0;
|
||
|
|
for(size_t i = 0; i < numPermutations; i++)
|
||
|
|
{
|
||
|
|
std::string compileMacros;
|
||
|
|
if(GetCompileMacrosString(i, compileMacros))
|
||
|
|
{
|
||
|
|
ri.Printf(PRINT_DEVELOPER, "Compile macros: '%s'\n", compileMacros.c_str());
|
||
|
|
|
||
|
|
shaderProgram_t *shaderProgram = &_shaderPrograms[i];
|
||
|
|
|
||
|
|
CompileAndLinkGPUShaderProgram( shaderProgram,
|
||
|
|
"debugShadowMap",
|
||
|
|
vertexShaderText,
|
||
|
|
fragmentShaderText,
|
||
|
|
compileMacros);
|
||
|
|
|
||
|
|
UpdateShaderProgramUniformLocations(shaderProgram);
|
||
|
|
|
||
|
|
shaderProgram->u_CurrentMap = glGetUniformLocationARB(shaderProgram->program, "u_CurrentMap");
|
||
|
|
|
||
|
|
glUseProgramObjectARB(shaderProgram->program);
|
||
|
|
glUniform1iARB(shaderProgram->u_CurrentMap, 0);
|
||
|
|
glUseProgramObjectARB(0);
|
||
|
|
|
||
|
|
ValidateProgram(shaderProgram->program);
|
||
|
|
//ShowProgramUniforms(shaderProgram->program);
|
||
|
|
GL_CheckErrors();
|
||
|
|
|
||
|
|
numCompiled++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SelectProgram();
|
||
|
|
|
||
|
|
int endTime = ri.Milliseconds();
|
||
|
|
ri.Printf(PRINT_ALL, "...compiled %i debugShadowMap shader permutations in %5.2f seconds\n", numCompiled, (endTime - startTime) / 1000.0);
|
||
|
|
}
|