Combine OpenGL uniforms into batches

Author: drops

res/gamedata/shaders/gl/deffer_detail_s_flat.vs

@@ -1,18 +1,24 @@
 #include "common.h"
 #include "iostructs\v_detail.h"
 
-uniform float4 		consts; // {1/quant,1/quant,diffusescale,ambient}
-//uniform float4 		array	[200] : register(c12);
-//tbuffer DetailsData
-//{
-	uniform float4 		array[61*4];
-//}
+layout(std140) uniform EnvironmentDetailUBO {
+    mat4 xform;
+    mat4 formView;
+    vec4 consts;
+    vec4 scale;
+    vec4 bias;
+    vec4 wind;
+    vec4 wave;
+    vec3 sun;
+};
+
+uniform float4 		array[61*4];
 
 v2p_flat 	_main (v_detail v)
 {
 	v2p_flat 		O;
 	// index
-	int 	i 	= int(v.misc.w);
+	int 	i 	= gl_InstanceID*4;
 	float4  m0 	= array[i+0];
 	float4  m1 	= array[i+1];
 	float4  m2 	= array[i+2];

res/gamedata/shaders/gl/deffer_detail_w_flat.vs

@@ -1,20 +1,24 @@
 #include "common.h"
 #include "iostructs\v_detail.h"
 
-uniform float4 		consts; // {1/quant,1/quant,diffusescale,ambient}
-uniform float4 		wave; 	// cx,cy,cz,tm
-uniform float4 		dir2D; 
-//uniform float4 		array	[200] : register(c12);
-//tbuffer DetailsData
-//{
-	uniform float4 		array[61*4];
-//}
+layout(std140) uniform EnvironmentDetailUBO {
+    mat4 xform;
+    mat4 formView;
+    vec4 consts;
+    vec4 scale;
+    vec4 bias;
+    vec4 wind;
+    vec4 wave;
+    vec3 sun;
+};
+
+uniform float4 		array[61*4];
 
 v2p_flat 	_main (v_detail v)
 {
 	v2p_flat 		O;
 	// index
-	int 	i 	= int(v.misc.w);
+	int 	i 	= gl_InstanceID*4;
 	float4  m0 	= array[i+0];
 	float4  m1 	= array[i+1];
 	float4  m2 	= array[i+2];
@@ -33,7 +37,7 @@ v2p_flat 	_main (v_detail v)
 	float 	H 	= pos.y - base;			// height of vertex (scaled)
 	float 	frac 	= v.misc.z*consts.x;		// fractional
 	float 	inten 	= H * dp;
-	float2 	result	= calc_xz_wave	(dir2D.xz*inten,frac);
+	float2 	result	= calc_xz_wave	(wind.xz*inten,frac);
 	pos		= float4(pos.x+result.x, pos.y, pos.z+result.y, 1);
 
 	// Normal in world coords

src/Layers/xrRender/DetailManager.h

@@ -50,9 +50,38 @@ extern float dm_current_fade;// = float(2*dm_current_size)-.5f;
 extern float ps_current_detail_density;
 extern float ps_current_detail_height;
 
+#ifdef USE_OGL
+#pragma pack(push, 1)
+struct EnvironmentDetailData
+{
+    glm::mat4x4	xform;
+    glm::mat4x4	xformView;
+    glm::vec4 consts;
+    glm::vec4 scale;
+    glm::vec4 bias;
+    glm::vec4 wind;
+    glm::vec4 wave;
+    glm::vec3 sun;
+
+private:
+    [[maybe_unused]]
+    glm::vec1 _glsl_140_padding {};
+    // 224 bytes
+};
+#pragma pack(pop)
+#endif
+
 class ECORE_API CDetailManager
 {
 public:
+#ifdef USE_OGL
+    EnvironmentDetailData environmentDetailData[3];
+
+    UniformBufferObject uniformBufferObject = {
+        GL_NONE, GL_DYNAMIC_DRAW, sizeof(EnvironmentDetailData)*3
+    };
+#endif
+
     struct SlotItem
     { // один кустик
         float scale;
@@ -70,9 +99,9 @@ class ECORE_API CDetailManager
 
     struct SlotPart
     { //
-        u32 id; // ID модельки
-        SlotItemVec items; // список кустиков
-        SlotItemVec r_items[3]; // список кустиков for render
+        u32 id; // ID models
+        SlotItemVec items; // list of bushes
+        SlotItemVec r_items[3]; // list of bushes for render
     };
 
     enum SlotType : u32
@@ -197,7 +226,11 @@ class ECORE_API CDetailManager
     void hw_Load_Shaders();
     void hw_Unload();
     void hw_Render(CBackend& cmd_list);
+#ifdef USE_OGL
+    void hw_Render_dump(CBackend& cmd_list, u32 var_id, u32 lod_id);
+#else
     void hw_Render_dump(CBackend& cmd_list, const Fvector4& consts, const Fvector4& wave, const Fvector4& wind, u32 var_id, u32 lod_id);
+#endif
 
     // get unpacked slot
     DetailSlot& QueryDB(int sx, int sz);

src/Layers/xrRender/SH_Atomic.h

@@ -31,6 +31,7 @@ struct ECORE_API SVS : public xr_resource_named
     ID3DVertexShader* sh;
 #elif defined(USE_OGL)
     GLuint sh;
+    uint32_t bindingSlots = 0;
 #else
 #   error No graphics API selected or enabled!
 #endif

src/Layers/xrRenderGL/glDetailManager_VS.cpp

@@ -32,67 +32,83 @@ void CDetailManager::hw_Render(CBackend& cmd_list)
 {
     using namespace detail_manager;
 
+    if (uniformBufferObject.id == GL_NONE)
+        RCache.uniformBufferObjectGenerate(uniformBufferObject);
+
     // Render-prepare
     //	Update timer
     //	Can't use Device.fTimeDelta since it is smoothed! Don't know why, but smoothed value looks more choppy!
     float fDelta = Device.fTimeGlobal - m_global_time_old;
     if (fDelta < 0 || fDelta > 1)
+    {
         fDelta = 0.03f;
+    }
     m_global_time_old = Device.fTimeGlobal;
 
     m_time_rot_1 += PI_MUL_2 * fDelta / swing_current.rot1;
     m_time_rot_2 += PI_MUL_2 * fDelta / swing_current.rot2;
     m_time_pos += fDelta * swing_current.speed;
 
-    //float		tm_rot1		= (PI_MUL_2*Device.fTimeGlobal/swing_current.rot1);
-    //float		tm_rot2		= (PI_MUL_2*Device.fTimeGlobal/swing_current.rot2);
-    float tm_rot1 = m_time_rot_1;
-    float tm_rot2 = m_time_rot_2;
-
-    Fvector4 dir1, dir2;
-    dir1.set(_sin(tm_rot1), 0, _cos(tm_rot1), 0).normalize().mul(swing_current.amp1);
-    dir2.set(_sin(tm_rot2), 0, _cos(tm_rot2), 0).normalize().mul(swing_current.amp2);
+    glm::vec4 wind1 = normalize(glm::vec4(_sin(m_time_rot_1), 0, _cos(m_time_rot_1), 0)) * swing_current.amp1;
+    glm::vec4 wind2 = normalize(glm::vec4(_sin(m_time_rot_2), 0, _cos(m_time_rot_2), 0)) * swing_current.amp2;
 
     // Setup geometry and DMA
     cmd_list.set_Geometry(hw_Geom);
 
+    const auto& desc = g_pGamePersistent->Environment().CurrentEnv;
+
     // Wave0
     float scale = 1.f / float(quant);
-    Fvector4 wave;
-    Fvector4 consts;
-    consts.set(scale, scale, ps_r__Detail_l_aniso, ps_r__Detail_l_ambient);
-    //wave.set				(1.f/5.f,		1.f/7.f,	1.f/3.f,	Device.fTimeGlobal*swing_current.speed);
-    wave.set(1.f / 5.f, 1.f / 7.f, 1.f / 3.f, m_time_pos);
-    //RCache.set_c			(&*hwc_consts,	scale,		scale,		ps_r__Detail_l_aniso,	ps_r__Detail_l_ambient);				// consts
-    //RCache.set_c			(&*hwc_wave,	wave.div(PI_MUL_2));	// wave
-    //RCache.set_c			(&*hwc_wind,	dir1);																					// wind-dir
-    //hw_Render_dump			(&*hwc_array,	1, 0, c_hdr );
-    hw_Render_dump(cmd_list, consts, wave.div(PI_MUL_2), dir1, 1, 0);
-
-    // Wave1
-    //wave.set				(1.f/3.f,		1.f/7.f,	1.f/5.f,	Device.fTimeGlobal*swing_current.speed);
-    wave.set(1.f / 3.f, 1.f / 7.f, 1.f / 5.f, m_time_pos);
-    //RCache.set_c			(&*hwc_wave,	wave.div(PI_MUL_2));	// wave
-    //RCache.set_c			(&*hwc_wind,	dir2);																					// wind-dir
-    //hw_Render_dump			(&*hwc_array,	2, 0, c_hdr );
-    hw_Render_dump(cmd_list, consts, wave.div(PI_MUL_2), dir2, 2, 0);
-
-    // Still
-    consts.set(scale, scale, scale, 1.f);
-    //RCache.set_c			(&*hwc_s_consts,scale,		scale,		scale,				1.f);
-    //RCache.set_c			(&*hwc_s_xform,	Device.mFullTransform);
-    //hw_Render_dump			(&*hwc_s_array,	0, 1, c_hdr );
-    hw_Render_dump(cmd_list, consts, wave.div(PI_MUL_2), dir2, 0, 1);
+
+    //environmentDetailUbo[0].xform = Device.mFullTransform;
+    memcpy(&environmentDetailData[0].xform, &Device.mFullTransform, sizeof(glm::mat4));
+    //environmentDetailUbo[0].xformView;
+    environmentDetailData[0].consts = glm::vec4(scale, scale, ps_r__Detail_l_aniso, ps_r__Detail_l_ambient);
+    environmentDetailData[0].scale = glm::vec4(scale, scale, ps_r__Detail_l_aniso, ps_r__Detail_l_ambient);
+    //environmentDetailUbo[0].bias;
+    environmentDetailData[0].wind = wind1;
+    environmentDetailData[0].wave = glm::vec4(1.f / 5.f, 1.f / 7.f, 1.f / 3.f, m_time_pos) / PI_MUL_2;
+    environmentDetailData[0].sun = glm::vec3(desc.sun_color.x, desc.sun_color.y, desc.sun_color.z) * 0.5f;
+
+    //
+
+    //environmentDetailUbo[1].xform = Device.mFullTransform;
+    memcpy(&environmentDetailData[1].xform, &Device.mFullTransform, sizeof(glm::mat4));
+    //environmentDetailUbo[1].xformView;
+    environmentDetailData[1].consts = glm::vec4(scale, scale, ps_r__Detail_l_aniso, ps_r__Detail_l_ambient);
+    environmentDetailData[1].scale = glm::vec4(scale, scale, ps_r__Detail_l_aniso, ps_r__Detail_l_ambient);
+    //environmentDetailUbo[1].bias;
+    environmentDetailData[1].wind = wind2;
+    environmentDetailData[1].wave = glm::vec4(1.f / 3.f, 1.f / 7.f, 1.f / 5.f, m_time_pos) / PI_MUL_2;
+    environmentDetailData[1].sun = glm::vec3(desc.sun_color.x, desc.sun_color.y, desc.sun_color.z) * 0.5f;
+
+    //
+
+    //environmentDetailUbo[2].xform = Device.mFullTransform;
+    memcpy(&environmentDetailData[2].xform, &Device.mFullTransform, sizeof(glm::mat4));
+    //environmentDetailUbo[2].xformView;
+    environmentDetailData[2].consts = glm::vec4(scale, scale, scale, 1.f);
+    environmentDetailData[2].scale = glm::vec4(scale, scale, ps_r__Detail_l_aniso, ps_r__Detail_l_ambient);
+    //environmentDetailUbo[2].bias;
+    environmentDetailData[2].wind = wind2;
+    environmentDetailData[2].wave = glm::vec4(1.f / 3.f, 1.f / 7.f, 1.f / 5.f, m_time_pos) / PI_MUL_2;
+    environmentDetailData[2].sun = glm::vec3(desc.sun_color.x, desc.sun_color.y, desc.sun_color.z) * 0.5f;
+
+    RCache.uniformBufferObjectPushToDevice(uniformBufferObject, uniformBufferObject.size, &environmentDetailData);
+
+    CHK_GL(glBindBufferRange(GL_UNIFORM_BUFFER, 3, uniformBufferObject.id, 0, sizeof(EnvironmentDetailData)));
+    hw_Render_dump(cmd_list, 1, 0);
+
+    CHK_GL(glBindBufferRange(GL_UNIFORM_BUFFER, 3, uniformBufferObject.id, sizeof(EnvironmentDetailData), sizeof(EnvironmentDetailData)));
+    hw_Render_dump(cmd_list, 2, 0);
+
+    CHK_GL(glBindBufferRange(GL_UNIFORM_BUFFER, 3, uniformBufferObject.id, sizeof(EnvironmentDetailData)*2, sizeof(EnvironmentDetailData)));
+    hw_Render_dump(cmd_list, 0, 1);
 }
 
-void CDetailManager::hw_Render_dump(CBackend& cmd_list, const Fvector4& consts, const Fvector4& wave, const Fvector4& wind, u32 var_id,
-                                    u32 lod_id)
+void CDetailManager::hw_Render_dump(CBackend& cmd_list, u32 var_id, u32 lod_id)
 {
-    static shared_str strConsts("consts");
-    static shared_str strWave("wave");
-    static shared_str strDir2D("dir2D");
     static shared_str strArray("array");
-    static shared_str strXForm("xform");
 
     RImplementation.BasicStats.DetailCount = 0;
 
@@ -118,35 +134,15 @@ void CDetailManager::hw_Render_dump(CBackend& cmd_list, const Fvector4& consts,
         {
             for (u32 iPass = 0; iPass < Object.shader->E[lod_id]->passes.size(); ++iPass)
             {
-                // Setup matrices + colors (and flush it as necessary)
-                //RCache.set_Element				(Object.shader->E[lod_id]);
+                // TODO register only once
+                RCache.uniformBufferObjectRegisterWithProgram(Object.shader->E[lod_id]->passes[iPass]->vs, "EnvironmentDetailUBO", 3, uniformBufferObject);
+
                 cmd_list.set_Element(Object.shader->E[lod_id], iPass);
                 cmd_list.apply_lmaterial();
 
-                //	This could be cached in the corresponding consatant buffer
-                //	as it is done for DX9
-                cmd_list.set_c(strConsts, consts);
-                cmd_list.set_c(strWave, wave);
-                cmd_list.set_c(strDir2D, wind);
-                cmd_list.set_c(strXForm, Device.mFullTransform);
-
                 ref_constant constArray = cmd_list.get_c(strArray);
                 VERIFY(constArray);
 
-                //u32			c_base				= x_array->vs.index;
-                //Fvector4*	c_storage			= RCache.get_ConstantCache_Vertex().get_array_f().access(c_base);
-                // TODO: OGL: Implement a constants buffer.
-                /*Fvector4*	c_storage=0;
-                //	Map constants to memory directly
-                {
-                    void*	pVData;
-                    RCache.get_ConstantDirect( strArray,
-                        hw_BatchSize*sizeof(Fvector4)*4,
-                        &pVData, 0, 0);
-                    c_storage = (Fvector4*) pVData;
-                }
-                VERIFY(c_storage);*/
-
                 u32 dwBatch = 0;
                 xr_vector<glm::vec4> uniformBuffer;
                 uniformBuffer.reserve(hw_BatchSize*4);
@@ -167,22 +163,19 @@ void CDetailManager::hw_Render_dump(CBackend& cmd_list, const Fvector4& consts,
 
                         // Build color
                         // R2 only needs hemisphere
-                        float h = instance->c_hemi;
-                        float s = instance->c_sun;
+                        uniformBuffer.emplace_back(instance->c_sun, instance->c_sun, instance->c_sun, instance->c_hemi);
 
-                        uniformBuffer.emplace_back(s, s, s, h);
                         dwBatch ++;
                         if (dwBatch == hw_BatchSize)
                         {
                             // flush
                             RImplementation.BasicStats.DetailCount += dwBatch;
                             u32 dwCNT_verts = dwBatch * Object.number_vertices;
                             u32 dwCNT_prims = dwBatch * Object.number_indices / 3;
-                            //RCache.get_ConstantCache_Vertex().b_dirty				=	TRUE;
-                            //RCache.get_ConstantCache_Vertex().get_array_f().dirty	(c_base,c_base+dwBatch*4);
 
                             cmd_list.set_uniforms(constArray->vs.program, constArray->vs.location, uniformBuffer);
-                            cmd_list.Render(D3DPT_TRIANGLELIST, vOffset, 0, dwCNT_verts, iOffset, dwCNT_prims);
+                            glDrawElementsInstancedBaseVertex(GL_TRIANGLES, Object.number_indices, GL_UNSIGNED_SHORT, (void*)(iOffset * sizeof(GLushort)), dwBatch, vOffset);
+
                             cmd_list.stat.r.s_details.add(dwCNT_verts);
                             uniformBuffer.clear();
 
@@ -197,16 +190,15 @@ void CDetailManager::hw_Render_dump(CBackend& cmd_list, const Fvector4& consts,
                     RImplementation.BasicStats.DetailCount += dwBatch;
                     u32 dwCNT_verts = dwBatch * Object.number_vertices;
                     u32 dwCNT_prims = dwBatch * Object.number_indices / 3;
-                    //RCache.get_ConstantCache_Vertex().b_dirty				=	TRUE;
-                    //RCache.get_ConstantCache_Vertex().get_array_f().dirty	(c_base,c_base+dwBatch*4);
+
                     cmd_list.set_uniforms(constArray->vs.program, constArray->vs.location, uniformBuffer);
-                    cmd_list.Render(D3DPT_TRIANGLELIST, vOffset, 0, dwCNT_verts, iOffset, dwCNT_prims);
+                    glDrawElementsInstancedBaseVertex(GL_TRIANGLES, Object.number_indices, GL_UNSIGNED_SHORT, (void*)(iOffset * sizeof(GLushort)), dwBatch, vOffset);
                     cmd_list.stat.r.s_details.add(dwCNT_verts);
                 }
             }
         }
-        vOffset += hw_BatchSize * Object.number_vertices;
-        iOffset += hw_BatchSize * Object.number_indices;
+        vOffset += Object.number_vertices;
+        iOffset += Object.number_indices;
     }
 }
 } // namespace xray::render::RENDER_NAMESPACE