Use RenderableParams for creating Renderables.

PiperOrigin-RevId: 902569516
Change-Id: Id233a5ef7fe86ce5902ce2552d8d0fec6ce860b7

src/experimental/filament/filament/imgui_bridge.cc

@@ -268,8 +268,11 @@ void ImguiBridge::Update() {
 
 void ImguiBridge::PrepareRenderables(int count) {
   while (renderables_.size() < count) {
+    RenderableParams config;
+    DefaultRenderableParams(&config);
+    config.shading_model = ShadingModel::Ux;
     auto& r = renderables_.emplace_back(
-        std::make_unique<Renderable>(Renderable::Usage::Ux, object_mgr_));
+        std::make_unique<Renderable>(object_mgr_, config));
     r->SetCastShadows(false);
     r->SetReceiveShadows(false);
     r->SetBlendOrder(static_cast<std::uint16_t>(renderables_.size()));

src/experimental/filament/filament/renderable.cc

@@ -16,7 +16,6 @@
 
 #include <algorithm>
 #include <cstdint>
-#include <utility>
 
 #include <filament/Engine.h>
 #include <filament/Material.h>
@@ -31,8 +30,12 @@
 
 namespace mujoco {
 
-Renderable::Renderable(Usage usage, ObjectManager* object_mgr)
-    : usage_(usage), object_mgr_(object_mgr) {}
+void DefaultRenderableParams(RenderableParams* params) {
+  params->shading_model = ShadingModel::SceneObject;
+}
+
+Renderable::Renderable(ObjectManager* object_mgr, const RenderableParams& params)
+    : object_mgr_(object_mgr), params_(params) {}
 
 Renderable::~Renderable() noexcept {
   while (!entities_.empty()) {
@@ -188,18 +191,19 @@ void Renderable::RemoveFromScene(filament::Scene* scene) {
 
 void Renderable::UpdateMaterial(const MaterialParams& params,
                                 const MaterialTextures& textures) {
-  params_ = params;
-  textures_ = textures;
+  material_params_ = params;
+  material_textures_ = textures;
 
   AssignMaterial(DrawMode::Color, GetColorMaterialType());
-  if (usage_ == Usage::SceneObject) {
+  if (params_.shading_model == ShadingModel::SceneObject) {
     AssignMaterial(DrawMode::Depth, ObjectManager::kUnlitDepth);
     AssignMaterial(DrawMode::Segmentation, ObjectManager::kUnlitSegmentation);
   }
 
   for (int i = 0; i < kNumDrawModes; ++i) {
     if (instances_[i]) {
-      UpdateMaterialInstance(instances_[i], params_, textures_, object_mgr_);
+      UpdateMaterialInstance(instances_[i], material_params_,
+                             material_textures_, object_mgr_);
     }
   }
   SetDrawMode(draw_mode_);
@@ -225,16 +229,16 @@ void Renderable::AssignMaterial(DrawMode mode,
 }
 
 const MaterialParams& Renderable::GetMaterialParams() const {
-  return params_;
+  return material_params_;
 }
 
 const MaterialTextures& Renderable::GetMaterialTextures() const {
-  return textures_;
+  return material_textures_;
 }
 
 void Renderable::SetDrawMode(DrawMode mode) {
   // Only SceneObjects support non-color draw modes.
-  if (usage_ != Usage::SceneObject) {
+  if (params_.shading_model != ShadingModel::SceneObject) {
     mode = DrawMode::Color;
   }
 
@@ -333,21 +337,21 @@ void Renderable::SetWireframe(bool wireframe) {
 
 
 ObjectManager::MaterialType Renderable::GetColorMaterialType() const {
-  if (usage_ == Usage::DecorLines) {
+  if (params_.shading_model == ShadingModel::DecorLines) {
     return ObjectManager::kUnlitLine;
-  } else if (usage_ == Usage::Decor) {
-    return ObjectManager::kUnlitSegmentation;
-  } else if (usage_ == Usage::Ux) {
+  } else if (params_.shading_model == ShadingModel::Decor) {
+    return ObjectManager::kUnlitDecor;
+  } else if (params_.shading_model == ShadingModel::Ux) {
     return ObjectManager::kUnlitUi;
-  } else if (textures_.orm) {
+  } else if (material_textures_.orm) {
     return ObjectManager::kPbrPacked;
-  } else if (textures_.metallic) {
+  } else if (material_textures_.metallic) {
     return ObjectManager::kPbr;
-  } else if (textures_.roughness) {
+  } else if (material_textures_.roughness) {
     return ObjectManager::kPbr;
-  } else if (params_.metallic >= 0) {
+  } else if (material_params_.metallic >= 0) {
     return ObjectManager::kPbr;
-  } else if (params_.roughness >= 0) {
+  } else if (material_params_.roughness >= 0) {
     return ObjectManager::kPbr;
   }
 
@@ -363,35 +367,35 @@ ObjectManager::MaterialType Renderable::GetColorMaterialType() const {
     has_texcoords = (it != attribs.end());
   }
 
-  if (textures_.color == nullptr) {
-    if (params_.color.a < 1.0f) {
+  if (material_textures_.color == nullptr) {
+    if (material_params_.color.a < 1.0f) {
       return ObjectManager::kPhongColorFade;
-    } else if (params_.reflective) {
+    } else if (material_params_.reflective) {
       return ObjectManager::kPhongColorReflect;
     } else {
       return ObjectManager::kPhongColor;
     }
-  } else if (textures_.color->GetFilamentTexture()->getTarget() ==
+  } else if (material_textures_.color->GetFilamentTexture()->getTarget() ==
               filament::Texture::Sampler::SAMPLER_CUBEMAP) {
-    if (params_.color.a < 1.0f) {
+    if (material_params_.color.a < 1.0f) {
       return ObjectManager::kPhongCubeFade;
-    } else if (params_.reflective) {
+    } else if (material_params_.reflective) {
       return ObjectManager::kPhongCubeReflect;
     } else {
       return ObjectManager::kPhongCube;
     }
   } else if (has_texcoords) {
-    if (params_.color.a < 1.0f) {
+    if (material_params_.color.a < 1.0f) {
       return ObjectManager::kPhong2dUvFade;
-    } else if (params_.reflective) {
+    } else if (material_params_.reflective) {
       return ObjectManager::kPhong2dUvReflect;
     } else {
       return ObjectManager::kPhong2dUv;
     }
   } else {
-    if (params_.color.a < 1.0f) {
+    if (material_params_.color.a < 1.0f) {
       return ObjectManager::kPhong2dFade;
-    } else if (params_.reflective) {
+    } else if (material_params_.reflective) {
       return ObjectManager::kPhong2dReflect;
     } else {
       return ObjectManager::kPhong2d;

src/experimental/filament/filament/renderable.h

@@ -28,6 +28,21 @@
 
 namespace mujoco {
 
+// The shading model (material) for a Renderable.
+enum class ShadingModel {
+  SceneObject,
+  Decor,
+  DecorLines,
+  Ux,
+};
+
+// Configuration parameters for a Renderable.
+struct RenderableParams {
+  ShadingModel shading_model;
+};
+
+void DefaultRenderableParams(RenderableParams* params);
+
 // A collection of meshes and a material that, together, define an object that
 // can be rendered in a scene.
 //
@@ -38,19 +53,11 @@ namespace mujoco {
 // assigns the same material instance to all of them.
 class Renderable {
  public:
-  // How the material is to be used for rendering.
-  enum class Usage {
-    SceneObject,
-    Decor,
-    DecorLines,
-    Ux,
-  };
-
   // Default filament values for priority and layer mask.
   static constexpr std::uint8_t kDefaultPriority = 4;
   static constexpr std::uint8_t kDefaultLayerMask = 0x01;
 
-  Renderable(Usage usage, ObjectManager* object_mgr);
+  Renderable(ObjectManager* object_mgr, const RenderableParams& params);
   ~Renderable() noexcept;
 
   Renderable(const Renderable&) = delete;
@@ -145,11 +152,11 @@ class Renderable {
 
   ObjectManager::MaterialType GetColorMaterialType() const;
 
-  Usage usage_;
   ObjectManager* object_mgr_;
+  RenderableParams params_;
   filament::MaterialInstance* instances_[kNumDrawModes] = {nullptr};
-  MaterialParams params_;
-  MaterialTextures textures_;
+  MaterialParams material_params_;
+  MaterialTextures material_textures_;
   DrawMode draw_mode_ = DrawMode::Color;
   filament::Scene* assigned_scene_ = nullptr;
   std::vector<utils::Entity> entities_;

src/experimental/filament/filament/scene_geom_util.cc

@@ -459,14 +459,17 @@ static void UpdateGeomMaterial(Renderable& renderable, const mjvGeom& geom,
 std::unique_ptr<Renderable> CreateGeomRenderable(
     const mjvGeom& geom, const mjvScene* scene, ObjectManager* object_mgr,
     ModelObjects* model_objs, const float headpos[3]) {
-  Renderable::Usage usage = Renderable::Usage::SceneObject;
+  ShadingModel shading_model = ShadingModel::SceneObject;
   if (geom.type == mjGEOM_LINE || geom.type == mjGEOM_LINEBOX) {
-    usage = Renderable::Usage::DecorLines;
+    shading_model = ShadingModel::DecorLines;
   } else if (geom.category == mjCAT_DECOR) {
-    usage = Renderable::Usage::Decor;
+    shading_model = ShadingModel::Decor;
   }
 
-  auto renderable = std::make_unique<Renderable>(usage, object_mgr);
+  RenderableParams config;
+  DefaultRenderableParams(&config);
+  config.shading_model = shading_model;
+  auto renderable = std::make_unique<Renderable>(object_mgr, config);
 
   // The order of these calls is important. e.g. We need to create the filament
   // renderable entities before we can set their transform.