Merge pull request #92 from Simple-Robotics/next

Rework debug scene (re-use `Mesh` object)

Author: ManifoldFR

.pre-commit-config.yaml

@@ -30,7 +30,7 @@ repos:
                 doc/doxygen-awesome.*
             )$
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.12.4'
+    rev: 'v0.12.7'
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]

CHANGELOG.md

@@ -7,7 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.8.0] - 2025-07-25
+- core : Add `LambertMaterial`
+- multibody/Visualizer : remove default world triad
+  * user must add it explicitly
+- multibody/Visualizer : pass scale to addFrameViz()
 
 ## [0.8.0] - 2025-07-25
 

bindings/python/candlewick/video_context.py

@@ -1,7 +1,9 @@
+import warnings
+import os
+
 from contextlib import contextmanager
 from . import Visualizer, hasFfmpegSupport
 from typing import Union, TYPE_CHECKING
-import warnings
 
 if TYPE_CHECKING:
     from .async_visualizer import AsyncVisualizer
@@ -14,7 +16,7 @@
 @contextmanager
 def create_recorder_context(
     viz: Union[Visualizer, "AsyncVisualizer"],
-    filename: str,
+    filename: Union[str | os.PathLike],
     /,
     fps: int = _DEFAULT_VIDEO_SETTINGS["fps"],
     bitRate: int = _DEFAULT_VIDEO_SETTINGS["bitRate"],

bindings/python/src/expose-visualizer.cpp

@@ -25,8 +25,12 @@ static auto visualizer_get_frame_debugs(Visualizer &viz) {
 
 void exposeVisualizer() {
   using pinocchio::python::VisualizerPythonVisitor;
+  using pinocchio::visualizers::Vector3;
 
   eigenpy::OptionalConverter<ConstVectorRef, std::optional>::registration();
+  eigenpy::OptionalConverter<Vector3, std::optional>::registration();
+  eigenpy::detail::NoneToPython<std::nullopt_t>::registration();
+
   bp::class_<Visualizer::Config>("VisualizerConfig", bp::init<>("self"_a))
       .def_readwrite("width", &Visualizer::Config::width)
       .def_readwrite("height", &Visualizer::Config::height);
@@ -71,7 +75,8 @@ void exposeVisualizer() {
            bp::return_internal_reference<>())
 #endif
       .def("addFrameViz", &Visualizer::addFrameViz,
-           ("self"_a, "frame_id", "show_velocity"_a = true),
+           ("self"_a, "frame_id", "show_velocity"_a = true,
+            "scale"_a = std::nullopt, "vel_scale"_a = std::nullopt),
            "Add visualization (triad and frame velocity) for the given frame "
            "by ID.")
       .def("removeFramesViz", &Visualizer::removeFramesViz, ("self"_a),

cmake

@@ -71,8 +71,7 @@ int main() {
 
   std::vector<Mesh> meshes;
   for (std::size_t j = 0; j < meshDatas.size(); j++) {
-    Mesh mesh = createMesh(device, meshDatas[j]);
-    uploadMeshToDevice(device, mesh, meshDatas[j]);
+    Mesh mesh = createMesh(device, meshDatas[j], true);
     meshes.push_back(std::move(mesh));
   }
   SDL_assert(meshDatas[0].numIndices() == meshes[0].indexCount);
@@ -204,14 +203,9 @@ int main() {
           .store_op = SDL_GPU_STOREOP_STORE,
           .cycle = false,
       };
-      SDL_GPUBufferBinding vertex_binding = meshes[0].getVertexBinding(0);
-      SDL_GPUBufferBinding index_binding = meshes[0].getIndexBinding();
       render_pass = SDL_BeginGPURenderPass(command_buffer, &ctinfo, 1,
                                            &depth_target_info);
       SDL_BindGPUGraphicsPipeline(render_pass, pipeline);
-      SDL_BindGPUVertexBuffers(render_pass, 0, &vertex_binding, 1);
-      SDL_BindGPUIndexBuffer(render_pass, &index_binding,
-                             SDL_GPU_INDEXELEMENTSIZE_32BIT);
 
       TransformUniformData cameraUniform{
           .modelView = modelView.matrix(),
@@ -224,16 +218,15 @@ int main() {
           myLight.intensity,
       };
 
+      rend::bindMesh(render_pass, meshes[0]);
+
       auto materialUbo = meshDatas[0].material;
 
-      SDL_PushGPUVertexUniformData(command_buffer, 0, &cameraUniform,
-                                   sizeof(cameraUniform));
-      SDL_PushGPUFragmentUniformData(command_buffer, 0, &materialUbo,
-                                     sizeof(materialUbo));
-      SDL_PushGPUFragmentUniformData(command_buffer, 1, &lightUbo,
-                                     sizeof(lightUbo));
-      SDL_DrawGPUIndexedPrimitives(render_pass, meshes[0].indexCount, 1, 0, 0,
-                                   0);
+      command_buffer.pushVertexUniform(0u, cameraUniform)
+          .pushFragmentUniform(0u, materialUbo)
+          .pushFragmentUniform(1u, lightUbo);
+
+      rend::draw(render_pass, meshes[0]);
 
       SDL_EndGPURenderPass(render_pass);
     }

examples/LitMesh.cpp

@@ -58,8 +58,7 @@ int main() {
 
   std::vector<Mesh> meshes;
   for (std::size_t j = 0; j < meshDatas.size(); j++) {
-    Mesh mesh = createMesh(device, meshDatas[j]);
-    uploadMeshToDevice(device, mesh, meshDatas[j]);
+    Mesh mesh = createMesh(device, meshDatas[j], true);
     meshes.push_back(std::move(mesh));
   }
   SDL_assert(meshDatas[0].numIndices() == meshes[0].indexCount);
@@ -117,8 +116,6 @@ int main() {
   vertexShader.release();
   fragmentShader.release();
 
-  SDL_GPUTexture *swapchain;
-
   Radf fov = 70.0_degf;
   Mat4f projectionMat = perspectiveFromFov(fov, aspectRatio, 0.1f, 40.0f);
 
@@ -185,17 +182,16 @@ int main() {
         modelView.topLeftCorner<3, 3>().inverse().transpose();
 
     // render pass
-
     SDL_GPURenderPass *render_pass;
 
     CommandBuffer command_buffer(device);
     SDL_Log("Frame [%u]", frameNo);
 
-    if (!SDL_WaitAndAcquireGPUSwapchainTexture(command_buffer, window,
-                                               &swapchain, NULL, NULL)) {
+    if (!ctx.waitAndAcquireSwapchain(command_buffer)) {
       SDL_Log("Failed to acquire swapchain: %s", SDL_GetError());
       break;
     } else {
+      auto *swapchain = ctx.swapchain;
 
       SDL_GPUColorTargetInfo ctinfo{
           .texture = swapchain,
@@ -204,24 +200,19 @@ int main() {
           .store_op = SDL_GPU_STOREOP_STORE,
           .cycle = false,
       };
-      SDL_GPUBufferBinding vertex_binding = meshes[0].getVertexBinding(0);
-      SDL_GPUBufferBinding index_binding = meshes[0].getIndexBinding();
       render_pass =
           SDL_BeginGPURenderPass(command_buffer, &ctinfo, 1, &depthTarget);
       SDL_BindGPUGraphicsPipeline(render_pass, pipeline);
-      SDL_BindGPUVertexBuffers(render_pass, 0, &vertex_binding, 1);
-      SDL_BindGPUIndexBuffer(render_pass, &index_binding,
-                             SDL_GPU_INDEXELEMENTSIZE_32BIT);
-
       TransformUniformData cameraUniform{
           projViewMat,
           normalMatrix,
       };
+      command_buffer.pushVertexUniform(0u, cameraUniform);
 
-      SDL_PushGPUVertexUniformData(command_buffer, 0, &cameraUniform,
-                                   sizeof(cameraUniform));
-      SDL_DrawGPUIndexedPrimitives(render_pass, meshes[0].indexCount, 1, 0, 0,
-                                   0);
+      for (auto &mesh : meshes) {
+        rend::bindMesh(render_pass, mesh);
+        rend::draw(render_pass, mesh);
+      }
 
       SDL_EndGPURenderPass(render_pass);
     }

examples/MeshNormalsRgb.cpp

@@ -10,6 +10,7 @@
 #include <CLI/Config.hpp>
 
 using namespace candlewick::multibody;
+using pinocchio::visualizers::Vector3;
 using std::chrono::steady_clock;
 namespace fs = std::filesystem;
 
@@ -41,6 +42,7 @@ int main(int argc, char **argv) {
 
   Visualizer visualizer{{window_dims[0], window_dims[1]}, model, geom_model};
   assert(!visualizer.hasExternalData());
+  visualizer.addFrameViz(model.getFrameId("world"), false, Vector3::Ones());
   visualizer.addFrameViz(model.getFrameId("elbow_joint"));
   visualizer.addFrameViz(model.getFrameId("ee_link"));
   pin::Data &data = visualizer.data();

examples/Visualizer.cpp

@@ -12,45 +12,55 @@ DebugScene::DebugScene(entt::registry &reg, const RenderContext &renderer)
     : m_registry(reg)
     , m_renderer(renderer)
     , m_trianglePipeline(nullptr)
-    , m_linePipeline(nullptr) {}
+    , m_linePipeline(nullptr)
+    , m_sharedMeshes() {
+  this->initializeSharedMeshes();
+}
 
 DebugScene::DebugScene(DebugScene &&other)
     : m_registry(other.m_registry)
     , m_renderer(other.m_renderer)
     , m_trianglePipeline(other.m_trianglePipeline)
     , m_linePipeline(other.m_linePipeline)
-    , m_subsystems(std::move(other.m_subsystems)) {
+    , m_subsystems(std::move(other.m_subsystems))
+    , m_sharedMeshes(std::move(other.m_sharedMeshes)) {
   other.m_trianglePipeline = nullptr;
   other.m_linePipeline = nullptr;
 }
 
+void DebugScene::initializeSharedMeshes() {
+  {
+    std::array triad_datas = loadTriadSolid();
+    Mesh mesh = createMeshFromBatch(device(), triad_datas, true);
+    setupPipelines(mesh.layout());
+    m_sharedMeshes.emplace(TRIAD, std::move(mesh));
+  }
+  {
+    MeshData grid_data = loadGrid(20);
+    m_sharedMeshes.emplace(GRID, createMesh(device(), grid_data, true));
+  }
+  {
+    MeshData arrow_data = loadArrowSolid(false);
+    m_sharedMeshes.emplace(ARROW, createMesh(device(), arrow_data, true));
+  }
+}
+
 std::tuple<entt::entity, DebugMeshComponent &>
 DebugScene::addTriad(const Float3 &scale) {
-  auto triad_datas = loadTriadSolid();
-  std::vector<Float4> triad_colors(3);
-  Mesh triad = createMeshFromBatch(device(), triad_datas, true);
-  for (size_t i = 0; i < 3; i++) {
-    triad_colors[i] = triad_datas[i].material.baseColor;
-  }
-  setupPipelines(triad.layout());
   entt::entity entity = m_registry.create();
   auto &item = m_registry.emplace<DebugMeshComponent>(
-      entity, DebugPipelines::TRIANGLE_FILL, std::move(triad), triad_colors,
-      true, scale);
+      entity, DebugPipelines::TRIANGLE_FILL, TRIAD,
+      std::vector<Float4>{m_triadColors.begin(), m_triadColors.end()}, true,
+      scale);
   m_registry.emplace<TransformComponent>(entity, Mat4f::Identity());
   return {entity, item};
 }
 
 std::tuple<entt::entity, DebugMeshComponent &>
 DebugScene::addLineGrid(const Float4 &color) {
-  auto grid_data = loadGrid(20);
-  Mesh grid = createMesh(device(), grid_data, true);
-
-  setupPipelines(grid.layout());
   auto entity = m_registry.create();
   auto &item = m_registry.emplace<DebugMeshComponent>(
-      entity, DebugPipelines::TRIANGLE_LINE, std::move(grid),
-      std::vector{color});
+      entity, DebugPipelines::TRIANGLE_LINE, GRID, std::vector{color});
   m_registry.emplace<TransformComponent>(entity, Mat4f::Identity());
   return {entity, item};
 }
@@ -116,7 +126,7 @@ void DebugScene::render(CommandBuffer &cmdBuf, const Camera &camera) const {
   auto group =
       m_registry.view<const DebugMeshComponent, const TransformComponent>(
           entt::exclude<Disable>);
-  group.each([&](auto &cmd, auto &tr) {
+  group.each([&](const DebugMeshComponent &cmd, auto &tr) {
     if (!cmd.enable)
       return;
 
@@ -131,11 +141,12 @@ void DebugScene::render(CommandBuffer &cmdBuf, const Camera &camera) const {
 
     const GpuMat4 mvp = viewProj * tr;
     cmdBuf.pushVertexUniform(TRANSFORM_SLOT, mvp);
-    rend::bindMesh(render_pass, cmd.mesh);
-    for (size_t i = 0; i < cmd.mesh.numViews(); i++) {
+    auto &mesh = this->getMesh(cmd.meshType);
+    rend::bindMesh(render_pass, mesh);
+    for (size_t i = 0; i < mesh.numViews(); i++) {
       const auto &color = cmd.colors[i];
       cmdBuf.pushFragmentUniform(COLOR_SLOT, color);
-      rend::drawView(render_pass, cmd.mesh.view(i));
+      rend::drawView(render_pass, mesh.view(i));
     }
   });