Hackily implement oit

Author: adamkewley

libopensimcreator/Graphics/OpenSimGraphicsHelpers.cpp

@@ -60,7 +60,7 @@ SceneRendererParams osc::CalcSceneRendererParams(
         rv.dimensions = viewportDims;
     }
     rv.device_pixel_ratio = viewportDevicePixelRatio;
-    rv.antialiasing_level = antiAliasingLevel;
+    rv.anti_aliasing_level = antiAliasingLevel;
     rv.light_direction = recommended_light_direction(renderParams.camera);
     renderParams.renderingOptions.applyTo(rv);
     rv.view_matrix = renderParams.camera.view_matrix();

libopensimcreator/UI/MeshImporter/MeshImporterSharedState.h

@@ -444,7 +444,7 @@ namespace osc::mi
             SceneRendererParams p;
             p.dimensions = get3DSceneDims();
             p.device_pixel_ratio = app.settings().get_value<float>("graphics/render_scale", 1.0f) * app.main_window_device_pixel_ratio();
-            p.antialiasing_level = app.anti_aliasing_level();
+            p.anti_aliasing_level = app.anti_aliasing_level();
             p.draw_rims = true;
             p.draw_floor = false;
             p.near_clipping_plane = m_3DSceneCamera.znear;

libopensimcreator/UI/SplashTab.cpp

@@ -197,7 +197,7 @@ class osc::SplashTab::Impl final : public TabPrivate {
         SceneRendererParams params{m_LastSceneRendererParams};
         params.dimensions = workspaceUIRect.dimensions();
         params.device_pixel_ratio = App::settings().get_value<float>("graphics/render_scale", 1.0f) * App::get().main_window_device_pixel_ratio(),
-        params.antialiasing_level = App::get().anti_aliasing_level();
+        params.anti_aliasing_level = App::get().anti_aliasing_level();
         params.projection_matrix = m_Camera.projection_matrix(aspect_ratio_of(workspaceUIRect));
 
         if (params != m_LastSceneRendererParams) {

liboscar-demos/MeshGenTestTab.cpp

@@ -104,7 +104,7 @@ class osc::MeshGenTestTab::Impl final : public TabPrivate {
             const Vector2 viewport_dimensions = viewport_ui_rect.dimensions();
             render_params_.dimensions = elementwise_max(viewport_dimensions, {0.0f, 0.0f});
             render_params_.device_pixel_ratio = App::settings().get_value<float>("graphics/render_scale", 1.0f) * App::get().main_window_device_pixel_ratio(),
-            render_params_.antialiasing_level = App::get().anti_aliasing_level();
+            render_params_.anti_aliasing_level = App::get().anti_aliasing_level();
             render_params_.light_direction = recommended_light_direction(camera_);
             render_params_.projection_matrix = camera_.projection_matrix(aspect_ratio_of(render_params_.dimensions));
             render_params_.view_matrix = camera_.view_matrix();

liboscar-demos/learnopengl/AdvancedLighting/LOGLPointShadowsTab.cpp

@@ -26,7 +26,7 @@ using namespace osc;
 
 namespace
 {
-    constexpr Vector2i c_shadowmap_pixel_dimensions = {1024, 1024};
+    constexpr Vector2i c_shadow_map_pixel_dimensions = {1024, 1024};
 
     Transform make_rotated_transform()
     {
@@ -66,7 +66,7 @@ namespace
     RenderTexture create_depth_texture()
     {
         return RenderTexture{{
-            .pixel_dimensions = c_shadowmap_pixel_dimensions,
+            .pixel_dimensions = c_shadow_map_pixel_dimensions,
             .dimensionality = TextureDimensionality::Cube,
             .color_format = ColorRenderBufferFormat::R32_SFLOAT,
         }};
@@ -128,7 +128,7 @@ class osc::LOGLPointShadowsTab::Impl final : public TabPrivate {
         const Rect workspace_screen_space_rect = ui::get_main_window_workspace_screen_space_rect();
 
         draw_shadow_pass_to_cubemap();
-        draw_shadowmapped_scene_to_screen(workspace_screen_space_rect);
+        draw_shadow_mapped_scene_to_screen(workspace_screen_space_rect);
     }
 
     void draw_shadow_pass_to_cubemap()
@@ -138,7 +138,7 @@ class osc::LOGLPointShadowsTab::Impl final : public TabPrivate {
         const float zfar = 25.0f;
         const Matrix4x4 projection_matrix = perspective(
             90_deg,
-            aspect_ratio_of(c_shadowmap_pixel_dimensions),
+            aspect_ratio_of(c_shadow_map_pixel_dimensions),
             znear,
             zfar
         );
@@ -148,19 +148,19 @@ class osc::LOGLPointShadowsTab::Impl final : public TabPrivate {
             calc_cubemap_view_proj_matrices(projection_matrix, light_pos_);
 
         // pass data to material
-        shadowmapping_material_.set_array("uShadowMatrices", shadow_matrices);
-        shadowmapping_material_.set("uLightPos", light_pos_);
-        shadowmapping_material_.set("uFarPlane", zfar);
+        shadow_mapping_material_.set_array("uShadowMatrices", shadow_matrices);
+        shadow_mapping_material_.set("uLightPos", light_pos_);
+        shadow_mapping_material_.set("uFarPlane", zfar);
 
-        // render (shadowmapping does not use the camera's view/projection matrices)
+        // render (shadow mapping does not use the camera's view/projection matrices)
         Camera camera;
         for (const SceneCube& cube : scene_cubes_) {
-            graphics::draw(cube_mesh_, cube.transform, shadowmapping_material_, camera);
+            graphics::draw(cube_mesh_, cube.transform, shadow_mapping_material_, camera);
         }
         camera.render_to(depth_texture_);
     }
 
-    void draw_shadowmapped_scene_to_screen(const Rect& viewport_screen_space_rect)
+    void draw_shadow_mapped_scene_to_screen(const Rect& viewport_screen_space_rect)
     {
         Material material = use_soft_shadows_ ? soft_scene_material_ : scene_material_;
 
@@ -200,7 +200,7 @@ class osc::LOGLPointShadowsTab::Impl final : public TabPrivate {
 
     ResourceLoader loader_ = App::resource_loader();
 
-    Material shadowmapping_material_{Shader{
+    Material shadow_mapping_material_{Shader{
         loader_.slurp("oscar_demos/learnopengl/shaders/AdvancedLighting/point_shadows/MakeShadowMap.vert"),
         loader_.slurp("oscar_demos/learnopengl/shaders/AdvancedLighting/point_shadows/MakeShadowMap.geom"),
         loader_.slurp("oscar_demos/learnopengl/shaders/AdvancedLighting/point_shadows/MakeShadowMap.frag"),

liboscar-demos/learnopengl/Guest/LOGLCSMTab.cpp

@@ -37,7 +37,7 @@ namespace rgs = std::ranges;
 
 namespace
 {
-    constexpr int c_shadowmap_edge_length = 256;
+    constexpr int c_shadow_map_edge_length = 256;
 
     // represents a single transformed mesh in the scene
     struct TransformedMesh {
@@ -94,11 +94,11 @@ namespace
         return rv;
     }
 
-    // returns blank depth buffers that the cascade (shadowmaps) are written to
+    // returns blank depth buffers that the cascade (shadow maps) are written to
     std::vector<SharedDepthStencilRenderBuffer> generate_blank_cascade_buffers()
     {
         const DepthStencilRenderBufferParams params = {
-            .pixel_dimensions = Vector2i{c_shadowmap_edge_length},
+            .pixel_dimensions = Vector2i{c_shadow_map_edge_length},
             .format = DepthStencilRenderBufferFormat::D32_SFloat,
         };
         return {

liboscar/Graphics/GraphicsImplementation.cpp

@@ -2023,7 +2023,7 @@ std::ostream& osc::operator<<(std::ostream& o, const RenderTextureParams& params
         "RenderTextureParams(width = " << params.pixel_dimensions.x
         << ", height = " << params.pixel_dimensions.y
         << ", device_pixel_ratio = " << params.device_pixel_ratio
-        << ", antialiasing_level = " << params.anti_aliasing_level
+        << ", anti_aliasing_level = " << params.anti_aliasing_level
         << ", color_format = " << params.color_format
         << ", depth_stencil_format = " << params.depth_stencil_format
         << ")";
@@ -3428,6 +3428,9 @@ class osc::Material::Impl final {
     DepthFunction depth_function() const { return depth_function_; }
     void set_depth_function(DepthFunction depth_function) { depth_function_ = depth_function; }
 
+    bool writes_to_depth_buffer() const { return writes_to_depth_buffer_; }
+    void set_writes_to_depth_buffer(bool value) { writes_to_depth_buffer_ = value; }
+
     bool is_wireframe() const { return is_wireframe_mode_; }
     void set_wireframe(bool value) { is_wireframe_mode_ = value; }
 
@@ -3446,6 +3449,7 @@ class osc::Material::Impl final {
     BlendingEquation blending_equation_ = BlendingEquation::Default;
     bool is_transparent_ = false;
     bool is_depth_tested_ = true;
+    bool writes_to_depth_buffer_ = true;
     bool is_wireframe_mode_ = false;
 };
 
@@ -3518,6 +3522,16 @@ void osc::Material::set_depth_function(DepthFunction depth_function)
     impl_.upd()->set_depth_function(depth_function);
 }
 
+bool osc::Material::writes_to_depth_buffer() const
+{
+    return impl_->writes_to_depth_buffer();
+}
+
+void osc::Material::set_writes_to_depth_buffer(bool value)
+{
+    impl_.upd()->set_writes_to_depth_buffer(value);
+}
+
 bool osc::Material::is_wireframe() const
 {
     return impl_->is_wireframe();
@@ -7346,6 +7360,10 @@ void osc::GraphicsBackend::handle_batch_with_same_material(
         glDepthFunc(to_opengl_depth_function_enum(material_impl.depth_function()));
     }
 
+    if (not material_impl.writes_to_depth_buffer()) {
+        glDepthMask(GL_FALSE);
+    }
+
     if (material_impl.cull_mode() != CullMode::Off) {
         glEnable(GL_CULL_FACE);
         glCullFace(to_opengl_cull_face_enum(material_impl.cull_mode()));
@@ -7403,6 +7421,10 @@ void osc::GraphicsBackend::handle_batch_with_same_material(
         glDisable(GL_CULL_FACE);
     }
 
+    if (not material_impl.writes_to_depth_buffer()) {
+        glDepthMask(GL_TRUE);  // Khronos: "Initially, depth buffer writing is enabled"
+    }
+
     if (material_impl.depth_function() != DepthFunction::Default) {
         glDepthFunc(to_opengl_depth_function_enum(DepthFunction::Default));
     }

liboscar/Graphics/Material.h

@@ -80,6 +80,9 @@ namespace osc
         DepthFunction depth_function() const;
         void set_depth_function(DepthFunction);
 
+        bool writes_to_depth_buffer() const;
+        void set_writes_to_depth_buffer(bool);
+
         bool is_wireframe() const;
         void set_wireframe(bool);
 

liboscar/Graphics/Material.tests.cpp

@@ -730,6 +730,22 @@ TEST_F(MaterialTest, MaterialGetDepthFunctionIsInitiallyDefault)
     ASSERT_EQ(material.depth_function(), DepthFunction::Default);
 }
 
+TEST_F(MaterialTest, MaterialWritesToDepthBufferIsInitiallyTrue)
+{
+    const Material material = generate_material();
+    ASSERT_TRUE(material.writes_to_depth_buffer());
+}
+
+TEST_F(MaterialTest, MaterialSetWritesToDepthBufferChangesWritesToDepthBuffer)
+{
+    Material material = generate_material();
+    ASSERT_TRUE(material.writes_to_depth_buffer());
+    material.set_writes_to_depth_buffer(false);
+    ASSERT_FALSE(material.writes_to_depth_buffer());
+    material.set_writes_to_depth_buffer(true);
+    ASSERT_TRUE(material.writes_to_depth_buffer());
+}
+
 TEST_F(MaterialTest, MaterialSetDepthFunctionBehavesAsExpected)
 {
     Material material = generate_material();

liboscar/Graphics/RenderTexture.tests.cpp

@@ -174,9 +174,9 @@ TEST(RenderTexture, upd_color_buffer_returns_independent_RenderBuffers_from_copi
     // this popped up while developing the `LearnOpenGL/CSM` tab implementation, where
     // it was using a pattern like:
     //
-    //     std::vector<RenderTexture> shadowmaps(num_cascades, RenderTexture{common_params});
+    //     std::vector<RenderTexture> shadow_maps(num_cascades, RenderTexture{common_params});
     //
-    // that pattern wasn't creating independent shadowmaps because the underlying `RenderBuffer`s
+    // that pattern wasn't creating independent shadow maps because the underlying `RenderBuffer`s
     // were being reference-copied, rather than value-copied
 
     RenderTexture render_texture;
@@ -190,9 +190,9 @@ TEST(RenderTexture, upd_depth_buffer_returns_independent_RenderBuffers_from_copi
     // this popped up while developing the `LearnOpenGL/CSM` tab implementation, where
     // it was using a pattern like:
     //
-    //     std::vector<RenderTexture> shadowmaps(num_cascades, RenderTexture{common_params});
+    //     std::vector<RenderTexture> shadow_maps(num_cascades, RenderTexture{common_params});
     //
-    // that pattern wasn't creating independent shadowmaps because the underlying `RenderBuffer`s
+    // that pattern wasn't creating independent shadow maps because the underlying `RenderBuffer`s
     // were being reference-copied, rather than value-copied
 
     RenderTexture rt;