forked from a1batross/Paranoia2_original
1359 lines
40 KiB
C++
1359 lines
40 KiB
C++
/*
|
|
gl_shader.cpp - glsl shaders
|
|
Copyright (C) 2014 Uncle Mike
|
|
|
|
This program 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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.
|
|
*/
|
|
|
|
#include "hud.h"
|
|
#include "cl_util.h"
|
|
#include "const.h"
|
|
#include "ref_params.h"
|
|
#include "gl_local.h"
|
|
#include <mathlib.h>
|
|
#include <stringlib.h>
|
|
#include "gl_shader.h"
|
|
#include "virtualfs.h"
|
|
#include "gl_world.h"
|
|
#include "gl_decals.h"
|
|
#include "studio.h"
|
|
#include "gl_grass.h"
|
|
|
|
//#define _DEBUG_UNIFORMS
|
|
#define SHADERS_HASH_SIZE (MAX_GLSL_PROGRAMS >> 2)
|
|
#define MAX_FILE_STACK 64
|
|
|
|
static char filenames_stack[MAX_FILE_STACK][256];
|
|
glsl_program_t glsl_programs[MAX_GLSL_PROGRAMS];
|
|
glsl_program_t *glsl_programsHashTable[SHADERS_HASH_SIZE];
|
|
int num_glsl_programs;
|
|
static int file_stack_pos;
|
|
static bool cache_needs_update = false;
|
|
|
|
typedef struct
|
|
{
|
|
const char *name;
|
|
uniformType_t type;
|
|
int flags; // hints
|
|
} uniformTable_t;
|
|
|
|
glsl_program_t *shader_t :: GetShader( void )
|
|
{
|
|
return &glsl_programs[shadernum];
|
|
}
|
|
|
|
void shader_t :: SetShader( unsigned short hand )
|
|
{
|
|
sequence = tr.glsl_valid_sequence;
|
|
shadernum = hand;
|
|
}
|
|
|
|
bool shader_t :: IsValid( void )
|
|
{
|
|
return (shadernum > 0) && (sequence == tr.glsl_valid_sequence);
|
|
}
|
|
|
|
int uniform_t :: GetSizeInBytes( void )
|
|
{
|
|
switch( format )
|
|
{
|
|
case GL_SAMPLER_1D_ARB:
|
|
case GL_SAMPLER_2D_ARB:
|
|
case GL_SAMPLER_3D_ARB:
|
|
case GL_SAMPLER_CUBE_ARB:
|
|
case GL_SAMPLER_1D_SHADOW_ARB:
|
|
case GL_SAMPLER_2D_SHADOW_ARB:
|
|
case GL_SAMPLER_2D_RECT_ARB:
|
|
case GL_SAMPLER_2D_RECT_SHADOW_ARB:
|
|
case GL_SAMPLER_CUBE_SHADOW_EXT:
|
|
return 4;
|
|
case GL_FLOAT:
|
|
case GL_INT:
|
|
case GL_UNSIGNED_INT:
|
|
return 4;
|
|
case GL_FLOAT_VEC2_ARB:
|
|
case GL_INT_VEC2_ARB:
|
|
return 8;
|
|
case GL_FLOAT_VEC3_ARB:
|
|
case GL_INT_VEC3_ARB:
|
|
return 12;
|
|
case GL_FLOAT_VEC4_ARB:
|
|
case GL_INT_VEC4_ARB:
|
|
return 16;
|
|
case GL_FLOAT_MAT2_ARB:
|
|
return 16;
|
|
case GL_FLOAT_MAT3_ARB:
|
|
return 36;
|
|
case GL_FLOAT_MAT4_ARB:
|
|
return 64;
|
|
}
|
|
|
|
ALERT( at_error, "uniform %s has unspecified size\n", name );
|
|
return 0; // assume error
|
|
}
|
|
|
|
void uniform_t :: SetValue( const void *pdata, int count )
|
|
{
|
|
unicache_t *check = (unicache_t *)pdata;
|
|
|
|
// set texture unit
|
|
if( FBitSet( flags, UFL_TEXTURE_UNIT ) && unit >= 0 )
|
|
{
|
|
GL_BindTexture( unit, check->iValue[0] );
|
|
}
|
|
else if( size > 1 )
|
|
{
|
|
// handle arrays
|
|
if( count == -1 )
|
|
count = size;
|
|
|
|
switch( format )
|
|
{
|
|
case GL_FLOAT:
|
|
pglUniform1fvARB( location, count, (const float *)pdata );
|
|
break;
|
|
case GL_FLOAT_VEC2_ARB:
|
|
pglUniform2fvARB( location, count, (const float *)pdata );
|
|
break;
|
|
case GL_FLOAT_VEC3_ARB:
|
|
pglUniform3fvARB( location, count, (const float *)pdata );
|
|
break;
|
|
case GL_FLOAT_VEC4_ARB:
|
|
pglUniform4fvARB( location, count, (const float *)pdata );
|
|
break;
|
|
case GL_FLOAT_MAT2_ARB:
|
|
pglUniformMatrix2fvARB( location, count, GL_FALSE, (const float *)pdata );
|
|
break;
|
|
case GL_FLOAT_MAT3_ARB:
|
|
pglUniformMatrix3fvARB( location, count, GL_FALSE, (const float *)pdata );
|
|
break;
|
|
case GL_FLOAT_MAT4_ARB:
|
|
pglUniformMatrix4fvARB( location, count, GL_FALSE, (const float *)pdata );
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int testSize = GetSizeInBytes();
|
|
|
|
// some values could be cached
|
|
if( testSize <= 16 && !memcmp( &cache, check, testSize ))
|
|
return;
|
|
|
|
// single cached values
|
|
switch( format )
|
|
{
|
|
case GL_FLOAT:
|
|
pglUniform1fARB( location, check->fValue[0] );
|
|
cache.fValue[0] = check->fValue[0];
|
|
break;
|
|
case GL_FLOAT_VEC2_ARB:
|
|
pglUniform2fARB( location, check->fValue[0], check->fValue[1] );
|
|
cache.fValue[0] = check->fValue[0];
|
|
cache.fValue[1] = check->fValue[1];
|
|
break;
|
|
case GL_FLOAT_VEC3_ARB:
|
|
pglUniform3fARB( location, check->fValue[0], check->fValue[1], check->fValue[2] );
|
|
cache.fValue[0] = check->fValue[0];
|
|
cache.fValue[1] = check->fValue[1];
|
|
cache.fValue[2] = check->fValue[2];
|
|
break;
|
|
case GL_FLOAT_VEC4_ARB:
|
|
pglUniform4fARB( location, check->fValue[0], check->fValue[1], check->fValue[2], check->fValue[3] );
|
|
cache.fValue[0] = check->fValue[0];
|
|
cache.fValue[1] = check->fValue[1];
|
|
cache.fValue[2] = check->fValue[2];
|
|
cache.fValue[3] = check->fValue[3];
|
|
break;
|
|
case GL_INT:
|
|
pglUniform1iARB( location, check->iValue[0] );
|
|
cache.iValue[0] = check->iValue[0];
|
|
break;
|
|
case GL_INT_VEC2_ARB:
|
|
pglUniform2iARB( location, check->iValue[0], check->iValue[1] );
|
|
cache.iValue[0] = check->iValue[0];
|
|
cache.iValue[1] = check->iValue[1];
|
|
break;
|
|
case GL_INT_VEC3_ARB:
|
|
pglUniform3iARB( location, check->iValue[0], check->iValue[1], check->iValue[2] );
|
|
cache.iValue[0] = check->iValue[0];
|
|
cache.iValue[1] = check->iValue[1];
|
|
cache.iValue[2] = check->iValue[2];
|
|
break;
|
|
case GL_INT_VEC4_ARB:
|
|
pglUniform4iARB( location, check->iValue[0], check->iValue[1], check->iValue[2], check->iValue[3] );
|
|
cache.iValue[0] = check->iValue[0];
|
|
cache.iValue[1] = check->iValue[1];
|
|
cache.iValue[2] = check->iValue[2];
|
|
cache.iValue[3] = check->iValue[3];
|
|
break;
|
|
case GL_FLOAT_MAT2_ARB:
|
|
pglUniformMatrix2fvARB( location, 1, GL_FALSE, (const float *)pdata );
|
|
cache.fValue[0] = check->fValue[0];
|
|
cache.fValue[1] = check->fValue[1];
|
|
cache.fValue[2] = check->fValue[2];
|
|
cache.fValue[3] = check->fValue[3];
|
|
break;
|
|
case GL_FLOAT_MAT3_ARB:
|
|
pglUniformMatrix3fvARB( location, 1, GL_FALSE, (const float *)pdata );
|
|
break;
|
|
case GL_FLOAT_MAT4_ARB:
|
|
pglUniformMatrix4fvARB( location, 1, GL_FALSE, (const float *)pdata );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// all known engine uniforms
|
|
static uniformTable_t glsl_uniformTable[] =
|
|
{
|
|
{ "u_ColorMap", UT_COLORMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_DepthMap", UT_DEPTHMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_NormalMap", UT_NORMALMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_GlossMap", UT_GLOSSMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_DetailMap", UT_DETAILMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_ProjectMap", UT_PROJECTMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_ShadowMap0", UT_SHADOWMAP0, UFL_TEXTURE_UNIT },
|
|
{ "u_ShadowMap1", UT_SHADOWMAP1, UFL_TEXTURE_UNIT },
|
|
{ "u_ShadowMap2", UT_SHADOWMAP2, UFL_TEXTURE_UNIT },
|
|
{ "u_ShadowMap3", UT_SHADOWMAP3, UFL_TEXTURE_UNIT },
|
|
{ "u_ShadowMap", UT_SHADOWMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_LightMap", UT_LIGHTMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_DeluxeMap", UT_DELUXEMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_DecalMap", UT_DECALMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_ScreenMap", UT_SCREENMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_VisLightMap0", UT_VISLIGHTMAP0, UFL_TEXTURE_UNIT },
|
|
{ "u_VisLightMap1", UT_VISLIGHTMAP1, UFL_TEXTURE_UNIT },
|
|
{ "u_EnvMap0", UT_ENVMAP0, UFL_TEXTURE_UNIT },
|
|
{ "u_EnvMap1", UT_ENVMAP1, UFL_TEXTURE_UNIT },
|
|
{ "u_EnvMap", UT_ENVMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_GlowMap", UT_GLOWMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_HeightMap", UT_HEIGHTMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_LayerMap", UT_LAYERMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_FragData0", UT_FRAGDATA0, UFL_TEXTURE_UNIT },
|
|
{ "u_FragData1", UT_FRAGDATA1, UFL_TEXTURE_UNIT },
|
|
{ "u_FragData2", UT_FRAGDATA2, UFL_TEXTURE_UNIT },
|
|
{ "u_BspPlanesMap", UT_BSPPLANESMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_BspModelsMap", UT_BSPMODELSMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_BspNodesMap", UT_BSPNODESMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_BspLightsMap", UT_BSPLIGHTSMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_FitNormalMap", UT_FITNORMALMAP, UFL_TEXTURE_UNIT },
|
|
{ "u_ModelMatrix", UT_MODELMATRIX, 0 },
|
|
{ "u_ReflectMatrix", UT_REFLECTMATRIX, 0 },
|
|
{ "u_BonesArray", UT_BONESARRAY, 0 },
|
|
{ "u_BoneQuaternion", UT_BONEQUATERNION, 0 },
|
|
{ "u_BonePosition", UT_BONEPOSITION, 0 },
|
|
{ "u_ScreenSizeInv", UT_SCREENSIZEINV, UFL_GLOBAL_PARM },
|
|
{ "u_zFar", UT_ZFAR, UFL_GLOBAL_PARM },
|
|
{ "u_LightStyleValues", UT_LIGHTSTYLEVALUES, UFL_GLOBAL_PARM },
|
|
{ "u_LightStyles", UT_LIGHTSTYLES, 0 },
|
|
{ "u_RealTime", UT_REALTIME, UFL_GLOBAL_PARM },
|
|
{ "u_DetailScale", UT_DETAILSCALE, 0 },
|
|
{ "u_FogParams", UT_FOGPARAMS, UFL_GLOBAL_PARM },
|
|
{ "u_ShadowParams", UT_SHADOWPARMS, 0 },
|
|
{ "u_TexOffset", UT_TEXOFFSET, 0 },
|
|
{ "u_ViewOrigin", UT_VIEWORIGIN, 0 }, // not in a global because it's transformed into modelspace
|
|
{ "u_ViewRight", UT_VIEWRIGHT, 0 },
|
|
{ "u_RenderColor", UT_RENDERCOLOR, 0 },
|
|
{ "u_RenderAlpha", UT_RENDERALPHA, 0 },
|
|
{ "u_Smoothness", UT_SMOOTHNESS, 0 },
|
|
{ "u_ShadowMatrix", UT_SHADOWMATRIX, 0 },
|
|
{ "u_ShadowSplitDist", UT_SHADOWSPLITDIST, UFL_GLOBAL_PARM },
|
|
{ "u_TexelSize", UT_TEXELSIZE, UFL_GLOBAL_PARM },
|
|
{ "u_GammaTable", UT_GAMMATABLE, UFL_GLOBAL_PARM },
|
|
{ "u_LightDir", UT_LIGHTDIR, 0 },
|
|
{ "u_LightDiffuse", UT_LIGHTDIFFUSE, 0 },
|
|
{ "u_LightShade", UT_LIGHTSHADE, 0 },
|
|
{ "u_LightOrigin", UT_LIGHTORIGIN, 0 },
|
|
{ "u_LightViewProjMatrix", UT_LIGHTVIEWPROJMATRIX, 0 },
|
|
{ "u_DiffuseFactor", UT_DIFFUSEFACTOR, UFL_GLOBAL_PARM },
|
|
{ "u_AmbientFactor", UT_AMBIENTFACTOR, UFL_GLOBAL_PARM },
|
|
{ "u_AmbientCube", UT_AMBIENTCUBE, 0 },
|
|
{ "u_SunRefract", UT_SUNREFRACT, UFL_GLOBAL_PARM },
|
|
{ "u_LerpFactor", UT_LERPFACTOR, 0 },
|
|
{ "u_RefractScale", UT_REFRACTSCALE, 0 },
|
|
{ "u_ReflectScale", UT_REFLECTSCALE, 0 },
|
|
{ "u_AberrationScale", UT_ABERRATIONSCALE, 0 },
|
|
{ "u_BoxMins", UT_BOXMINS, 0 },
|
|
{ "u_BoxMaxs", UT_BOXMAXS, 0 },
|
|
{ "u_CubeOrigin", UT_CUBEORIGIN, 0 },
|
|
{ "u_CubeMipCount", UT_CUBEMIPCOUNT, 0 },
|
|
{ "u_LightNums0", UT_LIGHTNUMS0, 0 },
|
|
{ "u_LightNums1", UT_LIGHTNUMS1, 0 },
|
|
{ "u_GrassParams", UT_GRASSPARAMS, 0 },
|
|
{ "u_ReliefParams", UT_RELIEFPARAMS, 0 },
|
|
{ "u_BlurFactor", UT_BLURFACTOR, 0 },
|
|
{ "u_ScreenWidth", UT_SCREENWIDTH, 0 },
|
|
{ "u_ScreenHeight", UT_SCREENHEIGHT, 0 },
|
|
{ "u_FocalDepth", UT_FOCALDEPTH, 0 },
|
|
{ "u_FocalLength", UT_FOCALLENGTH, 0 },
|
|
{ "u_DofDebug", UT_DOFDEBUG, 0 },
|
|
{ "u_FStop", UT_FSTOP, 0 },
|
|
{ "u_GrayScale", UT_GRAYSCALE, 0 },
|
|
{ "u_LightGamma", UT_LIGHTGAMMA, UFL_GLOBAL_PARM },
|
|
{ "u_LightScale", UT_LIGHTSCALE, UFL_GLOBAL_PARM },
|
|
{ "u_LightThreshold", UT_LIGHTTHRESHOLD, UFL_GLOBAL_PARM },
|
|
{ "u_NumVisibleModels", UT_NUMVISIBLEMODELS, UFL_GLOBAL_PARM },
|
|
{ "u_Undefined", UT_UNDEFINED, 0 },
|
|
};
|
|
|
|
static char *GL_PrintInfoLog( GLhandleARB object )
|
|
{
|
|
static char msg[32768];
|
|
int maxLength = 0;
|
|
|
|
pglGetObjectParameterivARB( object, GL_OBJECT_INFO_LOG_LENGTH_ARB, &maxLength );
|
|
|
|
if( maxLength >= sizeof( msg ))
|
|
{
|
|
ALERT( at_warning, "GL_PrintInfoLog: message exceeds %i symbols\n", sizeof( msg ));
|
|
maxLength = sizeof( msg ) - 1;
|
|
}
|
|
|
|
pglGetInfoLogARB( object, maxLength, &maxLength, msg );
|
|
|
|
return msg;
|
|
}
|
|
|
|
static char *GL_PrintShaderSource( GLhandleARB object )
|
|
{
|
|
static char msg[8192];
|
|
int maxLength = 0;
|
|
|
|
pglGetObjectParameterivARB( object, GL_OBJECT_SHADER_SOURCE_LENGTH_ARB, &maxLength );
|
|
|
|
if( maxLength >= sizeof( msg ))
|
|
{
|
|
ALERT( at_warning, "GL_PrintShaderSource: message exceeds %i symbols\n", sizeof( msg ));
|
|
maxLength = sizeof( msg ) - 1;
|
|
}
|
|
|
|
pglGetShaderSourceARB( object, maxLength, &maxLength, msg );
|
|
|
|
return msg;
|
|
}
|
|
|
|
static bool GL_PushFileStack( const char *filename )
|
|
{
|
|
if( file_stack_pos < MAX_FILE_STACK )
|
|
{
|
|
Q_strncpy( filenames_stack[file_stack_pos], filename, sizeof( filenames_stack[0] ));
|
|
file_stack_pos++;
|
|
return true;
|
|
}
|
|
|
|
ALERT( at_error, "GL_PushFileStack: stack overflow\n" );
|
|
return false;
|
|
}
|
|
|
|
static bool GL_PopFileStack( void )
|
|
{
|
|
file_stack_pos--;
|
|
|
|
if( file_stack_pos < 0 )
|
|
{
|
|
ALERT( at_error, "GL_PushFileStack: stack underflow\n" );
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool GL_CheckFileStack( const char *filename )
|
|
{
|
|
for( int i = 0; i < file_stack_pos; i++ )
|
|
{
|
|
if( !Q_stricmp( filenames_stack[i], filename ))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool GL_TestSource( const char *szFilename, const char *szCacheName, CVirtualFS *file )
|
|
{
|
|
int iCompare;
|
|
|
|
if( GL_CheckFileStack( szFilename ))
|
|
return false;
|
|
|
|
// check vertex shader source or include-file
|
|
if( COMPARE_FILE_TIME( szFilename, szCacheName, &iCompare ))
|
|
{
|
|
// glsl file is newer.
|
|
if( iCompare > 0 )
|
|
{
|
|
Msg( "%s was changed, %s will be updated\n", szFilename, szCacheName );
|
|
cache_needs_update = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Msg( "%s will be created\n", szCacheName );
|
|
cache_needs_update = true;
|
|
}
|
|
|
|
int size;
|
|
char *source = (char *)gEngfuncs.COM_LoadFile((char *)szFilename, 5, &size );
|
|
if( !source ) return false;
|
|
|
|
GL_PushFileStack( szFilename );
|
|
file->Write( source, size );
|
|
file->Seek( 0, SEEK_SET ); // rewind
|
|
|
|
gEngfuncs.COM_FreeFile( source );
|
|
|
|
return true;
|
|
}
|
|
|
|
static void GL_TestFile( const char *szFilename, const char *szCacheName, CVirtualFS *file )
|
|
{
|
|
char *pfile, token[256];
|
|
char line[2048];
|
|
int ret;
|
|
|
|
do
|
|
{
|
|
ret = file->Gets( line, sizeof( line ));
|
|
pfile = line;
|
|
|
|
// NOTE: if first keyword it's not an '#include' just ignore it
|
|
pfile = COM_ParseFile( pfile, token );
|
|
if( !Q_strcmp( token, "#include" ))
|
|
{
|
|
CVirtualFS incfile;
|
|
char incname[256];
|
|
|
|
pfile = COM_ParseLine( pfile, token );
|
|
Q_snprintf( incname, sizeof( incname ), "glsl/%s", token );
|
|
if( !GL_TestSource( incname, szCacheName, &incfile ))
|
|
continue;
|
|
|
|
if( cache_needs_update )
|
|
break; // no reason to seek more
|
|
GL_TestFile( incname, szCacheName, &incfile );
|
|
}
|
|
} while( ret != EOF );
|
|
|
|
GL_PopFileStack();
|
|
}
|
|
|
|
static bool GL_TestShader( const char *szFilename, const char *szCacheName )
|
|
{
|
|
CVirtualFS file;
|
|
|
|
cache_needs_update = false;
|
|
file_stack_pos = 0;
|
|
|
|
if( !GL_TestSource( szFilename, szCacheName, &file ))
|
|
return false;
|
|
GL_TestFile( szFilename, szCacheName, &file );
|
|
|
|
return cache_needs_update;
|
|
}
|
|
|
|
static bool GL_LoadSource( const char *filename, CVirtualFS *file )
|
|
{
|
|
if( GL_CheckFileStack( filename ))
|
|
{
|
|
ALERT( at_error, "recursive include for %s\n", filename );
|
|
return false;
|
|
}
|
|
|
|
int size;
|
|
char *source = (char *)gEngfuncs.COM_LoadFile((char *)filename, 5, &size );
|
|
if( !source )
|
|
{
|
|
ALERT( at_error, "couldn't load %s\n", filename );
|
|
return false;
|
|
}
|
|
|
|
GL_PushFileStack( filename );
|
|
file->Write( source, size );
|
|
file->Seek( 0, SEEK_SET ); // rewind
|
|
|
|
gEngfuncs.COM_FreeFile( source );
|
|
|
|
return true;
|
|
}
|
|
|
|
static void GL_ParseFile( const char *filename, CVirtualFS *file, CVirtualFS *out )
|
|
{
|
|
char *pfile, token[256];
|
|
int ret, fileline = 1;
|
|
char line[2048];
|
|
|
|
// out->Printf( "#file %s\n", filename ); // OpenGL doesn't support #file :-(
|
|
out->Printf( "#line 0\n" );
|
|
|
|
do
|
|
{
|
|
ret = file->Gets( line, sizeof( line ));
|
|
pfile = line;
|
|
|
|
// NOTE: if first keyword it's not an '#include' just ignore it
|
|
pfile = COM_ParseFile( pfile, token );
|
|
if( !Q_strcmp( token, "#include" ))
|
|
{
|
|
CVirtualFS incfile;
|
|
char incname[256];
|
|
|
|
pfile = COM_ParseLine( pfile, token );
|
|
Q_snprintf( incname, sizeof( incname ), "glsl/%s", token );
|
|
if( !GL_LoadSource( incname, &incfile ))
|
|
{
|
|
fileline++;
|
|
continue;
|
|
}
|
|
GL_ParseFile( incname, &incfile, out );
|
|
// out->Printf( "#file %s\n", filename ); // OpenGL doesn't support #file :-(
|
|
out->Printf( "#line %i\n", fileline );
|
|
}
|
|
else out->Printf( "%s\n", line );
|
|
fileline++;
|
|
} while( ret != EOF );
|
|
|
|
GL_PopFileStack();
|
|
}
|
|
|
|
static bool GL_ProcessShader( const char *filename, CVirtualFS *out, const char *defines = NULL )
|
|
{
|
|
CVirtualFS file;
|
|
|
|
file_stack_pos = 0;
|
|
|
|
if( !GL_LoadSource( filename, &file ))
|
|
return false;
|
|
|
|
// add internal defines
|
|
out->Printf( "#version 120\n" ); // OpenGL 2.1 required (because 'flat' modifier support only starts from this version)
|
|
out->Printf( "#ifndef M_PI\n#define M_PI 3.14159265358979323846\n#endif\n" );
|
|
out->Printf( "#ifndef M_PI2\n#define M_PI2 6.28318530717958647692\n#endif\n" );
|
|
if( GL_Support( R_EXT_GPU_SHADER4 ))
|
|
{
|
|
out->Printf( "#extension GL_EXT_gpu_shader4 : require\n" ); // support bitwise ops
|
|
out->Printf( "#define GLSL_gpu_shader4\n" );
|
|
if( GL_Support( R_TEXTURE_ARRAY_EXT ))
|
|
out->Printf( "#define GLSL_ALLOW_TEXTURE_ARRAY\n" );
|
|
}
|
|
else if( GL_Support( R_TEXTURE_ARRAY_EXT ))
|
|
{
|
|
out->Printf( "#extension GL_EXT_texture_array : require\n" ); // support texture arrays
|
|
out->Printf( "#define GLSL_ALLOW_TEXTURE_ARRAY\n" );
|
|
}
|
|
|
|
if( GL_Support( R_TEXTURE_2D_RECT_EXT ))
|
|
{
|
|
out->Printf( "#extension GL_ARB_texture_rectangle : enable\n" ); // support texture rectangle
|
|
}
|
|
|
|
if( defines ) out->Print( defines );
|
|
|
|
// user may override this constants
|
|
out->Printf( "#ifndef MAXSTUDIOBONES\n#define MAXSTUDIOBONES %i\n#endif\n", glConfig.max_skinning_bones );
|
|
out->Printf( "#ifndef MAX_SHADOWMAPS\n#define MAX_SHADOWMAPS %i\n#endif\n", MAX_SHADOWMAPS );
|
|
out->Printf( "#ifndef NUM_SHADOW_SPLITS\n#define NUM_SHADOW_SPLITS %i\n#endif\n", NUM_SHADOW_SPLITS );
|
|
out->Printf( "#ifndef LIGHT_SAMPLES\n#define LIGHT_SAMPLES %i\n#endif\n", LIGHT_SAMPLES );
|
|
out->Printf( "#ifndef MAX_LIGHTSTYLES\n#define MAX_LIGHTSTYLES %i\n#endif\n", MAX_LIGHTSTYLES );
|
|
out->Printf( "#ifndef MAXLIGHTMAPS\n#define MAXLIGHTMAPS %i\n#endif\n", MAXLIGHTMAPS );
|
|
out->Printf( "#ifndef MAXDYNLIGHTS\n#define MAXDYNLIGHTS %i\n#endif\n", (int)cv_deferred_maxlights->value );
|
|
out->Printf( "#ifndef GRASS_ANIM_DIST\n#define GRASS_ANIM_DIST %f\n#endif\n", GRASS_ANIM_DIST );
|
|
|
|
GL_ParseFile( filename, &file, out );
|
|
out->Write( "", 1 ); // terminator
|
|
|
|
return true;
|
|
}
|
|
|
|
static void GL_LoadGPUShader( glsl_program_t *shader, const char *name, GLenum shaderType, const char *defines = NULL )
|
|
{
|
|
char filename[256];
|
|
GLhandleARB object;
|
|
CVirtualFS source;
|
|
GLint compiled;
|
|
|
|
ASSERT( shader != NULL );
|
|
|
|
switch( shaderType )
|
|
{
|
|
case GL_VERTEX_SHADER_ARB:
|
|
Q_snprintf( filename, sizeof( filename ), "glsl/%s_vp.glsl", name );
|
|
break;
|
|
case GL_FRAGMENT_SHADER_ARB:
|
|
Q_snprintf( filename, sizeof( filename ), "glsl/%s_fp.glsl", name );
|
|
break;
|
|
default:
|
|
ALERT( at_error, "GL_LoadGPUShader: unknown shader type %p\n", shaderType );
|
|
return;
|
|
}
|
|
|
|
// load includes, add some directives
|
|
if( !GL_ProcessShader( filename, &source, defines ))
|
|
return;
|
|
|
|
GLcharARB *buffer = (GLcharARB *)source.GetBuffer();
|
|
int bufferSize = source.GetSize();
|
|
|
|
ALERT( at_aiconsole, "loading '%s'\n", filename );
|
|
object = pglCreateShaderObjectARB( shaderType );
|
|
pglShaderSourceARB( object, GL_TRUE, (const GLcharARB **)&buffer, &bufferSize );
|
|
|
|
// compile shader
|
|
pglCompileShaderARB( object );
|
|
|
|
// check if shader compiled
|
|
pglGetObjectParameterivARB( object, GL_OBJECT_COMPILE_STATUS_ARB, &compiled );
|
|
|
|
if( !compiled )
|
|
{
|
|
if( developer_level ) Msg( "%s", GL_PrintInfoLog( object ));
|
|
if( developer_level ) Msg( "Shader options:%s\n", GL_PretifyListOptions( defines ));
|
|
ALERT( at_error, "Couldn't compile %s\n", filename );
|
|
return;
|
|
}
|
|
|
|
if( shaderType == GL_VERTEX_SHADER_ARB )
|
|
shader->status |= SHADER_VERTEX_COMPILED;
|
|
else shader->status |= SHADER_FRAGMENT_COMPILED;
|
|
|
|
// attach shader to program
|
|
pglAttachObjectARB( shader->handle, object );
|
|
|
|
// delete shader, no longer needed
|
|
pglDeleteObjectARB( object );
|
|
}
|
|
|
|
static bool GL_LoadGPUBinaryShader( glsl_program_t *shader, const char *vpname, const char *fpname, uint checksum )
|
|
{
|
|
char szFilename[MAX_PATH];
|
|
char szVpSource[MAX_PATH];
|
|
char szFpSource[MAX_PATH];
|
|
GLint linked = 0;
|
|
int length;
|
|
|
|
if( !GL_Support( R_BINARY_SHADER_EXT ))
|
|
return false;
|
|
|
|
Q_snprintf( szFilename, sizeof( szFilename ), "cache/glsl/%p.bin", checksum );
|
|
Q_snprintf( szVpSource, sizeof( szVpSource ), "glsl/%s_vp.glsl", vpname );
|
|
Q_snprintf( szFpSource, sizeof( szFpSource ), "glsl/%s_fp.glsl", fpname );
|
|
|
|
// check vertex shader source
|
|
if( GL_TestShader( szVpSource, szFilename ))
|
|
return false;
|
|
|
|
// check fragment shader source
|
|
if( GL_TestShader( szFpSource, szFilename ))
|
|
return false;
|
|
|
|
byte *aMemFile = LOAD_FILE( szFilename, &length );
|
|
if( !aMemFile ) return false;
|
|
|
|
pglProgramBinary( shader->handle, glConfig.binary_formats, aMemFile, length );
|
|
pglGetObjectParameterivARB( shader->handle, GL_OBJECT_LINK_STATUS_ARB, &linked );
|
|
SetBits( shader->status, SHADER_FRAGMENT_COMPILED|SHADER_VERTEX_COMPILED );
|
|
FREE_FILE( aMemFile );
|
|
|
|
if( linked )
|
|
{
|
|
ALERT( at_aiconsole, "loading %s\n", szFilename );
|
|
SetBits( shader->status, SHADER_PROGRAM_LINKED );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool GL_SaveGPUBinaryShader( glsl_program_t *shader, uint checksum )
|
|
{
|
|
char szFilename[MAX_PATH];
|
|
int length, result;
|
|
GLenum outFormat;
|
|
byte *binary;
|
|
|
|
if( !GL_Support( R_BINARY_SHADER_EXT ))
|
|
return false;
|
|
|
|
Q_snprintf( szFilename, sizeof( szFilename ), "cache/glsl/%p.bin", checksum );
|
|
pglGetObjectParameterivARB( shader->handle, GL_PROGRAM_BINARY_LENGTH, &length );
|
|
if( length <= 0 ) return false;
|
|
|
|
binary = (byte *)malloc( length );
|
|
pglGetProgramBinary( shader->handle, length, &length, &outFormat, binary );
|
|
|
|
result = SAVE_FILE( szFilename, binary, length );
|
|
ALERT( at_aiconsole, "write glsl cache: %s\n", szFilename );
|
|
free( binary );
|
|
|
|
return (result != 0 );
|
|
}
|
|
|
|
static void GL_LinkProgram( glsl_program_t *shader )
|
|
{
|
|
GLint linked = 0;
|
|
|
|
if( !shader ) return;
|
|
|
|
if( GL_Support( R_BINARY_SHADER_EXT ))
|
|
pglProgramParameteri( shader->handle, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE );
|
|
|
|
pglLinkProgramARB( shader->handle );
|
|
|
|
pglGetObjectParameterivARB( shader->handle, GL_OBJECT_LINK_STATUS_ARB, &linked );
|
|
if( !linked )
|
|
{
|
|
ALERT( at_error, "%s\n%s shader failed to link\n", GL_PrintInfoLog( shader->handle ), shader->name );
|
|
if( developer_level ) Msg( "Shader options:%s\n", GL_PretifyListOptions( shader->options ));
|
|
}
|
|
else shader->status |= SHADER_PROGRAM_LINKED;
|
|
}
|
|
|
|
static void GL_ValidateProgram( glsl_program_t *shader )
|
|
{
|
|
GLint validated = 0;
|
|
|
|
if( !shader ) return;
|
|
|
|
pglValidateProgramARB( shader->handle );
|
|
|
|
pglGetObjectParameterivARB( shader->handle, GL_OBJECT_VALIDATE_STATUS_ARB, &validated );
|
|
if( !validated ) ALERT( at_error, "%s\n%s shader failed to validate\n", GL_PrintInfoLog( shader->handle ), shader->name );
|
|
}
|
|
|
|
int GL_UniformTypeToDwordCount( GLuint type, bool align = false )
|
|
{
|
|
switch( type )
|
|
{
|
|
case GL_INT:
|
|
case GL_UNSIGNED_INT:
|
|
case GL_SAMPLER_1D_ARB:
|
|
case GL_SAMPLER_2D_ARB:
|
|
case GL_SAMPLER_3D_ARB:
|
|
case GL_SAMPLER_CUBE_ARB:
|
|
case GL_SAMPLER_1D_SHADOW_ARB:
|
|
case GL_SAMPLER_2D_SHADOW_ARB:
|
|
case GL_SAMPLER_2D_RECT_ARB:
|
|
case GL_SAMPLER_2D_RECT_SHADOW_ARB:
|
|
case GL_SAMPLER_CUBE_SHADOW_EXT:
|
|
return align ? 4 : 1; // int[1]
|
|
case GL_FLOAT:
|
|
return align ? 4 : 1; // float[1]
|
|
case GL_FLOAT_VEC2_ARB:
|
|
return align ? 4 : 2; // float[2]
|
|
case GL_FLOAT_VEC3_ARB:
|
|
return align ? 4 : 3; // float[3]
|
|
case GL_FLOAT_VEC4_ARB:
|
|
return 4; // float[4]
|
|
case GL_FLOAT_MAT2_ARB:
|
|
return 4; // float[2][2]
|
|
case GL_FLOAT_MAT3_ARB:
|
|
return align ? 12 : 9; // float[3][3]
|
|
case GL_FLOAT_MAT4_ARB:
|
|
return 16;// float[4][4]
|
|
default: return align ? 4 : 1; // assume error
|
|
}
|
|
}
|
|
|
|
const char *GL_UniformTypeToName( GLuint type )
|
|
{
|
|
switch( type )
|
|
{
|
|
case GL_INT:
|
|
return "int";
|
|
case GL_UNSIGNED_INT:
|
|
return "uint";
|
|
case GL_FLOAT:
|
|
return "float";
|
|
case GL_FLOAT_VEC2_ARB:
|
|
return "vec2";
|
|
case GL_FLOAT_VEC3_ARB:
|
|
return "vec3";
|
|
case GL_FLOAT_VEC4_ARB:
|
|
return "vec4";
|
|
case GL_FLOAT_MAT2_ARB:
|
|
return "mat2";
|
|
case GL_FLOAT_MAT3_ARB:
|
|
return "mat3";
|
|
case GL_FLOAT_MAT4_ARB:
|
|
return "mat4";
|
|
case GL_SAMPLER_1D_ARB:
|
|
return "sampler1D";
|
|
case GL_SAMPLER_2D_ARB:
|
|
return "sampler2D";
|
|
case GL_SAMPLER_3D_ARB:
|
|
return "sampler3D";
|
|
case GL_SAMPLER_CUBE_ARB:
|
|
return "samplerCube";
|
|
case GL_SAMPLER_1D_ARRAY_EXT:
|
|
return "sampler1DArray";
|
|
case GL_SAMPLER_2D_ARRAY_EXT:
|
|
return "sampler2DArray";
|
|
case GL_SAMPLER_1D_SHADOW_ARB:
|
|
return "sampler1DShadow";
|
|
case GL_SAMPLER_2D_SHADOW_ARB:
|
|
return "sampler2DShadow";
|
|
case GL_SAMPLER_2D_RECT_ARB:
|
|
return "sampler2DRect";
|
|
case GL_SAMPLER_2D_RECT_SHADOW_ARB:
|
|
return "sampler2DRectShadow";
|
|
case GL_SAMPLER_CUBE_SHADOW_EXT:
|
|
return "samplerCubeShadow";
|
|
default: return "???";
|
|
}
|
|
}
|
|
|
|
void GL_ShowProgramUniforms( glsl_program_t *shader )
|
|
{
|
|
int count, size;
|
|
char uniformName[256];
|
|
int total_uniforms_used = 0;
|
|
GLuint type;
|
|
|
|
if( !shader || developer_level < DEV_EXTENDED )
|
|
return;
|
|
|
|
// install the executables in the program object as part of current state.
|
|
pglUseProgramObjectARB( shader->handle );
|
|
|
|
// query the number of active uniforms
|
|
pglGetObjectParameterivARB( shader->handle, GL_OBJECT_ACTIVE_UNIFORMS_ARB, &count );
|
|
|
|
// Loop over each of the active uniforms, and set their value
|
|
for( int i = 0; i < count; i++ )
|
|
{
|
|
pglGetActiveUniformARB( shader->handle, i, sizeof( uniformName ), NULL, &size, &type, uniformName );
|
|
if( developer_level >= DEV_EXTENDED )
|
|
{
|
|
if( size != 1 )
|
|
{
|
|
char *end = Q_strchr( uniformName, '[' );
|
|
if( end ) *end = '\0'; // cutoff [0]
|
|
}
|
|
|
|
if( size == 1 ) ALERT( at_aiconsole, "uniform %s %s;\n", GL_UniformTypeToName( type ), uniformName );
|
|
else ALERT( at_aiconsole, "uniform %s %s[%i];\n", GL_UniformTypeToName( type ), uniformName, size );
|
|
}
|
|
total_uniforms_used += GL_UniformTypeToDwordCount( type ) * size;
|
|
}
|
|
|
|
if( total_uniforms_used >= glConfig.max_vertex_uniforms )
|
|
ALERT( at_error, "used uniforms %i is overflowed max count %i\n", total_uniforms_used, glConfig.max_vertex_uniforms );
|
|
else ALERT( at_aiconsole, "used uniforms %i from %i\n", total_uniforms_used, glConfig.max_vertex_uniforms );
|
|
|
|
int max_shader_uniforms = total_uniforms_used;
|
|
|
|
if( max_shader_uniforms > ( glConfig.max_skinning_bones * 12 ))
|
|
max_shader_uniforms -= ( glConfig.max_skinning_bones * 12 );
|
|
|
|
ALERT( at_aiconsole, "%s used %i uniforms\n", shader->name, max_shader_uniforms );
|
|
|
|
if( max_shader_uniforms > glConfig.peak_used_uniforms )
|
|
{
|
|
glConfig.peak_used_uniforms = max_shader_uniforms;
|
|
tr.show_uniforms_peak = true;
|
|
}
|
|
|
|
pglUseProgramObjectARB( GL_NONE );
|
|
}
|
|
|
|
static void GL_ParseProgramUniforms( glsl_program_t *shader )
|
|
{
|
|
int count, size;
|
|
char uniformName[256];
|
|
int total_uniforms_used = 0;
|
|
char cleanName[256];
|
|
int enumUnits = 0;
|
|
GLuint format;
|
|
|
|
// query the number of active uniforms
|
|
pglGetObjectParameterivARB( shader->handle, GL_OBJECT_ACTIVE_UNIFORMS_ARB, &count );
|
|
pglUseProgramObjectARB( shader->handle );
|
|
|
|
shader->uniforms = (uniform_t *)Mem_Alloc( count * sizeof( uniform_t ));
|
|
shader->numUniforms = 0;
|
|
#ifdef _DEBUG_UNIFORMS
|
|
Msg( "%c%s%s\n", 3, shader->name, GL_PretifyListOptions( shader->options ));
|
|
#endif
|
|
// Loop over each of the active uniforms, and set their value
|
|
for( int i = 0; i < count; i++ )
|
|
{
|
|
uniformTable_t *desc;
|
|
uniform_t *uniform;
|
|
int location;
|
|
|
|
pglGetActiveUniformARB( shader->handle, i, sizeof( uniformName ), NULL, &size, &format, uniformName );
|
|
|
|
if(( location = pglGetUniformLocationARB( shader->handle, uniformName )) == -1 )
|
|
continue; // ignore built-in uniforms
|
|
|
|
// remove array size from name
|
|
Q_strncpy( cleanName, uniformName, sizeof( cleanName ));
|
|
char *end = Q_strchr( cleanName, '[' );
|
|
if( end ) *end = '\0'; // cutoff [0]
|
|
|
|
// check for description
|
|
for( int j = 0; j < ARRAYSIZE( glsl_uniformTable ); j++ )
|
|
{
|
|
desc = &glsl_uniformTable[j];
|
|
if( !Q_strcmp( desc->name, cleanName ))
|
|
break;
|
|
}
|
|
|
|
if( desc->type == UT_UNDEFINED )
|
|
{
|
|
ALERT( at_error, "%cUnhandled uniform %s. Ignoring\n", 3, uniformName );
|
|
continue;
|
|
}
|
|
|
|
// fill next uniform
|
|
uniform = &shader->uniforms[shader->numUniforms++];
|
|
Q_strncpy( uniform->name, cleanName, sizeof( uniform->name ));
|
|
uniform->location = location;
|
|
uniform->flags = desc->flags;
|
|
uniform->type = desc->type;
|
|
uniform->format = format;
|
|
uniform->size = size;
|
|
|
|
if( FBitSet( uniform->flags, UFL_TEXTURE_UNIT ))
|
|
{
|
|
uniform->unit = enumUnits++;
|
|
pglUniform1iARB( uniform->location, uniform->unit );
|
|
}
|
|
else uniform->unit = -1; // not a texture
|
|
|
|
if( enumUnits >= glConfig.max_texture_units )
|
|
ALERT( at_warning, "%c%s [%d] exceeded GL_MAX_IMAGE_UNITS\n", 3, cleanName, enumUnits );
|
|
#ifdef _DEBUG_UNIFORMS
|
|
if( uniform->unit != -1 ) Msg( "%c%s %s : %d;\n", 3, GL_UniformTypeToName( format ), cleanName, uniform->unit );
|
|
else if( size == 1 ) Msg( "%cuniform %s %s;\n", 3, GL_UniformTypeToName( format ), cleanName );
|
|
else Msg( "%cuniform %s %s[%i];\n", 3, GL_UniformTypeToName( format ), cleanName, size );
|
|
#endif
|
|
total_uniforms_used += GL_UniformTypeToDwordCount( format ) * size;
|
|
}
|
|
|
|
if( total_uniforms_used >= glConfig.max_vertex_uniforms )
|
|
ALERT( at_error, "%cused uniforms %i is overflowed max count %i\n", 3, total_uniforms_used, glConfig.max_vertex_uniforms );
|
|
#ifdef _DEBUG_UNIFORMS
|
|
ALERT( at_aiconsole, "%c%s used %i uniforms\n", 3, shader->name, total_uniforms_used );
|
|
#endif
|
|
if( total_uniforms_used > glConfig.peak_used_uniforms )
|
|
{
|
|
glConfig.peak_used_uniforms = total_uniforms_used;
|
|
tr.show_uniforms_peak = true;
|
|
}
|
|
|
|
pglUseProgramObjectARB( GL_NONE );
|
|
}
|
|
|
|
static void GL_SetDefaultVertexAttribs( glsl_program_t *shader )
|
|
{
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_POSITION, "attr_Position" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_TEXCOORD0, "attr_TexCoord0" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_TEXCOORD1, "attr_TexCoord1" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_TEXCOORD2, "attr_TexCoord2" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_TANGENT, "attr_Tangent" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_BINORMAL, "attr_Binormal" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_NORMAL, "attr_Normal" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_BONE_INDEXES, "attr_BoneIndexes" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_BONE_WEIGHTS, "attr_BoneWeights" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_LIGHT_STYLES, "attr_LightStyles" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_LIGHT_COLOR, "attr_LightColor" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_LIGHT_VECS, "attr_LightVecs" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_LIGHT_NUMS0, "attr_LightNums0" );
|
|
pglBindAttribLocationARB( shader->handle, ATTR_INDEX_LIGHT_NUMS1, "attr_LightNums1" );
|
|
}
|
|
|
|
static void GL_ParseProgramVertexAttribs( glsl_program_t *shader )
|
|
{
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_Position" ) == ATTR_INDEX_POSITION )
|
|
SetBits( shader->attribs, FATTR_POSITION );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_TexCoord0" ) == ATTR_INDEX_TEXCOORD0 )
|
|
SetBits( shader->attribs, FATTR_TEXCOORD0 );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_TexCoord1" ) == ATTR_INDEX_TEXCOORD1 )
|
|
SetBits( shader->attribs, FATTR_TEXCOORD1 );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_TexCoord2" ) == ATTR_INDEX_TEXCOORD2 )
|
|
SetBits( shader->attribs, FATTR_TEXCOORD2 );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_Tangent" ) == ATTR_INDEX_TANGENT )
|
|
SetBits( shader->attribs, FATTR_TANGENT );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_Binormal" ) == ATTR_INDEX_BINORMAL )
|
|
SetBits( shader->attribs, FATTR_BINORMAL );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_Normal" ) == ATTR_INDEX_NORMAL )
|
|
SetBits( shader->attribs, FATTR_NORMAL );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_BoneIndexes" ) == ATTR_INDEX_BONE_INDEXES )
|
|
SetBits( shader->attribs, FATTR_BONE_INDEXES );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_BoneWeights" ) == ATTR_INDEX_BONE_WEIGHTS )
|
|
SetBits( shader->attribs, FATTR_BONE_WEIGHTS );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_LightStyles" ) == ATTR_INDEX_LIGHT_STYLES )
|
|
SetBits( shader->attribs, FATTR_LIGHT_STYLES );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_LightColor" ) == ATTR_INDEX_LIGHT_COLOR )
|
|
SetBits( shader->attribs, FATTR_LIGHT_COLOR );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_LightVecs" ) == ATTR_INDEX_LIGHT_VECS )
|
|
SetBits( shader->attribs, FATTR_LIGHT_VECS );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_LightNums0" ) == ATTR_INDEX_LIGHT_NUMS0 )
|
|
SetBits( shader->attribs, FATTR_LIGHT_NUMS0 );
|
|
if( pglGetAttribLocationARB( shader->handle, "attr_LightNums1" ) == ATTR_INDEX_LIGHT_NUMS1 )
|
|
SetBits( shader->attribs, FATTR_LIGHT_NUMS1 );
|
|
}
|
|
|
|
void GL_BindShader( glsl_program_t *shader )
|
|
{
|
|
if( !shader && RI->currentshader )
|
|
{
|
|
pglUseProgramObjectARB( GL_NONE );
|
|
RI->currentshader = NULL;
|
|
}
|
|
else if( shader != RI->currentshader && shader != NULL && shader->handle )
|
|
{
|
|
pglUseProgramObjectARB( shader->handle );
|
|
r_stats.num_shader_binds++;
|
|
RI->currentshader = shader;
|
|
}
|
|
}
|
|
|
|
static void GL_FreeGPUShader( glsl_program_t *shader )
|
|
{
|
|
if( shader && shader->handle )
|
|
{
|
|
uint hash;
|
|
glsl_program_t *cur;
|
|
glsl_program_t **prev;
|
|
const char *find;
|
|
|
|
find = va( "%s %s", shader->name, shader->options );
|
|
if( shader->uniforms != NULL )
|
|
{
|
|
Mem_Free( shader->uniforms );
|
|
shader->uniforms = NULL;
|
|
}
|
|
|
|
// remove from hash table
|
|
hash = COM_HashKey( find, SHADERS_HASH_SIZE );
|
|
prev = &glsl_programsHashTable[hash];
|
|
|
|
while( 1 )
|
|
{
|
|
cur = *prev;
|
|
if( !cur ) break;
|
|
|
|
if( cur == shader )
|
|
{
|
|
*prev = cur->nextHash;
|
|
break;
|
|
}
|
|
prev = &cur->nextHash;
|
|
}
|
|
|
|
pglDeleteObjectARB( shader->handle );
|
|
memset( shader, 0, sizeof( *shader ));
|
|
}
|
|
}
|
|
|
|
static glsl_program_t *GL_CreateUberShader( GLint slot, const char *glname, const char *vpname, const char *fpname, const char *options, uint checksum )
|
|
{
|
|
if( !GL_Support( R_SHADER_GLSL100_EXT ))
|
|
return NULL;
|
|
|
|
if( num_glsl_programs >= MAX_GLSL_PROGRAMS )
|
|
{
|
|
ALERT( at_error, "GL_CreateUberShader: GLSL shaders limit exceeded (%i max)\n", MAX_GLSL_PROGRAMS );
|
|
return NULL;
|
|
}
|
|
|
|
// alloc new shader
|
|
glsl_program_t *shader = &glsl_programs[slot];
|
|
|
|
shader->handle = pglCreateProgramObjectARB();
|
|
if( !shader->handle ) return NULL; // some bad happens
|
|
|
|
Q_strncpy( shader->name, glname, sizeof( shader->name ));
|
|
Q_strncpy( shader->options, options, sizeof( shader->options ));
|
|
|
|
if( !GL_LoadGPUBinaryShader( shader, vpname, fpname, checksum ))
|
|
{
|
|
if( vpname ) GL_LoadGPUShader( shader, vpname, GL_VERTEX_SHADER_ARB, options );
|
|
else SetBits( shader->status, SHADER_VERTEX_COMPILED );
|
|
if( fpname ) GL_LoadGPUShader( shader, fpname, GL_FRAGMENT_SHADER_ARB, options );
|
|
else SetBits( shader->status, SHADER_FRAGMENT_COMPILED );
|
|
|
|
if( vpname && FBitSet( shader->status, SHADER_VERTEX_COMPILED ))
|
|
GL_SetDefaultVertexAttribs( shader );
|
|
|
|
GL_LinkProgram( shader );
|
|
|
|
if( FBitSet( shader->status, SHADER_PROGRAM_LINKED ))
|
|
GL_SaveGPUBinaryShader( shader, checksum );
|
|
}
|
|
|
|
// dynamic ubershaders has the identically name of fragment and vertex program
|
|
if(( glname == vpname ) && ( glname == fpname ))
|
|
SetBits( shader->status, SHADER_UBERSHADER ); // it's UberShader!
|
|
|
|
if( FBitSet( shader->status, SHADER_PROGRAM_LINKED ))
|
|
{
|
|
// register shader uniforms
|
|
GL_ParseProgramVertexAttribs( shader );
|
|
GL_ParseProgramUniforms( shader );
|
|
GL_ValidateProgram( shader );
|
|
}
|
|
|
|
// rewind generated errors if shader compile was failed
|
|
// to avoid show them later e.g. on textures loading
|
|
while( pglGetError() != GL_NO_ERROR );
|
|
#ifdef _DEBUG_UNIFORMS
|
|
if( FBitSet( shader->status, SHADER_UBERSHADER ))
|
|
ALERT( at_aiconsole, "CompileUberShader #%i: %s\n%s\n", slot, glname, options );
|
|
else ALERT( at_aiconsole, "CompileShader #%i: %s\n%s\n", slot, glname, options );
|
|
#endif
|
|
if( slot == num_glsl_programs )
|
|
{
|
|
if( num_glsl_programs == MAX_GLSL_PROGRAMS )
|
|
{
|
|
ALERT( at_error, "GL_CreateUberShader: GLSL shaders limit exceeded (%i max)\n", MAX_GLSL_PROGRAMS );
|
|
GL_FreeGPUShader( shader );
|
|
return NULL;
|
|
}
|
|
num_glsl_programs++;
|
|
}
|
|
|
|
// all done, program is loaded
|
|
|
|
return shader;
|
|
}
|
|
|
|
word GL_FindUberShader( const char *glname, const char *options )
|
|
{
|
|
glsl_program_t *prog;
|
|
|
|
if( !GL_Support( R_SHADER_GLSL100_EXT ))
|
|
return 0;
|
|
|
|
ASSERT( glname != NULL );
|
|
|
|
const char *find = va( "%s %s", glname, options );
|
|
uint hash = COM_HashKey( find, SHADERS_HASH_SIZE );
|
|
|
|
// check for coexist
|
|
for( prog = glsl_programsHashTable[hash]; prog != NULL; prog = prog->nextHash )
|
|
{
|
|
if( !Q_strcmp( prog->name, glname ) && !Q_strcmp( prog->options, options ))
|
|
return (word)(prog - glsl_programs);
|
|
}
|
|
|
|
int i;
|
|
// find free spot
|
|
for( i = 1; i < num_glsl_programs; i++ )
|
|
if( !glsl_programs[i].name[0] )
|
|
break;
|
|
|
|
double start = Sys_DoubleTime();
|
|
uint checksum = FILE_CRC32( find, Q_strlen( find ));
|
|
prog = GL_CreateUberShader( i, glname, glname, glname, options, checksum );
|
|
double end = Sys_DoubleTime();
|
|
r_buildstats.compile_shader += (end - start);
|
|
if( RENDER_GET_PARM( PARM_CLIENT_ACTIVE, 0 ))
|
|
r_buildstats.total_buildtime += (end - start);
|
|
|
|
if( prog != NULL )
|
|
{
|
|
// add to hash table
|
|
prog->nextHash = glsl_programsHashTable[hash];
|
|
glsl_programsHashTable[hash] = prog;
|
|
}
|
|
|
|
return (word)(prog - glsl_programs);
|
|
}
|
|
|
|
word GL_FindShader( const char *glname, const char *vpname, const char *fpname, const char *options )
|
|
{
|
|
glsl_program_t *prog;
|
|
|
|
if( !GL_Support( R_SHADER_GLSL100_EXT ))
|
|
return 0;
|
|
|
|
ASSERT( glname != NULL );
|
|
|
|
const char *find = va( "%s %s", glname, options );
|
|
uint hash = COM_HashKey( find, SHADERS_HASH_SIZE );
|
|
|
|
// check for coexist
|
|
for( prog = glsl_programsHashTable[hash]; prog != NULL; prog = prog->nextHash )
|
|
{
|
|
if( !Q_strcmp( prog->name, glname ) && !Q_strcmp( prog->options, options ))
|
|
return (word)(prog - glsl_programs);
|
|
}
|
|
|
|
int i;
|
|
// find free spot
|
|
for( i = 1; i < num_glsl_programs; i++ )
|
|
if( !glsl_programs[i].name[0] )
|
|
break;
|
|
|
|
double start = Sys_DoubleTime();
|
|
uint checksum = FILE_CRC32( find, Q_strlen( find ));
|
|
prog = GL_CreateUberShader( i, glname, vpname, fpname, options, checksum );
|
|
double end = Sys_DoubleTime();
|
|
r_buildstats.compile_shader += (end - start);
|
|
if( RENDER_GET_PARM( PARM_CLIENT_ACTIVE, 0 ))
|
|
r_buildstats.total_buildtime += (end - start);
|
|
|
|
if( prog != NULL )
|
|
{
|
|
// add to hash table
|
|
prog->nextHash = glsl_programsHashTable[hash];
|
|
glsl_programsHashTable[hash] = prog;
|
|
}
|
|
|
|
return (word)(prog - glsl_programs);
|
|
}
|
|
|
|
void GL_AddShaderFeature( word shaderNum, int feature )
|
|
{
|
|
if( shaderNum <= 0 || shaderNum >= MAX_GLSL_PROGRAMS )
|
|
return;
|
|
|
|
glsl_program_t *shader = &glsl_programs[shaderNum];
|
|
SetBits( shader->status, feature );
|
|
}
|
|
|
|
void GL_SetShaderDirective( char *options, const char *directive )
|
|
{
|
|
options[0] = '\0';
|
|
Q_strncat( options, va( "#define %s\n", directive ), MAX_OPTIONS_LENGTH );
|
|
}
|
|
|
|
void GL_AddShaderDirective( char *options, const char *directive )
|
|
{
|
|
Q_strncat( options, va( "#define %s\n", directive ), MAX_OPTIONS_LENGTH );
|
|
}
|
|
|
|
const char *GL_PretifyListOptions( const char *options, bool newlines )
|
|
{
|
|
static char output[MAX_OPTIONS_LENGTH];
|
|
const char *pstart = options;
|
|
const char *pend = options + Q_strlen( options );
|
|
char *pout = output;
|
|
|
|
*pout = '\0';
|
|
|
|
while( pstart < pend )
|
|
{
|
|
const char *pfind = Q_strstr( pstart, "#define" );
|
|
if( !pfind ) break;
|
|
|
|
pstart = pfind + Q_strlen( "#define" );
|
|
|
|
for( ; *pstart != '\n'; pstart++, pout++ )
|
|
*pout = *pstart;
|
|
if( newlines )
|
|
*pout++ = *pstart++;
|
|
else pstart++; // skip '\n'
|
|
}
|
|
|
|
if( pout == output )
|
|
return ""; // nothing found
|
|
|
|
*pout++ = ' ';
|
|
*pout = '\0';
|
|
|
|
return output;
|
|
}
|
|
|
|
void GL_CheckTextureAlpha( char *options, int texturenum )
|
|
{
|
|
if( RENDER_GET_PARM( PARM_TEX_ENCODE, texturenum ) == DXT_ENCODE_ALPHA_SDF )
|
|
GL_AddShaderDirective( options, "SIGNED_DISTANCE_FIELD" );
|
|
}
|
|
|
|
void GL_EncodeNormal( char *options, int texturenum )
|
|
{
|
|
if( RENDER_GET_PARM( PARM_TEX_GLFORMAT, texturenum ) == GL_COMPRESSED_RED_GREEN_RGTC2_EXT )
|
|
{
|
|
GL_AddShaderDirective( options, "NORMAL_RG_PARABOLOID" );
|
|
}
|
|
else if( RENDER_GET_PARM( PARM_TEX_GLFORMAT, texturenum ) == GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI )
|
|
{
|
|
GL_AddShaderDirective( options, "NORMAL_3DC_PARABOLOID" );
|
|
}
|
|
else if( RENDER_GET_PARM( PARM_TEX_ENCODE, texturenum ) == DXT_ENCODE_NORMAL_AG_PARABOLOID )
|
|
{
|
|
GL_AddShaderDirective( options, "NORMAL_AG_PARABOLOID" );
|
|
}
|
|
else if( RENDER_GET_PARM( PARM_TEX_GLFORMAT, texturenum ) == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT )
|
|
{
|
|
// implicit DXT5NM format (Paranoia2 v 1.2 old stuff)
|
|
if( FBitSet( RENDER_GET_PARM( PARM_TEX_FLAGS, texturenum ), TF_HAS_ALPHA ))
|
|
GL_AddShaderDirective( options, "NORMAL_AG_PARABOLOID" );
|
|
}
|
|
}
|
|
|
|
void GL_ListGPUShaders( void )
|
|
{
|
|
int count = 0;
|
|
|
|
for( uint i = 1; i < num_glsl_programs; i++ )
|
|
{
|
|
glsl_program_t *cur = &glsl_programs[i];
|
|
if( !cur->name[0] ) continue;
|
|
|
|
const char *options = GL_PretifyListOptions( cur->options );
|
|
|
|
if( Q_stricmp( options, "" ))
|
|
Msg( "#%i %s [%s]\n", i, cur->name, options );
|
|
else Msg( "#%i %s\n", i, cur->name );
|
|
count++;
|
|
}
|
|
|
|
Msg( "total %i shaders\n", count );
|
|
}
|
|
|
|
void GL_InitGPUShaders( void )
|
|
{
|
|
char options[MAX_OPTIONS_LENGTH];
|
|
|
|
memset( &glsl_programs, 0, sizeof( glsl_programs ));
|
|
num_glsl_programs = 1; // entry #0 isn't used
|
|
|
|
if( !GL_Support( R_SHADER_GLSL100_EXT ))
|
|
return;
|
|
|
|
ADD_COMMAND( "shaderlist", GL_ListGPUShaders );
|
|
|
|
// init sky shaders
|
|
GL_SetShaderDirective( options, "SKYBOX_DAYTIME" );
|
|
tr.skyboxEnv[0] = GL_FindShader( "forward/skybox", "forward/generic", "forward/skybox" );
|
|
tr.skyboxEnv[1] = GL_FindShader( "forward/skybox", "forward/generic", "forward/skybox", options );
|
|
tr.defSceneSky = GL_FindShader( "deferred/skybox", "deferred/generic", "deferred/sky_scene" );
|
|
tr.defLightSky = GL_FindShader( "deferred/skybox", "deferred/generic", "deferred/sky_light" );
|
|
}
|
|
|
|
void GL_FreeUberShaders( void )
|
|
{
|
|
if( !GL_Support( R_SHADER_GLSL100_EXT ))
|
|
return;
|
|
|
|
for( uint i = 1; i < num_glsl_programs; i++ )
|
|
{
|
|
if( FBitSet( glsl_programs[i].status, SHADER_UBERSHADER ))
|
|
GL_FreeGPUShader( &glsl_programs[i] );
|
|
}
|
|
|
|
GL_BindShader( GL_NONE );
|
|
}
|
|
|
|
void GL_FreeGPUShaders( void )
|
|
{
|
|
if( !GL_Support( R_SHADER_GLSL100_EXT ))
|
|
return;
|
|
|
|
for( uint i = 1; i < num_glsl_programs; i++ )
|
|
GL_FreeGPUShader( &glsl_programs[i] );
|
|
|
|
GL_BindShader( GL_NONE );
|
|
} |