move renderer config to global

Author: fbxiang

include/sapien/sapien_renderer/sapien_renderer_default.h

@@ -12,6 +12,16 @@ class SapienRendererDefault {
 public:
   static SapienRendererDefault &Get();
 
+  static void setGlobalConfig(bool offscreenOnly, int32_t maxNumMaterials, uint32_t maxNumTextures,
+                              uint32_t defaultMipMaps, std::string const &device,
+                              bool doNotLoadTexture);
+  static bool getOffscreenOnly();
+  static uint32_t getDefaultMipMaps();
+  static std::string getDevice();
+  static bool getDoNotLoadTexture();
+  static uint32_t getMaxNumMaterials();
+  static uint32_t getMaxNumTextures();
+
   static void setImguiIniFilename(std::string const &filename);
   static std::string getImguiIniFilename();
 
@@ -39,6 +49,13 @@ class SapienRendererDefault {
   static void internalSetShaderSearchPath(std::string const &dir);
 
 public:
+  bool offscreenOnly = false;
+  uint32_t defaultMipMaps = 1;
+  std::string device = "";
+  bool doNotLoadTexture = false;
+  uint32_t maxNumMaterials = 128;
+  uint32_t maxNumTextures = 512;
+
   std::string viewerShaderDirectory{};
   std::string cameraShaderDirectory{};
   std::unordered_map<std::string, vk::Format> renderTargetFormats;

include/sapien/sapien_renderer/sapien_renderer_system.h

@@ -23,13 +23,9 @@ class SapienRenderCubemap;
 
 class SapienRenderEngine {
 public:
-  static std::shared_ptr<SapienRenderEngine>
-  Get(bool offscreenOnly = false, uint32_t maxNumMaterials = 512, uint32_t maxNumTextures = 128,
-      uint32_t defaultMipLevels = 1, std::string const &device = "",
-      bool doNotLoadTexture = false);
+  static std::shared_ptr<SapienRenderEngine> Get();
 
-  SapienRenderEngine(bool offscreenOnly, uint32_t maxNumMaterials, uint32_t maxNumTextures,
-                     uint32_t defaultMipLevels, std::string const &device, bool doNotLoadTexture);
+  SapienRenderEngine();
 
   std::shared_ptr<svulkan2::core::Context> getContext() const { return mContext; }
   std::shared_ptr<svulkan2::resource::SVResourceManager> getResourceManager() const {

python/py_package/__init__.pyi

@@ -35,4 +35,4 @@ from . import utils
 from . import version
 from . import wrapper
 __all__ = ['ActorBuilder', 'ArticulationBuilder', 'Component', 'CudaArray', 'Engine', 'Entity', 'Path', 'PinocchioModel', 'Pose', 'SapienRenderer', 'Scene', 'SceneConfig', 'System', 'Widget', 'asset', 'internal_renderer', 'math', 'os', 'physx', 'pkg_resources', 'platform', 'profile', 'pysapien', 'pysapien_pinocchio', 'render', 'render_server', 'set_cuda_tensor_backend', 'set_log_level', 'simsense', 'utils', 'version', 'warn', 'wrapper']
-__version__: str = '3.0.0.dev20240119+1bba5fa8'
+__version__: str = '3.0.0.dev20240122+a8854ccd'

python/py_package/pysapien/render.pyi

@@ -4,7 +4,7 @@ import pybind11_stubgen.typing_ext
 import sapien.pysapien
 import sapien.pysapien.internal_renderer
 import typing
-__all__ = ['RenderBodyComponent', 'RenderCameraComponent', 'RenderCameraGroup', 'RenderCubemap', 'RenderCudaMeshComponent', 'RenderDirectionalLightComponent', 'RenderLightComponent', 'RenderMaterial', 'RenderParallelogramLightComponent', 'RenderPointCloudComponent', 'RenderPointLightComponent', 'RenderShape', 'RenderShapeBox', 'RenderShapeCapsule', 'RenderShapeCylinder', 'RenderShapePlane', 'RenderShapeSphere', 'RenderShapeTriangleMesh', 'RenderShapeTriangleMeshPart', 'RenderSpotLightComponent', 'RenderSystem', 'RenderSystemGroup', 'RenderTexture', 'RenderTexture2D', 'RenderTexturedLightComponent', 'RenderWindow', 'SapienRenderer', 'clear_cache', 'get_camera_shader_dir', 'get_device_summary', 'get_imgui_ini_filename', 'get_msaa', 'get_ray_tracing_denoiser', 'get_ray_tracing_dof_aperture', 'get_ray_tracing_dof_plane', 'get_ray_tracing_path_depth', 'get_ray_tracing_samples_per_pixel', 'get_viewer_shader_dir', 'load_scene', 'set_camera_shader_dir', 'set_imgui_ini_filename', 'set_log_level', 'set_msaa', 'set_picture_format', 'set_ray_tracing_denoiser', 'set_ray_tracing_dof_aperture', 'set_ray_tracing_dof_plane', 'set_ray_tracing_path_depth', 'set_ray_tracing_samples_per_pixel', 'set_viewer_shader_dir']
+__all__ = ['RenderBodyComponent', 'RenderCameraComponent', 'RenderCameraGroup', 'RenderCubemap', 'RenderCudaMeshComponent', 'RenderDirectionalLightComponent', 'RenderLightComponent', 'RenderMaterial', 'RenderParallelogramLightComponent', 'RenderPointCloudComponent', 'RenderPointLightComponent', 'RenderShape', 'RenderShapeBox', 'RenderShapeCapsule', 'RenderShapeCylinder', 'RenderShapePlane', 'RenderShapeSphere', 'RenderShapeTriangleMesh', 'RenderShapeTriangleMeshPart', 'RenderSpotLightComponent', 'RenderSystem', 'RenderSystemGroup', 'RenderTexture', 'RenderTexture2D', 'RenderTexturedLightComponent', 'RenderWindow', 'SapienRenderer', 'clear_cache', 'get_camera_shader_dir', 'get_device_summary', 'get_imgui_ini_filename', 'get_msaa', 'get_ray_tracing_denoiser', 'get_ray_tracing_dof_aperture', 'get_ray_tracing_dof_plane', 'get_ray_tracing_path_depth', 'get_ray_tracing_samples_per_pixel', 'get_viewer_shader_dir', 'load_scene', 'set_camera_shader_dir', 'set_global_config', 'set_imgui_ini_filename', 'set_log_level', 'set_msaa', 'set_picture_format', 'set_ray_tracing_denoiser', 'set_ray_tracing_dof_aperture', 'set_ray_tracing_dof_plane', 'set_ray_tracing_path_depth', 'set_ray_tracing_samples_per_pixel', 'set_viewer_shader_dir']
 M = typing.TypeVar("M", bound=int)
 N = typing.TypeVar("N", bound=int)
 class RenderBodyComponent(sapien.pysapien.Component):
@@ -807,7 +807,7 @@ class RenderWindow:
     def super(self) -> bool:
         ...
 class SapienRenderer:
-    def __init__(self, offscreen_only: bool = False, max_num_materials: int = 128, max_num_textures: int = 512, default_mipmap_levels: int = 1, default_device: str = '', do_not_load_texture: bool = False) -> None:
+    def __init__(self) -> None:
         ...
     @property
     def _internal_context(self) -> sapien.pysapien.internal_renderer.Context:
@@ -840,6 +840,10 @@ def load_scene(filename: str, apply_scale: bool = True) -> dict:
     ...
 def set_camera_shader_dir(dir: str) -> None:
     ...
+def set_global_config(offscreen_only: bool = False, max_num_materials: int = 128, max_num_textures: int = 512, default_mipmap_levels: int = 1, default_device: str = '', do_not_load_texture: bool = False) -> None:
+    """
+    Sets global properties for SAPIEN renderer. This function should only be called before creating any renderer-related objects.
+    """
 def set_imgui_ini_filename(filename: str) -> None:
     ...
 def set_log_level(level: str) -> None:

python/pybind/sapien_renderer.cpp

@@ -389,7 +389,14 @@ void init_sapien_renderer(py::module &sapien) {
             return parseSceneNode(*root);
           },
           py::arg("filename"), py::arg("apply_scale") = true)
-      .def("get_device_summary", []() { return SapienRenderEngine::Get()->getSummary(); });
+      .def("get_device_summary", []() { return SapienRenderEngine::Get()->getSummary(); })
+
+      .def("set_global_config", &SapienRendererDefault::setGlobalConfig,
+           py::arg("offscreen_only") = false, py::arg("max_num_materials") = 128,
+           py::arg("max_num_textures") = 512, py::arg("default_mipmap_levels") = 1,
+           py::arg("default_device") = "", py::arg("do_not_load_texture") = false,
+           "Sets global properties for SAPIEN renderer. This function should only be called "
+           "before creating any renderer-related objects.");
 
   ////////// end global //////////
 
@@ -447,11 +454,7 @@ void init_sapien_renderer(py::module &sapien) {
 
   auto PyRenderWindow = py::class_<SapienRendererWindow>(m, "RenderWindow");
 
-  PySapienRenderer
-      .def(py::init(&SapienRenderEngine::Get), py::arg("offscreen_only") = false,
-           py::arg("max_num_materials") = 128, py::arg("max_num_textures") = 512,
-           py::arg("default_mipmap_levels") = 1, py::arg("default_device") = "",
-           py::arg("do_not_load_texture") = false)
+  PySapienRenderer.def(py::init(&SapienRenderEngine::Get))
       .def_property_readonly("_internal_context", &SapienRenderEngine::getContext);
 
   PyRenderSystemGroup.def(py::init<std::vector<std::shared_ptr<SapienRendererSystem>>>())

src/sapien_renderer/sapien_renderer_default.cpp

@@ -7,6 +7,25 @@ namespace fs = std::filesystem;
 namespace sapien {
 namespace sapien_renderer {
 
+void SapienRendererDefault::setGlobalConfig(bool offscreenOnly, int32_t maxNumMaterials,
+                                            uint32_t maxNumTextures, uint32_t defaultMipMaps,
+                                            std::string const &device, bool doNotLoadTexture) {
+  auto &d = Get();
+  d.offscreenOnly = offscreenOnly;
+  d.defaultMipMaps = defaultMipMaps;
+  d.device = device;
+  d.doNotLoadTexture = doNotLoadTexture;
+  d.maxNumMaterials = maxNumMaterials;
+  d.maxNumTextures = maxNumTextures;
+}
+
+bool SapienRendererDefault::getOffscreenOnly() { return Get().offscreenOnly; }
+uint32_t SapienRendererDefault::getDefaultMipMaps() { return Get().defaultMipMaps; }
+std::string SapienRendererDefault::getDevice() { return Get().device; }
+bool SapienRendererDefault::getDoNotLoadTexture() { return Get().doNotLoadTexture; }
+uint32_t SapienRendererDefault::getMaxNumMaterials() { return Get().maxNumMaterials; }
+uint32_t SapienRendererDefault::getMaxNumTextures() { return Get().maxNumTextures; }
+
 void SapienRendererDefault::setViewerShaderDirectory(std::string const &dir) {
   auto path = fs::path(dir);
   if (!fs::is_directory(path)) {

src/sapien_renderer/sapien_renderer_system.cpp

@@ -5,6 +5,7 @@
 #include "sapien/sapien_renderer/light_component.h"
 #include "sapien/sapien_renderer/point_cloud_component.h"
 #include "sapien/sapien_renderer/render_body_component.h"
+#include "sapien/sapien_renderer/sapien_renderer_default.h"
 #include <svulkan2/core/context.h>
 #include <svulkan2/core/physical_device.h>
 #include <svulkan2/renderer/renderer.h>
@@ -18,17 +19,13 @@
 namespace sapien {
 namespace sapien_renderer {
 
-std::shared_ptr<SapienRenderEngine>
-SapienRenderEngine::Get(bool offscreenOnly, uint32_t maxNumMaterials, uint32_t maxNumTextures,
-                        uint32_t defaultMipLevels, std::string const &device,
-                        bool doNotLoadTexture) {
+std::shared_ptr<SapienRenderEngine> SapienRenderEngine::Get() {
   static std::weak_ptr<SapienRenderEngine> gEngine;
   std::shared_ptr<SapienRenderEngine> engine;
   if ((engine = gEngine.lock())) {
     return engine;
   }
-  gEngine = engine = std::make_shared<SapienRenderEngine>(
-      offscreenOnly, maxNumMaterials, maxNumTextures, defaultMipLevels, device, doNotLoadTexture);
+  gEngine = engine = std::make_shared<SapienRenderEngine>();
   return engine;
 }
 
@@ -47,11 +44,11 @@ std::string SapienRenderEngine::getSummary() {
   return ss.str();
 }
 
-SapienRenderEngine::SapienRenderEngine(bool offscreenOnly, uint32_t maxNumMaterials,
-                                       uint32_t maxNumTextures, uint32_t defaultMipLevels,
-                                       std::string const &device, bool doNotLoadTexture) {
-  mContext = svulkan2::core::Context::Create(!offscreenOnly, maxNumMaterials, maxNumTextures,
-                                             defaultMipLevels, doNotLoadTexture, device);
+SapienRenderEngine::SapienRenderEngine() {
+  auto &d = SapienRendererDefault::Get();
+  mContext = svulkan2::core::Context::Create(!d.getOffscreenOnly(), d.getMaxNumMaterials(),
+                                             d.getMaxNumTextures(), d.getDefaultMipMaps(),
+                                             d.getDoNotLoadTexture());
   mResourceManager = mContext->createResourceManager();
 }