Pack material data, material system clean-up

Uniforms are now tightly packed into the material struct where possible, e. g. it will try to put a 1-component uniform after a vec3.

Author: VReaperV

src/engine/renderer/Material.cpp

@@ -1313,7 +1313,7 @@ void MaterialSystem::ProcessStage( MaterialSurface* surface, shaderStage_t* pSta
 
 	material.bspSurface = surface->bspSurface;
 	pStage->materialProcessor( &material, pStage, surface );
-	pStage->paddedSize = material.shader->GetPaddedSize();
+	pStage->paddedSize = material.shader->GetSTD430Size();
 
 	// HACK: Copy the shaderStage_t and MaterialSurface that we need into the material, so we can use it with glsl_restart
 	material.refStage = pStage;

src/engine/renderer/gl_shader.cpp

@@ -1523,10 +1523,10 @@ std::string GLShaderManager::ShaderPostProcess( GLShader *shader, const std::str
 	std::string newShaderText;
 	std::string materialStruct = "\nstruct Material {\n";
 	// 6 kb for materials
-	const uint32_t count = ( 4096 + 2048 ) / shader->GetPaddedSize();
+	const uint32_t count = ( 4096 + 2048 ) / shader->GetSTD430Size();
 	std::string materialBlock = "layout(std140, binding = "
-		                        + std::to_string( BufferBind::MATERIALS )
-		                        + ") uniform materialsUBO {\n"
+	                            + std::to_string( BufferBind::MATERIALS )
+	                            + ") uniform materialsUBO {\n"
 	                            "	Material materials[" + std::to_string( count ) + "]; \n"
 	                            "};\n\n";
 
@@ -1582,45 +1582,19 @@ std::string GLShaderManager::ShaderPostProcess( GLShader *shader, const std::str
 	* #define uniformx materials[baseInstance].uniformx
 	*/
 
-	for( GLUniform* uniform : shader->_uniforms ) {
-		if ( uniform->IsGlobal() ) {
-			continue;
-		}
-
-		if ( !uniform->IsTexture() ) {
-			materialStruct += "	" + uniform->GetType() + " " + uniform->GetName();
-
-			if ( uniform->GetComponentSize() ) {
-				materialStruct += "[ " + std::to_string( uniform->GetComponentSize() ) + " ]";
-			}
-			materialStruct += ";\n";
-
-			// vec3 is aligned to 4 components, so just pad it with int
-			// TODO: Try to move 1 component uniforms here to avoid wasting memory
-			if ( uniform->GetSTD430Size() == 3 ) {
-				materialStruct += "	int ";
-				materialStruct += uniform->GetName();
-				materialStruct += "_padding;\n";
-			}
-		}
+	for( GLUniform* uniform : shader->_materialSystemUniforms ) {
+		materialStruct += "	" + uniform->GetType() + " " + uniform->GetName();
 
-		if ( uniform->IsTexture() ) {
-			continue;
+		if ( uniform->GetComponentSize() ) {
+			materialStruct += "[" + std::to_string( uniform->GetComponentSize() ) + "]";
 		}
+		materialStruct += ";\n";
 
 		materialDefines += "#define ";
 		materialDefines += uniform->GetName();
 
-		if ( uniform->IsTexture() ) { // Driver bug: AMD compiler crashes when using the SSBO value directly
-			materialDefines += "_initial uvec2("; // We'll need this to create sampler objects later
-		}
-
 		materialDefines += " materials[baseInstance & 0xFFF].";
 		materialDefines += uniform->GetName();
-		
-		if ( uniform->IsTexture() ) {
-			materialDefines += " )";
-		}
 
 		materialDefines += "\n";
 	}
@@ -1645,13 +1619,11 @@ std::string GLShaderManager::ShaderPostProcess( GLShader *shader, const std::str
 	while( std::getline( shaderTextStream, line, '\n' ) ) {
 		bool skip = false;
 		if ( line.find( "uniform" ) < line.find( "//" ) && line.find( ";" ) != std::string::npos ) {
-			for ( GLUniform* uniform : shader->_uniforms ) {
-				if ( !uniform->IsGlobal() ) {
-					const size_t pos = line.find( uniform->GetName() );
-					if ( pos != std::string::npos && !Str::cisalpha( line[pos + strlen( uniform->GetName() )] ) ) {
-						skip = true;
-						break;
-					}
+			for ( GLUniform* uniform : shader->_materialSystemUniforms ) {
+				const size_t pos = line.find( uniform->GetName() );
+				if ( pos != std::string::npos && !Str::cisalpha( line[pos + strlen( uniform->GetName() )] ) ) {
+					skip = true;
+					break;
 				}
 			}
 		}
@@ -1665,7 +1637,7 @@ std::string GLShaderManager::ShaderPostProcess( GLShader *shader, const std::str
 
 	materialDefines += "\n";
 
-	newShaderText = "#define USE_MATERIAL_SYSTEM\n" + materialStruct + materialBlock + texDataBlock + materialDefines; // + shaderMain;
+	newShaderText = "#define USE_MATERIAL_SYSTEM\n" + materialStruct + materialBlock + texDataBlock + materialDefines;
 	shaderMain.insert( offset, newShaderText );
 	return shaderMain;
 }
@@ -2113,71 +2085,73 @@ uint32_t* GLUniform::WriteToBuffer( uint32_t* buffer ) {
 
 void GLShader::RegisterUniform( GLUniform* uniform ) {
 	_uniforms.push_back( uniform );
-	textureCount += uniform->IsTexture();
 }
 
 GLint GLShader::GetUniformLocation( const GLchar *uniformName ) const {
 	ShaderProgramDescriptor* p = GetProgram();
 	return glGetUniformLocation( p->id, uniformName );
 }
 
+static int FindUniformForAlignment( std::vector<GLUniform*>& uniforms, const GLuint alignment ) {
+	for ( uint32_t i = 0; i < uniforms.size(); i++ ) {
+		if ( uniforms[i]->GetSTD430Size() == alignment ) {
+			return i;
+		}
+	}
+
+	if ( uniforms[uniforms.size() - 1]->GetSTD430Size() < alignment ) {
+		return uniforms.size() - 1;
+	}
+
+	return -1;
+}
+
 // Compute std430 size/alignment and sort uniforms from highest to lowest alignment
 void GLShader::PostProcessUniforms() {
 	if ( !_useMaterialSystem ) {
 		return;
 	}
 
-	std::vector<GLUniform*> tmp;
-
-	std::vector<GLUniform*> globalUniforms;
 	for ( GLUniform* uniform : _uniforms ) {
-		if ( uniform->IsGlobal() || uniform->IsTexture() ) {
-			globalUniforms.emplace_back( uniform );
+		if ( !uniform->IsGlobal() ) {
+			_materialSystemUniforms.emplace_back( uniform );
 		}
 	}
-	for ( GLUniform* uniform : globalUniforms ) {
-		_uniforms.erase( std::remove( _uniforms.begin(), _uniforms.end(), uniform ), _uniforms.end() );
-	}
+
+	std::sort( _materialSystemUniforms.begin(), _materialSystemUniforms.end(),
+		[]( const GLUniform* lhs, const GLUniform* rhs ) {
+			return lhs->GetSTD430Size() > rhs->GetSTD430Size();
+		}
+	);
 
 	// Sort uniforms from highest to lowest alignment so we don't need to pad uniforms (other than vec3s)
-	const uint numUniforms = _uniforms.size();
-	GLuint structSize = 0;
+	const uint numUniforms = _materialSystemUniforms.size();
+	std::vector<GLUniform*> tmp;
 	while ( tmp.size() < numUniforms ) {
 		// Higher-alignment uniforms first to avoid wasting memory
-		GLuint highestAlignment = 0;
-		int highestUniform = 0;
-		for( uint i = 0; i < _uniforms.size(); i++ ) {
-			if ( _uniforms[i]->GetSTD430Alignment() > highestAlignment ) {
-				highestAlignment = _uniforms[i]->GetSTD430Alignment();
-				highestUniform = i;
-			}
+		GLuint size = _materialSystemUniforms[0]->GetSTD430Size();
+		GLuint components = _materialSystemUniforms[0]->GetComponentSize();
+		size = components ? 4 * components : size;
+		GLuint alignmentConsume = 4 - size % 4;
 
-			if ( highestAlignment == 4 ) {
-				break; // 4-component is the highest alignment in std430
-			}
-		}
-			
-		const GLuint size = _uniforms[highestUniform]->GetSTD430Size();
-		if ( _uniforms[highestUniform]->GetComponentSize() != 0 ) {
-			structSize += ( size == 3 ) ? 4 * _uniforms[highestUniform]->GetComponentSize() :
-												size * _uniforms[highestUniform]->GetComponentSize();
-		} else {
-			structSize += ( size == 3 ) ? 4 : size;
+		tmp.emplace_back( _materialSystemUniforms[0] );
+		_materialSystemUniforms.erase( _materialSystemUniforms.begin() );
+
+		int uniform;
+		while ( ( alignmentConsume & 3 ) && _materialSystemUniforms.size()
+			&& ( uniform = FindUniformForAlignment( _materialSystemUniforms, alignmentConsume ) ) != -1 ) {
+			alignmentConsume -= _materialSystemUniforms[uniform]->GetSTD430Size();
+
+			tmp.emplace_back( _materialSystemUniforms[uniform] );
+			_materialSystemUniforms.erase( _materialSystemUniforms.begin() + uniform );
 		}
 
-		tmp.emplace_back( _uniforms[highestUniform] );
-		_uniforms.erase( _uniforms.begin() + highestUniform );
+		size = PAD( size, 4 );
+		std430Size += size;
+		padding = alignmentConsume;
 	}
-	_uniforms = tmp;
 
-	const GLuint structAlignment = 4; // Material buffer is now a UBO, so it uses std140 layout, which is aligned to vec4
-	if ( structSize > 0 ) {
-		padding = ( structAlignment - ( structSize % structAlignment ) ) % structAlignment;
-	}
-	std430Size = structSize;
-	for ( GLUniform* uniform : globalUniforms ) {
-		_uniforms.emplace_back( uniform );
-	}
+	_materialSystemUniforms = tmp;
 }
 
 uint32_t GLShader::GetUniqueCompileMacros( size_t permutation, const int type ) const {
@@ -2361,10 +2335,8 @@ void GLShader::SetRequiredVertexPointers()
 
 void GLShader::WriteUniformsToBuffer( uint32_t* buffer ) {
 	uint32_t* bufPtr = buffer;
-	for ( GLUniform* uniform : _uniforms ) {
-		if ( !uniform->IsGlobal() && !uniform->IsTexture() ) {
-			bufPtr = uniform->WriteToBuffer( bufPtr );
-		}
+	for ( GLUniform* uniform : _materialSystemUniforms ) {
+		bufPtr = uniform->WriteToBuffer( bufPtr );
 	}
 }