Rename LightManager to ModelLights and RenderableManager to ModelRenderables.

This better reflects the purpose of these classes.

PiperOrigin-RevId: 952123609
Change-Id: Ib14c54c3d9b137258ebc706590aca3b2e80015fe

src/experimental/filament/compat/scene_bridge.cc

@@ -30,7 +30,7 @@
 #include "experimental/filament/compat/scene_objects.h"
 #include "render/filament/mjrfilament_cpp.h"
 #include "render/filament/support/filament_util.h"
-#include "render/filament/support/light_manager.h"
+#include "render/filament/support/model_lights.h"
 #include "render/filament/support/model_objects.h"
 
 namespace mujoco {
@@ -51,11 +51,11 @@ SceneBridge::SceneBridge(mjrfContext* ctx, mjrfScene* scene, const mjModel* mode
                                  filament::math::float4(0, 0, 0, 1));
   mjrf_setClearColor(ctx_, &clear_color[0]);
 
-  light_manager_ = std::make_unique<LightManager>(scene_, model_objects_.get());
+  model_lights_ = std::make_unique<ModelLights>(scene_, model_objects_.get());
 }
 
 SceneBridge::~SceneBridge() {
-  light_manager_.reset();
+  model_lights_.reset();
   for (auto& iter : renderables_) {
     mjrf_removeRenderableFromScene(scene_, iter.get());
   }
@@ -221,7 +221,7 @@ void SceneBridge::Update(const mjrRect& viewport, const mjvScene* scene) {
     const mjvLight& scene_light = scene->lights[i];
     if (scene_light.id < 0 && scene_light.headlight) {
       // The headlight, if it exists, is assigned the id `scene->nlight`.
-      headlight = light_manager_->GetLight(scene->nlight);
+      headlight = model_lights_->GetLight(scene->nlight);
       if (!headlight) {
         continue;
       }
@@ -235,7 +235,7 @@ void SceneBridge::Update(const mjrRect& viewport, const mjvScene* scene) {
       mjrf_setLightColor(headlight, scene_light.diffuse);
       mjrf_setLightTransform(headlight, headpos, gazedir);
       continue;
-    } else if (mjrfLight* light = light_manager_->GetLight(scene_light.id)) {
+    } else if (mjrfLight* light = model_lights_->GetLight(scene_light.id)) {
       mjrf_setLightColor(light, scene_light.diffuse);
       mjrf_setLightTransform(light, scene_light.pos, scene_light.dir);
     } else {

src/experimental/filament/compat/scene_bridge.h

@@ -27,8 +27,8 @@
 #include <mujoco/mujoco.h>
 #include "experimental/filament/compat/scene_objects.h"
 #include "render/filament/mjrfilament_cpp.h"
+#include "render/filament/support/model_lights.h"
 #include "render/filament/support/model_objects.h"
-#include "render/filament/support/light_manager.h"
 
 namespace mujoco {
 
@@ -66,7 +66,7 @@ class SceneBridge {
   mjrfScene* scene_ = nullptr;
   std::unique_ptr<ModelObjects> model_objects_;
   std::unique_ptr<SceneObjects> scene_objects_;
-  std::unique_ptr<LightManager> light_manager_;
+  std::unique_ptr<ModelLights> model_lights_;
   mjrCamera camera_;
   DrawTextAtFn draw_text_callback_;
   std::vector<UniquePtr<mjrfRenderable>> renderables_;

src/render/filament/CMakeLists.txt

@@ -55,16 +55,16 @@ target_sources(${MUJOCO_FILAMENT_TARGET_NAME}
         core/types.h
         support/filament_util.h
         support/filament_util.cc
-        support/light_manager.h
-        support/light_manager.cc
         support/mesh_util.h
         support/mesh_util.cc
         support/model_decorations.h
         support/model_decorations.cc
+        support/model_lights.h
+        support/model_lights.cc
         support/model_objects.h
         support/model_objects.cc
-        support/renderable_manager.h
-        support/renderable_manager.cc
+        support/model_renderables.h
+        support/model_renderables.cc
 )
 
 target_include_directories(${MUJOCO_FILAMENT_TARGET_NAME}

src/render/filament/support/model_lights.cc

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "render/filament/support/light_manager.h"
+#include "render/filament/support/model_lights.h"
 
 #include <memory>
 #include <string>
@@ -63,20 +63,19 @@ static UniquePtr<mjrfTexture> CreateFallbackIndirectLightTexture(
   mjrf_defaultTextureData(&payload);
   payload.bytes = bytes;
   payload.num_bytes = nbytes;
-  payload.release = +[](void* user_data) {
-    mju_closeResource((mjResource*)user_data);
-  };
+  payload.release =
+      +[](void* user_data) { mju_closeResource((mjResource*)user_data); };
   payload.user_data = resource;
 
   mjrf_setTextureData(texture.get(), &payload);
   return texture;
 }
 
-LightManager::LightManager(mjrfScene* scene, ModelObjects* model_objects)
+ModelLights::ModelLights(mjrfScene* scene, ModelObjects* model_objects)
     : scene_(scene), model_objects_(model_objects) {
   const mjModel* model = model_objects->GetModel();
-  default_shadow_map_size_ = ReadElement(
-      model, "filament.shadows.map_size", default_shadow_map_size_);
+  default_shadow_map_size_ =
+      ReadElement(model, "filament.shadows.map_size", default_shadow_map_size_);
   fallback_head_light_intensity_ =
       ReadElement(model, "filament.fallback.head_light_intensity",
                   fallback_head_light_intensity_);
@@ -89,7 +88,7 @@ LightManager::LightManager(mjrfScene* scene, ModelObjects* model_objects)
   Prepare();
 }
 
-LightManager::~LightManager() {
+ModelLights::~ModelLights() {
   for (auto& iter : lights_) {
     mjrf_removeLightFromScene(scene_, iter.get());
   }
@@ -100,7 +99,7 @@ LightManager::~LightManager() {
   fallback_ibl_.reset();
 }
 
-void LightManager::Prepare() {
+void ModelLights::Prepare() {
   mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
@@ -194,9 +193,9 @@ void LightManager::Prepare() {
     for (auto& light : lights_) {
       if (light) {
         const bool is_headlight = (light == lights_.back());
-        mjrf_setLightIntensity(light.get(),
-                               is_headlight ? fallback_head_light_intensity_
-                                            : intensity);
+        mjrf_setLightIntensity(light.get(), is_headlight
+                                                ? fallback_head_light_intensity_
+                                                : intensity);
       }
     }
   }
@@ -204,7 +203,7 @@ void LightManager::Prepare() {
   mjrf_setSceneSkybox(scene_, model_objects_->GetSkyboxTexture());
 }
 
-void LightManager::Update(const mjData* data) {
+void ModelLights::Update(const mjData* data) {
   const mjModel* model = model_objects_->GetModel();
   for (int i = 0; i <= model->nlight; ++i) {
     // Light with index nlight is the headlight.
@@ -226,7 +225,7 @@ void LightManager::Update(const mjData* data) {
   }
 }
 
-mjrfLight* LightManager::GetLight(int index) {
+mjrfLight* ModelLights::GetLight(int index) {
   if (index < 0 || index >= lights_.size()) {
     return nullptr;
   }

src/render/filament/support/model_lights.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_LIGHT_MANAGER_H_
-#define MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_LIGHT_MANAGER_H_
+#ifndef MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_LIGHTS_H_
+#define MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_LIGHTS_H_
 
 #include <vector>
 
@@ -24,11 +24,11 @@
 
 namespace mujoco {
 
-// Manages Light entities for an mjrfScene.
-class LightManager {
+// Manages Light entities in an mjrfScene for an mjModel.
+class ModelLights {
  public:
-  LightManager(mjrfScene* scene, ModelObjects* model_objects);
-  ~LightManager();
+  ModelLights(mjrfScene* scene, ModelObjects* model_objects);
+  ~ModelLights();
 
   // Updates the state of the lights in the scene.
   void Update(const mjData* data);
@@ -37,8 +37,8 @@ class LightManager {
   // headlight is assigned of the index `nlight`.
   mjrfLight* GetLight(int index);
 
-  LightManager(const LightManager&) = delete;
-  LightManager& operator=(const LightManager&) = delete;
+  ModelLights(const ModelLights&) = delete;
+  ModelLights& operator=(const ModelLights&) = delete;
 
  private:
   void Prepare();
@@ -57,4 +57,4 @@ class LightManager {
 
 }  // namespace mujoco
 
-#endif  // MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_LIGHT_MANAGER_H_
+#endif  // MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_LIGHTS_H_

src/render/filament/support/model_renderables.cc

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "render/filament/support/renderable_manager.h"
+#include "render/filament/support/model_renderables.h"
 
 #include <array>
 #include <memory>
@@ -142,7 +142,8 @@ static void SetGeomMesh(mjrfRenderable* renderable, ModelObjects* model_objs,
     }
     case mjGEOM_HFIELD: {
       const int data_id = model->geom_dataid[geom_index];
-      mjrf_setRenderableMesh(renderable, model_objs->GetHeightField(data_id), 0, 0);
+      mjrf_setRenderableMesh(renderable, model_objs->GetHeightField(data_id), 0,
+                             0);
       break;
     }
     case mjGEOM_FLEX:
@@ -175,8 +176,8 @@ static void SetGeomMesh(mjrfRenderable* renderable, ModelObjects* model_objs,
   }
 }
 
-RenderableManager::RenderableManager(mjrfScene* scene,
-                                     ModelObjects* model_objects)
+ModelRenderables::ModelRenderables(mjrfScene* scene,
+                                   ModelObjects* model_objects)
     : scene_(scene), model_objects_(model_objects) {
   mjv_defaultOption(&vopts_);
 
@@ -190,7 +191,7 @@ RenderableManager::RenderableManager(mjrfScene* scene,
   tendons_.resize(model_objects_->GetModel()->ntendon);
 }
 
-RenderableManager::~RenderableManager() {
+ModelRenderables::~ModelRenderables() {
   for (auto& renderable : geoms_) {
     mjrf_removeRenderableFromScene(scene_, renderable.get());
   }
@@ -217,7 +218,7 @@ RenderableManager::~RenderableManager() {
   }
 }
 
-void RenderableManager::Update(const mjData* data) {
+void ModelRenderables::Update(const mjData* data) {
   mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
@@ -343,8 +344,8 @@ void RenderableManager::Update(const mjData* data) {
   }
 }
 
-mjrfRenderable* RenderableManager::GetRenderable(mjtObj obj_type, int obj_index,
-                                                 int sub_index) {
+mjrfRenderable* ModelRenderables::GetRenderable(mjtObj obj_type, int obj_index,
+                                                int sub_index) {
   switch (obj_type) {
     case mjOBJ_GEOM:
       if (obj_index >= 0 && obj_index < geoms_.size()) {
@@ -405,7 +406,7 @@ mjrfRenderable* RenderableManager::GetRenderable(mjtObj obj_type, int obj_index,
   return nullptr;
 }
 
-void RenderableManager::AddGeomGeoms() {
+void ModelRenderables::AddGeomGeoms() {
   mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
@@ -434,7 +435,7 @@ void RenderableManager::AddGeomGeoms() {
   }
 }
 
-void RenderableManager::AddSiteGeoms() {
+void ModelRenderables::AddSiteGeoms() {
   mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
@@ -463,7 +464,7 @@ void RenderableManager::AddSiteGeoms() {
   }
 }
 
-void RenderableManager::AddFlexGeoms() {
+void ModelRenderables::AddFlexGeoms() {
   mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
@@ -504,7 +505,7 @@ void RenderableManager::AddFlexGeoms() {
   }
 }
 
-void RenderableManager::AddSkinGeoms() {
+void ModelRenderables::AddSkinGeoms() {
   mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
@@ -526,7 +527,7 @@ void RenderableManager::AddSkinGeoms() {
   }
 }
 
-void RenderableManager::AddSliderCrankGeoms() {
+void ModelRenderables::AddSliderCrankGeoms() {
   mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
   const int nstack = model->vis.quality.numstacks;
@@ -558,8 +559,7 @@ void RenderableManager::AddSliderCrankGeoms() {
   }
 }
 
-void RenderableManager::UpdateSliderCranks(const mjData* data,
-                                           int actuator_id) {
+void ModelRenderables::UpdateSliderCranks(const mjData* data, int actuator_id) {
   auto it = slider_cranks_.find(actuator_id);
   if (it == slider_cranks_.end()) {
     mju_error("Slider/crank not found: %d", actuator_id);
@@ -609,7 +609,7 @@ void RenderableManager::UpdateSliderCranks(const mjData* data,
   mjrf_setRenderableMaterial(crank, &material);
 }
 
-void RenderableManager::AppendSegmentToTendon(int tendon_id) {
+void ModelRenderables::AppendSegmentToTendon(int tendon_id) {
   mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
@@ -630,15 +630,14 @@ void RenderableManager::AppendSegmentToTendon(int tendon_id) {
   segments.emplace_back(std::move(renderable));
 }
 
-void RenderableManager::RemoveSegmentFromTendon(int tendon_id) {
+void ModelRenderables::RemoveSegmentFromTendon(int tendon_id) {
   auto& segments = tendons_[tendon_id];
   mjrfRenderable* renderable = segments.back().get();
   mjrf_removeRenderableFromScene(scene_, renderable);
   segments.pop_back();
 }
 
-void RenderableManager::UpdateSpatialTendons(const mjData* data,
-                                             int tendon_id) {
+void ModelRenderables::UpdateSpatialTendons(const mjData* data, int tendon_id) {
   const mjModel* model = model_objects_->GetModel();
 
   // Gather the points that define the tendon. We'll use a simple cache to avoid
@@ -697,7 +696,7 @@ void RenderableManager::UpdateSpatialTendons(const mjData* data,
   }
 }
 
-int RenderableManager::GetSegmentationId(mjtObj obj_type, int obj_index) {
+int ModelRenderables::GetSegmentationId(mjtObj obj_type, int obj_index) {
   const mjModel* model = model_objects_->GetModel();
 
   int id = 0;
@@ -735,8 +734,8 @@ int RenderableManager::GetSegmentationId(mjtObj obj_type, int obj_index) {
   return -1;
 }
 
-mjrfMaterial RenderableManager::GetDefaultMaterial(mjtObj obj_type,
-                                                   int obj_index) {
+mjrfMaterial ModelRenderables::GetDefaultMaterial(mjtObj obj_type,
+                                                  int obj_index) {
   const mjModel* model = model_objects_->GetModel();
 
   mjrfMaterial material;
@@ -970,7 +969,7 @@ static void ApplyVisibility(VisibilityOp* ops, int group, mjrfScene* scene,
   }
 }
 
-void RenderableManager::SetVisibility(mjtObj obj_type, int idx, bool visible) {
+void ModelRenderables::SetVisibility(mjtObj obj_type, int idx, bool visible) {
   const mjModel* model = model_objects_->GetModel();
 
   VisibilityOp ops[mjNGROUP] = {kNoop};
@@ -988,25 +987,29 @@ void RenderableManager::SetVisibility(mjtObj obj_type, int idx, bool visible) {
       }
       break;
     case mjOBJ_FLEX:
-      DetermineVisibilities(ops, vopts_.flexgroup, &vopts_.flags[mjVIS_FLEXSKIN], idx, visible);
+      DetermineVisibilities(ops, vopts_.flexgroup,
+                            &vopts_.flags[mjVIS_FLEXSKIN], idx, visible);
       for (int i = 0; i < model->nflex; ++i) {
         ApplyVisibility(ops, model->flex_group[i], scene_, flexes_[i]);
       }
       break;
     case mjOBJ_SKIN:
-      DetermineVisibilities(ops, vopts_.skingroup, &vopts_.flags[mjVIS_SKIN], idx, visible);
+      DetermineVisibilities(ops, vopts_.skingroup, &vopts_.flags[mjVIS_SKIN],
+                            idx, visible);
       for (int i = 0; i < model->nskin; ++i) {
         ApplyVisibility(ops, model->skin_group[i], scene_, {&skins_[i], 1});
       }
       break;
     case mjOBJ_TENDON:
-      DetermineVisibilities(ops, vopts_.tendongroup, &vopts_.flags[mjVIS_TENDON], idx, visible);
+      DetermineVisibilities(ops, vopts_.tendongroup,
+                            &vopts_.flags[mjVIS_TENDON], idx, visible);
       for (int i = 0; i < model->ntendon; ++i) {
         ApplyVisibility(ops, model->tendon_group[i], scene_, tendons_[i]);
       }
       break;
     case mjOBJ_ACTUATOR:
-      DetermineVisibilities(ops, vopts_.actuatorgroup, &vopts_.flags[mjVIS_ACTUATOR], idx, visible);
+      DetermineVisibilities(ops, vopts_.actuatorgroup,
+                            &vopts_.flags[mjVIS_ACTUATOR], idx, visible);
       for (int i = 0; i < model->nu; ++i) {
         auto it = slider_cranks_.find(i);
         if (it == slider_cranks_.end()) {
@@ -1021,7 +1024,7 @@ void RenderableManager::SetVisibility(mjtObj obj_type, int idx, bool visible) {
   }
 }
 
-void RenderableManager::SetOptions(const mjvOption& opt) {
+void ModelRenderables::SetOptions(const mjvOption& opt) {
   const mjModel* model = model_objects_->GetModel();
 
   for (int i = 0; i < mjNGROUP; ++i) {
@@ -1092,12 +1095,12 @@ void RenderableManager::SetOptions(const mjvOption& opt) {
   vopts_ = opt;
 }
 
-void RenderableManager::MarkAsSelected(mjtObj obj_type, int obj_index) {
+void ModelRenderables::MarkAsSelected(mjtObj obj_type, int obj_index) {
   if (obj_type != selected_obj_type_ || obj_index != selected_obj_index_) {
     mjrfMaterial material;
 
-    mjrfRenderable* prev_renderable = GetRenderable(
-        selected_obj_type_, selected_obj_index_);
+    mjrfRenderable* prev_renderable =
+        GetRenderable(selected_obj_type_, selected_obj_index_);
     if (prev_renderable) {
       mjrf_getRenderableMaterial(prev_renderable, &material);
       material.selected = 0;
@@ -1107,8 +1110,8 @@ void RenderableManager::MarkAsSelected(mjtObj obj_type, int obj_index) {
     selected_obj_type_ = obj_type;
     selected_obj_index_ = obj_index;
 
-    mjrfRenderable* curr_renderable = GetRenderable(
-        selected_obj_type_, selected_obj_index_);
+    mjrfRenderable* curr_renderable =
+        GetRenderable(selected_obj_type_, selected_obj_index_);
     if (curr_renderable) {
       mjrf_getRenderableMaterial(curr_renderable, &material);
       material.selected = 1;

src/render/filament/support/model_renderables.h

@@ -12,12 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_RENDERABLE_MANAGER_H_
-#define MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_RENDERABLE_MANAGER_H_
+#ifndef MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_RENDERABLES_H_
+#define MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_RENDERABLES_H_
 
 #include <array>
 #include <unordered_map>
 #include <vector>
+
 #include <math/vec4.h>
 #include <mujoco/mjdata.h>
 #include <mujoco/mjrfilament.h>
@@ -28,12 +29,12 @@
 
 namespace mujoco {
 
-// Manages Renderable entities for an mjrfScene.
-class RenderableManager {
+// Manages Renderable entities in an mjrfScene for an mjModel.
+class ModelRenderables {
  public:
   // Populates the mjrScene with the renderables from the model.
-  RenderableManager(mjrfScene* scene, ModelObjects* model_objects);
-  ~RenderableManager();
+  ModelRenderables(mjrfScene* scene, ModelObjects* model_objects);
+  ~ModelRenderables();
 
   // Updates the state of the renderables in the scene.
   void Update(const mjData* data);
@@ -69,9 +70,8 @@ class RenderableManager {
   // Returns the current visualization options.
   const mjvOption& GetOptions() const { return vopts_; }
 
-
-  RenderableManager(const RenderableManager&) = delete;
-  RenderableManager& operator=(const RenderableManager&) = delete;
+  ModelRenderables(const ModelRenderables&) = delete;
+  ModelRenderables& operator=(const ModelRenderables&) = delete;
 
  private:
   void AddGeomGeoms();
@@ -101,7 +101,8 @@ class RenderableManager {
   std::vector<UniquePtr<mjrfRenderable>> skins_;
   std::vector<std::vector<UniquePtr<mjrfRenderable>>> flexes_;
   std::vector<std::vector<UniquePtr<mjrfRenderable>>> tendons_;
-  std::unordered_map<int, std::array<UniquePtr<mjrfRenderable>, 2>> slider_cranks_;
+  std::unordered_map<int, std::array<UniquePtr<mjrfRenderable>, 2>>
+      slider_cranks_;
 
   std::vector<UniquePtr<mjrfMesh>> flex_meshes_;
   std::vector<UniquePtr<mjrfMesh>> skin_meshes_;
@@ -109,4 +110,4 @@ class RenderableManager {
 };
 }  // namespace mujoco
 
-#endif  // MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_RENDERABLE_MANAGER_H_
+#endif  // MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_RENDERABLES_H_