xrRender_R1: support for fast geometry

Xottab-DUTY · Xottab-DUTY · commit e14ec3dab44a · 2018-10-02T00:09:48.000+05:00
Only for debugging purpose for now. (requires level reload to apply)

New console command r1_force_geomx allows you to force render fast
geometry on all renderers
diff --git a/src/Layers/xrRender/FVisual.cpp b/src/Layers/xrRender/FVisual.cpp
@@ -60,9 +60,12 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags)
         p_rm_Indices->AddRef();
 #endif
 #endif
-#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER == R_GL)
         // check for fast-vertices
+#if RENDER == R_R1
+        if (data->find_chunk(OGF_FASTPATH) && ps_r1_force_geomx)
+#else
         if (data->find_chunk(OGF_FASTPATH))
+#endif
         {
             destructor<IReader> geomdef(data->open_chunk(OGF_FASTPATH));
             destructor<IReader> def(geomdef().open_chunk(OGF_GCONTAINER));
@@ -97,7 +100,6 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags)
             // geom
             m_fast->rm_geom.create(fmt, m_fast->p_rm_Vertices, m_fast->p_rm_Indices);
         }
-#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL)
     }
 
     // read vertices
@@ -222,8 +224,11 @@ void Fvisual::Load(const char* N, IReader* data, u32 dwFlags)
 
 void Fvisual::Render(float)
 {
-#if (RENDER == R_R2) || (RENDER == R_R3) || (RENDER == R_R4) || (RENDER==R_GL)
-    if (m_fast && RImplementation.phase == CRender::PHASE_SMAP && !RCache.is_TessEnabled())
+#if RENDER == R_R1
+    if (m_fast && ps_r1_force_geomx)
+#else
+    if (m_fast && (ps_r1_force_geomx || RImplementation.phase == CRender::PHASE_SMAP && !RCache.is_TessEnabled()))
+#endif
     {
         RCache.set_Geometry(m_fast->rm_geom);
         RCache.Render(D3DPT_TRIANGLELIST, m_fast->vBase, 0, m_fast->vCount, m_fast->iBase, m_fast->dwPrimitives);
@@ -235,11 +240,6 @@ void Fvisual::Render(float)
         RCache.Render(D3DPT_TRIANGLELIST, vBase, 0, vCount, iBase, dwPrimitives);
         RCache.stat.r.s_static.add(vCount);
     }
-#else // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL)
-    RCache.set_Geometry(rm_geom);
-    RCache.Render(D3DPT_TRIANGLELIST, vBase, 0, vCount, iBase, dwPrimitives);
-    RCache.stat.r.s_static.add(vCount);
-#endif // (RENDER==R_R2) || (RENDER==R_R3) || (RENDER==R_R4) || (RENDER==R_GL)
 }
 
 #define PCOPY(a) a = pFrom->a
diff --git a/src/Layers/xrRender/xrRender_console.cpp b/src/Layers/xrRender/xrRender_console.cpp
@@ -116,6 +116,7 @@ float ps_r1_lmodel_lerp = 0.1f;
 float ps_r1_dlights_clip = 40.f;
 float ps_r1_pps_u = 0.f;
 float ps_r1_pps_v = 0.f;
+int ps_r1_force_geomx = 0;
 
 // R1-specific
 int ps_r1_GlowsPerFrame = 16; // r1-only
@@ -743,6 +744,7 @@ void xrRender_initconsole()
     CMD4(CCC_Float, "r1_dlights_clip", &ps_r1_dlights_clip, 10.f, 150.f);
     CMD4(CCC_Float, "r1_pps_u", &ps_r1_pps_u, -1.f, +1.f);
     CMD4(CCC_Float, "r1_pps_v", &ps_r1_pps_v, -1.f, +1.f);
+    CMD4(CCC_Integer, "r1_force_geomx", &ps_r1_force_geomx, 0, 1);
 
     // R1-specific
     CMD4(CCC_Integer, "r1_glows_per_frame", &ps_r1_GlowsPerFrame, 2, 32);
diff --git a/src/Layers/xrRender/xrRender_console.h b/src/Layers/xrRender/xrRender_console.h
@@ -63,6 +63,7 @@ extern ECORE_API float ps_r1_lmodel_lerp;
 extern ECORE_API float ps_r1_dlights_clip;
 extern ECORE_API float ps_r1_pps_u;
 extern ECORE_API float ps_r1_pps_v;
+extern ECORE_API int ps_r1_force_geomx;
 
 // R1-specific
 extern ECORE_API int ps_r1_GlowsPerFrame; // r1-only
diff --git a/src/Layers/xrRenderPC_R1/FStaticRender.cpp b/src/Layers/xrRenderPC_R1/FStaticRender.cpp
@@ -250,20 +250,44 @@ IRenderVisual* CRender::getVisual(int id)
     VERIFY(id < int(Visuals.size()));
     return Visuals[id];
 }
-D3DVERTEXELEMENT9* CRender::getVB_Format(int id)
+D3DVERTEXELEMENT9* CRender::getVB_Format(int id, bool alternative)
 {
-    VERIFY(id < int(DCL.size()));
-    return DCL[id].begin();
+    if (alternative)
+    {
+        VERIFY(id < int(xDC.size()));
+        return xDC[id].begin();
+    }
+    else
+    {
+        VERIFY(id < int(nDC.size()));
+        return nDC[id].begin();
+    }
 }
-ID3DVertexBuffer* CRender::getVB(int id)
+ID3DVertexBuffer* CRender::getVB(int id, bool alternative)
 {
-    VERIFY(id < int(VB.size()));
-    return VB[id];
+    if (alternative)
+    {
+        VERIFY(id < int(xVB.size()));
+        return xVB[id];
+    }
+    else
+    {
+        VERIFY(id < int(nVB.size()));
+        return nVB[id];
+    }
 }
-ID3DIndexBuffer* CRender::getIB(int id)
+ID3DIndexBuffer* CRender::getIB(int id, bool alternative)
 {
-    VERIFY(id < int(IB.size()));
-    return IB[id];
+    if (alternative)
+    {
+        VERIFY(id < int(xIB.size()));
+        return xIB[id];
+    }
+    else
+    {
+        VERIFY(id < int(nIB.size()));
+        return nIB[id];
+    }
 }
 FSlideWindowItem* CRender::getSWI(int id)
 {
diff --git a/src/Layers/xrRenderPC_R1/FStaticRender.h b/src/Layers/xrRenderPC_R1/FStaticRender.h
@@ -50,9 +50,9 @@ class CRender : public D3DXRenderBase
     xr_vector<FSlideWindowItem> SWIs;
     xr_vector<ref_shader> Shaders;
     typedef svector<D3DVERTEXELEMENT9, MAXD3DDECLLENGTH + 1> VertexDeclarator;
-    xr_vector<VertexDeclarator> DCL;
-    xr_vector<ID3DVertexBuffer*> VB;
-    xr_vector<ID3DIndexBuffer*> IB;
+    xr_vector<VertexDeclarator> nDC, xDC;
+    xr_vector<ID3DVertexBuffer*> nVB, xVB;
+    xr_vector<ID3DIndexBuffer*> nIB, xIB;
     xr_vector<dxRender_Visual*> Visuals;
     CPSLibrary PSLibrary;
     CLight_DB Lights;
@@ -78,7 +78,7 @@ class CRender : public D3DXRenderBase
 
 private:
     // Loading / Unloading
-    void LoadBuffers(CStreamReader* fs);
+    void LoadBuffers(CStreamReader* fs, bool alternative = false);
     void LoadVisuals(IReader* fs);
     void LoadLights(IReader* fs);
     void LoadSectors(IReader* fs);
@@ -91,9 +91,9 @@ class CRender : public D3DXRenderBase
 public:
     ShaderElement* rimp_select_sh_static(dxRender_Visual* pVisual, float cdist_sq);
     ShaderElement* rimp_select_sh_dynamic(dxRender_Visual* pVisual, float cdist_sq);
-    D3DVERTEXELEMENT9* getVB_Format(int id);
-    ID3DVertexBuffer* getVB(int id);
-    ID3DIndexBuffer* getIB(int id);
+    D3DVERTEXELEMENT9* getVB_Format(int id, bool alternative = false);
+    ID3DVertexBuffer* getVB(int id, bool alternative = false);
+    ID3DIndexBuffer* getIB(int id, bool alternative = false);
     FSlideWindowItem* getSWI(int id);
     IRender_Portal* getPortal(int id);
     IRender_Sector* getSectorActive();
diff --git a/src/Layers/xrRenderPC_R1/FStaticRender_Loader.cpp b/src/Layers/xrRenderPC_R1/FStaticRender_Loader.cpp
@@ -62,10 +62,22 @@ void CRender::level_Load(IReader* fs)
         // VB,IB,SWI
         g_pGamePersistent->SetLoadStageTitle("st_loading_geometry");
         g_pGamePersistent->LoadTitle();
-        CStreamReader* geom = FS.rs_open("$level$", "level.geom");
-        LoadBuffers(geom);
-        LoadSWIs(geom);
-        FS.r_close(geom);
+        {
+            CStreamReader* geom = FS.rs_open("$level$", "level.geom");
+            R_ASSERT2(geom, "level.geom");
+            LoadBuffers(geom, false);
+            LoadSWIs(geom);
+            FS.r_close(geom);
+        }
+
+        //...and alternate/fast geometry
+        if (ps_r1_force_geomx)
+        {
+            CStreamReader* geom = FS.rs_open("$level$", "level.geomx");
+            R_ASSERT2(geom, "level.geomX");
+            LoadBuffers(geom, true);
+            FS.r_close(geom);
+        }
 
         // Visuals
         g_pGamePersistent->SetLoadStageTitle("st_loading_spatial_db");
@@ -147,13 +159,36 @@ void CRender::level_Unload()
     SWIs.clear();
 
     //*** VB/IB
-    for (I = 0; I < VB.size(); I++)
-        _RELEASE(VB[I]);
-    for (I = 0; I < IB.size(); I++)
-        _RELEASE(IB[I]);
-    DCL.clear();
-    VB.clear();
-    IB.clear();
+    for (I = 0; I < nVB.size(); I++)
+    {
+        HW.stats_manager.decrement_stats_vb(nVB[I]);
+        _RELEASE(nVB[I]);
+    }
+
+    for (I = 0; I < xVB.size(); I++)
+    {
+        HW.stats_manager.decrement_stats_vb(xVB[I]);
+        _RELEASE(xVB[I]);
+    }
+    nVB.clear();
+    xVB.clear();
+
+    for (I = 0; I < nIB.size(); I++)
+    {
+        HW.stats_manager.decrement_stats_ib(nIB[I]);
+        _RELEASE(nIB[I]);
+    }
+
+    for (I = 0; I < xIB.size(); I++)
+    {
+        HW.stats_manager.decrement_stats_ib(xIB[I]);
+        _RELEASE(xIB[I]);
+    }
+
+    nIB.clear();
+    xIB.clear();
+    nDC.clear();
+    xDC.clear();
 
     //*** Components
     xr_delete(Details);
@@ -172,19 +207,23 @@ void CRender::level_Unload()
     b_loaded = FALSE;
 }
 
-void CRender::LoadBuffers(CStreamReader* base_fs)
+void CRender::LoadBuffers(CStreamReader* base_fs, bool alternative)
 {
     Resources->Evict();
     u32 dwUsage = D3DUSAGE_WRITEONLY | (HW.Caps.geometry.bSoftware ? D3DUSAGE_SOFTWAREPROCESSING : 0);
 
+    xr_vector<VertexDeclarator>& _DC  = alternative ? xDC : nDC;
+    xr_vector<ID3DVertexBuffer*>& _VB = alternative ? xVB : nVB;
+    xr_vector<ID3DIndexBuffer*>& _IB  = alternative ? xIB : nIB;
+
     // Vertex buffers
     if (base_fs->find_chunk(fsL_VB))
     {
         // Use DX9-style declarators
         CStreamReader* fs = base_fs->open_chunk(fsL_VB);
         u32 count = fs->r_u32();
-        DCL.resize(count);
-        VB.resize(count);
+        _DC.resize(count);
+        _VB.resize(count);
 
         u32 buffer_size = (MAXD3DDECLLENGTH + 1) * sizeof(D3DVERTEXELEMENT9);
         D3DVERTEXELEMENT9* dcl = (D3DVERTEXELEMENT9*)_alloca(buffer_size);
@@ -200,9 +239,9 @@ void CRender::LoadBuffers(CStreamReader* base_fs)
 
             u32 dcl_len = D3DXGetDeclLength(dcl) + 1;
 
-            DCL[i].resize(dcl_len);
-            fs->r(DCL[i].begin(), dcl_len * sizeof(D3DVERTEXELEMENT9));
-            //.????????? remove T&B from DCL[]
+            _DC[i].resize(dcl_len);
+            fs->r(_DC[i].begin(), dcl_len * sizeof(D3DVERTEXELEMENT9));
+            //.????????? remove T&B from _DC[]
 
             // count, size
             u32 vCount = fs->r_u32();
@@ -211,12 +250,12 @@ void CRender::LoadBuffers(CStreamReader* base_fs)
 
             // Create and fill
             BYTE* pData = nullptr;
-            R_CHK(HW.pDevice->CreateVertexBuffer(vCount * vSize, dwUsage, 0, D3DPOOL_MANAGED, &VB[i], nullptr));
-            HW.stats_manager.increment_stats(vCount * vSize, enum_stats_buffer_type_vertex, D3DPOOL_MANAGED);
-            R_CHK(VB[i]->Lock(0, 0, (void**)&pData, 0));
+            R_CHK(HW.pDevice->CreateVertexBuffer(vCount * vSize, dwUsage, 0, D3DPOOL_MANAGED, &_VB[i], nullptr));
+            HW.stats_manager.increment_stats_vb(_VB[i]);
+            R_CHK(_VB[i]->Lock(0, 0, (void**)&pData, 0));
             fs->r(pData, vCount * vSize);
             //			CopyMemory			(pData,fs->pointer(),vCount*vSize);	//.???? copy while skip T&B
-            VB[i]->Unlock();
+            _VB[i]->Unlock();
 
             //			fs->advance			(vCount*vSize);
         }
@@ -232,20 +271,20 @@ void CRender::LoadBuffers(CStreamReader* base_fs)
     {
         CStreamReader* fs = base_fs->open_chunk(fsL_IB);
         u32 count = fs->r_u32();
-        IB.resize(count);
+        _IB.resize(count);
         for (u32 i = 0; i < count; i++)
         {
             u32 iCount = fs->r_u32();
             Msg("* [Loading IB] %d indices, %d Kb", iCount, (iCount * 2) / 1024);
 
             // Create and fill
             BYTE* pData = nullptr;
-            R_CHK(HW.pDevice->CreateIndexBuffer(iCount * 2, dwUsage, D3DFMT_INDEX16, D3DPOOL_MANAGED, &IB[i], nullptr));
-            HW.stats_manager.increment_stats(iCount * 2, enum_stats_buffer_type_index, D3DPOOL_MANAGED);
-            R_CHK(IB[i]->Lock(0, 0, (void**)&pData, 0));
+            R_CHK(HW.pDevice->CreateIndexBuffer(iCount * 2, dwUsage, D3DFMT_INDEX16, D3DPOOL_MANAGED, &_IB[i], nullptr));
+            HW.stats_manager.increment_stats_ib(_IB[i]);
+            R_CHK(_IB[i]->Lock(0, 0, (void**)&pData, 0));
             //			CopyMemory			(pData,fs->pointer(),iCount*2);
             fs->r(pData, iCount * 2);
-            IB[i]->Unlock();
+            _IB[i]->Unlock();
 
             //			fs->advance			(iCount*2);
         }
