Skip to content

Commit 6b06dd7

Browse files
VReaperVVReaperV
committed
Simplify some GLSL shader loading code
Merge the two branches in `GLShaderManager::buildPermutation()` into one since they were doing essentially the same thing. Change some variable names to avoid confusion between shader and shader programs, fixed some formatting like whitespaces in [] and missing {} in if statements. Removed a redundant namespace in function call.
1 parent afee459 commit 6b06dd7

File tree

2 files changed

+60
-44
lines changed

2 files changed

+60
-44
lines changed

‎src/engine/renderer/gl_shader.cpp

Lines changed: 59 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -897,8 +897,7 @@ static bool IsUnusedPermutation( const char *compileMacros )
897897
void GLShaderManager::buildPermutation( GLShader *shader, int macroIndex, int deformIndex )
898898
{
899899
std::string compileMacros;
900-
int startTime = ri.Milliseconds();
901-
int endTime;
900+
int startTime = ri.Milliseconds();
902901
size_t i = macroIndex + ( deformIndex << shader->_compileMacros.size() );
903902

904903
// program already exists
@@ -913,36 +912,28 @@ void GLShaderManager::buildPermutation( GLShader *shader, int macroIndex, int de
913912
shader->BuildShaderCompileMacros( compileMacros );
914913

915914
if ( IsUnusedPermutation( compileMacros.c_str() ) )
915+
{
916916
return;
917+
}
917918

918-
if( i >= shader->_shaderPrograms.size() )
919-
shader->_shaderPrograms.resize( (deformIndex + 1) << shader->_compileMacros.size() );
919+
if ( i >= shader->_shaderPrograms.size() )
920+
{
921+
shader->_shaderPrograms.resize( ( deformIndex + 1 ) << shader->_compileMacros.size() );
922+
}
920923

921-
shaderProgram_t *shaderProgram = &shader->_shaderPrograms[ i ];
922-
shaderProgram->attribs = shader->_vertexAttribsRequired; // | _vertexAttribsOptional;
924+
shaderProgram_t *shaderProgram = &shader->_shaderPrograms[i];
925+
shaderProgram->attribs = shader->_vertexAttribsRequired;
923926

924-
if( deformIndex > 0 )
927+
if ( ( deformIndex > 0 ) || !LoadShaderBinary( shader, i ) )
925928
{
926-
shaderProgram_t *baseShader = &shader->_shaderPrograms[ macroIndex ];
927-
if( ( !baseShader->VS && shader->_hasVertexShader ) || ( !baseShader->FS && shader->_hasFragmentShader ) )
928-
CompileGPUShaders( shader, baseShader, compileMacros );
929-
930-
shaderProgram->program = glCreateProgram();
931-
if ( shader->_hasVertexShader ) {
932-
glAttachShader( shaderProgram->program, baseShader->VS );
933-
glAttachShader( shaderProgram->program, _deformShaders[deformIndex] );
934-
}
935-
if ( shader->_hasFragmentShader ) {
936-
glAttachShader( shaderProgram->program, baseShader->FS );
937-
}
929+
shaderProgram_t* baseProgram = &shader->_shaderPrograms[macroIndex];
938930

939-
BindAttribLocations( shaderProgram->program );
940-
LinkProgram( shaderProgram->program );
941-
}
942-
else if ( !LoadShaderBinary( shader, i ) )
943-
{
944-
CompileAndLinkGPUShaderProgram( shader, shaderProgram, compileMacros, deformIndex );
945-
SaveShaderBinary( shader, i );
931+
CompileAndLinkGPUShaderProgram( shader, shaderProgram, baseProgram, compileMacros, deformIndex );
932+
933+
if ( deformIndex == 0 )
934+
{
935+
SaveShaderBinary( shader, i );
936+
}
946937
}
947938

948939
UpdateShaderProgramUniformLocations( shader, shaderProgram );
@@ -952,7 +943,7 @@ void GLShaderManager::buildPermutation( GLShader *shader, int macroIndex, int de
952943

953944
GL_CheckErrors();
954945

955-
endTime = ri.Milliseconds();
946+
int endTime = ri.Milliseconds();
956947
_totalBuildTime += ( endTime - startTime );
957948
}
958949
}
@@ -966,9 +957,8 @@ void GLShaderManager::buildAll()
966957
std::string shaderName = shader.GetMainShaderName();
967958

968959
size_t numPermutations = static_cast<size_t>(1) << shader.GetNumOfCompiledMacros();
969-
size_t i;
970960

971-
for( i = 0; i < numPermutations; i++ )
961+
for( size_t i = 0; i < numPermutations; i++ )
972962
{
973963
buildPermutation( &shader, i, 0 );
974964
}
@@ -1052,29 +1042,41 @@ bool GLShaderManager::LoadShaderBinary( GLShader *shader, size_t programNum )
10521042
const byte *binaryptr;
10531043
GLBinaryHeader shaderHeader;
10541044

1055-
if (!GetShaderPath().empty())
1045+
if ( !GetShaderPath().empty() )
1046+
{
10561047
return false;
1048+
}
10571049

10581050
// don't even try if the necessary functions aren't available
1059-
if( !glConfig2.getProgramBinaryAvailable )
1051+
if ( !glConfig2.getProgramBinaryAvailable )
1052+
{
10601053
return false;
1054+
}
10611055

1062-
if (_shaderBinaryCacheInvalidated)
1056+
if ( _shaderBinaryCacheInvalidated )
1057+
{
10631058
return false;
1059+
}
10641060

10651061
std::error_code err;
10661062

10671063
std::string shaderFilename = Str::Format("glsl/%s/%s_%u.bin", shader->GetName(), shader->GetName(), (unsigned int)programNum);
10681064
FS::File shaderFile = FS::HomePath::OpenRead(shaderFilename, err);
1069-
if (err)
1065+
if ( err )
1066+
{
10701067
return false;
1068+
}
10711069

10721070
std::string shaderData = shaderFile.ReadAll(err);
1073-
if (err)
1071+
if ( err )
1072+
{
10741073
return false;
1074+
}
10751075

1076-
if (shaderData.size() < sizeof(shaderHeader))
1076+
if ( shaderData.size() < sizeof( shaderHeader ) )
1077+
{
10771078
return false;
1079+
}
10781080

10791081
binaryptr = reinterpret_cast<const byte*>(shaderData.data());
10801082

@@ -1095,18 +1097,24 @@ bool GLShaderManager::LoadShaderBinary( GLShader *shader, size_t programNum )
10951097

10961098
// make sure this shader uses the same number of macros
10971099
if ( shaderHeader.numMacros != shader->GetNumOfCompiledMacros() )
1100+
{
10981101
return false;
1102+
}
10991103

11001104
// make sure this shader uses the same macros
11011105
for ( unsigned int i = 0; i < shaderHeader.numMacros; i++ )
11021106
{
11031107
if ( shader->_compileMacros[ i ]->GetType() != shaderHeader.macros[ i ] )
1108+
{
11041109
return false;
1110+
}
11051111
}
11061112

11071113
// make sure the checksums for the source code match
11081114
if ( shaderHeader.checkSum != shader->_checkSum )
1115+
{
11091116
return false;
1117+
}
11101118

11111119
if ( shaderHeader.binaryLength != shaderData.size() - sizeof( shaderHeader ) )
11121120
{
@@ -1121,7 +1129,9 @@ bool GLShaderManager::LoadShaderBinary( GLShader *shader, size_t programNum )
11211129
glGetProgramiv( shaderProgram->program, GL_LINK_STATUS, &success );
11221130

11231131
if ( !success )
1132+
{
11241133
return false;
1134+
}
11251135

11261136
return true;
11271137
#else
@@ -1138,8 +1148,10 @@ void GLShaderManager::SaveShaderBinary( GLShader *shader, size_t programNum )
11381148
GLBinaryHeader shaderHeader{}; // Zero init.
11391149
shaderProgram_t *shaderProgram;
11401150

1141-
if (!GetShaderPath().empty())
1151+
if ( !GetShaderPath().empty() )
1152+
{
11421153
return;
1154+
}
11431155

11441156
// don't even try if the necessary functions aren't available
11451157
if( !glConfig2.getProgramBinaryAvailable )
@@ -1175,15 +1187,15 @@ void GLShaderManager::SaveShaderBinary( GLShader *shader, size_t programNum )
11751187

11761188
for ( unsigned int i = 0; i < shaderHeader.numMacros; i++ )
11771189
{
1178-
shaderHeader.macros[ i ] = shader->_compileMacros[ i ]->GetType();
1190+
shaderHeader.macros[i] = shader->_compileMacros[ i ]->GetType();
11791191
}
11801192

11811193
shaderHeader.binaryLength = binaryLength;
11821194
shaderHeader.checkSum = shader->_checkSum;
11831195
shaderHeader.driverVersionHash = _driverVersionHash;
11841196

11851197
// write the header to the buffer
1186-
memcpy(binary, &shaderHeader, sizeof( shaderHeader ) );
1198+
memcpy( binary, &shaderHeader, sizeof( shaderHeader ) );
11871199

11881200
auto fileName = Str::Format("glsl/%s/%s_%u.bin", shader->GetName(), shader->GetName(), (unsigned int)programNum);
11891201
ri.FS_WriteFile(fileName.c_str(), binary, binarySize);
@@ -1248,21 +1260,25 @@ void GLShaderManager::CompileGPUShaders( GLShader *shader, shaderProgram_t *prog
12481260
}
12491261
}
12501262

1251-
void GLShaderManager::CompileAndLinkGPUShaderProgram( GLShader *shader, shaderProgram_t *program,
1263+
void GLShaderManager::CompileAndLinkGPUShaderProgram( GLShader *shader, shaderProgram_t *program, shaderProgram_t* baseProgram,
12521264
Str::StringRef compileMacros, int deformIndex )
12531265
{
1254-
GLShaderManager::CompileGPUShaders( shader, program, compileMacros );
1266+
if ( ( !baseProgram->VS && shader->_hasVertexShader ) || ( !baseProgram->FS && shader->_hasFragmentShader )
1267+
|| ( !baseProgram->CS && shader->_hasComputeShader ) )
1268+
{
1269+
CompileGPUShaders( shader, baseProgram, compileMacros );
1270+
}
12551271

12561272
program->program = glCreateProgram();
12571273
if ( shader->_hasVertexShader ) {
1258-
glAttachShader( program->program, program->VS );
1274+
glAttachShader( program->program, baseProgram->VS );
12591275
glAttachShader( program->program, _deformShaders[ deformIndex ] );
12601276
}
12611277
if ( shader->_hasFragmentShader ) {
1262-
glAttachShader( program->program, program->FS );
1278+
glAttachShader( program->program, baseProgram->FS );
12631279
}
12641280
if ( shader->_hasComputeShader ) {
1265-
glAttachShader( program->program, program->CS );
1281+
glAttachShader( program->program, baseProgram->CS );
12661282
}
12671283

12681284
BindAttribLocations( program->program );

‎src/engine/renderer/gl_shader.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -340,7 +340,7 @@ class GLShaderManager
340340
GLenum shaderType ) const;
341341
void CompileGPUShaders( GLShader *shader, shaderProgram_t *program,
342342
const std::string &compileMacros );
343-
void CompileAndLinkGPUShaderProgram( GLShader *shader, shaderProgram_t *program,
343+
void CompileAndLinkGPUShaderProgram( GLShader *shader, shaderProgram_t *program, shaderProgram_t* baseProgram,
344344
Str::StringRef compileMacros, int deformIndex );
345345
std::string BuildDeformShaderText( const std::string& steps );
346346
std::string BuildGPUShaderText( Str::StringRef mainShader, Str::StringRef libShaders, GLenum shaderType ) const;

0 commit comments

Comments
 (0)