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/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/Scene/SceneHelpers.cpp

@@ -336,7 +336,7 @@ SceneRendererParams osc::calc_standard_dark_scene_render_params(
     return SceneRendererParams{
         .dimensions = dimensions,
         .device_pixel_ratio = device_pixel_ratio,
-        .antialiasing_level = aa_level,
+        .anti_aliasing_level = aa_level,
         .draw_mesh_normals = false,
         .draw_floor = false,
         .near_clipping_plane = camera.znear,