Generalise uniform post-processing

Also adds `GLShader.pushSkip` and `GLShader._pushUniforms`. Add `padding` back to the `GLShader` size calculations in material system.

Author: VReaperV

src/engine/renderer/gl_shader.cpp

@@ -2096,11 +2096,7 @@ static auto FindUniformForOffset( std::vector<GLUniform*>& uniforms, const GLuin
 // Compute std140 size/alignment and sort uniforms from highest to lowest alignment
 // Note: using the std430 uniform size will give the wrong result for matrix types where
 // the number of rows is not 4
-void GLShader::PostProcessUniforms() {
-	if ( !_useMaterialSystem ) {
-		return;
-	}
-
+GLuint GLShaderManager::SortUniforms( std::vector<GLUniform*>& uniforms ) {
 	std::vector<GLUniform*> uniformQueue;
 	for ( GLUniform* uniform : _uniforms ) {
 		if ( !uniform->_global ) {
@@ -2116,15 +2112,15 @@ void GLShader::PostProcessUniforms() {
 
 	// Sort uniforms from highest to lowest alignment so we don't need to pad uniforms (other than vec3s)
 	GLuint align = 4; // mininum alignment since this will be used as an std140 array element
-	std140Size = 0;
-	_materialSystemUniforms.clear();
+	GLuint structSize = 0;
+	uniforms.clear();
 	while ( !uniformQueue.empty() || std140Size & ( align - 1 ) ) {
 		auto iterNext = FindUniformForOffset( uniformQueue, std140Size );
 		if ( iterNext == uniformQueue.end() ) {
 			// add 1 unit of padding
 			ASSERT( !_materialSystemUniforms.back()->_components); // array WriteToBuffer impls don't handle padding correctly
 			++std140Size;
-			++_materialSystemUniforms.back()->_std430Size;
+			++uniforms.back()->_std430Size;
 		} else {
 			( *iterNext )->_std430Size = ( *iterNext )->_std430BaseSize;
 			if ( ( *iterNext )->_components ) {
@@ -2134,10 +2130,24 @@ void GLShader::PostProcessUniforms() {
 				std140Size += ( *iterNext )->_std430Size;
 			}
 			align = std::max( align, ( *iterNext )->_std430Alignment );
-			_materialSystemUniforms.push_back( *iterNext );
+			uniforms.push_back( *iterNext );
 			uniformQueue.erase( iterNext );
 		}
 	}
+	return structSize;
+}
+
+void GLShader::PostProcessUniforms() {
+	if ( _useMaterialSystem ) {
+		_materialSystemUniforms = gl_shaderManager.ProcessUniforms( GLUniform::MATERIAL_OR_PUSH, GLUniform::MATERIAL_OR_PUSH,
+			true, _uniforms, std430Size, padding );
+	}
+
+	if ( glConfig.pushBufferAvailable && !pushSkip ) {
+		GLuint unused;
+		_pushUniforms = gl_shaderManager.ProcessUniforms( GLUniform::CONST, GLUniform::FRAME,
+			false, _uniforms, unused, unused );
+	}
 }
 
 uint32_t GLShader::GetUniqueCompileMacros( size_t permutation, const int type ) const {

src/engine/renderer/gl_shader.h

@@ -188,6 +188,7 @@ class GLShader {
 	GLuint std140Size = 0;
 
 	const bool worldShader;
+	const bool pushSkip;
 protected:
 	int _activeMacros = 0;
 	ShaderProgramDescriptor* currentProgram;
@@ -202,13 +203,15 @@ class GLShader {
 
 	size_t _uniformStorageSize;
 	std::vector<GLUniform*> _uniforms;
+	std::vector<GLUniform*> _pushUniforms;
 	std::vector<GLUniform*> _materialSystemUniforms;
 	std::vector<GLUniformBlock*> _uniformBlocks;
 	std::vector<GLCompileMacro*> _compileMacros;
 
 	GLShader( const std::string& name, uint32_t vertexAttribsRequired,
 		const bool useMaterialSystem,
-		const std::string newVertexShaderName, const std::string newFragmentShaderName ) :
+		const std::string newVertexShaderName, const std::string newFragmentShaderName,
+		const bool newPushSkip = false ) :
 		_name( name ),
 		_vertexAttribsRequired( vertexAttribsRequired ),
 		_useMaterialSystem( useMaterialSystem ),
@@ -217,7 +220,8 @@ class GLShader {
 		hasVertexShader( true ),
 		hasFragmentShader( true ),
 		hasComputeShader( false ),
-		worldShader( false ) {
+		worldShader( false ),
+		pushSkip( newPushSkip ) {
 	}
 
 	GLShader( const std::string& name,
@@ -230,7 +234,8 @@ class GLShader {
 		hasVertexShader( false ),
 		hasFragmentShader( false ),
 		hasComputeShader( true ),
-		worldShader( newWorldShader ) {
+		worldShader( newWorldShader ),
+		pushSkip( false ) {
 	}
 
 public:
@@ -396,6 +401,10 @@ class GLShaderManager {
 	void GenerateBuiltinHeaders();
 	void GenerateWorldHeaders();
 
+	static GLuint SortUniforms( std::vector<GLUniform*>& uniforms );
+	static std::vector<GLUniform*> ProcessUniforms( const GLUniform::UpdateType minType, const GLUniform::UpdateType maxType,
+		const bool skipTextures, std::vector<GLUniform*>& uniforms, GLuint& structSize, GLuint& padding );
+
 	template<class T>
 	void LoadShader( T*& shader ) {
 		if ( !deformShaderCount ) {