Refactor: treat shader deform index like a GLSL macro

Instead of passing the deform index as a BindProgram argument, use a
SetDeform function that stores the deform index in the shader object.
This makes it work the same way as setting GLSL macro options (e.g.
SetVertexSkining), which makes sense because the deform index is also an
option that determines which variant of the GLSL shader gets compiled.
SetDeform is a member of GLDeformStage, so you are no longer allowed
and no longer required to pass a deform index to GLSL shaders that don't
use deforms.

This eliminates a fair amount of plumbing of the deform index through
functions that shouldn't have to care about it.

Author: slipher

src/engine/renderer/GeometryOptimiser.cpp

@@ -85,39 +85,39 @@ void MarkShaderBuildNOP( const shaderStage_t* ) {
 
 void MarkShaderBuildGeneric3D( const shaderStage_t* pStage ) {
 	ProcessShaderGeneric3D( pStage );
-	gl_genericShader->MarkProgramForBuilding( pStage->deformIndex );
+	gl_genericShader->MarkProgramForBuilding();
 }
 
 void MarkShaderBuildLightMapping( const shaderStage_t* pStage ) {
 	ProcessShaderLightMapping( pStage );
-	gl_lightMappingShader->MarkProgramForBuilding( pStage->deformIndex );
+	gl_lightMappingShader->MarkProgramForBuilding();
 }
 
 void MarkShaderBuildReflection( const shaderStage_t* pStage ) {
 	ProcessShaderReflection( pStage );
-	gl_reflectionShader->MarkProgramForBuilding( pStage->deformIndex );
+	gl_reflectionShader->MarkProgramForBuilding();
 }
 
-void MarkShaderBuildSkybox( const shaderStage_t* pStage ) {
-	gl_skyboxShader->MarkProgramForBuilding( pStage->deformIndex );
+void MarkShaderBuildSkybox( const shaderStage_t* ) {
+	gl_skyboxShader->MarkProgramForBuilding();
 }
 
-void MarkShaderBuildScreen( const shaderStage_t* pStage ) {
-	gl_screenShader->MarkProgramForBuilding( pStage->deformIndex );
+void MarkShaderBuildScreen( const shaderStage_t* ) {
+	gl_screenShader->MarkProgramForBuilding();
 }
 
-void MarkShaderBuildPortal( const shaderStage_t* pStage ) {
-	gl_portalShader->MarkProgramForBuilding( pStage->deformIndex );
+void MarkShaderBuildPortal( const shaderStage_t* ) {
+	gl_portalShader->MarkProgramForBuilding();
 }
 
 void MarkShaderBuildHeatHaze( const shaderStage_t* pStage ) {
 	ProcessShaderHeatHaze( pStage );
-	gl_heatHazeShader->MarkProgramForBuilding( pStage->deformIndex );
+	gl_heatHazeShader->MarkProgramForBuilding();
 }
 
 void MarkShaderBuildLiquid( const shaderStage_t* pStage ) {
 	ProcessShaderLiquid( pStage );
-	gl_liquidShader->MarkProgramForBuilding( pStage->deformIndex );
+	gl_liquidShader->MarkProgramForBuilding();
 }
 
 void MarkShaderBuild( shader_t* shader, const int lightMapNum, const bool bspSurface,

src/engine/renderer/Material.cpp

@@ -891,9 +891,10 @@ void BindShaderGeneric3D( Material* material ) {
 	gl_genericShaderMaterial->SetTCGenEnvironment( material->tcGenEnvironment );
 	gl_genericShaderMaterial->SetTCGenLightmap( material->tcGen_Lightmap );
 	gl_genericShaderMaterial->SetDepthFade( material->hasDepthFade );
+	gl_genericShaderMaterial->SetDeform( material->deformIndex );
 
 	// Bind shader program.
-	gl_genericShaderMaterial->BindProgram( material->deformIndex );
+	gl_genericShaderMaterial->BindProgram();
 
 	// Set shader uniforms.
 	if ( material->tcGenEnvironment ) {
@@ -926,9 +927,10 @@ void BindShaderLightMapping( Material* material ) {
 	because we don't have cubemaps built yet at this point, but for the purposes of the material ordering there's no difference */
 	gl_lightMappingShaderMaterial->SetReflectiveSpecular( glConfig.reflectionMapping && material->enableSpecularMapping && !( tr.refdef.rdflags & RDF_NOCUBEMAP ) );
 	gl_lightMappingShaderMaterial->SetPhysicalShading( material->enablePhysicalMapping );
+	gl_lightMappingShaderMaterial->SetDeform( material->deformIndex );
 
 	// Bind shader program.
-	gl_lightMappingShaderMaterial->BindProgram( material->deformIndex );
+	gl_lightMappingShaderMaterial->BindProgram();
 
 	// Set shader uniforms.
 	if ( tr.world ) {
@@ -1011,35 +1013,37 @@ void BindShaderReflection( Material* material ) {
 	// Select shader permutation.
 	gl_reflectionShaderMaterial->SetHeightMapInNormalMap( material->hasHeightMapInNormalMap );
 	gl_reflectionShaderMaterial->SetReliefMapping( material->enableReliefMapping );
+	gl_reflectionShaderMaterial->SetDeform( material->deformIndex );
 
 	// Bind shader program.
-	gl_reflectionShaderMaterial->BindProgram( material->deformIndex );
+	gl_reflectionShaderMaterial->BindProgram();
 
 	// Set shader uniforms.
 	gl_reflectionShaderMaterial->SetUniform_ViewOrigin( backEnd.viewParms.orientation.origin );
 	gl_reflectionShaderMaterial->SetUniform_ModelMatrix( backEnd.orientation.transformMatrix );
 	gl_reflectionShaderMaterial->SetUniform_ModelViewProjectionMatrix( glState.modelViewProjectionMatrix[glState.stackIndex] );
 }
 
-void BindShaderSkybox( Material* material ) {
+void BindShaderSkybox( Material* ) {
 	// Bind shader program.
-	gl_skyboxShaderMaterial->BindProgram( material->deformIndex );
+	gl_skyboxShaderMaterial->BindProgram();
 
 	// Set shader uniforms.
 	gl_skyboxShaderMaterial->SetUniform_ModelViewProjectionMatrix( glState.modelViewProjectionMatrix[glState.stackIndex] );
 }
 
-void BindShaderScreen( Material* material ) {
+void BindShaderScreen( Material* ) {
 	// Bind shader program.
-	gl_screenShaderMaterial->BindProgram( material->deformIndex );
+	gl_screenShaderMaterial->BindProgram();
 
 	// Set shader uniforms.
 	gl_screenShaderMaterial->SetUniform_ModelViewProjectionMatrix( glState.modelViewProjectionMatrix[glState.stackIndex] );
 }
 
 void BindShaderHeatHaze( Material* material ) {
 	// Bind shader program.
-	gl_heatHazeShaderMaterial->BindProgram( material->deformIndex );
+	gl_heatHazeShaderMaterial->SetDeform( material->deformIndex );
+	gl_heatHazeShaderMaterial->BindProgram();
 
 	// Set shader uniforms.
 	gl_heatHazeShaderMaterial->SetUniform_ModelViewProjectionMatrix( glState.modelViewProjectionMatrix[glState.stackIndex] );
@@ -1067,7 +1071,7 @@ void BindShaderLiquid( Material* material ) {
 	gl_liquidShaderMaterial->SetGridLighting( material->enableGridLighting );
 
 	// Bind shader program.
-	gl_liquidShaderMaterial->BindProgram( material->deformIndex );
+	gl_liquidShaderMaterial->BindProgram();
 
 	// Set shader uniforms.
 	gl_liquidShaderMaterial->SetUniform_ViewOrigin( backEnd.viewParms.orientation.origin );
@@ -1084,7 +1088,8 @@ void BindShaderLiquid( Material* material ) {
 
 void BindShaderFog( Material* material ) {
 	// Bind shader program.
-	gl_fogQuake3ShaderMaterial->BindProgram( material->deformIndex );
+	gl_fogQuake3ShaderMaterial->SetDeform( material->deformIndex );
+	gl_fogQuake3ShaderMaterial->BindProgram();
 
 	// Set shader uniforms.
 	const fog_t* fog = tr.world->fogs + material->fog;
@@ -1140,7 +1145,9 @@ void ProcessMaterialGeneric3D( Material* material, shaderStage_t* pStage, Materi
 	material->hasDepthFade = hasDepthFade;
 	gl_genericShaderMaterial->SetDepthFade( hasDepthFade );
 
-	material->program = gl_genericShaderMaterial->GetProgram( pStage->deformIndex, materialSystem.buildOneShader );
+	gl_genericShaderMaterial->SetDeform( pStage->deformIndex );
+
+	material->program = gl_genericShaderMaterial->GetProgram( materialSystem.buildOneShader );
 }
 
 void ProcessMaterialLightMapping( Material* material, shaderStage_t* pStage, MaterialSurface* surface ) {
@@ -1181,7 +1188,9 @@ void ProcessMaterialLightMapping( Material* material, shaderStage_t* pStage, Mat
 
 	gl_lightMappingShaderMaterial->SetPhysicalShading( pStage->enablePhysicalMapping );
 
-	material->program = gl_lightMappingShaderMaterial->GetProgram( pStage->deformIndex, materialSystem.buildOneShader );
+	gl_lightMappingShaderMaterial->SetDeform( pStage->deformIndex );
+
+	material->program = gl_lightMappingShaderMaterial->GetProgram( materialSystem.buildOneShader );
 }
 
 void ProcessMaterialReflection( Material* material, shaderStage_t* pStage, MaterialSurface* /* surface */ ) {
@@ -1195,31 +1204,35 @@ void ProcessMaterialReflection( Material* material, shaderStage_t* pStage, Mater
 
 	gl_reflectionShaderMaterial->SetReliefMapping( pStage->enableReliefMapping );
 
-	material->program = gl_reflectionShaderMaterial->GetProgram( pStage->deformIndex, materialSystem.buildOneShader );
+	gl_reflectionShaderMaterial->SetDeform( pStage->deformIndex );
+
+	material->program = gl_reflectionShaderMaterial->GetProgram(  materialSystem.buildOneShader );
 }
 
 void ProcessMaterialSkybox( Material* material, shaderStage_t* pStage, MaterialSurface* /* surface */ ) {
 	material->shader = gl_skyboxShaderMaterial;
 
 	material->deformIndex = pStage->deformIndex;
 
-	material->program = gl_skyboxShaderMaterial->GetProgram( pStage->deformIndex, materialSystem.buildOneShader );
+	material->program = gl_skyboxShaderMaterial->GetProgram( materialSystem.buildOneShader );
 }
 
 void ProcessMaterialScreen( Material* material, shaderStage_t* pStage, MaterialSurface* /* surface */ ) {
 	material->shader = gl_screenShaderMaterial;
 
 	material->deformIndex = pStage->deformIndex;
 
-	material->program = gl_screenShaderMaterial->GetProgram( pStage->deformIndex, materialSystem.buildOneShader );
+	material->program = gl_screenShaderMaterial->GetProgram( materialSystem.buildOneShader );
 }
 
 void ProcessMaterialHeatHaze( Material* material, shaderStage_t* pStage, MaterialSurface* ) {
 	material->shader = gl_heatHazeShaderMaterial;
 
 	material->deformIndex = pStage->deformIndex;
 
-	material->program = gl_heatHazeShaderMaterial->GetProgram( pStage->deformIndex, materialSystem.buildOneShader );
+	gl_heatHazeShaderMaterial->SetDeform( pStage->deformIndex );
+
+	material->program = gl_heatHazeShaderMaterial->GetProgram( materialSystem.buildOneShader );
 }
 
 void ProcessMaterialLiquid( Material* material, shaderStage_t* pStage, MaterialSurface* surface ) {
@@ -1243,14 +1256,16 @@ void ProcessMaterialLiquid( Material* material, shaderStage_t* pStage, MaterialS
 
 	gl_liquidShaderMaterial->SetGridLighting( lightMode == lightMode_t::GRID );
 
-	material->program = gl_liquidShaderMaterial->GetProgram( pStage->deformIndex, materialSystem.buildOneShader );
+	material->program = gl_liquidShaderMaterial->GetProgram( materialSystem.buildOneShader );
 }
 
 void ProcessMaterialFog( Material* material, shaderStage_t* pStage, MaterialSurface* surface ) {
 	material->shader = gl_fogQuake3ShaderMaterial;
 	material->fog = surface->fog;
 
-	material->program = gl_fogQuake3ShaderMaterial->GetProgram( pStage->deformIndex, materialSystem.buildOneShader );
+	gl_fogQuake3ShaderMaterial->SetDeform( pStage->deformIndex );
+
+	material->program = gl_fogQuake3ShaderMaterial->GetProgram( materialSystem.buildOneShader );
 }
 
 void MaterialSystem::AddStage( MaterialSurface* surface, shaderStage_t* pStage, uint32_t stage,
@@ -1607,7 +1622,7 @@ void MaterialSystem::UpdateDynamicSurfaces() {
 }
 
 void MaterialSystem::UpdateFrameData() {
-	gl_clearSurfacesShader->BindProgram( 0 );
+	gl_clearSurfacesShader->BindProgram();
 	gl_clearSurfacesShader->SetUniform_Frame( nextFrame );
 	gl_clearSurfacesShader->DispatchCompute( MAX_VIEWS, 1, 1 );
 
@@ -1632,7 +1647,7 @@ void MaterialSystem::DepthReduction() {
 	int width = depthImage->width;
 	int height = depthImage->height;
 
-	gl_depthReductionShader->BindProgram( 0 );
+	gl_depthReductionShader->BindProgram();
 
 	uint32_t globalWorkgroupX = ( width + 7 ) / 8;
 	uint32_t globalWorkgroupY = ( height + 7 ) / 8;
@@ -1690,7 +1705,7 @@ void MaterialSystem::CullSurfaces() {
 			MatrixCopy( backEnd.viewParms.world.modelViewMatrix, viewMatrix );
 		}
 
-		gl_cullShader->BindProgram( 0 );
+		gl_cullShader->BindProgram();
 		uint32_t globalWorkGroupX = surfaceDescriptorsCount % MAX_COMMAND_COUNTERS == 0 ?
 			surfaceDescriptorsCount / MAX_COMMAND_COUNTERS : surfaceDescriptorsCount / MAX_COMMAND_COUNTERS + 1;
 		GL_Bind( depthImage );
@@ -1733,7 +1748,7 @@ void MaterialSystem::CullSurfaces() {
 
 		gl_cullShader->DispatchCompute( globalWorkGroupX, 1, 1 );
 
-		gl_processSurfacesShader->BindProgram( 0 );
+		gl_processSurfacesShader->BindProgram();
 		gl_processSurfacesShader->SetUniform_Frame( nextFrame );
 		gl_processSurfacesShader->SetUniform_ViewID( view );
 		gl_processSurfacesShader->SetUniform_SurfaceCommandsOffset( surfaceCommandsCount * ( MAX_VIEWS * nextFrame + view ) );

src/engine/renderer/gl_shader.cpp

@@ -1040,11 +1040,9 @@ ShaderProgramDescriptor* GLShaderManager::FindShaderProgram( std::vector<ShaderE
 	return &*it;
 }
 
-bool GLShaderManager::BuildPermutation( GLShader* shader, int macroIndex, int deformIndex, const bool buildOneShader ) {
-	size_t i = macroIndex + ( deformIndex << shader->_compileMacros.size() );
-
+bool GLShaderManager::BuildPermutation( GLShader* shader, int index, const bool buildOneShader ) {
 	std::string compileMacros;
-	if ( !shader->GetCompileMacrosString( i, compileMacros, GLCompileMacro::VERTEX | GLCompileMacro::FRAGMENT ) ) {
+	if ( !shader->GetCompileMacrosString( index, compileMacros, GLCompileMacro::VERTEX | GLCompileMacro::FRAGMENT ) ) {
 		return false;
 	}
 
@@ -1053,8 +1051,8 @@ bool GLShaderManager::BuildPermutation( GLShader* shader, int macroIndex, int de
 	}
 
 	// Program already exists
-	if ( i < shader->shaderPrograms.size() &&
-		shader->shaderPrograms[i].id ) {
+	if ( index < shader->shaderPrograms.size() &&
+		shader->shaderPrograms[index].id ) {
 		return false;
 	}
 
@@ -1076,7 +1074,10 @@ bool GLShaderManager::BuildPermutation( GLShader* shader, int macroIndex, int de
 
 	const int start = Sys::Milliseconds();
 
-	if ( i >= shader->shaderPrograms.size() ) {
+	int macroIndex = index & ( ( 1 << shader->_compileMacros.size() ) - 1 );
+	int deformIndex = index >> shader->_compileMacros.size();
+
+	if ( index >= shader->shaderPrograms.size() ) {
 		shader->shaderPrograms.resize( ( deformIndex + 1 ) << shader->_compileMacros.size() );
 	}
 
@@ -1104,7 +1105,7 @@ bool GLShaderManager::BuildPermutation( GLShader* shader, int macroIndex, int de
 	GL_BindNullProgram();
 
 	// Copy this for a fast look-up, but the values held in program aren't supposed to change after
-	shader->shaderPrograms[i] = *program;
+	shader->shaderPrograms[index] = *program;
 
 	GL_CheckErrors();
 
@@ -1144,17 +1145,15 @@ void GLShaderManager::BuildAll( const bool buildOnlyMarked ) {
 		if ( buildOnlyMarked ) {
 			for ( size_t i = 0; i < shader->shaderProgramsToBuild.size(); i++ ) {
 				if ( shader->shaderProgramsToBuild[i] ) {
-					const int macroIndex = i & ( ( 1u << shader->GetNumOfCompiledMacros() ) - 1 );
-					const int deformIndex = i >> shader->GetNumOfCompiledMacros();
-
-					count += +BuildPermutation( shader, macroIndex, deformIndex, false );
+					count += +BuildPermutation( shader, i, false );
 				}
 			}
 		} else {
 			size_t numPermutations = static_cast<size_t>( 1 ) << shader->GetNumOfCompiledMacros();
 
 			for ( size_t i = 0; i < numPermutations; i++ ) {
-				count += +BuildPermutation( shader, i, 0, false );
+				// doesn't include deform vertex shaders, those are built elsewhere!
+				count += +BuildPermutation( shader, i, false );
 			}
 		}
 
@@ -2192,38 +2191,36 @@ int GLShader::SelectProgram()
 {
 	int    index = 0;
 
-	size_t numMacros = _compileMacros.size();
+	int numMacros = static_cast<int>( _compileMacros.size() );
 
-	for ( size_t i = 0; i < numMacros; i++ )
+	for ( int i = 0; i < numMacros; i++ )
 	{
 		if ( _activeMacros & BIT( i ) )
 		{
 			index += BIT( i );
 		}
 	}
 
-	return index;
+	return index | ( _deformIndex << numMacros );
 }
 
-void GLShader::MarkProgramForBuilding( int deformIndex ) {
-	int macroIndex = SelectProgram();
-	size_t index = macroIndex + ( size_t( deformIndex ) << _compileMacros.size() );
+void GLShader::MarkProgramForBuilding() {
+	int index = SelectProgram();
 
-	if ( index >= shaderProgramsToBuild.size() ) {
+	if ( size_t(index) >= shaderProgramsToBuild.size() ) {
 		shaderProgramsToBuild.resize( index + 1 );
 	}
 
 	shaderProgramsToBuild[index] = true;
 }
 
-GLuint GLShader::GetProgram( int deformIndex, const bool buildOneShader ) {
-	int macroIndex = SelectProgram();
-	size_t index = macroIndex + ( size_t( deformIndex ) << _compileMacros.size() );
+GLuint GLShader::GetProgram( const bool buildOneShader ) {
+	int index = SelectProgram();
 
 	// program may not be loaded yet because the shader manager hasn't yet gotten to it
 	// so try to load it now
 	if ( index >= shaderPrograms.size() || !shaderPrograms[index].id ) {
-		gl_shaderManager.BuildPermutation( this, macroIndex, deformIndex, buildOneShader );
+		gl_shaderManager.BuildPermutation( this, index, buildOneShader );
 	}
 
 	// program is still not loaded
@@ -2248,15 +2245,14 @@ GLuint GLShader::GetProgram( int deformIndex, const bool buildOneShader ) {
 	return shaderPrograms[index].id;
 }
 
-void GLShader::BindProgram( int deformIndex ) {
-	int macroIndex = SelectProgram();
-	size_t index = macroIndex + ( size_t(deformIndex) << _compileMacros.size() );
+void GLShader::BindProgram() {
+	int index = SelectProgram();
 
 	// program may not be loaded yet because the shader manager hasn't yet gotten to it
 	// so try to load it now
 	if ( index >= shaderPrograms.size() || !shaderPrograms[index].id )
 	{
-		gl_shaderManager.BuildPermutation( this, macroIndex, deformIndex, true );
+		gl_shaderManager.BuildPermutation( this, index, true );
 	}
 
 	// program is still not loaded