Added depth testing.

0suddenly0 · 0suddenly0 · commit 0a31aa818cc5 · 2024-12-09T21:50:02.000+05:00
diff --git a/backends/directx11/src/null-render-backend-directx11/shaders/color/color.cpp b/backends/directx11/src/null-render-backend-directx11/shaders/color/color.cpp
@@ -5,6 +5,6 @@ namespace ntl::render::directx11 {
         if(empty()) return;
         c_shader::use();
 
-        color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation() });
+        color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation(), backend::renderer->get_depth() });
     }
 }
diff --git a/backends/directx11/src/null-render-backend-directx11/shaders/color/compiled-object.h b/backends/directx11/src/null-render-backend-directx11/shaders/color/compiled-object.h
@@ -31,6 +31,7 @@ namespace ntl::render::directx11 {
         public:
             matrix4x4_t matrix{ };
             vec2_t<float> translation{ };
+            float depth{ };
         };
         c_constant_buffer<constant_buffer_t> constant_buffer{ };
 
diff --git a/backends/directx11/src/null-render-backend-directx11/shaders/color/hlsl/color-vs.hlsl b/backends/directx11/src/null-render-backend-directx11/shaders/color/hlsl/color-vs.hlsl
@@ -1,6 +1,7 @@
 cbuffer constant_buffer : register(b0) {
     matrix projection_matrix;
     float2 translation;
+    float depth;
 };
 
 struct vs_input_t {
@@ -17,8 +18,7 @@ struct ps_input_t {
 
 ps_input_t main(vs_input_t input) {
     ps_input_t output;
-    output.position = mul(projection_matrix, float4(input.position + translation, 0.f, 1.f));
-    
+    output.position = mul(projection_matrix, float4(input.position + translation, depth, 1.f));
     output.color = input.color / 255.f;
     output.color.rgb *= output.color.a;
     
diff --git a/backends/directx11/src/null-render-backend-directx11/shaders/linear-gradient/linear-gradient.cpp b/backends/directx11/src/null-render-backend-directx11/shaders/linear-gradient/linear-gradient.cpp
@@ -5,7 +5,7 @@ namespace ntl::render::directx11 {
         if(empty()) return;
         c_shader::use();
 
-        color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation() });
+        color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation(), backend::renderer->get_depth() });
     }
 
     void c_linear_gradient_shader::set_constants(const constants_t& constants) {
diff --git a/backends/directx11/src/null-render-backend-directx11/shaders/quad-gradient/quad-gradient.cpp b/backends/directx11/src/null-render-backend-directx11/shaders/quad-gradient/quad-gradient.cpp
@@ -5,7 +5,7 @@ namespace ntl::render::directx11 {
         if(empty()) return;
         c_shader::use();
 
-        color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation() });
+        color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation(), backend::renderer->get_depth() });
     }
 
     void c_quad_gradient_shader::set_constants(const constants_t& constants) {
diff --git a/backends/directx11/src/null-render-backend-directx11/shaders/radial-gradient/radial-gradient.cpp b/backends/directx11/src/null-render-backend-directx11/shaders/radial-gradient/radial-gradient.cpp
@@ -5,7 +5,7 @@ namespace ntl::render::directx11 {
         if(empty()) return;
         c_shader::use();
 
-        color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation() });
+        color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation(), backend::renderer->get_depth() });
     }
 
     void c_radial_gradient_shader::set_constants(const constants_t& constants) {
diff --git a/backends/directx11/src/null-render-backend-directx11/shaders/sdf/sdf.h b/backends/directx11/src/null-render-backend-directx11/shaders/sdf/sdf.h
@@ -16,7 +16,7 @@ namespace ntl::render::directx11 {
             if(empty()) return;
             c_shader::use();
 
-            color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation() });
+            color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation(), backend::renderer->get_depth() });
         }
 
     public:
diff --git a/backends/directx11/src/null-render-backend-directx11/shaders/texture/texture.cpp b/backends/directx11/src/null-render-backend-directx11/shaders/texture/texture.cpp
@@ -5,6 +5,6 @@ namespace ntl::render::directx11 {
         if(empty()) return;
         c_shader::use();
 
-        color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation() });
+        color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation(), backend::renderer->get_depth() });
     }
 }
diff --git a/backends/directx11/src/null-render-backend-directx11/state-pipeline/stencil-state/stencil-state.h b/backends/directx11/src/null-render-backend-directx11/state-pipeline/stencil-state/stencil-state.h
@@ -16,9 +16,9 @@ namespace ntl::render::directx11 {
 
     public:
         c_stencil_state() : i_state_machine(D3D11_DEPTH_STENCIL_DESC{
-            .DepthEnable{ false },
+            .DepthEnable{ true },
             .DepthWriteMask{ D3D11_DEPTH_WRITE_MASK_ALL },
-            .DepthFunc{ D3D11_COMPARISON_LESS },
+            .DepthFunc{ D3D11_COMPARISON_LESS_EQUAL },
             .StencilReadMask{ D3D11_DEFAULT_STENCIL_READ_MASK },
             .StencilWriteMask{ D3D11_DEFAULT_STENCIL_WRITE_MASK }
             }) { }
diff --git a/backends/directx11/src/null-render-backend-directx11/stencil-buffer/stencil-buffer.cpp b/backends/directx11/src/null-render-backend-directx11/stencil-buffer/stencil-buffer.cpp
@@ -29,7 +29,7 @@ namespace ntl::render::directx11 {
             .ViewDimension{ shared::msaa_quality > 1 ? D3D11_DSV_DIMENSION_TEXTURE2DMS : D3D11_DSV_DIMENSION_TEXTURE2D },
         };
 
-        if(auto result = shared.device->CreateDepthStencilView(texture, nullptr, &buffer); FAILED(result)) {
+        if(auto result = shared.device->CreateDepthStencilView(texture, &depth_stencil_view_desc, &buffer); FAILED(result)) {
             sdk::logger(sdk::e_log_type::error, "CreateDepthStencilView failed, return code {}.", result);
             return;
         }
diff --git a/backends/directx9/src/null-render-backend-directx9/internal/shader.h b/backends/directx9/src/null-render-backend-directx9/internal/shader.h
@@ -33,8 +33,10 @@ namespace ntl::render::directx9 {
             if(empty()) return;
             c_shader::use();
 
+            float depth = backend::renderer->get_depth();
             vertex_shader->set_constant(1, backend::renderer->get_matrix().linear_array.data(), 4);
             vertex_shader->set_constant(5, backend::renderer->get_translation().coordinates.data());
+            vertex_shader->set_constant(6, &depth);
         }
     };
 }
diff --git a/backends/directx9/src/null-render-backend-directx9/shaders/color/hlsl/color-vs.hlsl b/backends/directx9/src/null-render-backend-directx9/shaders/color/hlsl/color-vs.hlsl
@@ -1,6 +1,7 @@
 float2 texel_offset : register(c0);
 matrix projection_matrix : register(c1);
 float2 translation : register(c5);
+float depth : register(c6);
 
 struct vs_input_t {
     float2 position : POSITION0;
@@ -21,7 +22,7 @@ ps_input_t main(vs_input_t input) {
     output.color = input.color / 255.f;
     output.color.rgb *= output.color.a;
     
-    output.position = mul(projection_matrix, float4(input.position + translation, 0.0f, 1.0f));
+    output.position = mul(projection_matrix, float4(input.position + translation, depth, 1.0f));
     output.position.xy += texel_offset;
     
     return output;
diff --git a/backends/directx9/src/null-render-backend-directx9/state-pipeline/state-pipeline.cpp b/backends/directx9/src/null-render-backend-directx9/state-pipeline/state-pipeline.cpp
@@ -11,8 +11,8 @@ namespace ntl::render::directx9 {
 
         shared.device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
         shared.device->SetRenderState(D3DRS_LIGHTING, false);
-        shared.device->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
-        shared.device->SetRenderState(D3DRS_ZWRITEENABLE, false);
+        shared.device->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
+        shared.device->SetRenderState(D3DRS_ZWRITEENABLE, true);
         shared.device->SetRenderState(D3DRS_ALPHATESTENABLE, false);
         shared.device->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
         shared.device->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
diff --git a/backends/opengl3/src/null-render-backend-opengl3/internal/shader/shader.cpp b/backends/opengl3/src/null-render-backend-opengl3/internal/shader/shader.cpp
@@ -29,12 +29,14 @@ namespace ntl::render::opengl3 {
 
         matrix.get_location(program.get(), "matrix");
         translation.get_location(program.get(), "translation");
+        depth.get_location(program.get(), "depth");
     }
 
     void c_default_shader::use() {
         c_shader::use();
 
         matrix.set(backend::renderer->get_matrix());
         translation.set(backend::renderer->get_translation());
+        depth.set(backend::renderer->get_depth());
     }
 }
diff --git a/backends/opengl3/src/null-render-backend-opengl3/internal/shader/shader.h b/backends/opengl3/src/null-render-backend-opengl3/internal/shader/shader.h
@@ -27,6 +27,7 @@ namespace ntl::render::opengl3 {
     public:
         c_uniform<matrix4x4_t> matrix{ };
         c_uniform<vec2_t<float>> translation{ };
+        c_uniform<float> depth{ };
 
     public:
         virtual ~c_default_shader() { }
diff --git a/backends/opengl3/src/null-render-backend-opengl3/shaders/color/glsl/color.vert b/backends/opengl3/src/null-render-backend-opengl3/shaders/color/glsl/color.vert
@@ -1,6 +1,7 @@
 #version 330
 uniform mat4 matrix;
 uniform vec2 translation;
+uniform float depth;
 
 in vec3 position;
 in vec2 uv;
@@ -14,5 +15,5 @@ void main() {
     frag_color = color / 255.f;
     frag_color.rgb *= frag_color.a;
 
-    gl_Position = matrix * vec4(position.xy + translation,0,1);
+    gl_Position = matrix * vec4(position.xy + translation, depth, 1);
 }
diff --git a/backends/opengl3/src/null-render-backend-opengl3/state-pipeline/state-pipeline.cpp b/backends/opengl3/src/null-render-backend-opengl3/state-pipeline/state-pipeline.cpp
@@ -4,8 +4,11 @@
 namespace ntl::render::opengl3 {
     void c_state_pipeline::setup_state() {
         opengl::blend_equation(opengl::e_func_add);
+        opengl::enable(opengl::e_depth_test);
+        opengl::depth_mask(true);
+        opengl::depth_func(opengl::e_lequal);
+
         opengl::disable(opengl::e_cull_face);
-        opengl::disable(opengl::e_depth_test);
         opengl::disable(opengl::e_primitive_restart);
 
         i_state_pipeline::setup_state();
@@ -28,6 +31,8 @@ namespace ntl::render::opengl3 {
         opengl::get_integerv(opengl::e_scissor_box, saved_state.scissor_box);
         saved_state.enable_cull_face = opengl::is_enabled(opengl::e_cull_face);
         saved_state.enable_depth_test = opengl::is_enabled(opengl::e_depth_test);
+        saved_state.depth_mask = opengl::is_enabled(opengl::e_depth_writemask);
+        opengl::get_integerv(opengl::e_depth_func, &saved_state.depth_func);
         saved_state.enable_primitive_restart = opengl::is_enabled(opengl::e_primitive_restart);
         saved_state.enable_stencil_test = opengl::is_enabled(opengl::e_stencil_test);
 
@@ -80,6 +85,8 @@ namespace ntl::render::opengl3 {
 
         if(saved_state.enable_cull_face) opengl::enable(opengl::e_cull_face); else opengl::disable(opengl::e_cull_face);
         if(saved_state.enable_depth_test) opengl::enable(opengl::e_depth_test); else opengl::disable(opengl::e_depth_test);
+        opengl::depth_mask(saved_state.depth_mask);
+        opengl::depth_func(saved_state.depth_func);
         if(saved_state.enable_primitive_restart) opengl::enable(opengl::e_primitive_restart); else opengl::disable(opengl::e_primitive_restart);
         opengl::viewport(saved_state.viewport[0], saved_state.viewport[1], saved_state.viewport[2], saved_state.viewport[3]);
         opengl::scissor(saved_state.scissor_box[0], saved_state.scissor_box[1], saved_state.scissor_box[2], saved_state.scissor_box[3]);
diff --git a/backends/opengl3/src/null-render-backend-opengl3/state-pipeline/state-pipeline.h b/backends/opengl3/src/null-render-backend-opengl3/state-pipeline/state-pipeline.h
@@ -12,8 +12,8 @@ namespace ntl::render::opengl3 {
 
             std::uint32_t draw_fbo{ }, read_fbo{ }, rbo{ };
             std::uint32_t active_texture{ }, program{ }, texture{ }, sampler{ }, array_buffer{ }, element_array_buffer{ }, vertex_array_object{ };
-            bool enable_cull_face{ }, enable_depth_test{ }, enable_stencil_test{ }, enable_primitive_restart{ };
-            int stencil_clear_value{ };
+            bool enable_cull_face{ }, enable_depth_test{ }, depth_mask{ }, enable_stencil_test{ }, enable_primitive_restart{ };
+            int stencil_clear_value{ }, depth_func{ };
             int viewport[4]{ }, scissor_box[4]{ };
         } saved_state{ };
 
diff --git a/src/null-render/backend/renderer/renderer.h b/src/null-render/backend/renderer/renderer.h
@@ -12,6 +12,7 @@ namespace ntl::render {
         protected:
             matrix4x4_t matrix{ };
             vec2_t<float> translation{ };
+            float depth{ };
 
         public:
             i_renderer() { }
@@ -21,13 +22,17 @@ namespace ntl::render {
             virtual void update_uniforms();
 
         public:
-            void set_matrix(const matrix4x4_t& _matrix) { matrix = _matrix; }
-            void update_matrix(const matrix4x4_t& _matrix) { set_matrix(_matrix); update_uniforms(); }
-            const matrix4x4_t& get_matrix() const { return matrix; }
+            inline void set_matrix(const matrix4x4_t& _matrix) { matrix = _matrix; }
+            inline void update_matrix(const matrix4x4_t& _matrix) { set_matrix(_matrix); update_uniforms(); }
+            inline const matrix4x4_t& get_matrix() const { return matrix; }
 
-            void set_translation(const vec2_t<float>& _translation) { translation = _translation; }
-            void update_translation(const vec2_t<float>& _translation) { set_translation(_translation); update_uniforms(); }
-            const vec2_t<float>& get_translation() { return translation; }
+            inline void set_translation(const vec2_t<float>& _translation) { translation = _translation; }
+            inline void update_translation(const vec2_t<float>& _translation) { set_translation(_translation); update_uniforms(); }
+            inline const vec2_t<float>& get_translation() { return translation; }
+
+            inline void set_depth(float _depth) { depth = _depth; }
+            inline void update_depth(float _depth) { set_depth(_depth); update_uniforms(); }
+            inline float get_depth() { return depth; }
 
             //@note: opengl is crap, there may be an easier way to do this, but for now it will be like this
             constexpr virtual bool framebuffer_uvs_flipped() = 0;
diff --git a/src/null-render/backend/state-pipeline/state-pipeline.cpp b/src/null-render/backend/state-pipeline/state-pipeline.cpp
@@ -38,8 +38,9 @@ namespace ntl::render::backend {
         stencils.push(default_stencil_state);
         backend::renderer->set_clip({ { 0 }, shared::viewport });
         backend::renderer->set_matrix(backend::renderer->get_projection_matrix());
-        backend::renderer->update_translation(0.f);
         backend::renderer->set_translation(0.f);
+        backend::renderer->set_depth(0.f);
+        backend::stencil_buffer->clear();
         backend::renderer_event_dispatcher.setup_state();
     }
 
diff --git a/src/null-render/graphic/commands/renderer/renderer.cpp b/src/null-render/graphic/commands/renderer/renderer.cpp
@@ -27,6 +27,14 @@ namespace ntl::render {
         backend::renderer->update_translation(translation);
     }
 
+    void c_set_depth_command::handle() {
+        backend::renderer->set_depth(depth);
+    }
+
+    void c_update_depth_command::handle() {
+        backend::renderer->update_depth(depth);
+    }
+
     void c_stencil_test_command::handle() {
         backend::stencil_buffer->set_test(test);
     }
diff --git a/src/null-render/graphic/commands/renderer/renderer.h b/src/null-render/graphic/commands/renderer/renderer.h
@@ -99,6 +99,38 @@ namespace ntl::render {
         void handle() override;
     };
 
+    class c_set_depth_command : public i_command {
+    public:
+        static std::shared_ptr<c_set_depth_command> instance() { return std::make_shared<c_set_depth_command>(); }
+        static std::shared_ptr<c_set_depth_command> instance(float depth) { return std::make_shared<c_set_depth_command>(depth); }
+
+    public:
+        float depth{ };
+
+    public:
+        c_set_depth_command() { }
+        c_set_depth_command(float _depth) : depth(_depth) { }
+
+    public:
+        void handle() override;
+    };
+
+    class c_update_depth_command : public i_command {
+    public:
+        static std::shared_ptr<c_update_depth_command> instance() { return std::make_shared<c_update_depth_command>(); }
+        static std::shared_ptr<c_update_depth_command> instance(float depth) { return std::make_shared<c_update_depth_command>(depth); }
+
+    public:
+        float depth{ };
+
+    public:
+        c_update_depth_command() { }
+        c_update_depth_command(float _depth) : depth(_depth) { }
+
+    public:
+        void handle() override;
+    };
+
     class c_stencil_test_command : public i_command {
     public:
         static std::shared_ptr<c_stencil_test_command> instance() { return std::make_shared<c_stencil_test_command>(); }

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,6 @@ namespace ntl::render::directx11 {`
`5`	`5`	`if(empty()) return;`
`6`	`6`	`c_shader::use();`
`7`	`7`
`8`		`- color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation() });`
	`8`	`+ color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation(), backend::renderer->get_depth() });`
`9`	`9`	`}`
`10`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace ntl::render::directx11 {`
`5`	`5`	`if(empty()) return;`
`6`	`6`	`c_shader::use();`
`7`	`7`
`8`		`- color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation() });`
	`8`	`+ color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation(), backend::renderer->get_depth() });`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`void c_linear_gradient_shader::set_constants(const constants_t& constants) {`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ namespace ntl::render::directx11 {`
`16`	`16`	`if(empty()) return;`
`17`	`17`	`c_shader::use();`
`18`	`18`
`19`		`- color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation() });`
	`19`	`+ color_vertex_shader_object.set_constant({ backend::renderer->get_matrix(), backend::renderer->get_translation(), backend::renderer->get_depth() });`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`public:`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ namespace ntl::render::directx11 {`
`29`	`29`	`.ViewDimension{ shared::msaa_quality > 1 ? D3D11_DSV_DIMENSION_TEXTURE2DMS : D3D11_DSV_DIMENSION_TEXTURE2D },`
`30`	`30`	`};`
`31`	`31`
`32`		`- if(auto result = shared.device->CreateDepthStencilView(texture, nullptr, &buffer); FAILED(result)) {`
	`32`	`+ if(auto result = shared.device->CreateDepthStencilView(texture, &depth_stencil_view_desc, &buffer); FAILED(result)) {`
`33`	`33`	`sdk::logger(sdk::e_log_type::error, "CreateDepthStencilView failed, return code {}.", result);`
`34`	`34`	`return;`
`35`	`35`	`}`