Add support for multisample anti-aliasing (MSAA), working HiDPI support

.pre-commit-config.yaml

@@ -12,7 +12,7 @@ repos:
       types: [text]
       files: '\.(cpp|cxx|c|h|hpp|hxx|txx)$'
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: check-added-large-files
         args: ['--maxkb=1800']
@@ -30,12 +30,12 @@ repos:
                 doc/doxygen-awesome.*
             )$
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.12.7'
+    rev: 'v0.12.9'
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
       - id: ruff-format
   - repo: https://github.com/BlankSpruce/gersemi
-    rev: 0.21.0
+    rev: 0.22.1
     hooks:
       - id: gersemi

CHANGELOG.md

@@ -7,6 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- core/DepthAndShadowPass : add support for multisampled depth/shadow passes
+- multibody : add MSAA support in `RobotScene` and `Visualizer`
+- core/RenderContext.h : implement move ctor and assignment op
+- multibody/Visualizer : working high DPI support
+- core/GraphicsPipeline : store pipeline metadata
+- core/Texture.h : add comparison operator
+- core/Texture.h : add `sampleCount()` getter
+- core : add RAII class `GraphicsPipeline`
+- multibody : add wireframe mode switch in Visualizer GUI
+- multibody/RobotDebug : add external forces to debug elts GUI
+- core/DebugScene : add getters for subsystems
+
+### Changed
+
+- multibody/RobotScene : always render to G-buffer normal map
+- core: move header `LoadCoalGeometries.h` and its functions to library core
+- multibody/Visualizer : rename a data member in Config
+- core/Device.h : implement move assignment operator
+- core/RenderContext : introduce intermediate color render target, start introducing MSAA texture buffers
+- core : move contents on `Scene.h` into `Core.h` header
+- multibody : better graphics pipeline management using RAII class
+- gui : Move all GUI functions into "gui" namespaces
+
+### Removed
+
+- Remove deprecated header `candlewick/multibody/LoadCoalPrimitives.h`
+
 ## [0.9.0] - 2025-08-12
 
 - utils/VideoRecorder : check filename extension (must be ".mp4")

bindings/python/src/expose-renderer.cpp

@@ -11,6 +11,22 @@ void exposeRenderer() {
       .def("driverName", &Device::driverName, ("self"_a))
       .def("shaderFormats", &Device::shaderFormats, ("self"_a));
 
+  bp::class_<Window, boost::noncopyable>("Window", bp::no_init)
+      .def("pixelDensity", &Window::pixelDensity, ("self"_a))
+      .def("displayScale", &Window::displayScale, ("self"_a))
+      .def(
+          "title", +[](const Window &w) { return w.title().data(); },
+          ("self"_a));
+
+#define _c(name) value(#name, SDL_GPUSampleCount::name)
+  bp::enum_<SDL_GPUSampleCount>("SampleCount")
+      ._c(SDL_GPU_SAMPLECOUNT_1)
+      ._c(SDL_GPU_SAMPLECOUNT_2)
+      ._c(SDL_GPU_SAMPLECOUNT_4)
+      ._c(SDL_GPU_SAMPLECOUNT_8)
+#undef _c
+      .export_values();
+
   bp::def("get_num_gpu_drivers", SDL_GetNumGPUDrivers,
           "Get number of available GPU drivers.");
 
@@ -36,5 +52,9 @@ void exposeRenderer() {
               "Automatically detect the compatible set of shader formats."});
 
   bp::class_<RenderContext, boost::noncopyable>("RenderContext", bp::no_init)
-      .def_readonly("device", &RenderContext::device);
+      .def_readonly("device", &RenderContext::device)
+      .def_readonly("window", &RenderContext::window)
+      .add_property("hasDepthTexture", &RenderContext::hasDepthTexture)
+      .def("enableMSAA", &RenderContext::enableMSAA, ("self"_a, "samples"))
+      .def("disableMSAA", &RenderContext::disableMSAA, ("self"_a));
 }

examples/ColoredCube.cpp

@@ -99,7 +99,6 @@ int main() {
       Window{window}, // take ownership of existing SDL_Window handle
       depth_stencil_format);
   Device &device = ctx.device;
-  SDL_GPUTexture *depthTexture = ctx.depth_texture;
 
   // Buffers
 
@@ -216,7 +215,6 @@ int main() {
     SDL_GPURenderPass *render_pass;
     SDL_GPUBufferBinding vertex_binding = mesh.getVertexBinding(0);
     CommandBuffer cmdbuf{device};
-    SDL_GPUTexture *&swapchain = ctx.swapchain;
     const Float3 center{0., 0., 0.};
     Float3 eye{0., 0., 0.};
     // start at phi -> eye.x = 2.5, eye.y = 0.5
@@ -227,18 +225,20 @@ int main() {
     projViewMat = perp * view * modelMat;
 
     if (ctx.waitAndAcquireSwapchain(cmdbuf)) {
-      SDL_GPUColorTargetInfo ctinfo{.texture = swapchain,
-                                    .clear_color = SDL_FColor{},
-                                    .load_op = SDL_GPU_LOADOP_CLEAR,
-                                    .store_op = SDL_GPU_STOREOP_STORE};
+      SDL_GPUColorTargetInfo ctinfo{
+          .texture = ctx.colorTarget(),
+          .clear_color = SDL_FColor{},
+          .load_op = SDL_GPU_LOADOP_CLEAR,
+          .store_op = SDL_GPU_STOREOP_STORE,
+      };
       SDL_GPUDepthStencilTargetInfo depth_target;
       SDL_zero(depth_target);
       depth_target.clear_depth = 1.0f;
       depth_target.load_op = SDL_GPU_LOADOP_CLEAR;
       depth_target.store_op = SDL_GPU_STOREOP_DONT_CARE;
       depth_target.stencil_load_op = SDL_GPU_LOADOP_DONT_CARE;
       depth_target.stencil_store_op = SDL_GPU_STOREOP_DONT_CARE;
-      depth_target.texture = depthTexture;
+      depth_target.texture = ctx.depthTarget();
       depth_target.cycle = true;
       render_pass = SDL_BeginGPURenderPass(cmdbuf, &ctinfo, 1, &depth_target);
       SDL_BindGPUGraphicsPipeline(render_pass, pipeline);
@@ -254,6 +254,7 @@ int main() {
       SDL_Log("Failed to acquire swapchain: %s", SDL_GetError());
       break;
     }
+    ctx.presentToSwapchain(cmdbuf);
     cmdbuf.submit();
   }
 

examples/LitMesh.cpp

@@ -2,6 +2,7 @@
 
 #include "candlewick/core/RenderContext.h"
 #include "candlewick/core/Mesh.h"
+#include "candlewick/core/GraphicsPipeline.h"
 #include "candlewick/core/Shader.h"
 #include "candlewick/utils/MeshData.h"
 #include "candlewick/utils/LoadMesh.h"
@@ -78,8 +79,7 @@ int main() {
 
   /** CREATE PIPELINE **/
   SDL_GPUDepthStencilTargetInfo depth_target_info;
-  SDL_GPUGraphicsPipeline *pipeline;
-  {
+  GraphicsPipeline pipeline = [&]() {
     auto vertexShader = Shader::fromMetadata(device, "PbrBasic.vert");
     auto fragmentShader = Shader::fromMetadata(device, "PbrBasic.frag");
 
@@ -94,7 +94,7 @@ int main() {
     depth_target_info.store_op = SDL_GPU_STOREOP_DONT_CARE;
     depth_target_info.stencil_load_op = SDL_GPU_LOADOP_DONT_CARE;
     depth_target_info.stencil_store_op = SDL_GPU_STOREOP_DONT_CARE;
-    depth_target_info.texture = ctx.depth_texture;
+    depth_target_info.texture = ctx.depthTarget();
     depth_target_info.cycle = true;
 
     // create pipeline
@@ -103,24 +103,27 @@ int main() {
         .fragment_shader = fragmentShader,
         .vertex_input_state = meshes[0].layout(),
         .primitive_type = meshDatas[0].primitiveType,
-        .rasterizer_state{.fill_mode = SDL_GPU_FILLMODE_FILL,
-                          .cull_mode = SDL_GPU_CULLMODE_NONE,
-                          .front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE},
-        .depth_stencil_state{.compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL,
-                             .enable_depth_test = true,
-                             .enable_depth_write = true},
-        .target_info{.color_target_descriptions = &color_target_desc,
-                     .num_color_targets = 1,
-                     .depth_stencil_format = ctx.depthFormat(),
-                     .has_depth_stencil_target = true},
+        .rasterizer_state{
+            .fill_mode = SDL_GPU_FILLMODE_FILL,
+            .cull_mode = SDL_GPU_CULLMODE_NONE,
+            .front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE,
+        },
+        .multisample_state{},
+        .depth_stencil_state{
+            .compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL,
+            .enable_depth_test = true,
+            .enable_depth_write = true,
+        },
+        .target_info{
+            .color_target_descriptions = &color_target_desc,
+            .num_color_targets = 1,
+            .depth_stencil_format = ctx.depthFormat(),
+            .has_depth_stencil_target = true,
+        },
         .props = 0,
     };
-    pipeline = SDL_CreateGPUGraphicsPipeline(device, &pipeline_desc);
-  }
-  if (pipeline == NULL) {
-    SDL_Log("Failed to create pipeline: %s", SDL_GetError());
-    return 1;
-  }
+    return GraphicsPipeline(device, pipeline_desc, nullptr);
+  }();
 
   Rad<float> fov = 55.0_degf;
   CylindricalCamera camera{Camera{
@@ -197,15 +200,15 @@ int main() {
     } else {
 
       SDL_GPUColorTargetInfo ctinfo{
-          .texture = ctx.swapchain,
+          .texture = ctx.colorTarget(),
           .clear_color = SDL_FColor{0., 0., 0., 0.},
           .load_op = SDL_GPU_LOADOP_CLEAR,
           .store_op = SDL_GPU_STOREOP_STORE,
           .cycle = false,
       };
       render_pass = SDL_BeginGPURenderPass(command_buffer, &ctinfo, 1,
                                            &depth_target_info);
-      SDL_BindGPUGraphicsPipeline(render_pass, pipeline);
+      pipeline.bind(render_pass);
 
       TransformUniformData cameraUniform{
           .modelView = modelView.matrix(),
@@ -231,15 +234,15 @@ int main() {
       SDL_EndGPURenderPass(render_pass);
     }
 
+    ctx.presentToSwapchain(command_buffer);
     command_buffer.submit();
     frameNo++;
   }
 
   for (auto &mesh : meshes) {
     mesh.release();
   }
-  SDL_ReleaseGPUGraphicsPipeline(device, pipeline);
-
+  pipeline.release();
   ctx.destroy();
   SDL_Quit();
   return 0;

examples/MeshNormalsRgb.cpp

@@ -2,6 +2,7 @@
 
 #include "candlewick/core/RenderContext.h"
 #include "candlewick/core/CommandBuffer.h"
+#include "candlewick/core/GraphicsPipeline.h"
 #include "candlewick/core/Mesh.h"
 #include "candlewick/core/Shader.h"
 #include "candlewick/utils/MeshData.h"
@@ -67,51 +68,47 @@ int main() {
   Shader vertexShader{device, "VertexNormal.vert", {.uniform_buffers = 1}};
   Shader fragmentShader{device, "VertexNormal.frag", {}};
 
-  SDL_GPUTexture *depthTexture = ctx.depth_texture;
-
   SDL_GPUColorTargetDescription colorTarget;
   SDL_zero(colorTarget);
-  colorTarget.format = SDL_GetGPUSwapchainTextureFormat(device, window);
+  colorTarget.format = ctx.colorFormat();
   SDL_GPUDepthStencilTargetInfo depthTarget;
   SDL_zero(depthTarget);
   depthTarget.clear_depth = 1.0;
   depthTarget.load_op = SDL_GPU_LOADOP_CLEAR;
   depthTarget.store_op = SDL_GPU_STOREOP_DONT_CARE;
   depthTarget.stencil_load_op = SDL_GPU_LOADOP_DONT_CARE;
   depthTarget.stencil_store_op = SDL_GPU_STOREOP_DONT_CARE;
-  depthTarget.texture = depthTexture;
+  depthTarget.texture = ctx.depthTarget();
   depthTarget.cycle = true;
 
   // create pipeline
-  SDL_GPUGraphicsPipelineCreateInfo pipeline_desc{
-      .vertex_shader = vertexShader,
-      .fragment_shader = fragmentShader,
-      .vertex_input_state = meshes[0].layout(),
-      .primitive_type = meshDatas[0].primitiveType,
-      .rasterizer_state{
-          .fill_mode = SDL_GPU_FILLMODE_FILL,
-          .cull_mode = SDL_GPU_CULLMODE_NONE,
-          .front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE,
-      },
-      .depth_stencil_state{
-          .compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL,
-          .enable_depth_test = true,
-          .enable_depth_write = true,
+  GraphicsPipeline pipeline{
+      device,
+      {
+          .vertex_shader = vertexShader,
+          .fragment_shader = fragmentShader,
+          .vertex_input_state = meshes[0].layout(),
+          .primitive_type = meshDatas[0].primitiveType,
+          .rasterizer_state{
+              .fill_mode = SDL_GPU_FILLMODE_FILL,
+              .cull_mode = SDL_GPU_CULLMODE_NONE,
+              .front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE,
+          },
+          .depth_stencil_state{
+              .compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL,
+              .enable_depth_test = true,
+              .enable_depth_write = true,
+          },
+          .target_info{
+              .color_target_descriptions = &colorTarget,
+              .num_color_targets = 1,
+              .depth_stencil_format = ctx.depthFormat(),
+              .has_depth_stencil_target = true,
+          },
+          .props = 0,
       },
-      .target_info{
-          .color_target_descriptions = &colorTarget,
-          .num_color_targets = 1,
-          .depth_stencil_format = ctx.depthFormat(),
-          .has_depth_stencil_target = true,
-      },
-      .props = 0,
+      "Main color pipeline",
   };
-  SDL_GPUGraphicsPipeline *pipeline =
-      SDL_CreateGPUGraphicsPipeline(device, &pipeline_desc);
-  if (pipeline == NULL) {
-    SDL_Log("Failed to create pipeline: %s", SDL_GetError());
-    return 1;
-  }
 
   vertexShader.release();
   fragmentShader.release();
@@ -191,18 +188,16 @@ int main() {
       SDL_Log("Failed to acquire swapchain: %s", SDL_GetError());
       break;
     } else {
-      auto *swapchain = ctx.swapchain;
-
       SDL_GPUColorTargetInfo ctinfo{
-          .texture = swapchain,
+          .texture = ctx.colorTarget(),
           .clear_color = SDL_FColor{0., 0., 0., 0.},
           .load_op = SDL_GPU_LOADOP_CLEAR,
           .store_op = SDL_GPU_STOREOP_STORE,
           .cycle = false,
       };
       render_pass =
           SDL_BeginGPURenderPass(command_buffer, &ctinfo, 1, &depthTarget);
-      SDL_BindGPUGraphicsPipeline(render_pass, pipeline);
+      pipeline.bind(render_pass);
       TransformUniformData cameraUniform{
           projViewMat,
           normalMatrix,
@@ -224,8 +219,7 @@ int main() {
   for (auto &mesh : meshes) {
     mesh.release();
   }
-  SDL_ReleaseGPUGraphicsPipeline(device, pipeline);
-
+  pipeline.release();
   ctx.destroy();
   SDL_Quit();
   return 0;