Get mjrfContext from the ModelObjects.

PiperOrigin-RevId: 943888955
Change-Id: Icfe6230e531a100ad5a09efe582977fd3de8f076

src/experimental/filament/compat/scene_bridge.cc

@@ -51,8 +51,7 @@ SceneBridge::SceneBridge(mjrfContext* ctx, mjrfScene* scene, const mjModel* mode
                                  filament::math::float4(0, 0, 0, 1));
   mjrf_setClearColor(ctx_, &clear_color[0]);
 
-  light_manager_ =
+  light_manager_ = std::make_unique<LightManager>(scene_, model_objects_.get());
-      std::make_unique<LightManager>(ctx_, scene_, model_objects_.get());
 }
 
 SceneBridge::~SceneBridge() {

src/render/filament/support/light_manager.cc

@@ -72,9 +72,8 @@ static UniquePtr<mjrfTexture> CreateFallbackIndirectLightTexture(
   return texture;
 }
 
-LightManager::LightManager(mjrfContext* ctx, mjrfScene* scene,
+LightManager::LightManager(mjrfScene* scene, ModelObjects* model_objects)
-                           ModelObjects* model_objects)
+    : scene_(scene), model_objects_(model_objects) {
-    : ctx_(ctx), 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_);
@@ -102,6 +101,7 @@ LightManager::~LightManager() {
 }
 
 void LightManager::Prepare() {
+  mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
   bool has_image_based_light = false;
@@ -115,7 +115,7 @@ void LightManager::Prepare() {
       params.type = mjLIGHT_IMAGE;
       params.texture = model_objects_->GetTexture(model->light_texid[i]);
       params.intensity = model->light_intensity[i];
-      auto light_obj = CreateLight(ctx_, params);
+      auto light_obj = CreateLight(ctx, params);
       mjrf_addLightToScene(scene_, light_obj.get());
       lights_.emplace_back(std::move(light_obj));
       has_image_based_light = true;
@@ -138,7 +138,7 @@ void LightManager::Prepare() {
         params.spot_cone_angle = model->light_cutoff[i];
       }
 
-      auto light_obj = CreateLight(ctx_, params);
+      auto light_obj = CreateLight(ctx, params);
       mjrf_addLightToScene(scene_, light_obj.get());
       lights_.emplace_back(std::move(light_obj));
     }
@@ -158,7 +158,7 @@ void LightManager::Prepare() {
     params.cast_shadows = 0;
     params.intensity = 0.0f;
     params.spot_cone_angle = 90.0f;
-    auto light_obj = CreateLight(ctx_, params);
+    auto light_obj = CreateLight(ctx, params);
     mjrf_addLightToScene(scene_, light_obj.get());
     lights_.emplace_back(std::move(light_obj));
   }
@@ -170,7 +170,7 @@ void LightManager::Prepare() {
     mjrf_defaultLightParams(&params);
     params.type = mjLIGHT_IMAGE;
     params.intensity = 10.0f;
-    fallback_ibl_ = CreateLight(ctx_, params);
+    fallback_ibl_ = CreateLight(ctx, params);
     mjrf_addLightToScene(scene_, fallback_ibl_.get());
   }
 
@@ -179,14 +179,14 @@ void LightManager::Prepare() {
   // default environment light and set the light intensity ourselves.
   if (total_light_intensity == 0.0f) {
     // Create a fallback environment light.
-    fallback_ibl_texture_ = CreateFallbackIndirectLightTexture(ctx_);
+    fallback_ibl_texture_ = CreateFallbackIndirectLightTexture(ctx);
 
     mjrfLightParams params;
     mjrf_defaultLightParams(&params);
     params.type = mjLIGHT_IMAGE;
     params.texture = fallback_ibl_texture_.get();
     params.intensity = fallback_environment_light_intensity_;
-    fallback_ibl_ = CreateLight(ctx_, params);
+    fallback_ibl_ = CreateLight(ctx, params);
     mjrf_addLightToScene(scene_, fallback_ibl_.get());
 
     // Distribute the fallback scene light intensity among the lights.

src/render/filament/support/light_manager.h

@@ -27,7 +27,7 @@ namespace mujoco {
 // Manages Light entities for an mjrfScene.
 class LightManager {
  public:
-  LightManager(mjrfContext* ctx, mjrfScene* scene, ModelObjects* model_objects);
+  LightManager(mjrfScene* scene, ModelObjects* model_objects);
   ~LightManager();
 
   // Updates the state of the lights in the scene.
@@ -43,7 +43,6 @@ class LightManager {
  private:
   void Prepare();
 
-  mjrfContext* ctx_ = nullptr;
   mjrfScene* scene_ = nullptr;
   ModelObjects* model_objects_ = nullptr;
 

src/render/filament/support/model_objects.h

@@ -55,6 +55,9 @@ class ModelObjects {
   // Returns the skybox texture in the mjModel.
   const mjrfTexture* GetSkyboxTexture() const;
 
+  // Returns the mjrfContext used by the ModelObjects.
+  mjrfContext* GetContext() const { return ctx_; }
+
   // Returns the mjModel from which the Model Objects are created.
   const mjModel* GetModel() const { return model_; }
 

src/render/filament/support/renderable_manager.cc

@@ -175,9 +175,9 @@ static void SetGeomMesh(mjrfRenderable* renderable, ModelObjects* model_objs,
   }
 }
 
-RenderableManager::RenderableManager(mjrfContext* ctx, mjrfScene* scene,
+RenderableManager::RenderableManager(mjrfScene* scene,
                                      ModelObjects* model_objects)
-    : ctx_(ctx), scene_(scene), model_objects_(model_objects) {
+    : scene_(scene), model_objects_(model_objects) {
   mjv_defaultOption(&vopts_);
 
   AddGeomGeoms();
@@ -217,6 +217,7 @@ RenderableManager::~RenderableManager() {
 }
 
 void RenderableManager::Update(const mjData* data) {
+  mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
   for (int i = 0; i < model->ngeom; ++i) {
@@ -231,20 +232,19 @@ void RenderableManager::Update(const mjData* data) {
     mjrf_setRenderableTransform(sites_[i].get(), pos.v, mat.asArray());
   }
 
-
   for (int i = 0; i < model->nflex; ++i) {
     const int flex_layer = vopts_.flex_layer;
     const bool smooth_skinning = vopts_.flags[mjVIS_FLEXSKIN];
     const bool edges = !smooth_skinning && vopts_.flags[mjVIS_FLEXEDGE];
     const bool vertices = !smooth_skinning && vopts_.flags[mjVIS_FLEXVERT];
-    auto mesh = CreateFlexMesh(ctx_, model, data, i, flex_layer,
+    auto mesh = CreateFlexMesh(ctx, model, data, i, flex_layer,
                                smooth_skinning, edges, vertices);
     mjrf_setRenderableMesh(flexes_[i].get(), mesh.get(), 0, 0);
     flex_meshes_[i] = std::move(mesh);
   }
 
   for (int i = 0; i < model->nskin; ++i) {
-    auto mesh = CreateSkinMesh(ctx_, model, data, i);
+    auto mesh = CreateSkinMesh(ctx, model, data, i);
     mjrf_setRenderableMesh(skins_[i].get(), mesh.get(), 0, 0);
     skin_meshes_[i] = std::move(mesh);
   }
@@ -377,6 +377,7 @@ mjrfRenderable* RenderableManager::GetRenderable(mjtObj obj_type,
 }
 
 void RenderableManager::AddGeomGeoms() {
+  mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
   geoms_.reserve(model->ngeom);
@@ -385,7 +386,7 @@ void RenderableManager::AddGeomGeoms() {
 
     mjrfRenderableParams params;
     mjrf_defaultRenderableParams(&params);
-    auto renderable = CreateRenderable(ctx_, params);
+    auto renderable = CreateRenderable(ctx, params);
 
     SetGeomMesh(renderable.get(), model_objects_, type, i);
 
@@ -405,6 +406,7 @@ void RenderableManager::AddGeomGeoms() {
 }
 
 void RenderableManager::AddSiteGeoms() {
+  mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
   sites_.reserve(model->nsite);
@@ -413,7 +415,7 @@ void RenderableManager::AddSiteGeoms() {
 
     mjrfRenderableParams params;
     mjrf_defaultRenderableParams(&params);
-    auto renderable = CreateRenderable(ctx_, params);
+    auto renderable = CreateRenderable(ctx, params);
 
     SetGeomMesh(renderable.get(), model_objects_, type);
 
@@ -433,6 +435,7 @@ void RenderableManager::AddSiteGeoms() {
 }
 
 void RenderableManager::AddFlexGeoms() {
+  mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
   flexes_.reserve(model->nflex);
@@ -440,7 +443,7 @@ void RenderableManager::AddFlexGeoms() {
   for (int i = 0; i < model->nflex; ++i) {
     mjrfRenderableParams params;
     mjrf_defaultRenderableParams(&params);
-    auto renderable = CreateRenderable(ctx_, params);
+    auto renderable = CreateRenderable(ctx, params);
 
     mjrfMaterial material = GetDefaultMaterial(mjOBJ_FLEX, i);
     mjrf_setRenderableMaterial(renderable.get(), &material);
@@ -454,6 +457,7 @@ void RenderableManager::AddFlexGeoms() {
 }
 
 void RenderableManager::AddSkinGeoms() {
+  mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
 
   skins_.reserve(model->nskin);
@@ -461,7 +465,7 @@ void RenderableManager::AddSkinGeoms() {
   for (int i = 0; i < model->nskin; i++) {
     mjrfRenderableParams params;
     mjrf_defaultRenderableParams(&params);
-    auto renderable = CreateRenderable(ctx_, params);
+    auto renderable = CreateRenderable(ctx, params);
 
     mjrfMaterial material = GetDefaultMaterial(mjOBJ_SKIN, i);
     mjrf_setRenderableMaterial(renderable.get(), &material);
@@ -475,6 +479,7 @@ void RenderableManager::AddSkinGeoms() {
 }
 
 void RenderableManager::AddSliderCrankGeoms() {
+  mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
   const int nstack = model->vis.quality.numstacks;
   const int nslice = model->vis.quality.numslices;
@@ -491,13 +496,13 @@ void RenderableManager::AddSliderCrankGeoms() {
     }
 
     // Create two renderables, one for the slider and the other for the crank.
-    auto slider = CreateRenderable(ctx_, params);
+    auto slider = CreateRenderable(ctx, params);
     mjrf_setRenderableGeomMesh(slider.get(), mjGEOM_CYLINDER, nstack, nslice,
                                nquad);
     mjrf_addRenderableToScene(scene_, slider.get());
     sliders_.emplace_back(std::move(slider));
 
-    auto crank = CreateRenderable(ctx_, params);
+    auto crank = CreateRenderable(ctx, params);
     mjrf_setRenderableGeomMesh(crank.get(), mjGEOM_CAPSULE, nstack, nslice,
                                nquad);
     mjrf_addRenderableToScene(scene_, crank.get());
@@ -551,13 +556,16 @@ void RenderableManager::UpdateSliderCranks(const mjData* data, int actuator_id,
 }
 
 void RenderableManager::AppendSegmentToTendon(int tendon_id) {
+  mjrfContext* ctx = model_objects_->GetContext();
   const mjModel* model = model_objects_->GetModel();
+
   const int nstack = model->vis.quality.numstacks;
   const int nslice = model->vis.quality.numslices;
   const int nquad = model->vis.quality.numquads;
+
   mjrfRenderableParams params;
   mjrf_defaultRenderableParams(&params);
-  auto renderable = CreateRenderable(ctx_, params);
+  auto renderable = CreateRenderable(ctx, params);
   mjrf_setRenderableGeomMesh(renderable.get(), mjGEOM_CAPSULE, nstack, nslice,
                              nquad);
   if (vopts_.tendongroup[model->tendon_group[tendon_id]]) {

src/render/filament/support/renderable_manager.h

@@ -31,8 +31,7 @@ namespace mujoco {
 class RenderableManager {
  public:
   // Populates the mjrScene with the renderables from the model.
-  RenderableManager(mjrfContext* ctx, mjrfScene* scene,
+  RenderableManager(mjrfScene* scene, ModelObjects* model_objects);
-                    ModelObjects* model_objects);
   ~RenderableManager();
 
   // Updates the state of the renderables in the scene.
@@ -75,7 +74,6 @@ class RenderableManager {
 
   int GetSegmentationId(mjtObj obj_type, int obj_index);
 
-  mjrfContext* ctx_;
   mjrfScene* scene_;
   ModelObjects* model_objects_;