Expose Renderable settings in mjrRenderableParams.

PiperOrigin-RevId: 908587103
Change-Id: Ic0e19a7fb3535bf32782b85d2da0049ec4ac8ec7

src/experimental/filament/compat/scene_bridge.cc

@@ -85,6 +85,8 @@ SceneBridge::SceneBridge(FilamentContext* ctx, const mjModel* model)
     : ctx_(ctx) {
   mjrSceneParams params;
   mjr_defaultSceneParams(&params);
+  params.layer_mask = mjCAT_ALL;
+  params.reflection_layer_mask = mjCAT_DYNAMIC | mjCAT_STATIC;
   scene_view_ = std::make_unique<SceneView>(ctx_, params);
   model_objects_ = std::make_unique<ModelObjects>(model, ctx_);
 

src/experimental/filament/filament/renderable.cc

@@ -122,11 +122,11 @@ void Renderable::InitPartEntity(Part& part) {
   if (instances_[static_cast<int>(draw_mode_)] != nullptr) {
     builder.material(0, instances_[static_cast<int>(draw_mode_)]);
   }
-  builder.castShadows(cast_shadows_);
-  builder.receiveShadows(receive_shadows_);
-  builder.layerMask(0xff, layer_mask_);
-  builder.priority(priority_);
-  builder.blendOrder(0, blend_order_);
+  builder.castShadows(params_.cast_shadows);
+  builder.receiveShadows(params_.receive_shadows);
+  builder.layerMask(0xff, params_.layer_mask);
+  builder.priority(params_.priority);
+  builder.blendOrder(0, params_.blend_order);
   builder.screenSpaceContactShadows(true);
 
   builder.build(*GetEngine(), part.entity);
@@ -264,62 +264,62 @@ void Renderable::SetDrawMode(mjrDrawMode mode) {
 }
 
 std::uint8_t Renderable::SetLayerMask(std::uint8_t mask) {
-  std::uint8_t prev = layer_mask_;
-  if (mask != layer_mask_) {
-    layer_mask_ = mask;
+  std::uint8_t prev = params_.layer_mask;
+  if (mask != params_.layer_mask) {
+    params_.layer_mask = mask;
 
     filament::RenderableManager& rm = GetEngine()->getRenderableManager();
     for (Part& part : parts_) {
-      rm.setLayerMask(rm.getInstance(part.entity), 0xff, layer_mask_);
+      rm.setLayerMask(rm.getInstance(part.entity), 0xff, params_.layer_mask);
     }
   }
   return prev;
 }
 
 std::uint8_t Renderable::SetPriority(std::uint8_t priority) {
-  std::uint8_t prev = priority_;
-  if (priority != priority_) {
-    priority_ = priority;
+  std::uint8_t prev = params_.priority;
+  if (priority != params_.priority) {
+    params_.priority = priority;
 
     filament::RenderableManager& rm = GetEngine()->getRenderableManager();
     for (Part& part : parts_) {
-      rm.setPriority(rm.getInstance(part.entity), priority_);
+      rm.setPriority(rm.getInstance(part.entity), params_.priority);
     }
   }
   return prev;
 }
 
 std::uint16_t Renderable::SetBlendOrder(std::uint16_t blend_order) {
-  std::uint16_t prev = blend_order_;
-  if (blend_order != blend_order_) {
-    blend_order_ = blend_order;
+  std::uint16_t prev = params_.blend_order;
+  if (blend_order != params_.blend_order) {
+    params_.blend_order = blend_order;
 
     filament::RenderableManager& rm = GetEngine()->getRenderableManager();
     for (Part& part : parts_) {
-      rm.setBlendOrderAt(rm.getInstance(part.entity), 0, blend_order_);
+      rm.setBlendOrderAt(rm.getInstance(part.entity), 0, params_.blend_order);
     }
   }
   return prev;
 }
 
 void Renderable::SetCastShadows(bool cast_shadows) {
-  if (cast_shadows_ != cast_shadows) {
-    cast_shadows_ = cast_shadows;
+  if (params_.cast_shadows != cast_shadows) {
+    params_.cast_shadows = cast_shadows;
 
     filament::RenderableManager& rm = GetEngine()->getRenderableManager();
   for (Part& part : parts_) {
-        rm.setCastShadows(rm.getInstance(part.entity), cast_shadows_);
+        rm.setCastShadows(rm.getInstance(part.entity), params_.cast_shadows);
     }
   }
 }
 
 void Renderable::SetReceiveShadows(bool receive_shadows) {
-  if (receive_shadows_ != receive_shadows) {
-    receive_shadows_ = receive_shadows;
+  if (params_.receive_shadows != receive_shadows) {
+    params_.receive_shadows = receive_shadows;
 
     filament::RenderableManager& rm = GetEngine()->getRenderableManager();
     for (Part& part : parts_) {
-      rm.setReceiveShadows(rm.getInstance(part.entity), receive_shadows_);
+      rm.setReceiveShadows(rm.getInstance(part.entity), params_.receive_shadows);
     }
   }
 }

src/experimental/filament/filament/renderable.h

@@ -48,10 +48,6 @@ namespace mujoco {
 // of the Renderable.
 class Renderable : public mjrRenderable {
  public:
-  // Default filament values for priority and layer mask.
-  static constexpr std::uint8_t kDefaultPriority = 4;
-  static constexpr std::uint8_t kDefaultLayerMask = 0x01;
-
   Renderable(FilamentContext* ctx, const mjrRenderableParams& params);
   ~Renderable() noexcept;
 
@@ -155,12 +151,7 @@ class Renderable : public mjrRenderable {
   std::vector<Part> parts_;
   filament::math::mat4f transform_;
   GetTransformFn get_transform_fn_;
-  std::uint8_t priority_ = kDefaultPriority;
-  std::uint8_t layer_mask_ = kDefaultLayerMask;
-  std::uint16_t blend_order_ = 0;
   bool wireframe_ = false;
-  bool cast_shadows_ = true;
-  bool receive_shadows_ = true;
 };
 
 }  // namespace mujoco

src/experimental/filament/filament/scene_view.cc

@@ -132,7 +132,7 @@ SceneView::SceneView(FilamentContext* ctx, const mjrSceneParams& params)
     view = engine->createView();
     view->setScene(scene_);
     view->setCamera(camera_);
-    view->setVisibleLayers(0xff, mjCAT_ALL);
+    view->setVisibleLayers(0xff, params.layer_mask);
   }
 
   reflect_view_ = engine->createView();
@@ -140,7 +140,7 @@ SceneView::SceneView(FilamentContext* ctx, const mjrSceneParams& params)
   reflect_view_->setCamera(reflect_camera_);
   reflect_view_->setShadowingEnabled(false);
   reflect_view_->setPostProcessingEnabled(false);
-  reflect_view_->setVisibleLayers(0xff, mjCAT_DYNAMIC | mjCAT_STATIC);
+  reflect_view_->setVisibleLayers(0xff, params.reflection_layer_mask);
 
   // Disable post processing for the depth and segmentation views to preserve
   // the values.

src/experimental/filament/render_context_filament.cc

@@ -67,6 +67,8 @@ void mjr_defaultSceneParams(mjrSceneParams* params) {
   params->enable_post_processing = true;
   params->enable_reflections = true;
   params->enable_shadows = true;
+  params->layer_mask = 0xff;
+  params->reflection_layer_mask = 0xff;
 }
 
 void mjr_defaultLightParams(mjrLightParams* params) {
@@ -113,6 +115,11 @@ void mjr_defaultMaterialParams(mjrMaterialParams* params) {
 
 void mjr_defaultRenderableParams(mjrRenderableParams* params) {
   params->shading_model = mjSHADING_MODEL_SCENE_OBJECT;
+  params->cast_shadows = true;
+  params->receive_shadows = true;
+  params->layer_mask = 0x01;
+  params->priority = 4;
+  params->blend_order = 0;
 }
 
 void mjr_defaultRenderTargetConfig(mjrRenderTargetConfig* config) {

src/experimental/filament/render_context_filament.h

@@ -206,6 +206,20 @@ void mjr_defaultTextureConfig(mjrTextureConfig* config);
 struct mjrRenderableParams {
   // The shading model to use for the Renderable.
   mjrShadingModel shading_model;
+  // Whether or not the Renderable casts shadows.
+  mjtByte cast_shadows;
+  // Whether or not the Renderable receives shadows.
+  mjtByte receive_shadows;
+  // The layers to which the Renderable belongs. This mask is used in
+  // conjunction with the layer mask in the Scene to determine which
+  // Renderables to render. Defaults to 0xff.
+  uint8_t layer_mask;
+  // Controls the order in which the Renderable is drawn relative to other
+  // Renderables; defaults to 4.
+  uint8_t priority;
+  // Similar to priority, but provides finer-grained control for Renderables
+  // with transparency; defaults to 0.
+  uint16_t blend_order;
 };
 
 // Initializes the mjrRenderableParams to default values.
@@ -292,6 +306,11 @@ struct mjrSceneParams {
   mjtByte enable_reflections;
   // Whether or not to enable shadows; enabled by default.
   mjtByte enable_shadows;
+  // This mask, in conjunction with the layer mask in the Renderable, determines
+  // which Renderables to render within the Scene.
+  uint8_t layer_mask;
+  // The layer mask to use for reflections.
+  uint8_t reflection_layer_mask;
 };
 
 // Initializes the mjrSceneParams to default values.