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

Add an Editor panel.

Browse Source 
The editor panel allows you to add, remove, and modify spec elements
as well as recompiling and loading the spec.

Also includes utilities for handling vertically split panels.

PiperOrigin-RevId: 875658785
Change-Id: I18b10971d587db5eb1e65a033e1dc042faac7f1d
This commit is contained in:
Haroon Qureshi
2026-02-26 04:50:31 -08:00
committed by Copybara-Service
parent 7232ec3b47
commit a9675fbaa6
7 changed files with 1015 additions and 560 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/experimental/platform/gui.cc
+1
View File
@@ -246,6 +246,7 @@ ImVec4 ConfigureDockingLayout() {
ImGui::DockBuilderDockWindow("Dockspace", main);
ImGui::DockBuilderDockWindow("Options", options);
ImGui::DockBuilderDockWindow("Explorer", inspector);
ImGui::DockBuilderDockWindow("Editor", inspector);
ImGui::DockBuilderDockWindow("Inspector", inspector);
ImGui::DockBuilderDockWindow("Properties", properties);
ImGui::DockBuilderDockWindow("Stats", stats);
src/experimental/platform/gui_spec.cc
+450 -365
View File
@@ -63,7 +63,7 @@ static int GetElementIndexInSpec(mjsElement* element) {
// Returns a name for the element; either the element has a name, or we
// construct a unique name from the element's id (using mjs_getId) or index
// (using GetElementIndexInSpec).
static std::string ElementName(mjsElement* element) {
std::string ElementName(mjsElement* element) {
const mjString* name = mjs_getName(element);
std::string label = *name;
if (label.empty()) {
@@ -77,22 +77,51 @@ static std::string ElementName(mjsElement* element) {
return label;
}
static void AddDeleteButton(mjsElement* element,
const SpecElementCallbackFn& on_delete) {
if (on_delete) {
// Right-align the delete button.
const float button_width = ImGui::CalcTextSize(ICON_FA_TRASH_CAN).x +
ImGui::GetStyle().FramePadding.x * 2.0f;
ImGui::SameLine(ImGui::GetWindowContentRegionMax().x - button_width);
if (ImGui::SmallButton(ICON_FA_TRASH_CAN)) {
on_delete(element);
}
static bool AddDeleteButton(mjsElement* element) {
// Right-align the delete button.
const float button_width = ImGui::CalcTextSize(ICON_FA_TRASH_CAN).x +
ImGui::GetStyle().FramePadding.x * 2.0f;
ImGui::SameLine(ImGui::GetWindowContentRegionMax().x - button_width);
if (ImGui::SmallButton(ICON_FA_TRASH_CAN)) {
mjs_delete(mjs_getSpec(element), element);
return true;
}
return false;
}
static void SelectableElement(mjsElement* element,
static bool AddBodyAddChildButton(mjsElement* element, mjsElement** selected_element) {
// Right-align the add button.
const float button_width = ImGui::CalcTextSize(ICON_FA_TRASH_CAN).x +
ImGui::CalcTextSize(ICON_FA_PLUS).x +
ImGui::GetStyle().FramePadding.x * 4.0f;
ImGui::SameLine(ImGui::GetWindowContentRegionMax().x - button_width);
if (ImGui::SmallButton(ICON_FA_PLUS)) {
ImGui::OpenPopupOnItemClick("BodyAddChild", 0);
}
bool modified = false;
if (ImGui::BeginPopupContextItem("BodyAddChild")) {
mjsBody* body = mjs_asBody(element);
auto option = [&](const char* label, auto fn) {
if (ImGui::Selectable(label)) {
*selected_element = fn()->element;
mjs_setName(*selected_element, ElementName(*selected_element).c_str());
modified = true;
}
};
option("Camera", [&]() { return mjs_addCamera(body, nullptr); });
option("Frame", [&]() { return mjs_addFrame(body, nullptr); });
option("Geom", [&]() { return mjs_addGeom(body, nullptr); });
option("Joint", [&]() { return mjs_addJoint(body, nullptr); });
option("Light", [&]() { return mjs_addLight(body, nullptr); });
option("Site", [&]() { return mjs_addSite(body, nullptr); });
ImGui::EndPopup();
}
return modified;
}
static bool SelectableElement(mjsElement* element,
mjsElement** selected_element,
const SpecElementCallbackFn& on_delete) {
SpecEditMode mode) {
constexpr ImGuiSelectableFlags flags = ImGuiSelectableFlags_AllowOverlap;
const std::string name = ElementName(element);
@@ -100,51 +129,63 @@ static void SelectableElement(mjsElement* element,
if (ImGui::Selectable(name.c_str(), selected, flags)) {
*selected_element = element;
}
if (selected) {
AddDeleteButton(element, on_delete);
bool modified = false;
if (selected && mode == SpecEditMode::kEdit) {
if (AddDeleteButton(element)) {
*selected_element = nullptr;
modified = true;
}
}
return modified;
}
static void BodyChildrenGui(const char* heading, mjtObj type,
static bool BodyChildrenGui(const char* heading, mjtObj type,
mjsElement** element, mjsBody* body,
const SpecElementCallbackFn& on_delete) {
SpecEditMode mode) {
mjsElement* iter = mjs_firstChild(body, type, 0);
if (!iter) {
return;
return false;
}
bool modified = false;
constexpr ImGuiTreeNodeFlags tree_flags =
ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_DrawLinesFull;
if (ImGui::TreeNodeEx(heading, tree_flags)) {
while (iter) {
SelectableElement(iter, element, on_delete);
iter = mjs_nextChild(body, iter, 0);
mjsElement* next = mjs_nextChild(body, iter, 0);
modified |= SelectableElement(iter, element, mode);
iter = next;
}
ImGui::TreePop();
}
return modified;
}
static void ElementListGui(const char* heading, mjtObj type,
static bool ElementListGui(const char* heading, mjtObj type,
mjsElement** element, mjSpec* spec,
const SpecElementCallbackFn& on_delete) {
SpecEditMode mode) {
mjsElement* iter = mjs_firstElement(spec, type);
if (!iter) {
return;
return false;
}
bool modified = false;
constexpr ImGuiTreeNodeFlags tree_flags =
ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_Framed;
if (ImGui::TreeNodeEx(heading, tree_flags)) {
while (iter) {
SelectableElement(iter, element, on_delete);
iter = mjs_nextElement(spec, iter);
mjsElement* next = mjs_nextElement(spec, iter);
modified |= SelectableElement(iter, element, mode);
iter = next;
}
ImGui::TreePop();
}
return modified;
}
static void BodyTreeGuiRecursive(mjsElement** element, mjsBody* body,
const SpecElementCallbackFn& on_delete) {
static bool BodyTreeGuiRecursive(mjsElement** element, mjsBody* body,
SpecEditMode mode) {
const std::string label = ElementName(body->element);
ImGui::PushID(body);
@@ -157,52 +198,61 @@ static void BodyTreeGuiRecursive(mjsElement** element, mjsBody* body,
flags |= ImGuiTreeNodeFlags_Selected;
}
bool modified = false;
const bool tree_open = ImGui::TreeNodeEx(label.c_str(), flags);
if (ImGui::IsItemClicked()) {
*element = body->element;
}
if (*element == body->element) {
AddDeleteButton(body->element, on_delete);
if (*element == body->element && mode == SpecEditMode::kEdit) {
modified |= AddBodyAddChildButton(body->element, element);
modified |= AddDeleteButton(body->element);
}
if (tree_open) {
mjsElement* iter = mjs_firstChild(body, mjOBJ_BODY, 0);
while (iter) {
BodyTreeGuiRecursive(element, mjs_asBody(iter), on_delete);
iter = mjs_nextChild(body, iter, 0);
mjsElement* next = mjs_nextChild(body, iter, 0);
modified |= BodyTreeGuiRecursive(element, mjs_asBody(iter), mode);
iter = next;
}
BodyChildrenGui("Frames", mjOBJ_FRAME, element, body, on_delete);
BodyChildrenGui("Sites", mjOBJ_SITE, element, body, on_delete);
BodyChildrenGui("Joints", mjOBJ_JOINT, element, body, on_delete);
BodyChildrenGui("Geoms", mjOBJ_GEOM, element, body, on_delete);
BodyChildrenGui("Lights", mjOBJ_LIGHT, element, body, on_delete);
BodyChildrenGui("Cameras", mjOBJ_CAMERA, element, body, on_delete);
modified |= BodyChildrenGui("Frames", mjOBJ_FRAME, element, body, mode);
modified |= BodyChildrenGui("Sites", mjOBJ_SITE, element, body, mode);
modified |= BodyChildrenGui("Joints", mjOBJ_JOINT, element, body, mode);
modified |= BodyChildrenGui("Geoms", mjOBJ_GEOM, element, body, mode);
modified |= BodyChildrenGui("Lights", mjOBJ_LIGHT, element, body, mode);
modified |= BodyChildrenGui("Cameras", mjOBJ_CAMERA, element, body, mode);
ImGui::TreePop();
}
ImGui::PopID();
return modified;
}
void SpecExplorerGui(mjsElement** element, mjSpec* spec,
const SpecElementCallbackFn& on_delete) {
bool SpecTreeGui(mjsElement** element, mjSpec* spec, SpecEditMode mode) {
bool modified = false;
const ImGuiTreeNodeFlags flags =
ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_Framed;
ScopedStyle style;
style.Var(ImGuiStyleVar_ItemSpacing, ImVec2(4, 2));
style.Var(ImGuiStyleVar_FramePadding, ImVec2(4, 0));
style.Color(ImGuiCol_Border, ImGuiCol_WindowBg);
if (ImGui::TreeNodeEx("Body Tree", flags)) {
mjsElement* root = mjs_firstElement(spec, mjOBJ_BODY);
if (root) {
mjsBody* body = mjs_asBody(root);
if (body) {
BodyTreeGuiRecursive(element, body, on_delete);
modified |= BodyTreeGuiRecursive(element, body, mode);
}
}
ImGui::TreePop();
}
auto list = [&](const char* heading, mjtObj type) {
ElementListGui(heading, type, element, spec, on_delete);
modified |= ElementListGui(heading, type, element, spec, mode);
};
ImGui::PushID(spec);
@@ -235,412 +285,447 @@ void SpecExplorerGui(mjsElement** element, mjSpec* spec,
}
ImGui::PopID();
return modified;
}
void ElementSpecGui(const mjSpec* spec, mjsElement* element) {
bool ElementSpecGui(mjsElement* element, mjsElement* ref_element,
SpecEditMode mode) {
if (element == nullptr) {
return;
return false;
}
if (ref_element == nullptr) {
ref_element = element;
}
ImGui_SpecElementTable table;
#define FIELD(NAME, TIP) table(#NAME, elem->NAME, ref->NAME, TIP);
#define QFIELD(NAME, ALT, TIP) table(#NAME, #ALT, elem->NAME, ref->NAME, elem->ALT, ref->ALT, TIP);
ImGui_SpecElementTable table(mode == SpecEditMode::kPlay);
switch (element->elemtype) {
case mjOBJ_BODY: {
mjsBody* body = mjs_asBody(element);
table("childclass", body->childclass, "childclass name");
table("pos", body->pos, "frame position");
table("quat", body->quat, "alt", body->alt, "frame orientation");
table("ipos", body->ipos, "inertial frame position");
table("iquat", body->iquat, "ialt", body->ialt, "inertial frame orientation");
table("mass", body->mass, "mass");
table("inertia", body->inertia, "diagonal inertia (in i-frame)");
table("fullinertia", body->fullinertia, "non-axis-aligned inertia matrix");
table("mocap", body->mocap, "is this a mocap body");
table("gravcomp", body->gravcomp, "gravity compensation");
table("explicitinertial", body->explicitinertial, "whether to save the body with explicit inertial clause");
table("sleep", body->sleep, "sleep policy");
table("info", body->info, "message appended to compiler errors");
mjsBody* elem = mjs_asBody(element);
mjsBody* ref = mjs_asBody(ref_element);
FIELD(childclass, "childclass name");
FIELD(pos, "frame position");
QFIELD(quat, alt, "frame orientation");
FIELD(ipos, "inertial frame position");
QFIELD(iquat, ialt, "inertial frame orientation");
FIELD(mass, "mass");
FIELD(inertia, "diagonal inertia (in i-frame)");
FIELD(fullinertia, "non-axis-aligned inertia matrix");
FIELD(mocap, "is this a mocap body");
FIELD(gravcomp, "gravity compensation");
FIELD(explicitinertial, "whether to save the body with explicit inertial clause");
FIELD(sleep, "sleep policy");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_JOINT: {
mjsJoint* joint = mjs_asJoint(element);
table("pos", joint->pos, "anchor position");
table("axis", joint->axis, "joint axis");
table("ref", joint->ref, "value at reference configuration: qpos0");
table("align", joint->align, "align free joint with body com (mjtAlignFree)");
table("stiffness", joint->stiffness, "stiffness coefficient");
table("springref", joint->springref, "spring reference value: qpos_spring");
table("springdamper", joint->springdamper, "timeconst, dampratio");
table("limited", joint->limited, "does joint have limits (mjtLimited)");
table("range", joint->range, "joint limits");
table("margin", joint->margin, "margin value for joint limit detection");
table("solref_limit", joint->solref_limit, "solver reference: joint limits");
table("solimp_limit", joint->solimp_limit, "solver impedance: joint limits");
table("actfrclimited", joint->actfrclimited, "are actuator forces on joint limited (mjtLimited)");
table("actfrcrange", joint->actfrcrange, "actuator force limits");
table("armature", joint->armature, "armature inertia (mass for slider)");
table("damping", joint->damping, "damping coefficient");
table("frictionloss", joint->frictionloss, "friction loss");
table("solref_friction", joint->solref_friction, "solver reference: dof friction");
table("solimp_friction", joint->solimp_friction, "solver impedance: dof friction");
table("group", joint->group, "group");
table("actgravcomp", joint->actgravcomp, "is gravcomp force applied via actuators");
table("info", joint->info, "message appended to compiler errors");
mjsJoint* elem = mjs_asJoint(element);
mjsJoint* ref = mjs_asJoint(ref_element);
FIELD(pos, "anchor position");
FIELD(axis, "joint axis");
FIELD(ref, "value at reference configuration: qpos0");
FIELD(align, "align free joint with body com (mjtAlignFree)");
FIELD(stiffness, "stiffness coefficient");
FIELD(springref, "spring reference value: qpos_spring");
FIELD(springdamper, "timeconst, dampratio");
FIELD(limited, "does joint have limits (mjtLimited)");
FIELD(range, "joint limits");
FIELD(margin, "margin value for joint limit detection");
FIELD(solref_limit, "solver reference: joint limits");
FIELD(solimp_limit, "solver impedance: joint limits");
FIELD(actfrclimited, "are actuator forces on joint limited (mjtLimited)");
FIELD(actfrcrange, "actuator force limits");
FIELD(armature, "armature inertia (mass for slider)");
FIELD(damping, "damping coefficient");
FIELD(frictionloss, "friction loss");
FIELD(solref_friction, "solver reference: dof friction");
FIELD(solimp_friction, "solver impedance: dof friction");
FIELD(group, "group");
FIELD(actgravcomp, "is gravcomp force applied via actuators");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_ACTUATOR: {
mjsActuator* actuator = mjs_asActuator(element);
table("gaintype", actuator->gaintype, "gain type");
table("gainprm", actuator->gainprm, "gain parameters");
table("biastype", actuator->biastype, "bias type");
table("biasprm", actuator->biasprm, "bias parameters");
table("dyntype", actuator->dyntype, "dynamics type");
table("dynprm", actuator->dynprm, "dynamics parameters");
table("actdim", actuator->actdim, "number of activation variables");
table("actearly", actuator->actearly, "apply next activations to qfrc");
table("trntype", actuator->trntype, "transmission type");
table("gear", actuator->gear, "length and transmitted force scaling");
table("target", actuator->target, "name of transmission target");
table("refsite", actuator->refsite, "reference site, for site transmission");
table("slidersite", actuator->slidersite, "site defining cylinder, for slider-crank");
table("cranklength", actuator->cranklength, "crank length, for slider-crank");
table("lengthrange", actuator->lengthrange, "transmission length range");
table("inheritrange", actuator->inheritrange, "automatic range setting for position and intvelocity");
table("ctrllimited", actuator->ctrllimited, "are control limits defined (mjtLimited)");
table("ctrlrange", actuator->ctrlrange, "control range");
table("forcelimited", actuator->forcelimited, "are force limits defined (mjtLimited)");
table("forcerange", actuator->forcerange, "force range");
table("actlimited", actuator->actlimited, "are activation limits defined (mjtLimited)");
table("actrange", actuator->actrange, "activation range");
table("group", actuator->group, "group");
table("nsample", actuator->nsample, "number of samples in history buffer");
table("interp", actuator->interp, "interpolation order (0=ZOH, 1=linear, 2=cubic)");
table("delay", actuator->delay, "delay time in seconds; 0: no delay");
table("info", actuator->info, "message appended to compiler errors");
mjsActuator* elem = mjs_asActuator(element);
mjsActuator* ref = mjs_asActuator(ref_element);
FIELD(gaintype, "gain type");
FIELD(gainprm, "gain parameters");
FIELD(biastype, "bias type");
FIELD(biasprm, "bias parameters");
FIELD(dyntype, "dynamics type");
FIELD(dynprm, "dynamics parameters");
FIELD(actdim, "number of activation variables");
FIELD(actearly, "apply next activations to qfrc");
FIELD(trntype, "transmission type");
FIELD(gear, "length and transmitted force scaling");
FIELD(target, "name of transmission target");
FIELD(refsite, "reference site, for site transmission");
FIELD(slidersite, "site defining cylinder, for slider-crank");
FIELD(cranklength, "crank length, for slider-crank");
FIELD(lengthrange, "transmission length range");
FIELD(inheritrange, "automatic range setting for position and intvelocity");
FIELD(ctrllimited, "are control limits defined (mjtLimited)");
FIELD(ctrlrange, "control range");
FIELD(forcelimited, "are force limits defined (mjtLimited)");
FIELD(forcerange, "force range");
FIELD(actlimited, "are activation limits defined (mjtLimited)");
FIELD(actrange, "activation range");
FIELD(group, "group");
FIELD(nsample, "number of samples in history buffer");
FIELD(interp, "interpolation order (0=ZOH, 1=linear, 2=cubic)");
FIELD(delay, "delay time in seconds; 0: no delay");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_SENSOR: {
mjsSensor* sensor = mjs_asSensor(element);
table("type", sensor->type, "type of sensor");
table("objtype", sensor->objtype, "type of sensorized object");
table("objname", sensor->objname, "name of sensorized object");
table("reftype", sensor->reftype, "type of referenced object");
table("refname", sensor->refname, "name of referenced object");
table("intprm", sensor->intprm, "integer parameters");
table("datatype", sensor->datatype, "data type for sensor measurement");
table("needstage", sensor->needstage, "compute stage needed to simulate sensor");
table("dim", sensor->dim, "number of scalar outputs");
table("cutoff", sensor->cutoff, "cutoff for real and positive datatypes");
table("noise", sensor->noise, "noise stdev");
table("nsample", sensor->nsample, "number of samples in history buffer");
table("interp", sensor->interp, "interpolation order (0=ZOH, 1=linear, 2=cubic)");
table("delay", sensor->delay, "delay time in seconds");
table("interval", sensor->interval, "[period, time_prev] in seconds");
table("info", sensor->info, "message appended to compiler errors");
mjsSensor* elem = mjs_asSensor(element);
mjsSensor* ref = mjs_asSensor(ref_element);
FIELD(type, "type of sensor");
FIELD(objtype, "type of sensorized object");
FIELD(objname, "name of sensorized object");
FIELD(reftype, "type of referenced object");
FIELD(refname, "name of referenced object");
FIELD(intprm, "integer parameters");
FIELD(datatype, "data type for sensor measurement");
FIELD(needstage, "compute stage needed to simulate sensor");
FIELD(dim, "number of scalar outputs");
FIELD(cutoff, "cutoff for real and positive datatypes");
FIELD(noise, "noise stdev");
FIELD(nsample, "number of samples in history buffer");
FIELD(interp, "interpolation order (0=ZOH, 1=linear, 2=cubic)");
FIELD(delay, "delay time in seconds");
FIELD(interval, "[period, time_prev] in seconds");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_SITE: {
mjsSite* site = mjs_asSite(element);
table("pos", site->pos, "position");
table("quat", site->quat, "alt", site->alt, "orientation");
table("fromto", site->fromto, "alternative for capsule, cylinder, box, ellipsoid");
table("size", site->size, "geom size");
table("type", site->type, "geom type");
table("material", site->material, "name of material");
table("group", site->group, "group");
table("rgba", site->rgba, "rgba when material is omitted");
table("info", site->info, "message appended to compiler errors");
mjsSite* elem = mjs_asSite(element);
mjsSite* ref = mjs_asSite(ref_element);
FIELD(pos, "position");
QFIELD(quat, alt, "orientation");
FIELD(fromto, "alternative for capsule, cylinder, box, ellipsoid");
FIELD(size, "geom size");
FIELD(type, "geom type");
FIELD(material, "name of material");
FIELD(group, "group");
FIELD(rgba, "rgba when material is omitted");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_FRAME: {
mjsFrame* frame = mjs_asFrame(element);
table("childclass", frame->childclass, "childclass name");
table("pos", frame->pos, "position");
table("quat", frame->quat, "alt", frame->alt, "orientation");
table("info", frame->info, "message appended to compiler errors");
mjsFrame* elem = mjs_asFrame(element);
mjsFrame* ref = mjs_asFrame(ref_element);
FIELD(childclass, "childclass name");
FIELD(pos, "position");
QFIELD(quat, alt, "orientation");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_GEOM: {
mjsGeom* geom = mjs_asGeom(element);
table("type", geom->type, "geom type");
table("pos", geom->pos, "position");
table("quat", geom->quat, "alt", geom->alt, "orientation");
table("fromto", geom->fromto, "alternative for capsule, cylinder, box, ellipsoid");
table("size", geom->size, "type-specific size");
table("contype", geom->contype, "contact type");
table("conaffinity", geom->conaffinity, "contact affinity");
table("condim", geom->condim, "contact dimensionality");
table("priority", geom->priority, "contact priority");
table("friction", geom->friction, "one-sided friction coefficients: slide, roll, spin");
table("solmix", geom->solmix, "solver mixing for contact pairs");
table("solref", geom->solref, "solver reference");
table("solimp", geom->solimp, "solver impedance");
table("margin", geom->margin, "margin for contact detection");
table("gap", geom->gap, "include in solver if dist < margin-gap");
table("mass", geom->mass, "used to compute density");
table("density", geom->density, "used to compute mass and inertia from volume or surface");
table("typeinertia", geom->typeinertia, "selects between surface and volume inertia");
table("fluid_ellipsoid", geom->fluid_ellipsoid, "whether ellipsoid-fluid model is active");
table("fluid_coefs", geom->fluid_coefs, "ellipsoid-fluid interaction coefs");
table("material", geom->material, "name of material");
table("rgba", geom->rgba, "rgba when material is omitted");
table("group", geom->group, "group");
table("hfieldname", geom->hfieldname, "heightfield attached to geom");
table("meshname", geom->meshname, "mesh attached to geom");
table("fitscale", geom->fitscale, "scale mesh uniformly");
table("info", geom->info, "message appended to compiler errors");
mjsGeom* elem = mjs_asGeom(element);
mjsGeom* ref = mjs_asGeom(ref_element);
FIELD(type, "geom type");
FIELD(pos, "position");
QFIELD(quat, alt, "orientation");
FIELD(fromto, "alternative for capsule, cylinder, box, ellipsoid");
FIELD(size, "type-specific size");
FIELD(contype, "contact type");
FIELD(conaffinity, "contact affinity");
FIELD(condim, "contact dimensionality");
FIELD(priority, "contact priority");
FIELD(friction, "one-sided friction coefficients: slide, roll, spin");
FIELD(solmix, "solver mixing for contact pairs");
FIELD(solref, "solver reference");
FIELD(solimp, "solver impedance");
FIELD(margin, "margin for contact detection");
FIELD(gap, "include in solver if dist < margin-gap");
FIELD(mass, "used to compute density");
FIELD(density, "used to compute mass and inertia from volume or surface");
FIELD(typeinertia, "selects between surface and volume inertia");
FIELD(fluid_ellipsoid, "whether ellipsoid-fluid model is active");
FIELD(fluid_coefs, "ellipsoid-fluid interaction coefs");
FIELD(material, "name of material");
FIELD(rgba, "rgba when material is omitted");
FIELD(group, "group");
FIELD(hfieldname, "heightfield attached to geom");
FIELD(meshname, "mesh attached to geom");
FIELD(fitscale, "scale mesh uniformly");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_LIGHT: {
mjsLight* light = mjs_asLight(element);
table("pos", light->pos, "position");
table("dir", light->dir, "direction");
table("mode", light->mode, "tracking mode");
table("targetbody", light->targetbody, "target body for targeting");
table("active", light->active, "is light active");
table("type", light->type, "type of light");
table("texture", light->texture, "texture name for image lights");
table("castshadow", light->castshadow, "does light cast shadows");
table("bulbradius", light->bulbradius, "bulb radius, for soft shadows");
table("intensity", light->intensity, "intensity, in candelas");
table("range", light->range, "range of effectiveness");
table("attenuation", light->attenuation, "OpenGL attenuation (quadratic model)");
table("cutoff", light->cutoff, "OpenGL cutoff");
table("exponent", light->exponent, "OpenGL exponent");
table("ambient", light->ambient, "ambient color");
table("diffuse", light->diffuse, "diffuse color");
table("specular", light->specular, "specular color");
table("info", light->info, "message appended to compiler errorsx");
mjsLight* elem = mjs_asLight(element);
mjsLight* ref = mjs_asLight(ref_element);
FIELD(pos, "position");
FIELD(dir, "direction");
FIELD(mode, "tracking mode");
FIELD(targetbody, "target body for targeting");
FIELD(active, "is light active");
FIELD(type, "type of light");
FIELD(texture, "texture name for image lights");
FIELD(castshadow, "does light cast shadows");
FIELD(bulbradius, "bulb radius, for soft shadows");
FIELD(intensity, "intensity, in candelas");
FIELD(range, "range of effectiveness");
FIELD(attenuation, "OpenGL attenuation (quadratic model)");
FIELD(cutoff, "OpenGL cutoff");
FIELD(exponent, "OpenGL exponent");
FIELD(ambient, "ambient color");
FIELD(diffuse, "diffuse color");
FIELD(specular, "specular color");
FIELD(info, "message appended to compiler errorsx");
break;
}
case mjOBJ_CAMERA: {
mjsCamera* camera = mjs_asCamera(element);
table("pos", camera->pos, "position");
table("quat", camera->quat, "alt", camera->alt, "orientation");
table("mode", camera->mode, "tracking mode");
table("targetbody", camera->targetbody, "target body for tracking/targeting");
table("proj", camera->proj, "camera projection type");
table("resolution", camera->resolution, "resolution (pixel)");
table("output", camera->output, "bit flags for output type");
table("fovy", camera->fovy, "y-field of view");
table("ipd", camera->ipd, "inter-pupillary distance");
table("intrinsic", camera->intrinsic, "camera intrinsics (length)");
table("sensor_size", camera->sensor_size, "sensor size (length)");
table("focal_length", camera->focal_length, "focal length (length)");
table("focal_pixel", camera->focal_pixel, "focal length (pixel)");
table("principal_length", camera->principal_length, "principal point (length)");
table("principal_pixel", camera->principal_pixel, "principal point (pixel)");
table("info", camera->info, "message appended to compiler errors");
mjsCamera* elem = mjs_asCamera(element);
mjsCamera* ref = mjs_asCamera(ref_element);
FIELD(pos, "position");
QFIELD(quat, alt, "orientation");
FIELD(mode, "tracking mode");
FIELD(targetbody, "target body for tracking/targeting");
FIELD(proj, "camera projection type");
FIELD(resolution, "resolution (pixel)");
FIELD(output, "bit flags for output type");
FIELD(fovy, "y-field of view");
FIELD(ipd, "inter-pupillary distance");
FIELD(intrinsic, "camera intrinsics (length)");
FIELD(sensor_size, "sensor size (length)");
FIELD(focal_length, "focal length (length)");
FIELD(focal_pixel, "focal length (pixel)");
FIELD(principal_length, "principal point (length)");
FIELD(principal_pixel, "principal point (pixel)");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_MESH: {
mjsMesh* mesh = mjs_asMesh(element);
table("content_type", mesh->content_type, "content type of file");
table("file", mesh->file, "mesh file");
table("refpos", mesh->refpos, "reference position");
table("refquat", mesh->refquat, "reference orientation");
table("scale", mesh->scale, "rescale mesh");
table("inertia", mesh->inertia, "inertia type (convex, legacy, exact, shell)");
table("smoothnormal", mesh->smoothnormal, "do not exclude large-angle faces from normals");
table("needsdf", mesh->needsdf, "compute sdf from mesh");
table("maxhullvert", mesh->maxhullvert, "maximum vertex count for the convex hull");
table("material", mesh->material, "name of material");
table("info", mesh->info, "message appended to compiler errors");
mjsMesh* elem = mjs_asMesh(element);
mjsMesh* ref = mjs_asMesh(ref_element);
FIELD(content_type, "content type of file");
FIELD(file, "mesh file");
FIELD(refpos, "reference position");
FIELD(refquat, "reference orientation");
FIELD(scale, "rescale mesh");
FIELD(inertia, "inertia type (convex, legacy, exact, shell)");
FIELD(smoothnormal, "do not exclude large-angle faces from normals");
FIELD(needsdf, "compute sdf from mesh");
FIELD(maxhullvert, "maximum vertex count for the convex hull");
FIELD(material, "name of material");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_HFIELD: {
mjsHField* hfield = mjs_asHField(element);
table("content_type", hfield->content_type, "content type of file");
table("file", hfield->file, "file: (nrow, ncol, [elevation data])");
table("size", hfield->size, "hfield size (ignore referencing geom size)");
table("nrow", hfield->nrow, "number of rows");
table("ncol", hfield->ncol, "number of columns");
table("info", hfield->info, "message appended to compiler errors");
mjsHField* elem = mjs_asHField(element);
mjsHField* ref = mjs_asHField(ref_element);
FIELD(content_type, "content type of file");
FIELD(file, "file: (nrow, ncol, [elevation data])");
FIELD(size, "hfield size (ignore referencing geom size)");
FIELD(nrow, "number of rows");
FIELD(ncol, "number of columns");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_SKIN: {
mjsSkin* skin = mjs_asSkin(element);
table("file", skin->file, "skin file");
table("material", skin->material, "name of material used for rendering");
table("rgba", skin->rgba, "rgba when material is omitted");
table("inflate", skin->inflate, "inflate in normal direction");
table("group", skin->group, "group for visualization");
table("info", skin->info, "message appended to compiler errors");
mjsSkin* elem = mjs_asSkin(element);
mjsSkin* ref = mjs_asSkin(ref_element);
FIELD(file, "skin file");
FIELD(material, "name of material used for rendering");
FIELD(rgba, "rgba when material is omitted");
FIELD(inflate, "inflate in normal direction");
FIELD(group, "group for visualization");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_FLEX: {
mjsFlex* flex = mjs_asFlex(element);
table("contype", flex->contype, "contact type");
table("conaffinity", flex->conaffinity, "contact affinity");
table("condim", flex->condim, "contact dimensionality");
table("priority", flex->priority, "contact priority");
table("friction", flex->friction, "one-sided friction coefficients: slide, roll, spin");
table("solmix", flex->solmix, "solver mixing for contact pairs");
table("solref", flex->solref, "solver reference");
table("solimp", flex->solimp, "solver impedance");
table("margin", flex->margin, "margin for contact detection");
table("gap", flex->gap, "include in solver if dist<margin-gap");
table("dim", flex->dim, "element dimensionality");
table("radius", flex->radius, "radius around primitive element");
table("size", flex->size, "vertex bounding box half sizes in qpos0");
table("internal", flex->internal, "enable internal collisions");
table("flatskin", flex->flatskin, "render flex skin with flat shading");
table("selfcollide", flex->selfcollide, "mode for flex self collision");
table("vertcollide", flex->vertcollide, "mode for vertex collision");
table("passive", flex->passive, "mode for passive collisions");
table("activelayers", flex->activelayers, "number of active element layers in 3D");
table("group", flex->group, "group for visualization");
table("edgestiffness", flex->edgestiffness, "edge stiffness");
table("edgedamping", flex->edgedamping, "edge damping");
table("rgba", flex->rgba, "rgba when material is omitted");
table("material", flex->material, "name of material used for rendering");
table("young", flex->young, "Young's modulus");
table("poisson", flex->poisson, "Poisson's ratio");
table("damping", flex->damping, "Rayleigh's damping");
table("thickness", flex->thickness, "thickness (2D only)");
table("elastic2d", flex->elastic2d, "2D passive forces; 0: none, 1: bending, 2: stretching, 3: both");
table("info", flex->info, "message appended to compiler errors");
mjsFlex* elem = mjs_asFlex(element);
mjsFlex* ref = mjs_asFlex(ref_element);
FIELD(contype, "contact type");
FIELD(conaffinity, "contact affinity");
FIELD(condim, "contact dimensionality");
FIELD(priority, "contact priority");
FIELD(friction, "one-sided friction coefficients: slide, roll, spin");
FIELD(solmix, "solver mixing for contact pairs");
FIELD(solref, "solver reference");
FIELD(solimp, "solver impedance");
FIELD(margin, "margin for contact detection");
FIELD(gap, "include in solver if dist<margin-gap");
FIELD(dim, "element dimensionality");
FIELD(radius, "radius around primitive element");
FIELD(size, "vertex bounding box half sizes in qpos0");
FIELD(internal, "enable internal collisions");
FIELD(flatskin, "render flex skin with flat shading");
FIELD(selfcollide, "mode for flex self collision");
FIELD(vertcollide, "mode for vertex collision");
FIELD(passive, "mode for passive collisions");
FIELD(activelayers, "number of active element layers in 3D");
FIELD(group, "group for visualization");
FIELD(edgestiffness, "edge stiffness");
FIELD(edgedamping, "edge damping");
FIELD(rgba, "rgba when material is omitted");
FIELD(material, "name of material used for rendering");
FIELD(young, "Young's modulus");
FIELD(poisson, "Poisson's ratio");
FIELD(damping, "Rayleigh's damping");
FIELD(thickness, "thickness (2D only)");
FIELD(elastic2d, "2D passive forces; 0: none, 1: bending, 2: stretching, 3: both");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_TENDON: {
mjsTendon* tendon = mjs_asTendon(element);
table("stiffness", tendon->stiffness, "stiffness coefficient");
table("springlength", tendon->springlength, "spring resting length; {-1, -1}: use qpos_spring");
table("damping", tendon->damping, "damping coefficient");
table("frictionloss", tendon->frictionloss, "friction loss");
table("solref_friction", tendon->solref_friction, "solver reference: tendon friction");
table("solimp_friction", tendon->solimp_friction, "solver impedance: tendon friction");
table("armature", tendon->armature, "inertia associated with tendon velocity");
table("limited", tendon->limited, "does tendon have limits (mjtLimited)");
table("actfrclimited", tendon->actfrclimited, "does tendon have actuator force limits");
table("range", tendon->range, "length limits");
table("actfrcrange", tendon->actfrcrange, "actuator force limits");
table("margin", tendon->margin, "margin value for tendon limit detection");
table("solref_limit", tendon->solref_limit, "solver reference: tendon limits");
table("solimp_limit", tendon->solimp_limit, "solver impedance: tendon limits");
table("material", tendon->material, "name of material for rendering");
table("width", tendon->width, "width for rendering");
table("rgba", tendon->rgba, "rgba when material is omitted");
table("group", tendon->group, "group");
table("info", tendon->info, "message appended to errors");
mjsTendon* elem = mjs_asTendon(element);
mjsTendon* ref = mjs_asTendon(ref_element);
FIELD(stiffness, "stiffness coefficient");
FIELD(springlength, "spring resting length; {-1, -1}: use qpos_spring");
FIELD(damping, "damping coefficient");
FIELD(frictionloss, "friction loss");
FIELD(solref_friction, "solver reference: tendon friction");
FIELD(solimp_friction, "solver impedance: tendon friction");
FIELD(armature, "inertia associated with tendon velocity");
FIELD(limited, "does tendon have limits (mjtLimited)");
FIELD(actfrclimited, "does tendon have actuator force limits");
FIELD(range, "length limits");
FIELD(actfrcrange, "actuator force limits");
FIELD(margin, "margin value for tendon limit detection");
FIELD(solref_limit, "solver reference: tendon limits");
FIELD(solimp_limit, "solver impedance: tendon limits");
FIELD(material, "name of material for rendering");
FIELD(width, "width for rendering");
FIELD(rgba, "rgba when material is omitted");
FIELD(group, "group");
FIELD(info, "message appended to errors");
break;
}
case mjOBJ_TEXTURE: {
mjsTexture* texture = mjs_asTexture(element);
table("type", texture->type, "texture type");
table("colorspace", texture->colorspace, "colorspace");
table("builtin", texture->builtin, "builtin type (mjtBuiltin)");
table("mark", texture->mark, "mark type (mjtMark)");
table("rgb1", texture->rgb1, "first color for builtin");
table("rgb2", texture->rgb2, "second color for builtin");
table("markrgb", texture->markrgb, "mark color");
table("random", texture->random, "probability of random dots");
table("height", texture->height, "height in pixels (square for cube and skybox)");
table("width", texture->width, "width in pixels");
table("nchannel", texture->nchannel, "number of channels");
table("content_type", texture->content_type, "content type of file");
table("file", texture->file, "png file to load; use for all sides of cube");
table("gridsize", texture->gridsize, "size of grid for composite file; (1,1)-repeat");
table("gridlayout", texture->gridlayout, "row-major: L,R,F,B,U,D for faces; . for unused");
table("cubefiles", texture->cubefiles, "different file for each side of the cube");
table("hflip", texture->hflip, "horizontal flip");
table("vflip", texture->vflip, "vertical flip");
table("info", texture->info, "message appended to compiler errors");
mjsTexture* elem = mjs_asTexture(element);
mjsTexture* ref = mjs_asTexture(ref_element);
FIELD(type, "texture type");
FIELD(colorspace, "colorspace");
FIELD(builtin, "builtin type (mjtBuiltin)");
FIELD(mark, "mark type (mjtMark)");
FIELD(rgb1, "first color for builtin");
FIELD(rgb2, "second color for builtin");
FIELD(markrgb, "mark color");
FIELD(random, "probability of random dots");
FIELD(height, "height in pixels (square for cube and skybox)");
FIELD(width, "width in pixels");
FIELD(nchannel, "number of channels");
FIELD(content_type, "content type of file");
FIELD(file, "png file to load; use for all sides of cube");
FIELD(gridsize, "size of grid for composite file; (1,1)-repeat");
FIELD(gridlayout, "row-major: L,R,F,B,U,D for faces; . for unused");
FIELD(cubefiles, "different file for each side of the cube");
FIELD(hflip, "horizontal flip");
FIELD(vflip, "vertical flip");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_MATERIAL: {
mjsMaterial* material = mjs_asMaterial(element);
table("textures", material->textures, "names of textures (empty: none)");
table("texuniform", material->texuniform, "make texture cube uniform");
table("texrepeat", material->texrepeat, "texture repetition for 2D mapping");
table("emission", material->emission, "emission");
table("specular", material->specular, "specular");
table("shininess", material->shininess, "shininess");
table("reflectance", material->reflectance, "reflectance");
table("metallic", material->metallic, "metallic");
table("roughness", material->roughness, "roughness");
table("rgba", material->rgba, "rgba");
table("info", material->info, "message appended to compiler errors");
mjsMaterial* elem = mjs_asMaterial(element);
mjsMaterial* ref = mjs_asMaterial(ref_element);
FIELD(textures, "names of textures (empty: none)");
FIELD(texuniform, "make texture cube uniform");
FIELD(texrepeat, "texture repetition for 2D mapping");
FIELD(emission, "emission");
FIELD(specular, "specular");
FIELD(shininess, "shininess");
FIELD(reflectance, "reflectance");
FIELD(metallic, "metallic");
FIELD(roughness, "roughness");
FIELD(rgba, "rgba");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_PAIR: {
mjsPair* pair = mjs_asPair(element);
table("geomname1", pair->geomname1, "name of geom 1");
table("geomname2", pair->geomname2, "name of geom 2");
table("condim", pair->condim, "contact dimensionality");
table("solref", pair->solref, "solver reference, normal direction");
table("solreffriction", pair->solreffriction, "solver reference, frictional directions");
table("solimp", pair->solimp, "solver impedance");
table("margin", pair->margin, "margin for contact detection");
table("gap", pair->gap, "include in solver if dist<margin-gap");
table("friction", pair->friction, "full contact friction");
table("info", pair->info, "message appended to errors");
mjsPair* elem = mjs_asPair(element);
mjsPair* ref = mjs_asPair(ref_element);
FIELD(geomname1, "name of geom 1");
FIELD(geomname2, "name of geom 2");
FIELD(condim, "contact dimensionality");
FIELD(solref, "solver reference, normal direction");
FIELD(solreffriction, "solver reference, frictional directions");
FIELD(solimp, "solver impedance");
FIELD(margin, "margin for contact detection");
FIELD(gap, "include in solver if dist<margin-gap");
FIELD(friction, "full contact friction");
FIELD(info, "message appended to errors");
break;
}
case mjOBJ_EQUALITY: {
mjsEquality* equality = mjs_asEquality(element);
table("type", equality->type, "constraint type");
table("data", equality->data, "type-dependent data");
table("active", equality->active, "is equality initially active");
table("name1", equality->name1, "name of object 1");
table("name2", equality->name2, "name of object 2");
table("objtype", equality->objtype, "type of both objects");
table("solref", equality->solref, "solver reference");
table("solimp", equality->solimp, "solver impedance");
table("info", equality->info, "message appended to errors");
mjsEquality* elem = mjs_asEquality(element);
mjsEquality* ref = mjs_asEquality(ref_element);
FIELD(type, "constraint type");
FIELD(data, "type-dependent data");
FIELD(active, "is equality initially active");
FIELD(name1, "name of object 1");
FIELD(name2, "name of object 2");
FIELD(objtype, "type of both objects");
FIELD(solref, "solver reference");
FIELD(solimp, "solver impedance");
FIELD(info, "message appended to errors");
break;
}
case mjOBJ_EXCLUDE: {
mjsExclude* exclude = mjs_asExclude(element);
table("bodyname1", exclude->bodyname1, "name of geom 1");
table("bodyname2", exclude->bodyname2, "name of geom 2");
table("info", exclude->info, "message appended to errors");
mjsExclude* elem = mjs_asExclude(element);
mjsExclude* ref = mjs_asExclude(ref_element);
FIELD(bodyname1, "name of geom 1");
FIELD(bodyname2, "name of geom 2");
FIELD(info, "message appended to errors");
break;
}
case mjOBJ_NUMERIC: {
mjsNumeric* numeric = mjs_asNumeric(element);
table("data", numeric->data, "initialization data");
table("size", numeric->size, "array size, can be bigger than data size");
table("info", numeric->info, "message appended to errors");
mjsNumeric* elem = mjs_asNumeric(element);
mjsNumeric* ref = mjs_asNumeric(ref_element);
FIELD(data, "initialization data");
FIELD(size, "array size, can be bigger than data size");
FIELD(info, "message appended to errors");
break;
}
case mjOBJ_TEXT: {
mjsText* text = mjs_asText(element);
table("data", text->data, "text string");
table("info", text->info, "message appended to compiler errors");
mjsText* elem = mjs_asText(element);
mjsText* ref = mjs_asText(ref_element);
FIELD(data, "text string");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_TUPLE: {
mjsTuple* tuple = mjs_asTuple(element);
table("objtype", tuple->objtype, "object types");
table("objname", tuple->objname, "object names");
table("objprm", tuple->objprm, "object parameters");
table("info", tuple->info, "message appended to compiler errors");
mjsTuple* elem = mjs_asTuple(element);
mjsTuple* ref = mjs_asTuple(ref_element);
FIELD(objtype, "object types");
FIELD(objname, "object names");
FIELD(objprm, "object parameters");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_KEY: {
mjsKey* key = mjs_asKey(element);
table("time", key->time, "time");
table("qpos", key->qpos, "qpos");
table("qvel", key->qvel, "qvel");
table("act", key->act, "act");
table("mpos", key->mpos, "mocap pos");
table("mquat", key->mquat, "mocap quat");
table("ctrl", key->ctrl, "ctrl");
table("info", key->info, "message appended to compiler errors");
mjsKey* elem = mjs_asKey(element);
mjsKey* ref = mjs_asKey(ref_element);
FIELD(time, "time");
FIELD(qpos, "qpos");
FIELD(qvel, "qvel");
FIELD(act, "act");
FIELD(mpos, "mocap pos");
FIELD(mquat, "mocap quat");
FIELD(ctrl, "ctrl");
FIELD(info, "message appended to compiler errors");
break;
}
case mjOBJ_PLUGIN: {
mjsPlugin* plugin = mjs_asPlugin(element);
table("name", plugin->name, "instance name");
table("plugin_name", plugin->plugin_name, "plugin name");
table("active", plugin->active, "is the plugin active");
table("info", plugin->info, "message appended to compiler errors");
mjsPlugin* elem = mjs_asPlugin(element);
mjsPlugin* ref = mjs_asPlugin(ref_element);
FIELD(name, "instance name");
FIELD(plugin_name, "plugin name");
FIELD(active, "is the plugin active");
FIELD(info, "message appended to compiler errors");
break;
}
default:
// ignore other types
break;
}
#undef FIELD
return table.WasModified();
}
void ElementModelGui(const mjModel* model, mjsElement* element) {
src/experimental/platform/gui_spec.h
+24 -7
View File
@@ -15,21 +15,38 @@
#ifndef MUJOCO_SRC_EXPERIMENTAL_PLATFORM_GUI_SPEC_H_
#define MUJOCO_SRC_EXPERIMENTAL_PLATFORM_GUI_SPEC_H_
#include <functional>
#include <string>
#include <mujoco/mujoco.h>
namespace mujoco::platform {
using SpecElementCallbackFn = std::function<void(mjsElement*)>;
// The mode of the spec visualizer.
enum class SpecEditMode {
kPlay,
kEdit,
};
// UX for displaying the spec as a tree.
void SpecExplorerGui(mjsElement** element, mjSpec* spec,
const SpecElementCallbackFn& on_delete);
// Returns the name of the given element.
std::string ElementName(mjsElement* element);
// UX for displaying the properties of an mjSpec element.
void ElementSpecGui(const mjSpec* spec, mjsElement* element);
// Displaying the mjSpec as a tree. `element` is the currently selected
// element and will be updated if a new element is selected. The function
// returns true if the spec was modified in any way.
bool SpecTreeGui(mjsElement** element, mjSpec* spec, SpecEditMode mode);
// Displays the properties of the given element in the table. Returns true if
// any value in the element was changed. The `ref_element` is used to highlight
// when a value differs from a reference element.
bool ElementSpecGui(mjsElement* element, mjsElement* ref_element,
SpecEditMode mode);
// Displays a (read-only) data table of the mjData values that correspond to the
// given element.
void ElementDataGui(const mjData* data, mjsElement* element);
// Displays a (read-only) data table of the mjModel values that correspond to
// the given element.
void ElementModelGui(const mjModel* model, mjsElement* element);
} // namespace mujoco::platform
src/experimental/platform/imgui_widgets.cc
+98 -32
View File
@@ -62,12 +62,17 @@ KeyValues ReadIniSection(const std::string& contents,
}
ImGui_DataPtrTable::ImGui_DataPtrTable(float w1, float w2) {
ImGui::BeginTable("##PropertiesTable", 2);
ImGui::BeginTable("##PropertiesTable", 2,
ImGuiTableFlags_RowBg);
const float width = ImGui::GetContentRegionAvail().x;
ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed, width * w1);
ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed, width * w2);
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(3.0f, 0.0f));
}
ImGui_DataPtrTable::~ImGui_DataPtrTable() {
ImGui::PopStyleVar();
ImGui::EndTable();
}
ImGui_DataPtrTable::~ImGui_DataPtrTable() { ImGui::EndTable(); }
void ImGui_DataPtrTable::SetPrefix(const char* prefix) {
prefix_ = strlen(prefix);
@@ -206,44 +211,50 @@ void ImGui_DataPtrTable::MakeLabel(const char* label, int index, int total) {
}
void ImGui_SpecElementTable::operator()(const char* label, mjtByte& val,
const mjtByte& ref,
const char* tooltip) {
MakeLabel(label);
ImGui::SetItemTooltip("%s", tooltip);
ImGui::Text("%s", val ? "true" : "false");
Label(label, tooltip);
Input(val, ref);
}
void ImGui_SpecElementTable::operator()(const char* label, mjtSize& val,
const mjtSize& ref,
const char* tooltip) {
Scalar(label, val, tooltip);
Label(label, tooltip);
Input(val, ref);
}
void ImGui_SpecElementTable::operator()(const char* label, int& val,
const char* tooltip) {
Scalar(label, val, tooltip);
const int& ref, const char* tooltip) {
Label(label, tooltip);
Input(val, ref);
}
void ImGui_SpecElementTable::operator()(const char* label, float& val,
const char* tooltip) {
Scalar(label, val, tooltip);
const float& ref, const char* tooltip) {
Label(label, tooltip);
Input(val, ref);
}
void ImGui_SpecElementTable::operator()(const char* label, double& val,
const double& ref,
const char* tooltip) {
Scalar(label, val, tooltip);
Label(label, tooltip);
Input(val, ref);
}
void ImGui_SpecElementTable::operator()(const char* label, std::string* ptr,
const std::string* ref,
const char* tooltip) {
MakeLabel(label);
ImGui::SetItemTooltip("%s", tooltip);
ImGui::Text("%s", ptr ? ptr->c_str() : "");
Label(label, tooltip);
Input(*ptr, *ref);
}
void ImGui_SpecElementTable::operator()(const char* label,
std::vector<int>* ptr,
const std::vector<int>* ref,
const char* tooltip) {
MakeLabel(label);
ImGui::SetItemTooltip("%s", tooltip);
Label(label, tooltip);
if (ptr == nullptr || ptr->empty()) {
ImGui::Text("[empty]");
} else {
@@ -253,9 +264,9 @@ void ImGui_SpecElementTable::operator()(const char* label,
void ImGui_SpecElementTable::operator()(const char* label,
std::vector<double>* ptr,
const std::vector<double>* ref,
const char* tooltip) {
MakeLabel(label);
ImGui::SetItemTooltip("%s", tooltip);
Label(label, tooltip);
if (ptr == nullptr || ptr->empty()) {
ImGui::Text("[empty]");
} else {
@@ -265,41 +276,49 @@ void ImGui_SpecElementTable::operator()(const char* label,
void ImGui_SpecElementTable::operator()(const char* label,
std::vector<std::string>* ptr,
const std::vector<std::string>* ref,
const char* tooltip) {
for (int i = 0; i < ptr->size(); ++i) {
MakeLabel(label, i, ptr->size());
ImGui::SetItemTooltip("%s", tooltip);
ImGui::Text("%s", ptr->at(i).c_str());
Label(label, tooltip, i, ptr->size());
Input(ptr->at(i));
}
}
void ImGui_SpecElementTable::operator()(const char* name, double (&quat)[4],
const char* alt,
mjsOrientation& orientation,
void ImGui_SpecElementTable::operator()(const char* name, const char* alt_name,
double (&quat)[4],
const double (&ref_quat)[4],
mjsOrientation& alt,
const mjsOrientation& ref_alt,
const char* tooltip) {
auto alt_name = [&](const char* label) {
return std::string(alt) + "." + label;
auto aname = [&](const char* label) {
return std::string(alt_name) + "." + label;
};
switch (orientation.type) {
switch (alt.type) {
case mjORIENTATION_QUAT:
(*this)(name, quat, tooltip);
(*this)(name, quat, ref_quat, tooltip);
break;
case mjORIENTATION_AXISANGLE:
(*this)(alt_name("axisangle").c_str(), orientation.axisangle, tooltip);
(*this)(aname("axisangle").c_str(), alt.axisangle, ref_alt.axisangle, tooltip);
break;
case mjORIENTATION_XYAXES:
(*this)(alt_name("xyaxes").c_str(), orientation.xyaxes, tooltip);
(*this)(aname("xyaxes").c_str(), alt.xyaxes, ref_alt.xyaxes, tooltip);
break;
case mjORIENTATION_ZAXIS:
(*this)(alt_name("zaxis").c_str(), orientation.zaxis, tooltip);
(*this)(aname("zaxis").c_str(), alt.zaxis, ref_alt.zaxis, tooltip);
break;
case mjORIENTATION_EULER:
(*this)(alt_name("euler").c_str(), orientation.euler, tooltip);
(*this)(aname("euler").c_str(), alt.euler, ref_alt.euler, tooltip);
break;
}
}
void ImGui_SpecElementTable::Label(const char* label, const char* tooltip,
int i, int n) {
MakeLabel(label, i, n);
ImGui::SetItemTooltip("%s", tooltip);
}
bool ImGui_Slider(const char* name, mjtNum* value, mjtNum min, mjtNum max) {
float f = *value;
const bool res = ImGui::SliderFloat(name, &f, min, max);
@@ -309,6 +328,53 @@ bool ImGui_Slider(const char* name, mjtNum* value, mjtNum min, mjtNum max) {
return res;
}
bool ImGui_BeginHSplit(const char* id, float* height, bool* open) {
const ImVec2 region = ImGui::GetContentRegionAvail();
if (*height < 0) {
*height = region.y / 2;
}
// If the split is closed, use the full region height.
const float h = *open ? *height : region.y;
return ImGui::BeginChild(id, ImVec2(0, h), 0);
}
bool ImGui_HSplit(const char* id, float* height, bool* open) {
// End the parent child.
ImGui::EndChild();
const ImVec2 region = ImGui::GetContentRegionAvail();
if (*open) {
// Just to make the splitter bar centered.
ImGui::InvisibleButton("##empty", ImVec2(10.0f, 8.0f));
// The splitter bar; drag to change the height.
ImGui::SameLine();
ImGui::Button(id, ImVec2(region.x - 30.0f, 8.0f));
if (ImGui::IsItemActive()) {
*height += ImGui::GetIO().MouseDelta.y;
if (*height < 0) *height = 0;
}
// The collapse button.
ImGui::SameLine();
if (ImGui::Button("x", ImVec2(10.0f, 8.0f))) {
*open = false;
}
}
if (*open) {
return ImGui::BeginChild(id, ImVec2(region.x, 0), 1);
} else {
return false;
}
}
void ImGui_EndHSplit(bool open) {
if (open) {
ImGui::EndChild();
}
}
void MaybeSaveToClipboard(const std::string& contents) {
if (ImGui::GetIO().SetClipboardTextFn) {
ImGui::GetIO().SetClipboardTextFn(nullptr, contents.c_str());
src/experimental/platform/imgui_widgets.h
+178 -56
View File
@@ -26,6 +26,7 @@
#include <imgui.h>
#include <imgui_internal.h>
#include "third_party/dear_imgui/misc/cpp/imgui_stdlib.h"
#include <mujoco/mujoco.h>
#include "experimental/platform/enum_utils.h"
@@ -38,18 +39,20 @@ static constexpr const char ICON_FA_CAMERA[] = "\xEF\x80\xBD";
static constexpr const char ICON_FA_CARET_LEFT[] = "\xEF\x83\x99";
static constexpr const char ICON_FA_CARET_RIGHT[] = "\xEF\x83\x9A";
static constexpr const char ICON_FA_CHECK_SQUARE_O[] = "\xEF\x81\x9D";
static constexpr const char ICON_FA_CIRCLE[] = "\xEF\x84\x91";
static constexpr const char ICON_FA_CIRCLE_O[] = "\xEF\x84\x8C";
static constexpr const char ICON_FA_CIRCLE[] = "\xEF\x84\x91";
static constexpr const char ICON_FA_COMMENT[] = "\xEF\x83\xA5";
static constexpr const char ICON_FA_COPY[] = "\xEF\x83\x85";
static constexpr const char ICON_FA_DIAMOND[] = "\xEF\x88\x99";
static constexpr const char ICON_FA_EJECT[] = "\xEF\x81\x92";
static constexpr const char ICON_FA_FAST_FORWARD[] = "\xEF\x81\x90";
static constexpr const char ICON_FA_MOON[] = "\xEF\x86\x86";
static constexpr const char ICON_FA_MAGIC[] = "\xEF\x83\x90";
static constexpr const char ICON_FA_MOON[] = "\xEF\x86\x86";
static constexpr const char ICON_FA_PAUSE[] = "\xEF\x81\x8C";
static constexpr const char ICON_FA_PLAY[] = "\xEF\x81\x8B";
static constexpr const char ICON_FA_PLUS[] = "\xEF\x81\xA7";
static constexpr const char ICON_FA_REFRESH[] = "\xEF\x80\xA1";
static constexpr const char ICON_FA_REPEAT[] = "\xEF\x80\x9E";
static constexpr const char ICON_FA_SQUARE_O[] = "\xEF\x87\x9B";
static constexpr const char ICON_FA_SUN[] = "\xEF\x86\x85";
static constexpr const char ICON_FA_TACHOMETER[] = "\xEF\x83\xA4";
@@ -62,6 +65,9 @@ using KeyValues = std::unordered_map<std::string, std::string>;
template <typename T>
struct dependent_false : std::false_type {};
template <typename T>
bool ImGui_Checkbox(const char* name, T& value);
// Appends key/value pairs to an Ini file.
void AppendIniSection(std::string& ini, const std::string& section,
const KeyValues& key_values);
@@ -193,93 +199,209 @@ class ImGui_DataPtrTable {
// Helper for displaying mjSpec elements in an ImGui table.
class ImGui_SpecElementTable : public ImGui_DataPtrTable {
public:
explicit ImGui_SpecElementTable(bool read_only = true)
: read_only_(read_only) {
}
// Scalar values used by mjSpec elements.
void operator()(const char* label, mjtByte& val, const char* tooltip);
void operator()(const char* label, mjtSize& val, const char* tooltip);
void operator()(const char* label, int& val, const char* tooltip);
void operator()(const char* label, float& val, const char* tooltip);
void operator()(const char* label, double& val, const char* tooltip);
void operator()(const char* label, mjtByte& val, const mjtByte& ref,
const char* tooltip);
void operator()(const char* label, mjtSize& val, const mjtSize& ref,
const char* tooltip);
void operator()(const char* label, int& val, const int& ref,
const char* tooltip);
void operator()(const char* label, float& val, const float& ref,
const char* tooltip);
void operator()(const char* label, double& val, const double& ref,
const char* tooltip);
// C++ container values used by mjSpec elements.
void operator()(const char* label, std::string* ptr, const char* tooltip);
void operator()(const char* label, std::string* ptr, const std::string* ref,
const char* tooltip);
void operator()(const char* label, std::vector<int>* ptr,
const char* tooltip);
const std::vector<int>* ref, const char* tooltip);
void operator()(const char* label, std::vector<double>* ptr,
const char* tooltip);
const std::vector<double>* ref, const char* tooltip);
void operator()(const char* label, std::vector<std::string>* ptr,
const char* tooltip);
const std::vector<std::string>* ref, const char* tooltip);
// C-style array values used by mjSpec elements.
template <std::size_t N>
void operator()(const char* label, char (&val)[N], const char* tooltip) {
MakeLabel(label);
ImGui::SetItemTooltip("%s", tooltip);
ImGui::Text("%s", std::string(val, N).c_str());
}
template <std::size_t N>
void operator()(const char* label, mjtByte (&val)[N], const char* tooltip) {
void operator()(const char* label, int (&val)[N], const int (&ref)[N],
const char* tooltip) {
for (int i = 0; i < N; ++i) {
MakeLabel(label, i, N);
ImGui::SetItemTooltip("%s", tooltip);
ImGui::Text("%s", val[i] ? "true" : "false");
Label(label, tooltip, i, N);
Input(val[i], ref[i]);
}
}
template <std::size_t N>
void operator()(const char* label, int (&val)[N], const char* tooltip) {
Vector(label, val, N, tooltip);
void operator()(const char* label, float (&val)[N], const float (&ref)[N],
const char* tooltip) {
for (int i = 0; i < N; ++i) {
Label(label, tooltip, i, N);
Input(val[i], ref[i]);
}
}
template <std::size_t N>
void operator()(const char* label, float (&val)[N], const char* tooltip) {
Vector(label, val, N, tooltip);
void operator()(const char* label, double (&val)[N], const double (&ref)[N],
const char* tooltip) {
for (int i = 0; i < N; ++i) {
Label(label, tooltip, i, N);
Input(val[i], ref[i]);
}
}
// Special handling for fixed-length character arrays.
template <std::size_t N>
void operator()(const char* label, double (&val)[N], const char* tooltip) {
Vector(label, val, N, tooltip);
void operator()(const char* label, char (&val)[N], const char (&ref)[N],
const char* tooltip) {
Label(label, tooltip);
char buf[N + 1];
strncpy(buf, val, N);
buf[N] = 0;
if (read_only_) {
ImGui::Text("%s", buf);
} else {
ImGui::PushID(&val);
if (ImGui::InputText("##", buf, N + 1)) {
strncpy(val, buf, N);
modified_ = true;
}
ImGui::PopID();
}
}
// Special handling for treating enum values as integers.
template <typename T, typename U=std::enable_if_t<std::is_enum_v<T>, T>>
void operator()(const char* label, T& val, const char* tooltip) {
auto v = enum_utils::enum_to_string(val);
MakeLabel(label);
ImGui::SetItemTooltip("%s", tooltip);
ImGui::Text("%s", v.data());
void operator()(const char* label, T& val, const T& ref, const char* tooltip) {
Label(label, tooltip);
Input(val, ref);
}
// Special handling for quaternion/orientation pairs.
void operator()(const char* name, double (&quat)[4], const char* alt,
mjsOrientation& orientation, const char* tooltip);
void operator()(const char* name, const char* alt_name, double (&quat)[4],
const double (&ref_quat)[4], mjsOrientation& alt,
const mjsOrientation& ref_alt, const char* tooltip);
// Returns true if any value in the table was modified.
bool WasModified() const { return modified_; }
private:
template <typename T>
void Scalar(const char* label, T& val, const char* tooltip) {
MakeLabel(label);
ImGui::SetItemTooltip("%s", tooltip);
if constexpr (std::is_enum_v<T>) {
ImGui::Text("%d", (int)val);
} else if constexpr (std::is_integral_v<T>) {
ImGui::Text("%d", (int)val);
} else if constexpr (std::is_floating_point_v<T>) {
ImGui::Text("%f", (float)val);
}
}
void Label(const char* label, const char* tooltip, int i = 0, int n = 1);
template <typename T>
void Vector(const char* label, T* ptr, int n, const char* tooltip) {
for (int i = 0; i < n; ++i) {
MakeLabel(label, i, n);
ImGui::SetItemTooltip("%s", tooltip);
if constexpr (std::is_enum_v<T>) {
ImGui::Text("%d", (int)ptr[i]);
} else if constexpr (std::is_integral_v<T>) {
ImGui::Text("%d", (int)ptr[i]);
} else if constexpr (std::is_floating_point_v<T>) {
ImGui::Text("%f", (float)ptr[i]);
void Input(T& val, const T& ref = T()) {
ScopedStyle style;
if (!read_only_ && val != ref) {
constexpr ImVec4 kModifiedColor = ImVec4(1.0f, 0.6f, 0.2f, 1.0f);
style.Color(ImGuiCol_Text, kModifiedColor);
}
ImGui::PushID(&val);
ImGui::SetNextItemWidth(-1.0f);
if constexpr (std::is_same_v<T, mjtByte>) {
if (read_only_) {
ImGui::Text("%s", val ? "true" : "false");
} else {
const int flags = ImGuiComboFlags_NoArrowButton;
if (ImGui::BeginCombo("##", val ? "true" : "false", flags)) {
if (ImGui::Selectable("true", val != 0)) {
val = 1;
modified_ = true;
}
if (ImGui::Selectable("false", val == 0)) {
val = 0;
modified_ = true;
}
ImGui::EndCombo();
}
}
} else if constexpr (std::is_enum_v<T>) {
const std::string preview(enum_utils::enum_to_string(val));
if (read_only_) {
ImGui::Text("%s", preview.c_str());
} else {
const int flags = ImGuiComboFlags_NoArrowButton;
if (ImGui::BeginCombo("##", preview.c_str(), flags)) {
for (const auto& [v, n] : enum_utils::entries_v<T>) {
if (ImGui::Selectable(std::string(n).c_str(), val == v)) {
val = v;
modified_ = true;
}
}
ImGui::EndCombo();
}
}
} else if constexpr (std::is_same_v<T, int>) {
if (read_only_) {
ImGui::Text("%d", val);
} else {
if (ImGui::InputInt("##", &val)) {
modified_ = true;
}
}
} else if constexpr (std::is_same_v<T, float>) {
if (read_only_) {
ImGui::Text("%f", val);
} else {
if (ImGui::InputFloat("##", &val)) {
modified_ = true;
}
}
} else if constexpr (std::is_same_v<T, double>) {
if (read_only_) {
ImGui::Text("%f", val);
} else {
if (ImGui::InputDouble("##", &val)) {
modified_ = true;
}
}
} else if constexpr (std::is_same_v<T, int64_t>) {
if (read_only_) {
ImGui::Text("%lld", val);
} else {
if (ImGui::InputScalarN("##", ImGuiDataType_S64, &val, 1)) {
modified_ = true;
}
}
} else if constexpr (std::is_same_v<T, std::string>) {
if (read_only_) {
ImGui::Text("%s", val.c_str());
} else {
if (ImGui::InputText("##", &val)) {
modified_ = true;
}
}
}
if (!read_only_) {
if (ImGui::IsItemClicked(ImGuiMouseButton_Right)) {
val = ref;
modified_ = true;
}
}
ImGui::PopID();
}
bool modified_ = false;
bool read_only_ = false;
};
// ImGui horizontal splitter. `height` is the height of the upper pane.
// `open` is whether the bottom pane is open. Usage is:
//
// if (ImGui_BeginHSplit("top", &height, &open)) {
// // Contents of the upper pane.
// if (ImGui_HSplit("bottom", &height, &open)) {
// // Contents of the bottom pane.
// }
// ImGui_EndHSplit(open);
// }
bool ImGui_BeginHSplit(const char* id, float* height, bool* open);
bool ImGui_HSplit(const char* id, float* height, bool* open);
void ImGui_EndHSplit(bool open);
// ImGui Slider that supports both float and double types.
bool ImGui_Slider(const char* name, mjtNum* value, mjtNum min, mjtNum max);
src/experimental/studio/app.cc
+243 -93
View File
@@ -67,6 +67,7 @@ static void SelectParentPerturb(const mjModel* model, mjvPerturb& perturb) {
perturb.active = 0;
}
}
// TODO: update selected element!
}
static constexpr const char* ICON_PLAY = platform::ICON_FA_PLAY;
@@ -86,7 +87,9 @@ static constexpr const char* ICON_PREV_FRAME = platform::ICON_FA_CARET_LEFT;
static constexpr const char* ICON_NEXT_FRAME = platform::ICON_FA_CARET_RIGHT;
static constexpr const char* ICON_CURR_FRAME = platform::ICON_FA_FAST_FORWARD;
static constexpr const char* ICON_SPEED = platform::ICON_FA_TACHOMETER;
static constexpr const char* ICON_DELETE = platform::ICON_FA_TRASH_CAN;
static constexpr const char* ICON_RELOAD_SPEC = platform::ICON_FA_REFRESH;
static constexpr const char* ICON_UNDO_SPEC = platform::ICON_FA_UNDO;
static constexpr const char* ICON_REDO_SPEC = platform::ICON_FA_REPEAT;
// UI labels for mjtLabel.
static constexpr const char* kLabelNames[] = {
@@ -201,6 +204,9 @@ void App::OnModelLoaded(std::string filename, ModelKind model_kind) {
const int state_size = mj_stateSize(model, mjSTATE_INTEGRATION);
history_.Init(state_size);
// Create a copy of the spec for editing.
CopyLoadedSpecForEditing();
if (!preserve_camera_on_load_) {
const int model_cam = model->vis.global.cameraid;
if (model_cam >= 0 && model_cam < model->ncam) {
@@ -422,44 +428,54 @@ void App::ProcessPendingLoads() {
});
}
void App::SpecSelectElement(mjsElement* element) {
tmp_.element = element;
if (tmp_.element == nullptr) {
tmp_.element_id = -1;
} else {
tmp_.element_id = mjs_getId(tmp_.element);
void App::CopyLoadedSpecForEditing() {
if (scratch_spec_ != nullptr) {
mj_deleteSpec(scratch_spec_);
scratch_spec_ = nullptr;
}
// If we selected a body, then select the same body for perturb.
if (tmp_.element->elemtype == mjOBJ_BODY &&
perturb_.select != tmp_.element_id) {
mjv_defaultPerturb(&perturb_);
perturb_.select = tmp_.element_id;
}
}
}
scratch_spec_modified_ = false;
tmp_.curr_edit_element = nullptr;
void App::SpecDeleteElement(mjsElement* element) {
if (element == nullptr) {
return;
}
// Only bodies can be deleted for now...
if (element->elemtype != mjOBJ_BODY) {
edit_error_ = "WARNING: Only bodies can be deleted (for now...)";
return;
}
spec_op_ = [this, element]() {
mjs_delete(spec(), element);
if (tmp_.element == element) {
tmp_.element = nullptr;
tmp_.element_id = -1;
}
if (element->elemtype == mjOBJ_BODY) {
if (perturb_.select == mjs_getId(element)) {
mjv_defaultPerturb(&perturb_);
if (has_spec()) {
scratch_spec_ = mj_copySpec(spec());
auto add_ref_elements = [&](mjtObj type) {
mjsElement* elem = mjs_firstElement(spec(), type);
mjsElement* scratch = mjs_firstElement(scratch_spec_, type);
while (elem != nullptr && scratch != nullptr) {
scratch_to_spec_[scratch] = elem;
spec_to_scratch_[elem] = scratch;
elem = mjs_nextElement(spec(), elem);
scratch = mjs_nextElement(scratch_spec_, scratch);
}
}
Recompile();
};
};
add_ref_elements(mjOBJ_BODY);
add_ref_elements(mjOBJ_XBODY);
add_ref_elements(mjOBJ_JOINT);
add_ref_elements(mjOBJ_DOF);
add_ref_elements(mjOBJ_GEOM);
add_ref_elements(mjOBJ_SITE);
add_ref_elements(mjOBJ_CAMERA);
add_ref_elements(mjOBJ_LIGHT);
add_ref_elements(mjOBJ_FLEX);
add_ref_elements(mjOBJ_MESH);
add_ref_elements(mjOBJ_SKIN);
add_ref_elements(mjOBJ_HFIELD);
add_ref_elements(mjOBJ_TEXTURE);
add_ref_elements(mjOBJ_MATERIAL);
add_ref_elements(mjOBJ_PAIR);
add_ref_elements(mjOBJ_EXCLUDE);
add_ref_elements(mjOBJ_EQUALITY);
add_ref_elements(mjOBJ_TENDON);
add_ref_elements(mjOBJ_ACTUATOR);
add_ref_elements(mjOBJ_SENSOR);
add_ref_elements(mjOBJ_NUMERIC);
add_ref_elements(mjOBJ_TEXT);
add_ref_elements(mjOBJ_TUPLE);
add_ref_elements(mjOBJ_KEY);
add_ref_elements(mjOBJ_PLUGIN);
}
}
void App::HandleWindowEvents() {
@@ -555,14 +571,12 @@ void App::HandleMouseEvents() {
perturb_.skinselect = picked.skin;
// Select the corresponding element in the spec.
tmp_.element = nullptr;
tmp_.element_id = -1;
tmp_.curr_element = nullptr;
if (has_spec()) {
mjsElement* element = mjs_firstElement(spec(), mjOBJ_BODY);
while (element) {
if (mjs_getId(element) == picked.body) {
tmp_.element = element;
tmp_.element_id = picked.body;
tmp_.curr_element = element;
break;
}
element = mjs_nextElement(spec(), element);
@@ -665,7 +679,7 @@ void App::HandleKeyboardEvents() {
} else if (ImGui_IsChordJustPressed(ImGuiKey_Backspace)) {
ResetPhysics();
} else if (ImGui_IsChordJustPressed(ImGuiKey_Delete)) {
SpecDeleteElement(tmp_.element);
// TODO: SpecDeleteElement(tmp_.curr_element);
} else if (ImGui_IsChordJustPressed(ImGuiKey_PageUp)) {
SelectParentPerturb(model(), perturb_);
} else if (ImGui_IsChordJustPressed(ImGuiKey_F1)) {
@@ -917,19 +931,15 @@ void App::BuildGui() {
}
ImGui::End();
bool explorer_is_open = false;
if (ImGui::Begin("Explorer", &tmp_.inspector_panel)) {
explorer_is_open = true;
SpecExplorerGui();
}
ImGui::End();
if (explorer_is_open && tmp_.element != nullptr) {
if (ImGui::Begin("Properties")) {
SpecPropertiesGui();
}
ImGui::End();
if (ImGui::Begin("Editor", &tmp_.inspector_panel)) {
SpecEditorGui();
}
ImGui::End();
}
if (tmp_.chart_performance) {
@@ -1165,56 +1175,196 @@ void App::SpecExplorerGui() {
return;
}
auto on_delete = [this](mjsElement* element) { SpecDeleteElement(element); };
mjsElement* element = tmp_.element;
platform::SpecExplorerGui(&element, spec(), on_delete);
if (element != tmp_.element) {
SpecSelectElement(element);
// Initialize the split height.
const ImVec2 region = ImGui::GetContentRegionAvail();
if (tmp_.explorer_split < 0) {
tmp_.explorer_split = region.y * 0.7f;
}
tmp_.explorer_split = std::clamp(tmp_.explorer_split, 20.f, region.y - 40.f);
mjsElement* element = tmp_.curr_element;
bool open = element != nullptr;
if (platform::ImGui_BeginHSplit("SpecExplorerTree",
&tmp_.explorer_split, &open)) {
platform::SpecTreeGui(&element, spec(), SpecEditMode::kPlay);
if (element != tmp_.curr_element) {
tmp_.curr_element = element;
// A different element was selected, so select it for perturb.
if (element) {
open = true;
const int element_id = mjs_getId(element);
if (element->elemtype == mjOBJ_BODY && perturb_.select != element_id) {
mjv_defaultPerturb(&perturb_);
perturb_.select = element_id;
}
}
}
if (platform::ImGui_HSplit("SpecExplorerProperties",
&tmp_.explorer_split, &open)) {
platform::ScopedStyle style;
ImGui::Text("%s", mju_type2Str(tmp_.curr_element->elemtype));
ImGui::SameLine();
ImGui::Text("(%d)", mjs_getId(tmp_.curr_element));
ImGui::SameLine(ImGui::GetContentRegionAvail().x - 100.0f);
if (tmp_.spec_prop_mode == SpecPropertiesMode::kSpec) {
style.Color(ImGuiCol_Button, ImGuiCol_ButtonActive);
}
style.Var(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
if (ImGui::Button("S", ImVec2(24.0f, 20.0f))) {
tmp_.spec_prop_mode = SpecPropertiesMode::kSpec;
}
ImGui::SetItemTooltip("Spec");
style.Reset();
ImGui::SameLine();
if (tmp_.spec_prop_mode == SpecPropertiesMode::kModel) {
style.Color(ImGuiCol_Button, ImGuiCol_ButtonActive);
}
style.Var(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
if (ImGui::Button("M", ImVec2(24.0f, 20.0f))) {
tmp_.spec_prop_mode = SpecPropertiesMode::kModel;
}
ImGui::SetItemTooltip("Model");
style.Reset();
ImGui::SameLine();
if (tmp_.spec_prop_mode == SpecPropertiesMode::kData) {
style.Color(ImGuiCol_Button, ImGuiCol_ButtonActive);
}
style.Var(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
if (ImGui::Button("D", ImVec2(24.0f, 20.0f))) {
tmp_.spec_prop_mode = SpecPropertiesMode::kData;
}
ImGui::SetItemTooltip("Data");
style.Reset();
ImGui::Separator();
if (tmp_.spec_prop_mode == SpecPropertiesMode::kSpec) {
platform::ElementSpecGui(element, element, SpecEditMode::kPlay);
} else if (tmp_.spec_prop_mode == SpecPropertiesMode::kModel) {
platform::ElementModelGui(model(), tmp_.curr_element);
} else {
platform::ElementDataGui(data(), tmp_.curr_element);
}
}
if (!open) {
tmp_.curr_element = nullptr;
}
}
platform::ImGui_EndHSplit(open);
}
void App::SpecPropertiesGui() {
platform::ScopedStyle style;
void App::SpecEditorGui() {
if (ImGui::BeginChild("SpecEditor", ImVec2(-1, 36))) {
if (ImGui::BeginTable("##SpecEditorHeader", 3)) {
ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed, 70.0f);
ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthStretch);
ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed, 30.0f);
ImGui::Text("%s", mju_type2Str(tmp_.element->elemtype));
ImGui::SameLine();
ImGui::Text("(%d)", tmp_.element_id);
ImGui::TableNextColumn();
if (ImGui::Button(ICON_RELOAD_SPEC)) {
CopyLoadedSpecForEditing();
}
ImGui::BeginDisabled(true);
ImGui::SameLine();
if (ImGui::Button(ICON_UNDO_SPEC)) {
// TODO...
}
ImGui::SameLine();
if (ImGui::Button(ICON_REDO_SPEC)) {
// TODO...
}
ImGui::EndDisabled();
ImGui::SameLine(120);
if (tmp_.spec_prop_mode == SpecPropertiesMode::kSpec) {
style.Color(ImGuiCol_Button, ImGuiCol_ButtonActive);
ImGui::TableNextColumn();
ImGui::PushStyleColor(ImGuiCol_Button, ImColor(40, 180, 40, 255).Value);
if (ImGui::Button("Compile and Reload", ImVec2(-1, 0))) {
spec_op_ = [this]() {
model_holder_ = platform::ModelHolder::FromSpec(scratch_spec_);
scratch_spec_ = nullptr;
OnModelLoaded(model_name_, model_kind_);
};
}
ImGui::PopStyleColor();
ImGui::TableNextColumn();
if (ImGui::Button(" + ")) {
ImGui::OpenPopupOnItemClick("SpecAddElement", 0);
}
if (ImGui::BeginPopupContextItem("SpecAddElement")) {
auto option = [&](const char* label, auto fn) {
if (ImGui::Selectable(label)) {
tmp_.curr_edit_element = fn()->element;
mjs_setName(tmp_.curr_edit_element,
platform::ElementName(tmp_.curr_edit_element).c_str());
scratch_spec_modified_ = true;
}
};
option("Actuator", [&]() { return mjs_addActuator(scratch_spec_, 0); });
option("Equality", [&]() { return mjs_addEquality(scratch_spec_, 0); });
option("Exclude", [&]() { return mjs_addExclude(scratch_spec_); });
option("Flex", [&]() { return mjs_addFlex(scratch_spec_); });
option("Height Field", [&]() { return mjs_addHField(scratch_spec_); });
option("Key", [&]() { return mjs_addKey(scratch_spec_); });
option("Material", [&]() { return mjs_addMaterial(scratch_spec_, 0); });
option("Mesh", [&]() { return mjs_addMesh(scratch_spec_, 0); });
option("Numeric", [&]() { return mjs_addNumeric(scratch_spec_); });
option("Pair", [&]() { return mjs_addPair(scratch_spec_, 0); });
option("Sensor", [&]() { return mjs_addSensor(scratch_spec_); });
option("Skin", [&]() { return mjs_addSkin(scratch_spec_); });
option("Tendon", [&]() { return mjs_addTendon(scratch_spec_, 0); });
option("Text", [&]() { return mjs_addText(scratch_spec_); });
option("Texture", [&]() { return mjs_addTexture(scratch_spec_); });
option("Tuple", [&]() { return mjs_addTuple(scratch_spec_); });
ImGui::EndPopup();
}
ImGui::EndTable();
}
}
if (ImGui::SmallButton("S")) {
tmp_.spec_prop_mode = SpecPropertiesMode::kSpec;
ImGui::EndChild();
// Initialize the split height.
const ImVec2 region = ImGui::GetContentRegionAvail();
if (tmp_.editor_split < 0) {
tmp_.editor_split = region.y * 0.7f;
}
ImGui::SetItemTooltip("Spec");
style.Reset();
ImGui::SameLine();
if (tmp_.spec_prop_mode == SpecPropertiesMode::kModel) {
style.Color(ImGuiCol_Button, ImGuiCol_ButtonActive);
}
if (ImGui::SmallButton("M")) {
tmp_.spec_prop_mode = SpecPropertiesMode::kModel;
}
ImGui::SetItemTooltip("Model");
style.Reset();
ImGui::SameLine();
if (tmp_.spec_prop_mode == SpecPropertiesMode::kData) {
style.Color(ImGuiCol_Button, ImGuiCol_ButtonActive);
}
if (ImGui::SmallButton("D")) {
tmp_.spec_prop_mode = SpecPropertiesMode::kData;
}
ImGui::SetItemTooltip("Data");
style.Reset();
ImGui::Separator();
if (tmp_.spec_prop_mode == SpecPropertiesMode::kSpec) {
platform::ElementSpecGui(spec(), tmp_.element);
} else if (tmp_.spec_prop_mode == SpecPropertiesMode::kModel) {
platform::ElementModelGui(model(), tmp_.element);
} else {
platform::ElementDataGui(data(), tmp_.element);
tmp_.editor_split = std::clamp(tmp_.editor_split, 20.0f, region.y - 40.0f);
bool open = tmp_.curr_edit_element != nullptr;
if (platform::ImGui_BeginHSplit("SpecEditorTree", &tmp_.editor_split,
&open)) {
if (platform::SpecTreeGui(&tmp_.curr_edit_element, scratch_spec_,
SpecEditMode::kEdit)) {
scratch_spec_modified_ = true;
}
open = tmp_.curr_edit_element != nullptr;
if (platform::ImGui_HSplit("SpecEditorProperties", &tmp_.editor_split,
&open)) {
ImGui::Text("%s", mju_type2Str(tmp_.curr_edit_element->elemtype));
ImGui::SameLine();
ImGui::Text("(%d)", mjs_getId(tmp_.curr_edit_element));
ImGui::Separator();
mjsElement* ref = scratch_to_spec_[tmp_.curr_edit_element];
if (platform::ElementSpecGui(tmp_.curr_edit_element, ref,
SpecEditMode::kEdit)) {
scratch_spec_modified_ = true;
}
}
platform::ImGui_EndHSplit(open);
if (!open) {
tmp_.curr_edit_element = nullptr;
}
}
}
@@ -1725,12 +1875,12 @@ void App::MainMenuGui() {
}
ImGui::Separator();
if (ImGui::MenuItem(tmp_.options_panel ? "Hide Options" : "Show Left UI",
if (ImGui::MenuItem(tmp_.options_panel ? "Hide Options" : "Show Options",
"Tab")) {
tmp_.options_panel = !tmp_.options_panel;
}
if (ImGui::MenuItem(
tmp_.inspector_panel ? "Hide Inspector" : "Show Right UI",
tmp_.inspector_panel ? "Hide Inspector" : "Show Inspector",
"Shift+Tab")) {
tmp_.inspector_panel = !tmp_.inspector_panel;
}
src/experimental/studio/app.h
+21 -7
View File
@@ -27,6 +27,7 @@
#include <mujoco/mujoco.h>
#include "experimental/platform/gui.h"
#include "experimental/platform/gui_spec.h"
#include "experimental/platform/interaction.h"
#include "experimental/platform/model_holder.h"
#include "experimental/platform/picture_gui.h"
@@ -84,6 +85,8 @@ class App {
void Render();
private:
using SpecEditMode = platform::SpecEditMode;
// The kind of model that is currently loaded.
enum ModelKind {
kEmptyModel,
@@ -127,6 +130,8 @@ class App {
bool style_editor = false;
bool imgui_demo = false;
bool implot_demo = false;
float editor_split = -1;
float explorer_split = -1;
// Controls.
bool perturb_active = false;
@@ -141,10 +146,10 @@ class App {
std::vector<std::string> camera_names;
std::vector<std::string> speed_names;
// Spec Properties.
// Spec editing.
SpecPropertiesMode spec_prop_mode = SpecPropertiesMode::kSpec;
mjsElement* element = nullptr;
int element_id = -1;
mjsElement* curr_element = nullptr;
mjsElement* curr_edit_element = nullptr;
// State.
int state_sig = 0;
@@ -216,13 +221,11 @@ class App {
void ModelOptionsGui();
void DataInspectorGui();
void SpecExplorerGui();
void SpecPropertiesGui();
void SpecSelectElement(mjsElement* element);
void SpecDeleteElement(mjsElement* element);
void SpecEditorGui();
float GetExpectedLabelWidth();
std::vector<const char*> GetCameraNames();
void CopyLoadedSpecForEditing();
mjSpec* spec() { return model_holder_->spec(); }
mjModel* model() { return model_holder_->model(); }
@@ -244,6 +247,17 @@ class App {
std::unique_ptr<platform::Window> window_;
std::unique_ptr<platform::Renderer> renderer_;
std::unique_ptr<platform::ModelHolder> model_holder_;
// Spec editing. We keep a separate copy of the loaded spec that we can edit.
// Once we're done editing, we will (re)compile the spec and update the
// active model and data.
mjSpec* scratch_spec_ = nullptr;
// Whether or not the scratch spec differs from the loaded spec.
bool scratch_spec_modified_ = false;
// We keep a mapping of the elements between the loaded spec and the scratch
// spec.
std::unordered_map<mjsElement*, mjsElement*> spec_to_scratch_;
std::unordered_map<mjsElement*, mjsElement*> scratch_to_spec_;
std::function<void()> spec_op_;
platform::StepControl step_control_;