Add depth bias support and viewport depth range functionality to VRHI

Author: hypernewbie

src/vrhi_backend.cpp

@@ -420,6 +420,15 @@ bool vhCmdBackendState::BE_PresubmitCommon_PipelineDesc(
         graphicsPipelineDesc->renderState.blendState = vhTranslateBlendState( state.stateFlags );
         graphicsPipelineDesc->renderState.depthStencilState = vhTranslateDepthStencilState( state.stateFlags, state.frontStencil, state.backStencil );
         graphicsPipelineDesc->renderState.rasterState = vhTranslateRasterState( state.stateFlags );
+        if ( state.viewScissor.z >= 0.0f && state.viewScissor.w >= 0.0f )
+        {
+            graphicsPipelineDesc->renderState.rasterState.scissorEnable = true;
+        }
+
+        // Apply depth bias values
+        graphicsPipelineDesc->renderState.rasterState.depthBias = state.depthBias;
+        graphicsPipelineDesc->renderState.rasterState.depthBiasClamp = state.depthBiasClamp;
+        graphicsPipelineDesc->renderState.rasterState.slopeScaledDepthBias = state.slopeScaledDepthBias;
 
         // [TODO] The following fields are not currently populated from vhState:
         // - patchControlPoints: tessellation is only supported if we add it.
@@ -1086,7 +1095,7 @@ bool vhCmdBackendState::BE_PreSubmitCommon_State(
         graphicsState->viewport.viewports.push_back( nvrhi::Viewport(
             state.viewRect.x, state.viewRect.x + state.viewRect.z,
             state.viewRect.y, state.viewRect.y + state.viewRect.w,
-            0.0f, 1.0f
+            state.viewDepthRange.x, state.viewDepthRange.y
         ) );
 
         graphicsState->viewport.scissorRects.resize( 0 );
@@ -2081,6 +2090,15 @@ void vhCmdBackendState::Handle_vhCmdSetStateStencil( VIDL_vhCmdSetStateStencil*
     state.backStencil = cmd->back;
 }
 
+void vhCmdBackendState::Handle_vhCmdSetStateDepthBias( VIDL_vhCmdSetStateDepthBias* cmd )
+{
+    BE_CmdRAII cmdRAII( cmd );
+    auto& state = backendStates[cmd->id];
+    state.depthBias = cmd->bias;
+    state.depthBiasClamp = cmd->clamp;
+    state.slopeScaledDepthBias = cmd->slopeScaled;
+}
+
 void vhCmdBackendState::Handle_vhCmdSetStateVertexBuffer( VIDL_vhCmdSetStateVertexBuffer* cmd )
 {
     BE_CmdRAII cmdRAII( cmd );

src/vrhi_backend.h

@@ -333,6 +333,8 @@ class vhCmdBackendState : public VIDLHandler
 
     void Handle_vhCmdSetStateStencil( VIDL_vhCmdSetStateStencil* cmd ) override;
 
+    void Handle_vhCmdSetStateDepthBias( VIDL_vhCmdSetStateDepthBias* cmd ) override;
+
     void Handle_vhCmdSetStateVertexBuffer( VIDL_vhCmdSetStateVertexBuffer* cmd ) override;
 
     void Handle_vhCmdSetStateIndexBuffer( VIDL_vhCmdSetStateIndexBuffer* cmd ) override;

src/vrhi_generated.h

@@ -511,6 +511,21 @@ struct VIDL_vhCmdSetStateStencil
         : id(_id), front(_front), back(_back) {}
 };
 
+struct VIDL_vhCmdSetStateDepthBias
+{
+    static constexpr uint64_t kMagic = 0x3290E5BB;
+    uint64_t MAGIC = kMagic;
+    vhStateId id;
+    int bias;
+    float clamp;
+    float slopeScaled;
+
+    VIDL_vhCmdSetStateDepthBias() = default;
+
+    VIDL_vhCmdSetStateDepthBias(vhStateId _id, int _bias, float _clamp, float _slopeScaled)
+        : id(_id), bias(_bias), clamp(_clamp), slopeScaled(_slopeScaled) {}
+};
+
 struct VIDL_vhCmdSetStateVertexBuffer
 {
     static constexpr uint64_t kMagic = 0xF0E68F37;
@@ -694,6 +709,7 @@ struct VIDLHandler
     virtual void Handle_vhCmdSetStateFlags( VIDL_vhCmdSetStateFlags* cmd ) { (void) cmd; };
     virtual void Handle_vhCmdSetStateDebugFlags( VIDL_vhCmdSetStateDebugFlags* cmd ) { (void) cmd; };
     virtual void Handle_vhCmdSetStateStencil( VIDL_vhCmdSetStateStencil* cmd ) { (void) cmd; };
+    virtual void Handle_vhCmdSetStateDepthBias( VIDL_vhCmdSetStateDepthBias* cmd ) { (void) cmd; };
     virtual void Handle_vhCmdSetStateVertexBuffer( VIDL_vhCmdSetStateVertexBuffer* cmd ) { (void) cmd; };
     virtual void Handle_vhCmdSetStateIndexBuffer( VIDL_vhCmdSetStateIndexBuffer* cmd ) { (void) cmd; };
     virtual void Handle_vhCmdSetStateTextures( VIDL_vhCmdSetStateTextures* cmd ) { (void) cmd; };
@@ -860,6 +876,10 @@ struct VIDLHandler
             HandleLogFunction("Handle_vhCmdSetStateStencil");
             Handle_vhCmdSetStateStencil( (VIDL_vhCmdSetStateStencil*) cmd );
             break;
+        case 0x3290E5BB:
+            HandleLogFunction("Handle_vhCmdSetStateDepthBias");
+            Handle_vhCmdSetStateDepthBias( (VIDL_vhCmdSetStateDepthBias*) cmd );
+            break;
         case 0xF0E68F37:
             HandleLogFunction("Handle_vhCmdSetStateVertexBuffer");
             Handle_vhCmdSetStateVertexBuffer( (VIDL_vhCmdSetStateVertexBuffer*) cmd );

src/vrhi_state.cpp

@@ -75,6 +75,11 @@ void vhCmdSetStateStencil( vhStateId id, uint32_t front, uint32_t back )
     vhCmdEnqueue( new VIDL_vhCmdSetStateStencil( id, front, back ) );
 }
 
+void vhCmdSetStateDepthBias( vhStateId id, int bias, float clamp, float slopeScaled )
+{
+    vhCmdEnqueue( new VIDL_vhCmdSetStateDepthBias( id, bias, clamp, slopeScaled ) );
+}
+
 void vhCmdSetStateVertexBuffer( vhStateId id, uint8_t stream, vhBuffer buffer, uint64_t offset, uint32_t start, uint32_t num )
 {
     vhCmdEnqueue( new VIDL_vhCmdSetStateVertexBuffer( id, stream, buffer, offset, start, num ) );
@@ -154,6 +159,11 @@ bool vhSetState( vhStateId id, vhState& state, uint64_t dirtyForceMask )
         vhCmdSetStateStencil( id, state.frontStencil, state.backStencil );
     }
 
+    if ( dirty & VRHI_DIRTY_DEPTH_BIAS )
+    {
+        vhCmdSetStateDepthBias( id, state.depthBias, state.depthBiasClamp, state.slopeScaledDepthBias );
+    }
+
     if ( dirty & VRHI_DIRTY_VERTEX_INDEX )
     {
         for ( uint8_t i = 0; i < ( uint8_t ) state.vertexBindings.size(); ++i )
@@ -351,6 +361,11 @@ nvrhi::DepthStencilState vhTranslateDepthStencilState( uint64_t stateFlags, uint
         dsState.depthTestEnable = true;
         dsState.depthFunc = fnConvertComparisonFunc( depthFunc );
     }
+    else if ( stateFlags & VRHI_STATE_DEPTH_TEST_ENABLE )
+    {
+        dsState.depthTestEnable = true;
+        dsState.depthFunc = nvrhi::ComparisonFunc::Less; // Default comparison when only enable flag is set
+    }
     else
     {
         dsState.depthTestEnable = false;
@@ -431,6 +446,7 @@ nvrhi::RasterState vhTranslateRasterState( uint64_t stateFlags )
     rasterState.multisampleEnable = ( stateFlags & VRHI_STATE_MSAA ) != 0;
     rasterState.antialiasedLineEnable = ( stateFlags & VRHI_STATE_LINEAA ) != 0;
     rasterState.conservativeRasterEnable = ( stateFlags & VRHI_STATE_CONSERVATIVE_RASTER ) != 0;
+    rasterState.depthClipEnable = ( stateFlags & VRHI_STATE_DEPTH_CLIP ) != 0;
 
     return rasterState;
 }

test/test.cpp

@@ -32,6 +32,7 @@
 #include <windows.h>
 #endif // _WIN32
 #include "utest.h"
+#include "test.h"
 #include <vrhi.h>
 
 UTEST( Vrhi, Dummy )
@@ -41,6 +42,22 @@ UTEST( Vrhi, Dummy )
 
 bool g_testInit = false;
 bool g_testInitQuiet = true;
+bool g_captureActive = false;
+
+void TestEnsureShutdown()
+{
+    if ( g_captureActive )
+    {
+        vhCaptureEnd();
+        g_captureActive = false;
+    }
+    
+    if ( g_testInit )
+    {
+        vhShutdown( g_testInitQuiet );
+        g_testInit = false;
+    }
+}
 
 UTEST_STATE();
 
@@ -64,12 +81,6 @@ int main( int argc, const char* const argv[] )
 #endif
 
     int result = utest_main( argc, argv );
-
-    if ( g_testInit )
-    {
-        vhShutdown( g_testInitQuiet );
-        g_testInit = false;
-    }
-
+    TestEnsureShutdown();
     return result;
 }

test/test.h

@@ -25,6 +25,9 @@
 #include <glm/glm.hpp>
 #include <nvrhi/nvrhi.h>
 
+extern bool g_captureActive;
+void TestEnsureShutdown();
+
 #if defined(__cplusplus) && (__cplusplus >= 201103L)
 #ifdef __clang__