Combine OpenGL uniforms into batches

Author: drops

res/gamedata/shaders/gl/deffer_detail_s_flat.vs

@@ -1,16 +1,7 @@
 #include "common.h"
 #include "iostructs\v_detail.h"
 
-layout(std140) uniform EnvironmentDetailUBO {
-    mat4 xform;
-    mat4 formView;
-    vec4 consts;
-    vec4 scale;
-    vec4 bias;
-    vec4 wind;
-    vec4 wave;
-    vec3 sun;
-};
+#include "shared\ubo_render_dump.h"
 
 uniform float4 		array[61*4];
 

res/gamedata/shaders/gl/deffer_detail_w_flat.vs

@@ -1,16 +1,7 @@
 #include "common.h"
 #include "iostructs\v_detail.h"
 
-layout(std140) uniform EnvironmentDetailUBO {
-    mat4 xform;
-    mat4 formView;
-    vec4 consts;
-    vec4 scale;
-    vec4 bias;
-    vec4 wind;
-    vec4 wave;
-    vec3 sun;
-};
+#include "shared\ubo_render_dump.h"
 
 uniform float4 		array[61*4];
 

res/gamedata/shaders/gl/shared/ubo_render_dump.h

@@ -0,0 +1,15 @@
+#ifndef OPENXRAY_UBO_RENDER_DUMP_H
+#define OPENXRAY_UBO_RENDER_DUMP_H
+
+layout(std140) uniform RenderDumpUBO {
+    float4x4 xform;
+    float4x4 formView;
+    float4 consts;
+    float4 scale;
+    float4 bias;
+    float4 wind;
+    float4 wave;
+    float4 sun;
+};
+
+#endif

src/Layers/xrRender/DetailManager.h

@@ -50,38 +50,9 @@ 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;
@@ -214,12 +185,14 @@ class ECORE_API CDetailManager
     VertexStagingBuffer hw_VB;
     IndexStagingBuffer hw_IB;
 
+#ifndef USE_OGL
     ref_constant hwc_consts;
     ref_constant hwc_wave;
     ref_constant hwc_wind;
-    ref_constant hwc_array;
     ref_constant hwc_s_consts;
     ref_constant hwc_s_xform;
+#endif
+    ref_constant hwc_array;
     ref_constant hwc_s_array;
     void hw_Load();
     void hw_Load_Geom();
@@ -258,5 +231,16 @@ class ECORE_API CDetailManager
 
     CDetailManager();
     virtual ~CDetailManager();
+
+#ifdef USE_OGL
+private:
+    // TODO move to global registry ?
+    GLuint renderDumpBlockBinding = 3;
+    ShaderInstanceData renderDumpData[3];
+
+    UniformBufferObject renderDumpUBO = {
+        BUFFER_DEBUG_NAME("DetailManagerUBO") GL_NONE, GL_DYNAMIC_DRAW, sizeof(ShaderInstanceData)*3
+    };
+#endif
 };
 } // namespace xray::render::RENDER_NAMESPACE

src/Layers/xrRender/R_Backend.h

@@ -23,7 +23,7 @@
 #endif
 #ifdef USE_OGL
 #include <glm/glm.hpp>
-#include "gl_backend_uniforms.h"
+#include "gl_backend_extension.h"
 #endif
 
 #include "FVF.h"
@@ -65,7 +65,7 @@ struct R_statistics
 #pragma warning(disable:4324)
 class ECORE_API CBackend
 #ifdef USE_OGL
-    : public CBackendUniforms
+    : public CBackendExtension
 #endif
 {
 public:
@@ -410,6 +410,7 @@ class ECORE_API CBackend
 public:
 #if defined(USE_OGL)
     ICF bool is_TessEnabled() { return false; }
+    void RenderInstanced(D3DPRIMITIVETYPE T, u32 baseV, u32 startV, u32 countV, u32 startI, u32 PC, GLsizei instanceCount);
 #elif defined(USE_DX11)
     ICF bool is_TessEnabled();
 #else

src/Layers/xrRender/SkeletonX.cpp

@@ -95,7 +95,7 @@ void CSkeletonX::_Render(CBackend& cmd_list, ref_geom& hGeom, u32 vCount, u32 iO
 
         // render
 #ifdef USE_OGL
-        cmd_list.set_uniforms(array->vs.program, array->vs.location, uniformBuffer);
+        cmd_list.setUniforms(array->vs.program, array->vs.location, uniformBuffer);
 #endif
         cmd_list.set_Geometry(hGeom);
         cmd_list.Render(D3DPT_TRIANGLELIST, 0, 0, vCount, iOffset, pCount);

src/Layers/xrRenderGL/glDetailManager_VS.cpp

@@ -19,22 +19,29 @@ void CDetailManager::hw_Load_Shaders()
     S.create("details" DELIMITER "set");
     R_constant_table& T0 = *S->E[0]->passes[0]->constants;
     R_constant_table& T1 = *S->E[1]->passes[0]->constants;
-    hwc_consts = T0.get("consts");
-    hwc_wave = T0.get("wave");
-    hwc_wind = T0.get("dir2D");
     hwc_array = T0.get("array");
-    hwc_s_consts = T1.get("consts");
-    hwc_s_xform = T1.get("xform");
     hwc_s_array = T1.get("array");
+
+    // TODO: There has to be a better way to do this
+    for (auto shader_element : S->E)
+    {
+        if (shader_element == nullptr)
+            continue;
+
+        for (auto pass : shader_element->passes)
+        {
+            if (pass->vs && pass->vs->sh)
+            {
+                RCache.uboRegisterWithProgram(pass->vs, "RenderDumpUBO", renderDumpBlockBinding, renderDumpUBO);
+            }
+        }
+    }
 }
 
 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!
@@ -58,51 +65,47 @@ void CDetailManager::hw_Render(CBackend& cmd_list)
     const auto& desc = g_pGamePersistent->Environment().CurrentEnv;
 
     // Wave0
-    float scale = 1.f / float(quant);
+    float scale = 1.f / static_cast<float>(quant);
 
     //environmentDetailUbo[0].xform = Device.mFullTransform;
-    memcpy(&environmentDetailData[0].xform, &Device.mFullTransform, sizeof(glm::mat4));
+    memcpy(&renderDumpData[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);
+    renderDumpData[0].consts = glm::vec4(scale, scale, ps_r__Detail_l_aniso, ps_r__Detail_l_ambient);
+    renderDumpData[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;
-
-    //
+    renderDumpData[0].wind = wind1;
+    renderDumpData[0].wave = glm::vec4(1.f / 5.f, 1.f / 7.f, 1.f / 3.f, m_time_pos) / PI_MUL_2;
+    renderDumpData[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));
+    memcpy(&renderDumpData[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);
+    renderDumpData[1].consts = glm::vec4(scale, scale, ps_r__Detail_l_aniso, ps_r__Detail_l_ambient);
+    renderDumpData[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;
-
-    //
+    renderDumpData[1].wind = wind2;
+    renderDumpData[1].wave = glm::vec4(1.f / 3.f, 1.f / 7.f, 1.f / 5.f, m_time_pos) / PI_MUL_2;
+    renderDumpData[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));
+    memcpy(&renderDumpData[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);
+    renderDumpData[2].consts = glm::vec4(scale, scale, scale, 1.f);
+    renderDumpData[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;
+    renderDumpData[2].wind = wind2;
+    renderDumpData[2].wave = glm::vec4(1.f / 3.f, 1.f / 7.f, 1.f / 5.f, m_time_pos) / PI_MUL_2;
+    renderDumpData[2].sun = glm::vec3(desc.sun_color.x, desc.sun_color.y, desc.sun_color.z) * 0.5f;
 
-    RCache.uniformBufferObjectPushToDevice(uniformBufferObject, uniformBufferObject.size, &environmentDetailData);
+    cmd_list.uboPushToDevice(renderDumpUBO, renderDumpUBO.size, &renderDumpData);
 
-    CHK_GL(glBindBufferRange(GL_UNIFORM_BUFFER, 3, uniformBufferObject.id, 0, sizeof(EnvironmentDetailData)));
+    cmd_list.uboBindRange(renderDumpUBO, renderDumpBlockBinding, 0, sizeof(ShaderInstanceData));
     hw_Render_dump(cmd_list, 1, 0);
 
-    CHK_GL(glBindBufferRange(GL_UNIFORM_BUFFER, 3, uniformBufferObject.id, sizeof(EnvironmentDetailData), sizeof(EnvironmentDetailData)));
+    cmd_list.uboBindRange(renderDumpUBO, renderDumpBlockBinding, sizeof(ShaderInstanceData), sizeof(ShaderInstanceData));
     hw_Render_dump(cmd_list, 2, 0);
 
-    CHK_GL(glBindBufferRange(GL_UNIFORM_BUFFER, 3, uniformBufferObject.id, sizeof(EnvironmentDetailData)*2, sizeof(EnvironmentDetailData)));
+    cmd_list.uboBindRange(renderDumpUBO, renderDumpBlockBinding, sizeof(ShaderInstanceData)*2, sizeof(ShaderInstanceData));
     hw_Render_dump(cmd_list, 0, 1);
 }
 
@@ -118,41 +121,30 @@ void CDetailManager::hw_Render_dump(CBackend& cmd_list, u32 var_id, u32 lod_id)
 
     vis_list& list = m_visibles [var_id];
 
-    const auto& desc = g_pGamePersistent->Environment().CurrentEnv;
-    Fvector c_sun, c_ambient, c_hemi;
-    c_sun.set(desc.sun_color.x, desc.sun_color.y, desc.sun_color.z);
-    c_sun.mul(.5f);
-    c_ambient.set(desc.ambient.x, desc.ambient.y, desc.ambient.z);
-    c_hemi.set(desc.hemi_color.x, desc.hemi_color.y, desc.hemi_color.z);
-
     // Iterate
     for (u32 O = 0; O < objects.size(); O++)
     {
         CDetail& Object = *objects [O];
         xr_vector<SlotItemVec*>& vis = list [O];
+
         if (!vis.empty())
         {
             for (u32 iPass = 0; iPass < Object.shader->E[lod_id]->passes.size(); ++iPass)
             {
-                // 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();
 
                 ref_constant constArray = cmd_list.get_c(strArray);
                 VERIFY(constArray);
 
-                u32 dwBatch = 0;
+                u32 instanceCount = 0;
                 xr_vector<glm::vec4> uniformBuffer;
                 uniformBuffer.reserve(hw_BatchSize*4);
 
                 for (auto items : vis)
                 {
                     for (auto& instance : *items)
                     {
-                        u32 base = dwBatch * 4;
-
                         // Build matrix ( 3x4 matrix, last row - color )
                         float scale = instance->scale_calculated;
                         Fmatrix& M = instance->mRotY;
@@ -165,35 +157,28 @@ void CDetailManager::hw_Render_dump(CBackend& cmd_list, u32 var_id, u32 lod_id)
                         // R2 only needs hemisphere
                         uniformBuffer.emplace_back(instance->c_sun, instance->c_sun, instance->c_sun, instance->c_hemi);
 
-                        dwBatch ++;
-                        if (dwBatch == hw_BatchSize)
+                        instanceCount++;
+                        // flush when buffer full
+                        if (instanceCount == hw_BatchSize) // flush
                         {
-                            // flush
-                            RImplementation.BasicStats.DetailCount += dwBatch;
-                            u32 dwCNT_verts = dwBatch * Object.number_vertices;
-                            u32 dwCNT_prims = dwBatch * Object.number_indices / 3;
-
-                            cmd_list.set_uniforms(constArray->vs.program, constArray->vs.location, uniformBuffer);
-                            glDrawElementsInstancedBaseVertex(GL_TRIANGLES, Object.number_indices, GL_UNSIGNED_SHORT, (void*)(iOffset * sizeof(GLushort)), dwBatch, vOffset);
+                            RImplementation.BasicStats.DetailCount += instanceCount;
 
-                            cmd_list.stat.r.s_details.add(dwCNT_verts);
-                            uniformBuffer.clear();
+                            cmd_list.setUniforms(constArray->vs.program, constArray->vs.location, uniformBuffer);
+                            cmd_list.RenderInstanced(D3DPT_TRIANGLELIST, vOffset, 0, Object.number_vertices, iOffset, Object.number_indices / 3, instanceCount);
 
                             // restart
-                            dwBatch = 0;
+                            instanceCount = 0;
+                            uniformBuffer.clear();
                         }
                     }
                 }
-                // flush if nessecary
-                if (dwBatch)
+                // flush if necessary
+                if (instanceCount)
                 {
-                    RImplementation.BasicStats.DetailCount += dwBatch;
-                    u32 dwCNT_verts = dwBatch * Object.number_vertices;
-                    u32 dwCNT_prims = dwBatch * Object.number_indices / 3;
+                    RImplementation.BasicStats.DetailCount += instanceCount;
 
-                    cmd_list.set_uniforms(constArray->vs.program, constArray->vs.location, uniformBuffer);
-                    glDrawElementsInstancedBaseVertex(GL_TRIANGLES, Object.number_indices, GL_UNSIGNED_SHORT, (void*)(iOffset * sizeof(GLushort)), dwBatch, vOffset);
-                    cmd_list.stat.r.s_details.add(dwCNT_verts);
+                    cmd_list.setUniforms(constArray->vs.program, constArray->vs.location, uniformBuffer);
+                    cmd_list.RenderInstanced(D3DPT_TRIANGLELIST, vOffset, 0, Object.number_vertices, iOffset, Object.number_indices / 3, instanceCount);
                 }
             }
         }