Skip to content

Commit b2a1bc1

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 b2a1bc1

File tree

2 files changed

+51
-52
lines changed

2 files changed

+51
-52
lines changed

‎src/engine/renderer/gl_shader.cpp‎

Lines changed: 50 additions & 51 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
@@ -912,37 +911,25 @@ void GLShaderManager::buildPermutation( GLShader *shader, int macroIndex, int de
912911
{
913912
shader->BuildShaderCompileMacros( compileMacros );
914913

915-
if ( IsUnusedPermutation( compileMacros.c_str() ) )
914+
if ( IsUnusedPermutation( compileMacros.c_str() ) ) {
916915
return;
916+
}
917917

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

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

924-
if( deformIndex > 0 )
925-
{
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-
}
925+
if ( ( deformIndex > 0 ) || !LoadShaderBinary( shader, i ) ) {
926+
shaderProgram_t* baseProgram = &shader->_shaderPrograms[macroIndex];
938927

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 );
928+
CompileAndLinkGPUShaderProgram( shader, shaderProgram, baseProgram, compileMacros, deformIndex );
929+
930+
if ( deformIndex == 0 ) {
931+
SaveShaderBinary( shader, i );
932+
}
946933
}
947934

948935
UpdateShaderProgramUniformLocations( shader, shaderProgram );
@@ -952,7 +939,7 @@ void GLShaderManager::buildPermutation( GLShader *shader, int macroIndex, int de
952939

953940
GL_CheckErrors();
954941

955-
endTime = ri.Milliseconds();
942+
int endTime = ri.Milliseconds();
956943
_totalBuildTime += ( endTime - startTime );
957944
}
958945
}
@@ -966,9 +953,8 @@ void GLShaderManager::buildAll()
966953
std::string shaderName = shader.GetMainShaderName();
967954

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

971-
for( i = 0; i < numPermutations; i++ )
957+
for( size_t i = 0; i < numPermutations; i++ )
972958
{
973959
buildPermutation( &shader, i, 0 );
974960
}
@@ -1052,29 +1038,35 @@ bool GLShaderManager::LoadShaderBinary( GLShader *shader, size_t programNum )
10521038
const byte *binaryptr;
10531039
GLBinaryHeader shaderHeader;
10541040

1055-
if (!GetShaderPath().empty())
1041+
if ( !GetShaderPath().empty() ) {
10561042
return false;
1043+
}
10571044

10581045
// don't even try if the necessary functions aren't available
1059-
if( !glConfig2.getProgramBinaryAvailable )
1046+
if ( !glConfig2.getProgramBinaryAvailable ) {
10601047
return false;
1048+
}
10611049

1062-
if (_shaderBinaryCacheInvalidated)
1050+
if ( _shaderBinaryCacheInvalidated ) {
10631051
return false;
1052+
}
10641053

10651054
std::error_code err;
10661055

10671056
std::string shaderFilename = Str::Format("glsl/%s/%s_%u.bin", shader->GetName(), shader->GetName(), (unsigned int)programNum);
10681057
FS::File shaderFile = FS::HomePath::OpenRead(shaderFilename, err);
1069-
if (err)
1058+
if ( err ) {
10701059
return false;
1060+
}
10711061

10721062
std::string shaderData = shaderFile.ReadAll(err);
1073-
if (err)
1063+
if ( err ) {
10741064
return false;
1065+
}
10751066

1076-
if (shaderData.size() < sizeof(shaderHeader))
1067+
if ( shaderData.size() < sizeof( shaderHeader ) ) {
10771068
return false;
1069+
}
10781070

10791071
binaryptr = reinterpret_cast<const byte*>(shaderData.data());
10801072

@@ -1094,19 +1086,21 @@ bool GLShaderManager::LoadShaderBinary( GLShader *shader, size_t programNum )
10941086
}
10951087

10961088
// make sure this shader uses the same number of macros
1097-
if ( shaderHeader.numMacros != shader->GetNumOfCompiledMacros() )
1089+
if ( shaderHeader.numMacros != shader->GetNumOfCompiledMacros() ) {
10981090
return false;
1091+
}
10991092

11001093
// make sure this shader uses the same macros
11011094
for ( unsigned int i = 0; i < shaderHeader.numMacros; i++ )
11021095
{
1103-
if ( shader->_compileMacros[ i ]->GetType() != shaderHeader.macros[ i ] )
1096+
if ( shader->_compileMacros[i]->GetType() != shaderHeader.macros[i] )
11041097
return false;
11051098
}
11061099

11071100
// make sure the checksums for the source code match
1108-
if ( shaderHeader.checkSum != shader->_checkSum )
1101+
if ( shaderHeader.checkSum != shader->_checkSum ) {
11091102
return false;
1103+
}
11101104

11111105
if ( shaderHeader.binaryLength != shaderData.size() - sizeof( shaderHeader ) )
11121106
{
@@ -1115,13 +1109,14 @@ bool GLShaderManager::LoadShaderBinary( GLShader *shader, size_t programNum )
11151109
}
11161110

11171111
// load the shader
1118-
shaderProgram_t *shaderProgram = &shader->_shaderPrograms[ programNum ];
1112+
shaderProgram_t *shaderProgram = &shader->_shaderPrograms[programNum];
11191113
shaderProgram->program = glCreateProgram();
11201114
glProgramBinary( shaderProgram->program, shaderHeader.binaryFormat, binaryptr, shaderHeader.binaryLength );
11211115
glGetProgramiv( shaderProgram->program, GL_LINK_STATUS, &success );
11221116

1123-
if ( !success )
1117+
if ( !success ) {
11241118
return false;
1119+
}
11251120

11261121
return true;
11271122
#else
@@ -1138,16 +1133,17 @@ void GLShaderManager::SaveShaderBinary( GLShader *shader, size_t programNum )
11381133
GLBinaryHeader shaderHeader{}; // Zero init.
11391134
shaderProgram_t *shaderProgram;
11401135

1141-
if (!GetShaderPath().empty())
1136+
if ( !GetShaderPath().empty() ) {
11421137
return;
1138+
}
11431139

11441140
// don't even try if the necessary functions aren't available
11451141
if( !glConfig2.getProgramBinaryAvailable )
11461142
{
11471143
return;
11481144
}
11491145

1150-
shaderProgram = &shader->_shaderPrograms[ programNum ];
1146+
shaderProgram = &shader->_shaderPrograms[programNum];
11511147

11521148
// find output size
11531149
binarySize += sizeof( shaderHeader );
@@ -1175,15 +1171,15 @@ void GLShaderManager::SaveShaderBinary( GLShader *shader, size_t programNum )
11751171

11761172
for ( unsigned int i = 0; i < shaderHeader.numMacros; i++ )
11771173
{
1178-
shaderHeader.macros[ i ] = shader->_compileMacros[ i ]->GetType();
1174+
shaderHeader.macros[i] = shader->_compileMacros[i]->GetType();
11791175
}
11801176

11811177
shaderHeader.binaryLength = binaryLength;
11821178
shaderHeader.checkSum = shader->_checkSum;
11831179
shaderHeader.driverVersionHash = _driverVersionHash;
11841180

11851181
// write the header to the buffer
1186-
memcpy(binary, &shaderHeader, sizeof( shaderHeader ) );
1182+
memcpy( binary, &shaderHeader, sizeof( shaderHeader ) );
11871183

11881184
auto fileName = Str::Format("glsl/%s/%s_%u.bin", shader->GetName(), shader->GetName(), (unsigned int)programNum);
11891185
ri.FS_WriteFile(fileName.c_str(), binary, binarySize);
@@ -1248,21 +1244,24 @@ void GLShaderManager::CompileGPUShaders( GLShader *shader, shaderProgram_t *prog
12481244
}
12491245
}
12501246

1251-
void GLShaderManager::CompileAndLinkGPUShaderProgram( GLShader *shader, shaderProgram_t *program,
1247+
void GLShaderManager::CompileAndLinkGPUShaderProgram( GLShader *shader, shaderProgram_t *program, shaderProgram_t* baseProgram,
12521248
Str::StringRef compileMacros, int deformIndex )
12531249
{
1254-
GLShaderManager::CompileGPUShaders( shader, program, compileMacros );
1250+
if ( ( !baseProgram->VS && shader->_hasVertexShader ) || ( !baseProgram->FS && shader->_hasFragmentShader )
1251+
|| ( !baseProgram->CS && shader->_hasComputeShader ) ) {
1252+
CompileGPUShaders( shader, baseProgram, compileMacros );
1253+
}
12551254

12561255
program->program = glCreateProgram();
12571256
if ( shader->_hasVertexShader ) {
1258-
glAttachShader( program->program, program->VS );
1257+
glAttachShader( program->program, baseProgram->VS );
12591258
glAttachShader( program->program, _deformShaders[ deformIndex ] );
12601259
}
12611260
if ( shader->_hasFragmentShader ) {
1262-
glAttachShader( program->program, program->FS );
1261+
glAttachShader( program->program, baseProgram->FS );
12631262
}
12641263
if ( shader->_hasComputeShader ) {
1265-
glAttachShader( program->program, program->CS );
1264+
glAttachShader( program->program, baseProgram->CS );
12661265
}
12671266

12681267
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)