chenlin/Mujoco_WASM
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename LightManager to ModelLights and RenderableManager to ModelRenderables.

Browse Source 
This better reflects the purpose of these classes.

PiperOrigin-RevId: 952123609
Change-Id: Ib14c54c3d9b137258ebc706590aca3b2e80015fe
This commit is contained in:
Haroon Qureshi
2026-07-22 08:02:45 -07:00
committed by Copybara-Service
parent 8c0a73482c
commit b6ab11dc6b
7 changed files with 81 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/experimental/filament/compat/scene_bridge.cc
+5 -5
View File
@@ -30,7 +30,7 @@
#include "experimental/filament/compat/scene_objects.h" #include "experimental/filament/compat/scene_objects.h"
#include "render/filament/mjrfilament_cpp.h" #include "render/filament/mjrfilament_cpp.h"
#include "render/filament/support/filament_util.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" #include "render/filament/support/model_objects.h"
namespace mujoco { namespace mujoco {
@@ -51,11 +51,11 @@ SceneBridge::SceneBridge(mjrfContext* ctx, mjrfScene* scene, const mjModel* mode
filament::math::float4(0, 0, 0, 1)); filament::math::float4(0, 0, 0, 1));
mjrf_setClearColor(ctx_, &clear_color[0]); 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() { SceneBridge::~SceneBridge() {
light_manager_.reset(); model_lights_.reset();
for (auto& iter : renderables_) { for (auto& iter : renderables_) {
mjrf_removeRenderableFromScene(scene_, iter.get()); 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]; const mjvLight& scene_light = scene->lights[i];
if (scene_light.id < 0 && scene_light.headlight) { if (scene_light.id < 0 && scene_light.headlight) {
// The headlight, if it exists, is assigned the id `scene->nlight`. // 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) { if (!headlight) {
continue; continue;
} }
@@ -235,7 +235,7 @@ void SceneBridge::Update(const mjrRect& viewport, const mjvScene* scene) {
mjrf_setLightColor(headlight, scene_light.diffuse); mjrf_setLightColor(headlight, scene_light.diffuse);
mjrf_setLightTransform(headlight, headpos, gazedir); mjrf_setLightTransform(headlight, headpos, gazedir);
continue; 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_setLightColor(light, scene_light.diffuse);
mjrf_setLightTransform(light, scene_light.pos, scene_light.dir); mjrf_setLightTransform(light, scene_light.pos, scene_light.dir);
} else { } else {
src/experimental/filament/compat/scene_bridge.h
+2 -2
View File
@@ -27,8 +27,8 @@
#include <mujoco/mujoco.h> #include <mujoco/mujoco.h>
#include "experimental/filament/compat/scene_objects.h" #include "experimental/filament/compat/scene_objects.h"
#include "render/filament/mjrfilament_cpp.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/model_objects.h"
#include "render/filament/support/light_manager.h"
namespace mujoco { namespace mujoco {
@@ -66,7 +66,7 @@ class SceneBridge {
mjrfScene* scene_ = nullptr; mjrfScene* scene_ = nullptr;
std::unique_ptr<ModelObjects> model_objects_; std::unique_ptr<ModelObjects> model_objects_;
std::unique_ptr<SceneObjects> scene_objects_; std::unique_ptr<SceneObjects> scene_objects_;
std::unique_ptr<LightManager> light_manager_; std::unique_ptr<ModelLights> model_lights_;
mjrCamera camera_; mjrCamera camera_;
DrawTextAtFn draw_text_callback_; DrawTextAtFn draw_text_callback_;
std::vector<UniquePtr<mjrfRenderable>> renderables_; std::vector<UniquePtr<mjrfRenderable>> renderables_;
src/render/filament/CMakeLists.txt
+4 -4
View File
@@ -55,16 +55,16 @@ target_sources(${MUJOCO_FILAMENT_TARGET_NAME}
core/types.h core/types.h
support/filament_util.h support/filament_util.h
support/filament_util.cc support/filament_util.cc
support/light_manager.h
support/light_manager.cc
support/mesh_util.h support/mesh_util.h
support/mesh_util.cc support/mesh_util.cc
support/model_decorations.h support/model_decorations.h
support/model_decorations.cc support/model_decorations.cc
support/model_lights.h
support/model_lights.cc
support/model_objects.h support/model_objects.h
support/model_objects.cc support/model_objects.cc
support/renderable_manager.h support/model_renderables.h
support/renderable_manager.cc support/model_renderables.cc
) )
target_include_directories(${MUJOCO_FILAMENT_TARGET_NAME} target_include_directories(${MUJOCO_FILAMENT_TARGET_NAME}
src/render/filament/support/light_manager.cc → src/render/filament/support/model_lights.cc
+13 -14
View File
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
#include "render/filament/support/light_manager.h" #include "render/filament/support/model_lights.h"
#include <memory> #include <memory>
#include <string> #include <string>
@@ -63,20 +63,19 @@ static UniquePtr<mjrfTexture> CreateFallbackIndirectLightTexture(
mjrf_defaultTextureData(&payload); mjrf_defaultTextureData(&payload);
payload.bytes = bytes; payload.bytes = bytes;
payload.num_bytes = nbytes; payload.num_bytes = nbytes;
payload.release = +[](void* user_data) { payload.release =
mju_closeResource((mjResource*)user_data); +[](void* user_data) { mju_closeResource((mjResource*)user_data); };
};
payload.user_data = resource; payload.user_data = resource;
mjrf_setTextureData(texture.get(), &payload); mjrf_setTextureData(texture.get(), &payload);
return texture; return texture;
} }
LightManager::LightManager(mjrfScene* scene, ModelObjects* model_objects) ModelLights::ModelLights(mjrfScene* scene, ModelObjects* model_objects)
: scene_(scene), model_objects_(model_objects) { : scene_(scene), model_objects_(model_objects) {
const mjModel* model = model_objects->GetModel(); const mjModel* model = model_objects->GetModel();
default_shadow_map_size_ = ReadElement( default_shadow_map_size_ =
model, "filament.shadows.map_size", default_shadow_map_size_); ReadElement(model, "filament.shadows.map_size", default_shadow_map_size_);
fallback_head_light_intensity_ = fallback_head_light_intensity_ =
ReadElement(model, "filament.fallback.head_light_intensity", ReadElement(model, "filament.fallback.head_light_intensity",
fallback_head_light_intensity_); fallback_head_light_intensity_);
@@ -89,7 +88,7 @@ LightManager::LightManager(mjrfScene* scene, ModelObjects* model_objects)
Prepare(); Prepare();
} }
LightManager::~LightManager() { ModelLights::~ModelLights() {
for (auto& iter : lights_) { for (auto& iter : lights_) {
mjrf_removeLightFromScene(scene_, iter.get()); mjrf_removeLightFromScene(scene_, iter.get());
} }
@@ -100,7 +99,7 @@ LightManager::~LightManager() {
fallback_ibl_.reset(); fallback_ibl_.reset();
} }
void LightManager::Prepare() { void ModelLights::Prepare() {
mjrfContext* ctx = model_objects_->GetContext(); mjrfContext* ctx = model_objects_->GetContext();
const mjModel* model = model_objects_->GetModel(); const mjModel* model = model_objects_->GetModel();
@@ -194,9 +193,9 @@ void LightManager::Prepare() {
for (auto& light : lights_) { for (auto& light : lights_) {
if (light) { if (light) {
const bool is_headlight = (light == lights_.back()); const bool is_headlight = (light == lights_.back());
mjrf_setLightIntensity(light.get(), mjrf_setLightIntensity(light.get(), is_headlight
is_headlight ? fallback_head_light_intensity_ ? fallback_head_light_intensity_
: intensity); : intensity);
} }
} }
} }
@@ -204,7 +203,7 @@ void LightManager::Prepare() {
mjrf_setSceneSkybox(scene_, model_objects_->GetSkyboxTexture()); mjrf_setSceneSkybox(scene_, model_objects_->GetSkyboxTexture());
} }
void LightManager::Update(const mjData* data) { void ModelLights::Update(const mjData* data) {
const mjModel* model = model_objects_->GetModel(); const mjModel* model = model_objects_->GetModel();
for (int i = 0; i <= model->nlight; ++i) { for (int i = 0; i <= model->nlight; ++i) {
// Light with index nlight is the headlight. // 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()) { if (index < 0 || index >= lights_.size()) {
return nullptr; return nullptr;
} }
src/render/filament/support/light_manager.h → src/render/filament/support/model_lights.h
+9 -9
View File
@@ -12,8 +12,8 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
#ifndef MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_LIGHT_MANAGER_H_ #ifndef MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_LIGHTS_H_
#define MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_LIGHT_MANAGER_H_ #define MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_LIGHTS_H_
#include <vector> #include <vector>
@@ -24,11 +24,11 @@
namespace mujoco { namespace mujoco {
// Manages Light entities for an mjrfScene. // Manages Light entities in an mjrfScene for an mjModel.
class LightManager { class ModelLights {
public: public:
LightManager(mjrfScene* scene, ModelObjects* model_objects); ModelLights(mjrfScene* scene, ModelObjects* model_objects);
~LightManager(); ~ModelLights();
// Updates the state of the lights in the scene. // Updates the state of the lights in the scene.
void Update(const mjData* data); void Update(const mjData* data);
@@ -37,8 +37,8 @@ class LightManager {
// headlight is assigned of the index `nlight`. // headlight is assigned of the index `nlight`.
mjrfLight* GetLight(int index); mjrfLight* GetLight(int index);
LightManager(const LightManager&) = delete; ModelLights(const ModelLights&) = delete;
LightManager& operator=(const LightManager&) = delete; ModelLights& operator=(const ModelLights&) = delete;
private: private:
void Prepare(); void Prepare();
@@ -57,4 +57,4 @@ class LightManager {
} // namespace mujoco } // namespace mujoco
#endif // MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_LIGHT_MANAGER_H_ #endif // MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_LIGHTS_H_
src/render/filament/support/renderable_manager.cc → src/render/filament/support/model_renderables.cc
+36 -33
View File
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
#include "render/filament/support/renderable_manager.h" #include "render/filament/support/model_renderables.h"
#include <array> #include <array>
#include <memory> #include <memory>
@@ -142,7 +142,8 @@ static void SetGeomMesh(mjrfRenderable* renderable, ModelObjects* model_objs,
} }
case mjGEOM_HFIELD: { case mjGEOM_HFIELD: {
const int data_id = model->geom_dataid[geom_index]; 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; break;
} }
case mjGEOM_FLEX: case mjGEOM_FLEX:
@@ -175,8 +176,8 @@ static void SetGeomMesh(mjrfRenderable* renderable, ModelObjects* model_objs,
} }
} }
RenderableManager::RenderableManager(mjrfScene* scene, ModelRenderables::ModelRenderables(mjrfScene* scene,
ModelObjects* model_objects) ModelObjects* model_objects)
: scene_(scene), model_objects_(model_objects) { : scene_(scene), model_objects_(model_objects) {
mjv_defaultOption(&vopts_); mjv_defaultOption(&vopts_);
@@ -190,7 +191,7 @@ RenderableManager::RenderableManager(mjrfScene* scene,
tendons_.resize(model_objects_->GetModel()->ntendon); tendons_.resize(model_objects_->GetModel()->ntendon);
} }
RenderableManager::~RenderableManager() { ModelRenderables::~ModelRenderables() {
for (auto& renderable : geoms_) { for (auto& renderable : geoms_) {
mjrf_removeRenderableFromScene(scene_, renderable.get()); 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(); mjrfContext* ctx = model_objects_->GetContext();
const mjModel* model = model_objects_->GetModel(); 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, mjrfRenderable* ModelRenderables::GetRenderable(mjtObj obj_type, int obj_index,
int sub_index) { int sub_index) {
switch (obj_type) { switch (obj_type) {
case mjOBJ_GEOM: case mjOBJ_GEOM:
if (obj_index >= 0 && obj_index < geoms_.size()) { if (obj_index >= 0 && obj_index < geoms_.size()) {
@@ -405,7 +406,7 @@ mjrfRenderable* RenderableManager::GetRenderable(mjtObj obj_type, int obj_index,
return nullptr; return nullptr;
} }
void RenderableManager::AddGeomGeoms() { void ModelRenderables::AddGeomGeoms() {
mjrfContext* ctx = model_objects_->GetContext(); mjrfContext* ctx = model_objects_->GetContext();
const mjModel* model = model_objects_->GetModel(); const mjModel* model = model_objects_->GetModel();
@@ -434,7 +435,7 @@ void RenderableManager::AddGeomGeoms() {
} }
} }
void RenderableManager::AddSiteGeoms() { void ModelRenderables::AddSiteGeoms() {
mjrfContext* ctx = model_objects_->GetContext(); mjrfContext* ctx = model_objects_->GetContext();
const mjModel* model = model_objects_->GetModel(); const mjModel* model = model_objects_->GetModel();
@@ -463,7 +464,7 @@ void RenderableManager::AddSiteGeoms() {
} }
} }
void RenderableManager::AddFlexGeoms() { void ModelRenderables::AddFlexGeoms() {
mjrfContext* ctx = model_objects_->GetContext(); mjrfContext* ctx = model_objects_->GetContext();
const mjModel* model = model_objects_->GetModel(); const mjModel* model = model_objects_->GetModel();
@@ -504,7 +505,7 @@ void RenderableManager::AddFlexGeoms() {
} }
} }
void RenderableManager::AddSkinGeoms() { void ModelRenderables::AddSkinGeoms() {
mjrfContext* ctx = model_objects_->GetContext(); mjrfContext* ctx = model_objects_->GetContext();
const mjModel* model = model_objects_->GetModel(); const mjModel* model = model_objects_->GetModel();
@@ -526,7 +527,7 @@ void RenderableManager::AddSkinGeoms() {
} }
} }
void RenderableManager::AddSliderCrankGeoms() { void ModelRenderables::AddSliderCrankGeoms() {
mjrfContext* ctx = model_objects_->GetContext(); mjrfContext* ctx = model_objects_->GetContext();
const mjModel* model = model_objects_->GetModel(); const mjModel* model = model_objects_->GetModel();
const int nstack = model->vis.quality.numstacks; const int nstack = model->vis.quality.numstacks;
@@ -558,8 +559,7 @@ void RenderableManager::AddSliderCrankGeoms() {
} }
} }
void RenderableManager::UpdateSliderCranks(const mjData* data, void ModelRenderables::UpdateSliderCranks(const mjData* data, int actuator_id) {
int actuator_id) {
auto it = slider_cranks_.find(actuator_id); auto it = slider_cranks_.find(actuator_id);
if (it == slider_cranks_.end()) { if (it == slider_cranks_.end()) {
mju_error("Slider/crank not found: %d", actuator_id); mju_error("Slider/crank not found: %d", actuator_id);
@@ -609,7 +609,7 @@ void RenderableManager::UpdateSliderCranks(const mjData* data,
mjrf_setRenderableMaterial(crank, &material); mjrf_setRenderableMaterial(crank, &material);
} }
void RenderableManager::AppendSegmentToTendon(int tendon_id) { void ModelRenderables::AppendSegmentToTendon(int tendon_id) {
mjrfContext* ctx = model_objects_->GetContext(); mjrfContext* ctx = model_objects_->GetContext();
const mjModel* model = model_objects_->GetModel(); const mjModel* model = model_objects_->GetModel();
@@ -630,15 +630,14 @@ void RenderableManager::AppendSegmentToTendon(int tendon_id) {
segments.emplace_back(std::move(renderable)); segments.emplace_back(std::move(renderable));
} }
void RenderableManager::RemoveSegmentFromTendon(int tendon_id) { void ModelRenderables::RemoveSegmentFromTendon(int tendon_id) {
auto& segments = tendons_[tendon_id]; auto& segments = tendons_[tendon_id];
mjrfRenderable* renderable = segments.back().get(); mjrfRenderable* renderable = segments.back().get();
mjrf_removeRenderableFromScene(scene_, renderable); mjrf_removeRenderableFromScene(scene_, renderable);
segments.pop_back(); segments.pop_back();
} }
void RenderableManager::UpdateSpatialTendons(const mjData* data, void ModelRenderables::UpdateSpatialTendons(const mjData* data, int tendon_id) {
int tendon_id) {
const mjModel* model = model_objects_->GetModel(); const mjModel* model = model_objects_->GetModel();
// Gather the points that define the tendon. We'll use a simple cache to avoid // 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(); const mjModel* model = model_objects_->GetModel();
int id = 0; int id = 0;
@@ -735,8 +734,8 @@ int RenderableManager::GetSegmentationId(mjtObj obj_type, int obj_index) {
return -1; return -1;
} }
mjrfMaterial RenderableManager::GetDefaultMaterial(mjtObj obj_type, mjrfMaterial ModelRenderables::GetDefaultMaterial(mjtObj obj_type,
int obj_index) { int obj_index) {
const mjModel* model = model_objects_->GetModel(); const mjModel* model = model_objects_->GetModel();
mjrfMaterial material; 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(); const mjModel* model = model_objects_->GetModel();
VisibilityOp ops[mjNGROUP] = {kNoop}; VisibilityOp ops[mjNGROUP] = {kNoop};
@@ -988,25 +987,29 @@ void RenderableManager::SetVisibility(mjtObj obj_type, int idx, bool visible) {
} }
break; break;
case mjOBJ_FLEX: 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) { for (int i = 0; i < model->nflex; ++i) {
ApplyVisibility(ops, model->flex_group[i], scene_, flexes_[i]); ApplyVisibility(ops, model->flex_group[i], scene_, flexes_[i]);
} }
break; break;
case mjOBJ_SKIN: 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) { for (int i = 0; i < model->nskin; ++i) {
ApplyVisibility(ops, model->skin_group[i], scene_, {&skins_[i], 1}); ApplyVisibility(ops, model->skin_group[i], scene_, {&skins_[i], 1});
} }
break; break;
case mjOBJ_TENDON: 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) { for (int i = 0; i < model->ntendon; ++i) {
ApplyVisibility(ops, model->tendon_group[i], scene_, tendons_[i]); ApplyVisibility(ops, model->tendon_group[i], scene_, tendons_[i]);
} }
break; break;
case mjOBJ_ACTUATOR: 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) { for (int i = 0; i < model->nu; ++i) {
auto it = slider_cranks_.find(i); auto it = slider_cranks_.find(i);
if (it == slider_cranks_.end()) { 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(); const mjModel* model = model_objects_->GetModel();
for (int i = 0; i < mjNGROUP; ++i) { for (int i = 0; i < mjNGROUP; ++i) {
@@ -1092,12 +1095,12 @@ void RenderableManager::SetOptions(const mjvOption& opt) {
vopts_ = 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_) { if (obj_type != selected_obj_type_ || obj_index != selected_obj_index_) {
mjrfMaterial material; mjrfMaterial material;
mjrfRenderable* prev_renderable = GetRenderable( mjrfRenderable* prev_renderable =
selected_obj_type_, selected_obj_index_); GetRenderable(selected_obj_type_, selected_obj_index_);
if (prev_renderable) { if (prev_renderable) {
mjrf_getRenderableMaterial(prev_renderable, &material); mjrf_getRenderableMaterial(prev_renderable, &material);
material.selected = 0; material.selected = 0;
@@ -1107,8 +1110,8 @@ void RenderableManager::MarkAsSelected(mjtObj obj_type, int obj_index) {
selected_obj_type_ = obj_type; selected_obj_type_ = obj_type;
selected_obj_index_ = obj_index; selected_obj_index_ = obj_index;
mjrfRenderable* curr_renderable = GetRenderable( mjrfRenderable* curr_renderable =
selected_obj_type_, selected_obj_index_); GetRenderable(selected_obj_type_, selected_obj_index_);
if (curr_renderable) { if (curr_renderable) {
mjrf_getRenderableMaterial(curr_renderable, &material); mjrf_getRenderableMaterial(curr_renderable, &material);
material.selected = 1; material.selected = 1;
src/render/filament/support/renderable_manager.h → src/render/filament/support/model_renderables.h
+12 -11
View File
@@ -12,12 +12,13 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
#ifndef MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_RENDERABLE_MANAGER_H_ #ifndef MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_RENDERABLES_H_
#define MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_RENDERABLE_MANAGER_H_ #define MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_RENDERABLES_H_
#include <array> #include <array>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include <math/vec4.h> #include <math/vec4.h>
#include <mujoco/mjdata.h> #include <mujoco/mjdata.h>
#include <mujoco/mjrfilament.h> #include <mujoco/mjrfilament.h>
@@ -28,12 +29,12 @@
namespace mujoco { namespace mujoco {
// Manages Renderable entities for an mjrfScene. // Manages Renderable entities in an mjrfScene for an mjModel.
class RenderableManager { class ModelRenderables {
public: public:
// Populates the mjrScene with the renderables from the model. // Populates the mjrScene with the renderables from the model.
RenderableManager(mjrfScene* scene, ModelObjects* model_objects); ModelRenderables(mjrfScene* scene, ModelObjects* model_objects);
~RenderableManager(); ~ModelRenderables();
// Updates the state of the renderables in the scene. // Updates the state of the renderables in the scene.
void Update(const mjData* data); void Update(const mjData* data);
@@ -69,9 +70,8 @@ class RenderableManager {
// Returns the current visualization options. // Returns the current visualization options.
const mjvOption& GetOptions() const { return vopts_; } const mjvOption& GetOptions() const { return vopts_; }
ModelRenderables(const ModelRenderables&) = delete;
RenderableManager(const RenderableManager&) = delete; ModelRenderables& operator=(const ModelRenderables&) = delete;
RenderableManager& operator=(const RenderableManager&) = delete;
private: private:
void AddGeomGeoms(); void AddGeomGeoms();
@@ -101,7 +101,8 @@ class RenderableManager {
std::vector<UniquePtr<mjrfRenderable>> skins_; std::vector<UniquePtr<mjrfRenderable>> skins_;
std::vector<std::vector<UniquePtr<mjrfRenderable>>> flexes_; std::vector<std::vector<UniquePtr<mjrfRenderable>>> flexes_;
std::vector<std::vector<UniquePtr<mjrfRenderable>>> tendons_; 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>> flex_meshes_;
std::vector<UniquePtr<mjrfMesh>> skin_meshes_; std::vector<UniquePtr<mjrfMesh>> skin_meshes_;
@@ -109,4 +110,4 @@ class RenderableManager {
}; };
} // namespace mujoco } // namespace mujoco
#endif // MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_RENDERABLE_MANAGER_H_ #endif // MUJOCO_SRC_RENDER_FILAMENT_SUPPORT_MODEL_RENDERABLES_H_