From e0e08aa597cc2f4fa0f3ecd59206566a01a8b2aa Mon Sep 17 00:00:00 2001 From: Yuval Tassa Date: Fri, 16 Aug 2024 05:33:45 -0700 Subject: [PATCH] Rename xml_native_writer variables to be consistent with xml_native_reader. PiperOrigin-RevId: 663699130 Change-Id: If11ed48d3b30d3c6d09ca77e3d8048c2a3d9f054 --- src/xml/xml_native_reader.cc | 4 +- src/xml/xml_native_writer.cc | 1092 +++++++++++++++++----------------- 2 files changed, 548 insertions(+), 548 deletions(-) diff --git a/src/xml/xml_native_reader.cc b/src/xml/xml_native_reader.cc index 433e33a7..5881ba4f 100644 --- a/src/xml/xml_native_reader.cc +++ b/src/xml/xml_native_reader.cc @@ -2304,7 +2304,7 @@ void mjXReader::OneActuator(XMLElement* elem, mjsActuator* actuator) { // make composite -void mjXReader::OneComposite(XMLElement* elem, mjsBody* pbody, mjsDefault* def) { +void mjXReader::OneComposite(XMLElement* elem, mjsBody* body, mjsDefault* def) { string text; int n; @@ -2526,7 +2526,7 @@ void mjXReader::OneComposite(XMLElement* elem, mjsBody* pbody, mjsDefault* def) // make composite char error[200]; - bool res = comp.Make(spec, pbody, error, 200); + bool res = comp.Make(spec, body, error, 200); // throw error if (!res) { diff --git a/src/xml/xml_native_writer.cc b/src/xml/xml_native_writer.cc index 23c77c63..993d1a52 100644 --- a/src/xml/xml_native_writer.cc +++ b/src/xml/xml_native_writer.cc @@ -124,54 +124,54 @@ XMLElement* mjXWriter::InsertEnd(XMLElement* parent, const char* name) { //---------------------------------- class mjXWriter: one-element writers -------------------------- // write flex -void mjXWriter::OneFlex(XMLElement* elem, const mjCFlex* pflex) { +void mjXWriter::OneFlex(XMLElement* elem, const mjCFlex* flex) { std::string text; mjCFlex defflex; // common attributes - WriteAttrTxt(elem, "name", pflex->name); - WriteAttr(elem, "radius", 1, &pflex->radius, &defflex.radius); - if (pflex->get_material() != defflex.get_material()) { - WriteAttrTxt(elem, "material", pflex->get_material()); + WriteAttrTxt(elem, "name", flex->name); + WriteAttr(elem, "radius", 1, &flex->radius, &defflex.radius); + if (flex->get_material() != defflex.get_material()) { + WriteAttrTxt(elem, "material", flex->get_material()); } - WriteAttr(elem, "rgba", 4, pflex->rgba, defflex.rgba); - WriteAttrKey(elem, "flatskin", bool_map, 2, pflex->flatskin, defflex.flatskin); - WriteAttrInt(elem, "dim", pflex->dim, defflex.dim); - WriteAttrInt(elem, "group", pflex->group, defflex.group); + WriteAttr(elem, "rgba", 4, flex->rgba, defflex.rgba); + WriteAttrKey(elem, "flatskin", bool_map, 2, flex->flatskin, defflex.flatskin); + WriteAttrInt(elem, "dim", flex->dim, defflex.dim); + WriteAttrInt(elem, "group", flex->group, defflex.group); // data vectors - if (!pflex->get_vertbody().empty()) { - text = VectorToString(pflex->get_vertbody()); + if (!flex->get_vertbody().empty()) { + text = VectorToString(flex->get_vertbody()); WriteAttrTxt(elem, "body", text); } - if (!pflex->get_vert().empty()) { - text = VectorToString(pflex->get_vert()); + if (!flex->get_vert().empty()) { + text = VectorToString(flex->get_vert()); WriteAttrTxt(elem, "vertex", text); } - if (!pflex->get_elem().empty()) { - text = VectorToString(pflex->get_elem()); + if (!flex->get_elem().empty()) { + text = VectorToString(flex->get_elem()); WriteAttrTxt(elem, "element", text); } - if (!pflex->get_texcoord().empty()) { - text = VectorToString(pflex->get_texcoord()); + if (!flex->get_texcoord().empty()) { + text = VectorToString(flex->get_texcoord()); WriteAttrTxt(elem, "texcoord", text); } // contact subelement XMLElement* cont = InsertEnd(elem, "contact"); - WriteAttrInt(cont, "contype", pflex->contype, defflex.contype); - WriteAttrInt(cont, "conaffinity", pflex->conaffinity, defflex.conaffinity); - WriteAttrInt(cont, "condim", pflex->condim, defflex.condim); - WriteAttrInt(cont, "priority", pflex->priority, defflex.priority); - WriteAttr(cont, "friction", 3, pflex->friction, defflex.friction); - WriteAttr(cont, "solmix", 1, &pflex->solmix, &defflex.solmix); - WriteAttr(cont, "solref", mjNREF, pflex->solref, defflex.solref); - WriteAttr(cont, "solimp", mjNIMP, pflex->solimp, defflex.solimp); - WriteAttr(cont, "margin", 1, &pflex->margin, &defflex.margin); - WriteAttr(cont, "gap", 1, &pflex->gap, &defflex.gap); - WriteAttrKey(cont, "internal", bool_map, 2, pflex->internal, defflex.internal); - WriteAttrKey(cont, "selfcollide", flexself_map, 5, pflex->selfcollide, defflex.selfcollide); - WriteAttrInt(cont, "activelayers", pflex->activelayers, defflex.activelayers); + WriteAttrInt(cont, "contype", flex->contype, defflex.contype); + WriteAttrInt(cont, "conaffinity", flex->conaffinity, defflex.conaffinity); + WriteAttrInt(cont, "condim", flex->condim, defflex.condim); + WriteAttrInt(cont, "priority", flex->priority, defflex.priority); + WriteAttr(cont, "friction", 3, flex->friction, defflex.friction); + WriteAttr(cont, "solmix", 1, &flex->solmix, &defflex.solmix); + WriteAttr(cont, "solref", mjNREF, flex->solref, defflex.solref); + WriteAttr(cont, "solimp", mjNIMP, flex->solimp, defflex.solimp); + WriteAttr(cont, "margin", 1, &flex->margin, &defflex.margin); + WriteAttr(cont, "gap", 1, &flex->gap, &defflex.gap); + WriteAttrKey(cont, "internal", bool_map, 2, flex->internal, defflex.internal); + WriteAttrKey(cont, "selfcollide", flexself_map, 5, flex->selfcollide, defflex.selfcollide); + WriteAttrInt(cont, "activelayers", flex->activelayers, defflex.activelayers); // remove contact is no attributes if (!cont->FirstAttribute()) { @@ -180,8 +180,8 @@ void mjXWriter::OneFlex(XMLElement* elem, const mjCFlex* pflex) { // edge subelement XMLElement* edge = InsertEnd(elem, "edge"); - WriteAttr(edge, "stiffness", 1, &pflex->edgestiffness, &defflex.edgestiffness); - WriteAttr(edge, "damping", 1, &pflex->edgedamping, &defflex.edgedamping); + WriteAttr(edge, "stiffness", 1, &flex->edgestiffness, &defflex.edgestiffness); + WriteAttr(edge, "damping", 1, &flex->edgedamping, &defflex.edgedamping); // remove edge if no attributes if (!edge->FirstAttribute()) { @@ -192,99 +192,99 @@ void mjXWriter::OneFlex(XMLElement* elem, const mjCFlex* pflex) { // write mesh -void mjXWriter::OneMesh(XMLElement* elem, const mjCMesh* pmesh, mjCDef* def) { +void mjXWriter::OneMesh(XMLElement* elem, const mjCMesh* mesh, mjCDef* def) { std::string text; // regular if (!writingdefaults) { - WriteAttrTxt(elem, "name", pmesh->name); - if (pmesh->classname != "main") { - WriteAttrTxt(elem, "class", pmesh->classname); + WriteAttrTxt(elem, "name", mesh->name); + if (mesh->classname != "main") { + WriteAttrTxt(elem, "class", mesh->classname); } - WriteAttrTxt(elem, "content_type", pmesh->ContentType()); - WriteAttrTxt(elem, "file", pmesh->File()); + WriteAttrTxt(elem, "content_type", mesh->ContentType()); + WriteAttrTxt(elem, "file", mesh->File()); // write vertex data - if (!pmesh->UserVert().empty()) { - text = VectorToString(pmesh->UserVert()); + if (!mesh->UserVert().empty()) { + text = VectorToString(mesh->UserVert()); WriteAttrTxt(elem, "vertex", text); } // write normal data - if (!pmesh->UserNormal().empty()) { - text = VectorToString(pmesh->UserNormal()); + if (!mesh->UserNormal().empty()) { + text = VectorToString(mesh->UserNormal()); WriteAttrTxt(elem, "normal", text); } // write texcoord data - if (!pmesh->UserTexcoord().empty()) { - text = VectorToString(pmesh->UserTexcoord()); + if (!mesh->UserTexcoord().empty()) { + text = VectorToString(mesh->UserTexcoord()); WriteAttrTxt(elem, "texcoord", text); } // write face data - if (!pmesh->UserFace().empty()) { - text = VectorToString(pmesh->UserFace()); + if (!mesh->UserFace().empty()) { + text = VectorToString(mesh->UserFace()); WriteAttrTxt(elem, "face", text); } } // defaults and regular - WriteAttr(elem, "refpos", 3, pmesh->Refpos(), def->Mesh().Refpos()); - WriteAttr(elem, "refquat", 4, pmesh->Refquat(), def->Mesh().Refquat()); - WriteAttr(elem, "scale", 3, pmesh->Scale(), def->Mesh().Scale()); - WriteAttrKey(elem, "smoothnormal", bool_map, 2, pmesh->SmoothNormal(), + WriteAttr(elem, "refpos", 3, mesh->Refpos(), def->Mesh().Refpos()); + WriteAttr(elem, "refquat", 4, mesh->Refquat(), def->Mesh().Refquat()); + WriteAttr(elem, "scale", 3, mesh->Scale(), def->Mesh().Scale()); + WriteAttrKey(elem, "smoothnormal", bool_map, 2, mesh->SmoothNormal(), def->Mesh().SmoothNormal()); } // write skin -void mjXWriter::OneSkin(XMLElement* elem, const mjCSkin* pskin) { +void mjXWriter::OneSkin(XMLElement* elem, const mjCSkin* skin) { std::string text; mjCDef mydef; float zero = 0; // write attributes - WriteAttrTxt(elem, "name", pskin->name); - WriteAttrTxt(elem, "file", pskin->File()); - WriteAttrTxt(elem, "material", pskin->get_material()); - WriteAttrInt(elem, "group", pskin->group, 0); - WriteAttr(elem, "rgba", 4, pskin->rgba, mydef.Geom().rgba); - WriteAttr(elem, "inflate", 1, &pskin->inflate, &zero); + WriteAttrTxt(elem, "name", skin->name); + WriteAttrTxt(elem, "file", skin->File()); + WriteAttrTxt(elem, "material", skin->get_material()); + WriteAttrInt(elem, "group", skin->group, 0); + WriteAttr(elem, "rgba", 4, skin->rgba, mydef.Geom().rgba); + WriteAttr(elem, "inflate", 1, &skin->inflate, &zero); // write data if no file - if (pskin->File().empty()) { + if (skin->File().empty()) { // mesh vert - text = VectorToString(pskin->get_vert()); + text = VectorToString(skin->get_vert()); WriteAttrTxt(elem, "vertex", text); // mesh texcoord - if (!pskin->get_texcoord().empty()) { - text = VectorToString(pskin->get_texcoord()); + if (!skin->get_texcoord().empty()) { + text = VectorToString(skin->get_texcoord()); WriteAttrTxt(elem, "texcoord", text); } // mesh face - text = VectorToString(pskin->get_face()); + text = VectorToString(skin->get_face()); WriteAttrTxt(elem, "face", text); // bones - for (size_t i=0; iget_bodyname().size(); i++) { + for (size_t i=0; iget_bodyname().size(); i++) { // make bone XMLElement* bone = InsertEnd(elem, "bone"); // write attributes - WriteAttrTxt(bone, "body", pskin->get_bodyname()[i]); - WriteAttr(bone, "bindpos", 3, pskin->get_bindpos().data()+3*i); - WriteAttr(bone, "bindquat", 4, pskin->get_bindquat().data()+4*i); + WriteAttrTxt(bone, "body", skin->get_bodyname()[i]); + WriteAttr(bone, "bindpos", 3, skin->get_bindpos().data()+3*i); + WriteAttr(bone, "bindquat", 4, skin->get_bindquat().data()+4*i); // write vertid - text = VectorToString(pskin->get_vertid()[i]); + text = VectorToString(skin->get_vertid()[i]); WriteAttrTxt(bone, "vertid", text); // write vertweight - text = VectorToString(pskin->get_vertweight()[i]); + text = VectorToString(skin->get_vertweight()[i]); WriteAttrTxt(bone, "vertweight", text); } } @@ -293,128 +293,128 @@ void mjXWriter::OneSkin(XMLElement* elem, const mjCSkin* pskin) { // write material -void mjXWriter::OneMaterial(XMLElement* elem, const mjCMaterial* pmat, mjCDef* def) { +void mjXWriter::OneMaterial(XMLElement* elem, const mjCMaterial* material, mjCDef* def) { // regular if (!writingdefaults) { - WriteAttrTxt(elem, "name", pmat->name); - if (pmat->classname != "main") { - WriteAttrTxt(elem, "class", pmat->classname); + WriteAttrTxt(elem, "name", material->name); + if (material->classname != "main") { + WriteAttrTxt(elem, "class", material->classname); } } // defaults and regular bool has_non_rgb = false; for (int i=1; itextures_[i].empty()) { + if (!material->textures_[i].empty()) { if (i != mjTEXROLE_RGB) { has_non_rgb = true; } } - if (pmat->textures_[i] != def->Material().textures_[i]) { - WriteAttrTxt(elem, "texture", pmat->get_texture(i)); + if (material->textures_[i] != def->Material().textures_[i]) { + WriteAttrTxt(elem, "texture", material->get_texture(i)); } } if (has_non_rgb) { // // TODO elem = InsertEnd(section, "role"); throw mjXError(0, "no support for non-RGB textures."); } - WriteAttrKey(elem, "texuniform", bool_map, 2, pmat->texuniform, def->Material().texuniform); - WriteAttr(elem, "texrepeat", 2, pmat->texrepeat, def->Material().texrepeat); - WriteAttr(elem, "emission", 1, &pmat->emission, &def->Material().emission); - WriteAttr(elem, "specular", 1, &pmat->specular, &def->Material().specular); - WriteAttr(elem, "shininess", 1, &pmat->shininess, &def->Material().shininess); - WriteAttr(elem, "reflectance", 1, &pmat->reflectance, &def->Material().reflectance); - WriteAttr(elem, "metallic", 1, &pmat->metallic, &def->Material().metallic); - WriteAttr(elem, "roughness", 1, &pmat->roughness, &def->Material().roughness); - WriteAttr(elem, "rgba", 4, pmat->rgba, def->Material().rgba); + WriteAttrKey(elem, "texuniform", bool_map, 2, material->texuniform, def->Material().texuniform); + WriteAttr(elem, "texrepeat", 2, material->texrepeat, def->Material().texrepeat); + WriteAttr(elem, "emission", 1, &material->emission, &def->Material().emission); + WriteAttr(elem, "specular", 1, &material->specular, &def->Material().specular); + WriteAttr(elem, "shininess", 1, &material->shininess, &def->Material().shininess); + WriteAttr(elem, "reflectance", 1, &material->reflectance, &def->Material().reflectance); + WriteAttr(elem, "metallic", 1, &material->metallic, &def->Material().metallic); + WriteAttr(elem, "roughness", 1, &material->roughness, &def->Material().roughness); + WriteAttr(elem, "rgba", 4, material->rgba, def->Material().rgba); } // write joint -void mjXWriter::OneJoint(XMLElement* elem, const mjCJoint* pjoint, mjCDef* def, +void mjXWriter::OneJoint(XMLElement* elem, const mjCJoint* joint, mjCDef* def, std::string_view classname) { double zero = 0; // regular if (!writingdefaults) { - WriteAttrTxt(elem, "name", pjoint->name); - if (classname != pjoint->classname && pjoint->classname != "main") { - WriteAttrTxt(elem, "class", pjoint->classname); + WriteAttrTxt(elem, "name", joint->name); + if (classname != joint->classname && joint->classname != "main") { + WriteAttrTxt(elem, "class", joint->classname); } - if (pjoint->type != mjJNT_FREE) { - WriteAttr(elem, "pos", 3, pjoint->pos); + if (joint->type != mjJNT_FREE) { + WriteAttr(elem, "pos", 3, joint->pos); } - if (pjoint->type != mjJNT_FREE && pjoint->type != mjJNT_BALL) { - WriteAttr(elem, "axis", 3, pjoint->axis); + if (joint->type != mjJNT_FREE && joint->type != mjJNT_BALL) { + WriteAttr(elem, "axis", 3, joint->axis); } } // defaults and regular - if (pjoint->type != def->Joint().type) { - WriteAttrTxt(elem, "type", FindValue(joint_map, joint_sz, pjoint->type)); + if (joint->type != def->Joint().type) { + WriteAttrTxt(elem, "type", FindValue(joint_map, joint_sz, joint->type)); } - WriteAttrInt(elem, "group", pjoint->group, def->Joint().group); - WriteAttr(elem, "ref", 1, &pjoint->ref, &zero); - WriteAttr(elem, "springref", 1, &pjoint->springref, &zero); - WriteAttr(elem, "solreflimit", mjNREF, pjoint->solref_limit, def->Joint().solref_limit, true); - WriteAttr(elem, "solimplimit", mjNIMP, pjoint->solimp_limit, def->Joint().solimp_limit, true); - WriteAttr(elem, "solreffriction", mjNREF, pjoint->solref_friction, def->Joint().solref_friction, + WriteAttrInt(elem, "group", joint->group, def->Joint().group); + WriteAttr(elem, "ref", 1, &joint->ref, &zero); + WriteAttr(elem, "springref", 1, &joint->springref, &zero); + WriteAttr(elem, "solreflimit", mjNREF, joint->solref_limit, def->Joint().solref_limit, true); + WriteAttr(elem, "solimplimit", mjNIMP, joint->solimp_limit, def->Joint().solimp_limit, true); + WriteAttr(elem, "solreffriction", mjNREF, joint->solref_friction, def->Joint().solref_friction, true); - WriteAttr(elem, "solimpfriction", mjNIMP, pjoint->solimp_friction, def->Joint().solimp_friction, + WriteAttr(elem, "solimpfriction", mjNIMP, joint->solimp_friction, def->Joint().solimp_friction, true); - WriteAttr(elem, "stiffness", 1, &pjoint->stiffness, &def->Joint().stiffness); - WriteAttrKey(elem, "limited", TFAuto_map, 3, pjoint->limited, def->Joint().limited); - WriteAttr(elem, "range", 2, pjoint->range, def->Joint().range); - WriteAttrKey(elem, "actuatorfrclimited", TFAuto_map, 3, pjoint->actfrclimited, + WriteAttr(elem, "stiffness", 1, &joint->stiffness, &def->Joint().stiffness); + WriteAttrKey(elem, "limited", TFAuto_map, 3, joint->limited, def->Joint().limited); + WriteAttr(elem, "range", 2, joint->range, def->Joint().range); + WriteAttrKey(elem, "actuatorfrclimited", TFAuto_map, 3, joint->actfrclimited, def->Joint().actfrclimited); - WriteAttrKey(elem, "actuatorgravcomp", bool_map, 2, pjoint->actgravcomp, def->Joint().actgravcomp); - WriteAttr(elem, "actuatorfrcrange", 2, pjoint->actfrcrange, def->Joint().actfrcrange); - WriteAttr(elem, "margin", 1, &pjoint->margin, &def->Joint().margin); - WriteAttr(elem, "armature", 1, &pjoint->armature, &def->Joint().armature); - WriteAttr(elem, "damping", 1, &pjoint->damping, &def->Joint().damping); - WriteAttr(elem, "frictionloss", 1, &pjoint->frictionloss, &def->Joint().frictionloss); + WriteAttrKey(elem, "actuatorgravcomp", bool_map, 2, joint->actgravcomp, def->Joint().actgravcomp); + WriteAttr(elem, "actuatorfrcrange", 2, joint->actfrcrange, def->Joint().actfrcrange); + WriteAttr(elem, "margin", 1, &joint->margin, &def->Joint().margin); + WriteAttr(elem, "armature", 1, &joint->armature, &def->Joint().armature); + WriteAttr(elem, "damping", 1, &joint->damping, &def->Joint().damping); + WriteAttr(elem, "frictionloss", 1, &joint->frictionloss, &def->Joint().frictionloss); // userdata if (writingdefaults) { - WriteVector(elem, "user", pjoint->get_userdata()); + WriteVector(elem, "user", joint->get_userdata()); } else { - WriteVector(elem, "user", pjoint->get_userdata(), def->Joint().get_userdata()); + WriteVector(elem, "user", joint->get_userdata(), def->Joint().get_userdata()); } } // write geom -void mjXWriter::OneGeom(XMLElement* elem, const mjCGeom* pgeom, mjCDef* def, +void mjXWriter::OneGeom(XMLElement* elem, const mjCGeom* geom, mjCDef* def, std::string_view classname) { double unitq[4] = {1, 0, 0, 0}; double mass = 0; // regular if (!writingdefaults) { - WriteAttrTxt(elem, "name", pgeom->name); - if (classname != pgeom->classname && pgeom->classname != "main") { - WriteAttrTxt(elem, "class", pgeom->classname); + WriteAttrTxt(elem, "name", geom->name); + if (classname != geom->classname && geom->classname != "main") { + WriteAttrTxt(elem, "class", geom->classname); } - if (mjGEOMINFO[pgeom->type]) { - WriteAttr(elem, "size", mjGEOMINFO[pgeom->type], pgeom->size, def->Geom().size); + if (mjGEOMINFO[geom->type]) { + WriteAttr(elem, "size", mjGEOMINFO[geom->type], geom->size, def->Geom().size); } - if (mjuu_defined(pgeom->mass)) { - mass = pgeom->GetVolume() * def->Geom().density; + if (mjuu_defined(geom->mass)) { + mass = geom->GetVolume() * def->Geom().density; } // mesh geom - if (pgeom->type==mjGEOM_MESH || pgeom->type==mjGEOM_SDF) { - mjCMesh* pmesh = pgeom->mesh; + if (geom->type==mjGEOM_MESH || geom->type==mjGEOM_SDF) { + mjCMesh* mesh = geom->mesh; // write pos/quat if there is a difference - if (!SameVector(pgeom->pos, pmesh->GetPosPtr(pgeom->typeinertia), 3) || - !SameVector(pgeom->quat, pmesh->GetQuatPtr(pgeom->typeinertia), 4)) { + if (!SameVector(geom->pos, mesh->GetPosPtr(geom->typeinertia), 3) || + !SameVector(geom->quat, mesh->GetQuatPtr(geom->typeinertia), 4)) { // recover geom pos/quat before mesh frame transformation double p[3], q[4]; - mjuu_copyvec(p, pgeom->pos, 3); - mjuu_copyvec(q, pgeom->quat, 4); - mjuu_frameaccuminv(p, q, pmesh->GetPosPtr(pgeom->typeinertia), - pmesh->GetQuatPtr(pgeom->typeinertia)); + mjuu_copyvec(p, geom->pos, 3); + mjuu_copyvec(q, geom->quat, 4); + mjuu_frameaccuminv(p, q, mesh->GetPosPtr(geom->typeinertia), + mesh->GetQuatPtr(geom->typeinertia)); // write WriteAttr(elem, "pos", 3, p, unitq+1); @@ -424,229 +424,229 @@ void mjXWriter::OneGeom(XMLElement* elem, const mjCGeom* pgeom, mjCDef* def, // non-mesh geom else { - WriteAttr(elem, "pos", 3, pgeom->pos, unitq+1); - WriteAttr(elem, "quat", 4, pgeom->quat, unitq); + WriteAttr(elem, "pos", 3, geom->pos, unitq+1); + WriteAttr(elem, "quat", 4, geom->quat, unitq); } } else { - WriteAttr(elem, "size", 3, pgeom->size, def->Geom().size); + WriteAttr(elem, "size", 3, geom->size, def->Geom().size); } // defaults and regular - WriteAttrKey(elem, "type", geom_map, mjNGEOMTYPES, pgeom->type, def->Geom().type); - WriteAttrInt(elem, "contype", pgeom->contype, def->Geom().contype); - WriteAttrInt(elem, "conaffinity", pgeom->conaffinity, def->Geom().conaffinity); - WriteAttrInt(elem, "condim", pgeom->condim, def->Geom().condim); - WriteAttrInt(elem, "group", pgeom->group, def->Geom().group); - WriteAttrInt(elem, "priority", pgeom->priority, def->Geom().priority); - WriteAttr(elem, "friction", 3, pgeom->friction, def->Geom().friction, true); - WriteAttr(elem, "solmix", 1, &pgeom->solmix, &def->Geom().solmix); - WriteAttr(elem, "solref", mjNREF, pgeom->solref, def->Geom().solref, true); - WriteAttr(elem, "solimp", mjNIMP, pgeom->solimp, def->Geom().solimp, true); - WriteAttr(elem, "margin", 1, &pgeom->margin, &def->Geom().margin); - WriteAttr(elem, "gap", 1, &pgeom->gap, &def->Geom().gap); - WriteAttr(elem, "gap", 1, &pgeom->gap, &def->Geom().gap); - WriteAttrKey(elem, "fluidshape", fluid_map, 2, pgeom->fluid_ellipsoid, def->Geom().fluid_ellipsoid); - WriteAttr(elem, "fluidcoef", 5, pgeom->fluid_coefs, def->Geom().fluid_coefs); - WriteAttrKey(elem, "shellinertia", meshtype_map, 2, pgeom->typeinertia, def->Geom().typeinertia); - if (mjuu_defined(pgeom->mass)) { - WriteAttr(elem, "mass", 1, &pgeom->mass_, &mass); + WriteAttrKey(elem, "type", geom_map, mjNGEOMTYPES, geom->type, def->Geom().type); + WriteAttrInt(elem, "contype", geom->contype, def->Geom().contype); + WriteAttrInt(elem, "conaffinity", geom->conaffinity, def->Geom().conaffinity); + WriteAttrInt(elem, "condim", geom->condim, def->Geom().condim); + WriteAttrInt(elem, "group", geom->group, def->Geom().group); + WriteAttrInt(elem, "priority", geom->priority, def->Geom().priority); + WriteAttr(elem, "friction", 3, geom->friction, def->Geom().friction, true); + WriteAttr(elem, "solmix", 1, &geom->solmix, &def->Geom().solmix); + WriteAttr(elem, "solref", mjNREF, geom->solref, def->Geom().solref, true); + WriteAttr(elem, "solimp", mjNIMP, geom->solimp, def->Geom().solimp, true); + WriteAttr(elem, "margin", 1, &geom->margin, &def->Geom().margin); + WriteAttr(elem, "gap", 1, &geom->gap, &def->Geom().gap); + WriteAttr(elem, "gap", 1, &geom->gap, &def->Geom().gap); + WriteAttrKey(elem, "fluidshape", fluid_map, 2, geom->fluid_ellipsoid, def->Geom().fluid_ellipsoid); + WriteAttr(elem, "fluidcoef", 5, geom->fluid_coefs, def->Geom().fluid_coefs); + WriteAttrKey(elem, "shellinertia", meshtype_map, 2, geom->typeinertia, def->Geom().typeinertia); + if (mjuu_defined(geom->mass)) { + WriteAttr(elem, "mass", 1, &geom->mass_, &mass); } else { - WriteAttr(elem, "density", 1, &pgeom->density, &def->Geom().density); + WriteAttr(elem, "density", 1, &geom->density, &def->Geom().density); } - if (pgeom->get_material() != def->Geom().get_material()) { - WriteAttrTxt(elem, "material", pgeom->get_material()); + if (geom->get_material() != def->Geom().get_material()) { + WriteAttrTxt(elem, "material", geom->get_material()); } - WriteAttr(elem, "rgba", 4, pgeom->rgba, def->Geom().rgba); + WriteAttr(elem, "rgba", 4, geom->rgba, def->Geom().rgba); // hfield and mesh attributes - if (pgeom->type==mjGEOM_HFIELD) { - WriteAttrTxt(elem, "hfield", pgeom->get_hfieldname()); + if (geom->type==mjGEOM_HFIELD) { + WriteAttrTxt(elem, "hfield", geom->get_hfieldname()); } - if (pgeom->type==mjGEOM_MESH || pgeom->type==mjGEOM_SDF) { - WriteAttrTxt(elem, "mesh", pgeom->get_meshname()); + if (geom->type==mjGEOM_MESH || geom->type==mjGEOM_SDF) { + WriteAttrTxt(elem, "mesh", geom->get_meshname()); } // userdata if (writingdefaults) { - WriteVector(elem, "user", pgeom->get_userdata()); + WriteVector(elem, "user", geom->get_userdata()); } else { - WriteVector(elem, "user", pgeom->get_userdata(), def->Geom().get_userdata()); + WriteVector(elem, "user", geom->get_userdata(), def->Geom().get_userdata()); } // write plugin - if (pgeom->plugin.active) { - OnePlugin(InsertEnd(elem, "plugin"), &pgeom->plugin); + if (geom->plugin.active) { + OnePlugin(InsertEnd(elem, "plugin"), &geom->plugin); } } // write site -void mjXWriter::OneSite(XMLElement* elem, const mjCSite* psite, mjCDef* def, +void mjXWriter::OneSite(XMLElement* elem, const mjCSite* site, mjCDef* def, std::string_view classname) { double unitq[4] = {1, 0, 0, 0}; // regular if (!writingdefaults) { - WriteAttrTxt(elem, "name", psite->name); - if (classname != psite->classname && psite->classname != "main") { - WriteAttrTxt(elem, "class", psite->classname); + WriteAttrTxt(elem, "name", site->name); + if (classname != site->classname && site->classname != "main") { + WriteAttrTxt(elem, "class", site->classname); } - WriteAttr(elem, "pos", 3, psite->pos); - WriteAttr(elem, "quat", 4, psite->quat, unitq); - if (mjGEOMINFO[psite->type]) { - WriteAttr(elem, "size", mjGEOMINFO[psite->type], psite->size, def->Site().size); + WriteAttr(elem, "pos", 3, site->pos); + WriteAttr(elem, "quat", 4, site->quat, unitq); + if (mjGEOMINFO[site->type]) { + WriteAttr(elem, "size", mjGEOMINFO[site->type], site->size, def->Site().size); } } else { - WriteAttr(elem, "size", 3, psite->size, def->Site().size); + WriteAttr(elem, "size", 3, site->size, def->Site().size); } // defaults and regular - WriteAttrInt(elem, "group", psite->group, def->Site().group); - WriteAttrKey(elem, "type", geom_map, mjNGEOMTYPES, psite->type, def->Site().type); - if (psite->get_material() != def->Site().get_material()) { - WriteAttrTxt(elem, "material", psite->get_material()); + WriteAttrInt(elem, "group", site->group, def->Site().group); + WriteAttrKey(elem, "type", geom_map, mjNGEOMTYPES, site->type, def->Site().type); + if (site->get_material() != def->Site().get_material()) { + WriteAttrTxt(elem, "material", site->get_material()); } - WriteAttr(elem, "rgba", 4, psite->rgba, def->Site().rgba); + WriteAttr(elem, "rgba", 4, site->rgba, def->Site().rgba); // userdata if (writingdefaults) { - WriteVector(elem, "user", psite->get_userdata()); + WriteVector(elem, "user", site->get_userdata()); } else { - WriteVector(elem, "user", psite->get_userdata(), def->Site().get_userdata()); + WriteVector(elem, "user", site->get_userdata(), def->Site().get_userdata()); } } // write camera -void mjXWriter::OneCamera(XMLElement* elem, const mjCCamera* pcam, mjCDef* def, +void mjXWriter::OneCamera(XMLElement* elem, const mjCCamera* camera, mjCDef* def, std::string_view classname) { double unitq[4] = {1, 0, 0, 0}; // regular if (!writingdefaults) { - WriteAttrTxt(elem, "name", pcam->name); - if (classname != pcam->classname && pcam->classname != "main") { - WriteAttrTxt(elem, "class", pcam->classname); + WriteAttrTxt(elem, "name", camera->name); + if (classname != camera->classname && camera->classname != "main") { + WriteAttrTxt(elem, "class", camera->classname); } - WriteAttrTxt(elem, "target", pcam->get_targetbody()); - WriteAttr(elem, "pos", 3, pcam->pos); - WriteAttr(elem, "quat", 4, pcam->quat, unitq); + WriteAttrTxt(elem, "target", camera->get_targetbody()); + WriteAttr(elem, "pos", 3, camera->pos); + WriteAttr(elem, "quat", 4, camera->quat, unitq); } // defaults and regular - WriteAttr(elem, "ipd", 1, &pcam->ipd, &def->Camera().ipd); - WriteAttrKey(elem, "mode", camlight_map, camlight_sz, pcam->mode, def->Camera().mode); - WriteAttr(elem, "resolution", 2, pcam->resolution, def->Camera().resolution); - WriteAttrKey(elem, "orthographic", bool_map, 2, pcam->orthographic, def->Camera().orthographic); + WriteAttr(elem, "ipd", 1, &camera->ipd, &def->Camera().ipd); + WriteAttrKey(elem, "mode", camlight_map, camlight_sz, camera->mode, def->Camera().mode); + WriteAttr(elem, "resolution", 2, camera->resolution, def->Camera().resolution); + WriteAttrKey(elem, "orthographic", bool_map, 2, camera->orthographic, def->Camera().orthographic); // camera intrinsics if specified - if (pcam->sensor_size[0]>0 && pcam->sensor_size[1]>0) { - WriteAttr(elem, "sensorsize", 2, pcam->sensor_size); - WriteAttr(elem, "focal", 2, pcam->focal_length, def->Camera().focal_length); - WriteAttr(elem, "focalpixel", 2, pcam->focal_pixel, def->Camera().focal_pixel); - WriteAttr(elem, "principal", 2, pcam->principal_length, def->Camera().principal_length); - WriteAttr(elem, "principalpixel", 2, pcam->principal_pixel, def->Camera().principal_pixel); + if (camera->sensor_size[0]>0 && camera->sensor_size[1]>0) { + WriteAttr(elem, "sensorsize", 2, camera->sensor_size); + WriteAttr(elem, "focal", 2, camera->focal_length, def->Camera().focal_length); + WriteAttr(elem, "focalpixel", 2, camera->focal_pixel, def->Camera().focal_pixel); + WriteAttr(elem, "principal", 2, camera->principal_length, def->Camera().principal_length); + WriteAttr(elem, "principalpixel", 2, camera->principal_pixel, def->Camera().principal_pixel); } else { - WriteAttr(elem, "fovy", 1, &pcam->fovy, &def->Camera().fovy); + WriteAttr(elem, "fovy", 1, &camera->fovy, &def->Camera().fovy); } // userdata if (writingdefaults) { - WriteVector(elem, "user", pcam->get_userdata()); + WriteVector(elem, "user", camera->get_userdata()); } else { - WriteVector(elem, "user", pcam->get_userdata(), def->Camera().get_userdata()); + WriteVector(elem, "user", camera->get_userdata(), def->Camera().get_userdata()); } } // write light -void mjXWriter::OneLight(XMLElement* elem, const mjCLight* plight, mjCDef* def, +void mjXWriter::OneLight(XMLElement* elem, const mjCLight* light, mjCDef* def, std::string_view classname) { // regular if (!writingdefaults) { - WriteAttrTxt(elem, "name", plight->name); - if (classname != plight->classname && plight->classname != "main") { - WriteAttrTxt(elem, "class", plight->classname); + WriteAttrTxt(elem, "name", light->name); + if (classname != light->classname && light->classname != "main") { + WriteAttrTxt(elem, "class", light->classname); } - WriteAttrTxt(elem, "target", plight->get_targetbody()); - WriteAttr(elem, "pos", 3, plight->pos); - WriteAttr(elem, "dir", 3, plight->dir); + WriteAttrTxt(elem, "target", light->get_targetbody()); + WriteAttr(elem, "pos", 3, light->pos); + WriteAttr(elem, "dir", 3, light->dir); } // defaults and regular - WriteAttr(elem, "bulbradius", 1, &plight->bulbradius, &def->Light().bulbradius); - WriteAttrKey(elem, "directional", bool_map, 2, plight->directional, def->Light().directional); - WriteAttrKey(elem, "castshadow", bool_map, 2, plight->castshadow, def->Light().castshadow); - WriteAttrKey(elem, "active", bool_map, 2, plight->active, def->Light().active); - WriteAttr(elem, "attenuation", 3, plight->attenuation, def->Light().attenuation); - WriteAttr(elem, "cutoff", 1, &plight->cutoff, &def->Light().cutoff); - WriteAttr(elem, "exponent", 1, &plight->exponent, &def->Light().exponent); - WriteAttr(elem, "ambient", 3, plight->ambient, def->Light().ambient); - WriteAttr(elem, "diffuse", 3, plight->diffuse, def->Light().diffuse); - WriteAttr(elem, "specular", 3, plight->specular, def->Light().specular); - WriteAttrKey(elem, "mode", camlight_map, camlight_sz, plight->mode, def->Light().mode); + WriteAttr(elem, "bulbradius", 1, &light->bulbradius, &def->Light().bulbradius); + WriteAttrKey(elem, "directional", bool_map, 2, light->directional, def->Light().directional); + WriteAttrKey(elem, "castshadow", bool_map, 2, light->castshadow, def->Light().castshadow); + WriteAttrKey(elem, "active", bool_map, 2, light->active, def->Light().active); + WriteAttr(elem, "attenuation", 3, light->attenuation, def->Light().attenuation); + WriteAttr(elem, "cutoff", 1, &light->cutoff, &def->Light().cutoff); + WriteAttr(elem, "exponent", 1, &light->exponent, &def->Light().exponent); + WriteAttr(elem, "ambient", 3, light->ambient, def->Light().ambient); + WriteAttr(elem, "diffuse", 3, light->diffuse, def->Light().diffuse); + WriteAttr(elem, "specular", 3, light->specular, def->Light().specular); + WriteAttrKey(elem, "mode", camlight_map, camlight_sz, light->mode, def->Light().mode); } // write pair -void mjXWriter::OnePair(XMLElement* elem, const mjCPair* ppair, mjCDef* def) { +void mjXWriter::OnePair(XMLElement* elem, const mjCPair* pair, mjCDef* def) { // regular if (!writingdefaults) { - if (ppair->classname != "main") { - WriteAttrTxt(elem, "class", ppair->classname); + if (pair->classname != "main") { + WriteAttrTxt(elem, "class", pair->classname); } - WriteAttrTxt(elem, "geom1", ppair->get_geomname1()); - WriteAttrTxt(elem, "geom2", ppair->get_geomname2()); + WriteAttrTxt(elem, "geom1", pair->get_geomname1()); + WriteAttrTxt(elem, "geom2", pair->get_geomname2()); } // defaults and regular - WriteAttrTxt(elem, "name", ppair->name); - WriteAttrInt(elem, "condim", ppair->condim, def->Pair().spec.condim); - WriteAttr(elem, "margin", 1, &ppair->margin, &def->Pair().spec.margin); - WriteAttr(elem, "gap", 1, &ppair->gap, &def->Pair().spec.gap); - WriteAttr(elem, "solref", mjNREF, ppair->solref, def->Pair().spec.solref, true); - WriteAttr(elem, "solreffriction", mjNREF, ppair->solreffriction, def->Pair().spec.solreffriction, + WriteAttrTxt(elem, "name", pair->name); + WriteAttrInt(elem, "condim", pair->condim, def->Pair().spec.condim); + WriteAttr(elem, "margin", 1, &pair->margin, &def->Pair().spec.margin); + WriteAttr(elem, "gap", 1, &pair->gap, &def->Pair().spec.gap); + WriteAttr(elem, "solref", mjNREF, pair->solref, def->Pair().spec.solref, true); + WriteAttr(elem, "solreffriction", mjNREF, pair->solreffriction, def->Pair().spec.solreffriction, true); - WriteAttr(elem, "solimp", mjNIMP, ppair->solimp, def->Pair().spec.solimp, true); - WriteAttr(elem, "friction", 5, ppair->friction, def->Pair().spec.friction); // all 5 values + WriteAttr(elem, "solimp", mjNIMP, pair->solimp, def->Pair().spec.solimp, true); + WriteAttr(elem, "friction", 5, pair->friction, def->Pair().spec.friction); // all 5 values } // write equality -void mjXWriter::OneEquality(XMLElement* elem, const mjCEquality* peq, mjCDef* def) { +void mjXWriter::OneEquality(XMLElement* elem, const mjCEquality* equality, mjCDef* def) { // regular if (!writingdefaults) { - WriteAttrTxt(elem, "name", peq->name); - if (peq->classname != "main") { - WriteAttrTxt(elem, "class", peq->classname); + WriteAttrTxt(elem, "name", equality->name); + if (equality->classname != "main") { + WriteAttrTxt(elem, "class", equality->classname); } - switch (peq->type) { + switch (equality->type) { case mjEQ_CONNECT: - WriteAttrTxt(elem, "body1", mjs_getString(peq->name1)); - WriteAttrTxt(elem, "body2", mjs_getString(peq->name2)); - WriteAttr(elem, "anchor", 3, peq->data); + WriteAttrTxt(elem, "body1", mjs_getString(equality->name1)); + WriteAttrTxt(elem, "body2", mjs_getString(equality->name2)); + WriteAttr(elem, "anchor", 3, equality->data); break; case mjEQ_WELD: - WriteAttrTxt(elem, "body1", mjs_getString(peq->name1)); - WriteAttrTxt(elem, "body2", mjs_getString(peq->name2)); - WriteAttr(elem, "anchor", 3, peq->data); - WriteAttr(elem, "torquescale", 1, peq->data+10); - WriteAttr(elem, "relpose", 7, peq->data+3); + WriteAttrTxt(elem, "body1", mjs_getString(equality->name1)); + WriteAttrTxt(elem, "body2", mjs_getString(equality->name2)); + WriteAttr(elem, "anchor", 3, equality->data); + WriteAttr(elem, "torquescale", 1, equality->data+10); + WriteAttr(elem, "relpose", 7, equality->data+3); break; case mjEQ_JOINT: - WriteAttrTxt(elem, "joint1", mjs_getString(peq->name1)); - WriteAttrTxt(elem, "joint2", mjs_getString(peq->name2)); - WriteAttr(elem, "polycoef", 5, peq->data); + WriteAttrTxt(elem, "joint1", mjs_getString(equality->name1)); + WriteAttrTxt(elem, "joint2", mjs_getString(equality->name2)); + WriteAttr(elem, "polycoef", 5, equality->data); break; case mjEQ_TENDON: - WriteAttrTxt(elem, "tendon1", mjs_getString(peq->name1)); - WriteAttrTxt(elem, "tendon2", mjs_getString(peq->name2)); - WriteAttr(elem, "polycoef", 5, peq->data); + WriteAttrTxt(elem, "tendon1", mjs_getString(equality->name1)); + WriteAttrTxt(elem, "tendon2", mjs_getString(equality->name2)); + WriteAttr(elem, "polycoef", 5, equality->data); break; case mjEQ_FLEX: - WriteAttrTxt(elem, "flex", mjs_getString(peq->name1)); + WriteAttrTxt(elem, "flex", mjs_getString(equality->name1)); break; default: @@ -655,99 +655,99 @@ void mjXWriter::OneEquality(XMLElement* elem, const mjCEquality* peq, mjCDef* de } // defaults and regular - WriteAttrKey(elem, "active", bool_map, 2, peq->active, def->Equality().active); - WriteAttr(elem, "solref", mjNREF, peq->solref, def->Equality().solref, true); - WriteAttr(elem, "solimp", mjNIMP, peq->solimp, def->Equality().solimp, true); + WriteAttrKey(elem, "active", bool_map, 2, equality->active, def->Equality().active); + WriteAttr(elem, "solref", mjNREF, equality->solref, def->Equality().solref, true); + WriteAttr(elem, "solimp", mjNIMP, equality->solimp, def->Equality().solimp, true); } // write tendon -void mjXWriter::OneTendon(XMLElement* elem, const mjCTendon* pten, mjCDef* def) { - bool fixed = (pten->GetWrap(0) && pten->GetWrap(0)->type==mjWRAP_JOINT); +void mjXWriter::OneTendon(XMLElement* elem, const mjCTendon* tendon, mjCDef* def) { + bool fixed = (tendon->GetWrap(0) && tendon->GetWrap(0)->type==mjWRAP_JOINT); // regular if (!writingdefaults) { - WriteAttrTxt(elem, "name", pten->name); - if (pten->classname != "main") { - WriteAttrTxt(elem, "class", pten->classname); + WriteAttrTxt(elem, "name", tendon->name); + if (tendon->classname != "main") { + WriteAttrTxt(elem, "class", tendon->classname); } } // defaults and regular - WriteAttrInt(elem, "group", pten->group, def->Tendon().group); - WriteAttr(elem, "solreflimit", mjNREF, pten->solref_limit, def->Tendon().solref_limit, true); - WriteAttr(elem, "solimplimit", mjNIMP, pten->solimp_limit, def->Tendon().solimp_limit, true); - WriteAttr(elem, "solreffriction", mjNREF, pten->solref_friction, def->Tendon().solref_friction, + WriteAttrInt(elem, "group", tendon->group, def->Tendon().group); + WriteAttr(elem, "solreflimit", mjNREF, tendon->solref_limit, def->Tendon().solref_limit, true); + WriteAttr(elem, "solimplimit", mjNIMP, tendon->solimp_limit, def->Tendon().solimp_limit, true); + WriteAttr(elem, "solreffriction", mjNREF, tendon->solref_friction, def->Tendon().solref_friction, true); - WriteAttr(elem, "solimpfriction", mjNIMP, pten->solimp_friction, def->Tendon().solimp_friction, + WriteAttr(elem, "solimpfriction", mjNIMP, tendon->solimp_friction, def->Tendon().solimp_friction, true); - WriteAttrKey(elem, "limited", TFAuto_map, 3, pten->limited, def->Tendon().limited); - WriteAttr(elem, "range", 2, pten->range, def->Tendon().range); - WriteAttr(elem, "margin", 1, &pten->margin, &def->Tendon().margin); - WriteAttr(elem, "stiffness", 1, &pten->stiffness, &def->Tendon().stiffness); - WriteAttr(elem, "damping", 1, &pten->damping, &def->Tendon().damping); - WriteAttr(elem, "frictionloss", 1, &pten->frictionloss, &def->Tendon().frictionloss); - if (pten->springlength[0] != pten->springlength[1] || + WriteAttrKey(elem, "limited", TFAuto_map, 3, tendon->limited, def->Tendon().limited); + WriteAttr(elem, "range", 2, tendon->range, def->Tendon().range); + WriteAttr(elem, "margin", 1, &tendon->margin, &def->Tendon().margin); + WriteAttr(elem, "stiffness", 1, &tendon->stiffness, &def->Tendon().stiffness); + WriteAttr(elem, "damping", 1, &tendon->damping, &def->Tendon().damping); + WriteAttr(elem, "frictionloss", 1, &tendon->frictionloss, &def->Tendon().frictionloss); + if (tendon->springlength[0] != tendon->springlength[1] || def->Tendon().springlength[0] != def->Tendon().springlength[1]) { - WriteAttr(elem, "springlength", 2, pten->springlength, def->Tendon().springlength); + WriteAttr(elem, "springlength", 2, tendon->springlength, def->Tendon().springlength); } else { - WriteAttr(elem, "springlength", 1, pten->springlength, def->Tendon().springlength); + WriteAttr(elem, "springlength", 1, tendon->springlength, def->Tendon().springlength); } // spatial only if (!fixed) { - if (pten->get_material()!=def->Tendon().get_material()) { - WriteAttrTxt(elem, "material", pten->get_material()); + if (tendon->get_material()!=def->Tendon().get_material()) { + WriteAttrTxt(elem, "material", tendon->get_material()); } - WriteAttr(elem, "width", 1, &pten->width, &def->Tendon().width); - WriteAttr(elem, "rgba", 4, pten->rgba, def->Tendon().rgba); + WriteAttr(elem, "width", 1, &tendon->width, &def->Tendon().width); + WriteAttr(elem, "rgba", 4, tendon->rgba, def->Tendon().rgba); } // userdata if (writingdefaults) { - WriteVector(elem, "user", pten->get_userdata()); + WriteVector(elem, "user", tendon->get_userdata()); } else { - WriteVector(elem, "user", pten->get_userdata(), def->Tendon().get_userdata()); + WriteVector(elem, "user", tendon->get_userdata(), def->Tendon().get_userdata()); } } // write actuator -void mjXWriter::OneActuator(XMLElement* elem, const mjCActuator* pact, mjCDef* def) { +void mjXWriter::OneActuator(XMLElement* elem, const mjCActuator* actuator, mjCDef* def) { // regular if (!writingdefaults) { - WriteAttrTxt(elem, "name", pact->name); - if (pact->classname != "main") { - WriteAttrTxt(elem, "class", pact->classname); + WriteAttrTxt(elem, "name", actuator->name); + if (actuator->classname != "main") { + WriteAttrTxt(elem, "class", actuator->classname); } // transmission target - switch (pact->trntype) { + switch (actuator->trntype) { case mjTRN_JOINT: - WriteAttrTxt(elem, "joint", pact->get_target()); + WriteAttrTxt(elem, "joint", actuator->get_target()); break; case mjTRN_JOINTINPARENT: - WriteAttrTxt(elem, "jointinparent", pact->get_target()); + WriteAttrTxt(elem, "jointinparent", actuator->get_target()); break; case mjTRN_TENDON: - WriteAttrTxt(elem, "tendon", pact->get_target()); + WriteAttrTxt(elem, "tendon", actuator->get_target()); break; case mjTRN_SLIDERCRANK: - WriteAttrTxt(elem, "cranksite", pact->get_target()); - WriteAttrTxt(elem, "slidersite", pact->get_slidersite()); + WriteAttrTxt(elem, "cranksite", actuator->get_target()); + WriteAttrTxt(elem, "slidersite", actuator->get_slidersite()); break; case mjTRN_SITE: - WriteAttrTxt(elem, "site", pact->get_target()); - WriteAttrTxt(elem, "refsite", pact->get_refsite()); + WriteAttrTxt(elem, "site", actuator->get_target()); + WriteAttrTxt(elem, "refsite", actuator->get_refsite()); break; case mjTRN_BODY: - WriteAttrTxt(elem, "body", pact->get_target()); + WriteAttrTxt(elem, "body", actuator->get_target()); break; default: // SHOULD NOT OCCUR @@ -756,46 +756,46 @@ void mjXWriter::OneActuator(XMLElement* elem, const mjCActuator* pact, mjCDef* d } // defaults and regular - WriteAttrInt(elem, "group", pact->group, def->Actuator().group); - WriteAttrKey(elem, "ctrllimited", TFAuto_map, 3, pact->ctrllimited, def->Actuator().ctrllimited); - WriteAttr(elem, "ctrlrange", 2, pact->ctrlrange, def->Actuator().ctrlrange); - WriteAttrKey(elem, "forcelimited", TFAuto_map, 3, pact->forcelimited, def->Actuator().forcelimited); - WriteAttr(elem, "forcerange", 2, pact->forcerange, def->Actuator().forcerange); - WriteAttrKey(elem, "actlimited", TFAuto_map, 3, pact->actlimited, def->Actuator().actlimited); - WriteAttr(elem, "actrange", 2, pact->actrange, def->Actuator().actrange); - WriteAttr(elem, "lengthrange", 2, pact->lengthrange, def->Actuator().lengthrange); - WriteAttr(elem, "gear", 6, pact->gear, def->Actuator().gear); - WriteAttr(elem, "cranklength", 1, &pact->cranklength, &def->Actuator().cranklength); - WriteAttrKey(elem, "actearly", bool_map, 2, pact->actearly, + WriteAttrInt(elem, "group", actuator->group, def->Actuator().group); + WriteAttrKey(elem, "ctrllimited", TFAuto_map, 3, actuator->ctrllimited, def->Actuator().ctrllimited); + WriteAttr(elem, "ctrlrange", 2, actuator->ctrlrange, def->Actuator().ctrlrange); + WriteAttrKey(elem, "forcelimited", TFAuto_map, 3, actuator->forcelimited, def->Actuator().forcelimited); + WriteAttr(elem, "forcerange", 2, actuator->forcerange, def->Actuator().forcerange); + WriteAttrKey(elem, "actlimited", TFAuto_map, 3, actuator->actlimited, def->Actuator().actlimited); + WriteAttr(elem, "actrange", 2, actuator->actrange, def->Actuator().actrange); + WriteAttr(elem, "lengthrange", 2, actuator->lengthrange, def->Actuator().lengthrange); + WriteAttr(elem, "gear", 6, actuator->gear, def->Actuator().gear); + WriteAttr(elem, "cranklength", 1, &actuator->cranklength, &def->Actuator().cranklength); + WriteAttrKey(elem, "actearly", bool_map, 2, actuator->actearly, def->Actuator().actearly); // special handling of actdim which has default value of -1 if (writingdefaults) { - WriteAttrInt(elem, "actdim", pact->actdim, def->Actuator().actdim); + WriteAttrInt(elem, "actdim", actuator->actdim, def->Actuator().actdim); } else { - int default_actdim = pact->dyntype == mjDYN_NONE ? 0 : 1; - WriteAttrInt(elem, "actdim", pact->actdim, default_actdim); + int default_actdim = actuator->dyntype == mjDYN_NONE ? 0 : 1; + WriteAttrInt(elem, "actdim", actuator->actdim, default_actdim); } - WriteAttrKey(elem, "dyntype", dyn_map, dyn_sz, pact->dyntype, def->Actuator().dyntype); - WriteAttr(elem, "dynprm", mjNDYN, pact->dynprm, def->Actuator().dynprm); + WriteAttrKey(elem, "dyntype", dyn_map, dyn_sz, actuator->dyntype, def->Actuator().dyntype); + WriteAttr(elem, "dynprm", mjNDYN, actuator->dynprm, def->Actuator().dynprm); // plugins: write config attributes - if (pact->plugin.active) { - OnePlugin(elem, &pact->plugin); + if (actuator->plugin.active) { + OnePlugin(elem, &actuator->plugin); } // non-plugins: write actuator parameters else { - WriteAttrKey(elem, "gaintype", gain_map, gain_sz, pact->gaintype, def->Actuator().gaintype); - WriteAttrKey(elem, "biastype", bias_map, bias_sz, pact->biastype, def->Actuator().biastype); - WriteAttr(elem, "gainprm", mjNGAIN, pact->gainprm, def->Actuator().gainprm, true); - WriteAttr(elem, "biasprm", mjNBIAS, pact->biasprm, def->Actuator().biasprm, true); + WriteAttrKey(elem, "gaintype", gain_map, gain_sz, actuator->gaintype, def->Actuator().gaintype); + WriteAttrKey(elem, "biastype", bias_map, bias_sz, actuator->biastype, def->Actuator().biastype); + WriteAttr(elem, "gainprm", mjNGAIN, actuator->gainprm, def->Actuator().gainprm, true); + WriteAttr(elem, "biasprm", mjNBIAS, actuator->biasprm, def->Actuator().biasprm, true); } // userdata if (writingdefaults) { - WriteVector(elem, "user", pact->get_userdata()); + WriteVector(elem, "user", actuator->get_userdata()); } else { - WriteVector(elem, "user", pact->get_userdata(), def->Actuator().get_userdata()); + WriteVector(elem, "user", actuator->get_userdata(), def->Actuator().get_userdata()); } } @@ -1203,11 +1203,11 @@ void mjXWriter::Default(XMLElement* root, mjCDef* def) { XMLElement* section; // pointer to parent defaults - mjCDef* par; + mjCDef* parent; if (def->parent) { - par = def->parent; + parent = def->parent; } else { - par = new mjCDef; + parent = new mjCDef; } // create section, write class name @@ -1218,63 +1218,63 @@ void mjXWriter::Default(XMLElement* root, mjCDef* def) { // mesh elem = InsertEnd(section, "mesh"); - OneMesh(elem, &def->Mesh(), par); + OneMesh(elem, &def->Mesh(), parent); if (!elem->FirstAttribute()) section->DeleteChild(elem); // material elem = InsertEnd(section, "material"); - OneMaterial(elem, &def->Material(), par); + OneMaterial(elem, &def->Material(), parent); if (!elem->FirstAttribute()) section->DeleteChild(elem); // joint elem = InsertEnd(section, "joint"); - OneJoint(elem, &def->Joint(), par); + OneJoint(elem, &def->Joint(), parent); if (!elem->FirstAttribute()) section->DeleteChild(elem); // geom elem = InsertEnd(section, "geom"); - OneGeom(elem, &def->Geom(), par); + OneGeom(elem, &def->Geom(), parent); if (!elem->FirstAttribute()) section->DeleteChild(elem); // site elem = InsertEnd(section, "site"); - OneSite(elem, &def->Site(), par); + OneSite(elem, &def->Site(), parent); if (!elem->FirstAttribute()) section->DeleteChild(elem); // camera elem = InsertEnd(section, "camera"); - OneCamera(elem, &def->Camera(), par); + OneCamera(elem, &def->Camera(), parent); if (!elem->FirstAttribute()) section->DeleteChild(elem); // light elem = InsertEnd(section, "light"); - OneLight(elem, &def->Light(), par); + OneLight(elem, &def->Light(), parent); if (!elem->FirstAttribute()) section->DeleteChild(elem); // pair elem = InsertEnd(section, "pair"); - OnePair(elem, &def->Pair(), par); + OnePair(elem, &def->Pair(), parent); if (!elem->FirstAttribute()) section->DeleteChild(elem); // equality elem = InsertEnd(section, "equality"); - OneEquality(elem, &def->Equality(), par); + OneEquality(elem, &def->Equality(), parent); if (!elem->FirstAttribute()) section->DeleteChild(elem); // tendon elem = InsertEnd(section, "tendon"); - OneTendon(elem, &def->Tendon(), par); + OneTendon(elem, &def->Tendon(), parent); if (!elem->FirstAttribute()) section->DeleteChild(elem); // actuator elem = InsertEnd(section, "general"); - OneActuator(elem, &def->Actuator(), par); + OneActuator(elem, &def->Actuator(), parent); if (!elem->FirstAttribute()) section->DeleteChild(elem); // if top-level class has no members or children, delete it and return if (!def->parent && section->NoChildren() && def->child.empty()) { root->DeleteChild(section); - delete par; + delete parent; return; } @@ -1285,7 +1285,7 @@ void mjXWriter::Default(XMLElement* root, mjCDef* def) { // delete parent defaults if allocated here if (!def->parent) { - delete par; + delete parent; } } @@ -1373,33 +1373,33 @@ void mjXWriter::Custom(XMLElement* root) { // write all numerics for (int i=0; iGetObject(mjOBJ_NUMERIC, i); + mjCNumeric* numeric = (mjCNumeric*)model->GetObject(mjOBJ_NUMERIC, i); elem = InsertEnd(section, "numeric"); - WriteAttrTxt(elem, "name", ptr->name); - WriteAttrInt(elem, "size", ptr->size); - WriteAttr(elem, "data", ptr->size, ptr->data_.data()); + WriteAttrTxt(elem, "name", numeric->name); + WriteAttrInt(elem, "size", numeric->size); + WriteAttr(elem, "data", numeric->size, numeric->data_.data()); } // write all texts for (int i=0; iGetObject(mjOBJ_TEXT, i); + mjCText* text = (mjCText*)model->GetObject(mjOBJ_TEXT, i); elem = InsertEnd(section, "text"); - WriteAttrTxt(elem, "name", ptr->name); - WriteAttrTxt(elem, "data", ptr->data_.c_str()); + WriteAttrTxt(elem, "name", text->name); + WriteAttrTxt(elem, "data", text->data_.c_str()); } // write all tuples for (int i=0; iGetObject(mjOBJ_TUPLE, i); + mjCTuple* tuple = (mjCTuple*)model->GetObject(mjOBJ_TUPLE, i); elem = InsertEnd(section, "tuple"); - WriteAttrTxt(elem, "name", ptr->name); + WriteAttrTxt(elem, "name", tuple->name); // write objects in tuple - for (int j=0; j<(int)ptr->objtype_.size(); j++) { + for (int j=0; j<(int)tuple->objtype_.size(); j++) { XMLElement* obj = InsertEnd(elem, "element"); - WriteAttrTxt(obj, "objtype", mju_type2Str((int)ptr->objtype_[j])); - WriteAttrTxt(obj, "objname", ptr->objname_[j].c_str()); - double oprm = ptr->objprm_[j]; + WriteAttrTxt(obj, "objtype", mju_type2Str((int)tuple->objtype_[j])); + WriteAttrTxt(obj, "objname", tuple->objname_[j].c_str()); + double oprm = tuple->objprm_[j]; if (oprm!=0) { WriteAttr(obj, "prm", 1, &oprm); } @@ -1431,58 +1431,58 @@ void mjXWriter::Asset(XMLElement* root) { mjCTexture deftex(0); for (int i=0; iGetObject(mjOBJ_TEXTURE, i); + mjCTexture* texture = (mjCTexture*)model->GetObject(mjOBJ_TEXTURE, i); elem = InsertEnd(section, "texture"); // write common attributes - WriteAttrKey(elem, "type", texture_map, texture_sz, ptex->type); - WriteAttrTxt(elem, "name", ptex->name); + WriteAttrKey(elem, "type", texture_map, texture_sz, texture->type); + WriteAttrTxt(elem, "name", texture->name); // write builtin - if (ptex->builtin!=mjBUILTIN_NONE) { - WriteAttrKey(elem, "builtin", builtin_map, builtin_sz, ptex->builtin); - WriteAttrKey(elem, "mark", mark_map, mark_sz, ptex->mark, deftex.mark); - WriteAttr(elem, "rgb1", 3, ptex->rgb1, deftex.rgb1); - WriteAttr(elem, "rgb2", 3, ptex->rgb2, deftex.rgb2); - WriteAttr(elem, "markrgb", 3, ptex->markrgb, deftex.markrgb); - WriteAttr(elem, "random", 1, &ptex->random, &deftex.random); - WriteAttrInt(elem, "width", ptex->width); - WriteAttrInt(elem, "height", ptex->height); + if (texture->builtin!=mjBUILTIN_NONE) { + WriteAttrKey(elem, "builtin", builtin_map, builtin_sz, texture->builtin); + WriteAttrKey(elem, "mark", mark_map, mark_sz, texture->mark, deftex.mark); + WriteAttr(elem, "rgb1", 3, texture->rgb1, deftex.rgb1); + WriteAttr(elem, "rgb2", 3, texture->rgb2, deftex.rgb2); + WriteAttr(elem, "markrgb", 3, texture->markrgb, deftex.markrgb); + WriteAttr(elem, "random", 1, &texture->random, &deftex.random); + WriteAttrInt(elem, "width", texture->width); + WriteAttrInt(elem, "height", texture->height); } // write buffer - else if (ptex->get_cubefiles()[0].empty() && ptex->get_cubefiles()[1].empty() && - ptex->get_cubefiles()[2].empty() && ptex->get_cubefiles()[3].empty() && - ptex->get_cubefiles()[4].empty() && ptex->get_cubefiles()[5].empty() && - ptex->File().empty() && ptex->gridsize[0] == 1 && ptex->gridsize[1] == 1) { + else if (texture->get_cubefiles()[0].empty() && texture->get_cubefiles()[1].empty() && + texture->get_cubefiles()[2].empty() && texture->get_cubefiles()[3].empty() && + texture->get_cubefiles()[4].empty() && texture->get_cubefiles()[5].empty() && + texture->File().empty() && texture->gridsize[0] == 1 && texture->gridsize[1] == 1) { throw mjXError(0, "no support for buffer textures."); } // write textures loaded from files else { // write single file - WriteAttrTxt(elem, "content_type", ptex->get_content_type()); - WriteAttrTxt(elem, "file", ptex->File()); + WriteAttrTxt(elem, "content_type", texture->get_content_type()); + WriteAttrTxt(elem, "file", texture->File()); // write separate files - WriteAttrTxt(elem, "fileright", ptex->get_cubefiles()[0]); - WriteAttrTxt(elem, "fileleft", ptex->get_cubefiles()[1]); - WriteAttrTxt(elem, "fileup", ptex->get_cubefiles()[2]); - WriteAttrTxt(elem, "filedown", ptex->get_cubefiles()[3]); - WriteAttrTxt(elem, "filefront", ptex->get_cubefiles()[4]); - WriteAttrTxt(elem, "fileback", ptex->get_cubefiles()[5]); - if (ptex->hflip) { + WriteAttrTxt(elem, "fileright", texture->get_cubefiles()[0]); + WriteAttrTxt(elem, "fileleft", texture->get_cubefiles()[1]); + WriteAttrTxt(elem, "fileup", texture->get_cubefiles()[2]); + WriteAttrTxt(elem, "filedown", texture->get_cubefiles()[3]); + WriteAttrTxt(elem, "filefront", texture->get_cubefiles()[4]); + WriteAttrTxt(elem, "fileback", texture->get_cubefiles()[5]); + if (texture->hflip) { WriteAttrKey(elem, "hflip", bool_map, 2, 1); } - if (ptex->vflip) { + if (texture->vflip) { WriteAttrKey(elem, "vflip", bool_map, 2, 1); } // write grid - if (ptex->gridsize[0] != 1 || ptex->gridsize[1] != 1) { - double gsize[2] = { (double)ptex->gridsize[0], (double)ptex->gridsize[1] }; + if (texture->gridsize[0] != 1 || texture->gridsize[1] != 1) { + double gsize[2] = { (double)texture->gridsize[0], (double)texture->gridsize[1] }; WriteAttr(elem, "gridsize", 2, gsize); - WriteAttrTxt(elem, "gridlayout", ptex->gridlayout); + WriteAttrTxt(elem, "gridlayout", texture->gridlayout); } } } @@ -1490,43 +1490,43 @@ void mjXWriter::Asset(XMLElement* root) { // write materials for (int i=0; iGetObject(mjOBJ_MATERIAL, i); + mjCMaterial* material = (mjCMaterial*)model->GetObject(mjOBJ_MATERIAL, i); elem = InsertEnd(section, "material"); - OneMaterial(elem, pmat, model->def_map[pmat->classname]); + OneMaterial(elem, material, model->def_map[material->classname]); } // write meshes for (int i=0; iGetObject(mjOBJ_MESH, i); - if (pmesh->Plugin().active) { + mjCMesh* mesh = (mjCMesh*)model->GetObject(mjOBJ_MESH, i); + if (mesh->Plugin().active) { elem = InsertEnd(section, "mesh"); - WriteAttrTxt(elem, "name", pmesh->name); - OnePlugin(InsertEnd(elem, "plugin"), &pmesh->Plugin()); + WriteAttrTxt(elem, "name", mesh->name); + OnePlugin(InsertEnd(elem, "plugin"), &mesh->Plugin()); } else{ elem = InsertEnd(section, "mesh"); - OneMesh(elem, pmesh, model->def_map[pmesh->classname]); + OneMesh(elem, mesh, model->def_map[mesh->classname]); } } // write hfields for (int i=0; iGetObject(mjOBJ_HFIELD, i); + mjCHField* hfield = (mjCHField*)model->GetObject(mjOBJ_HFIELD, i); elem = InsertEnd(section, "hfield"); // write attributes - WriteAttrTxt(elem, "name", phf->name); - WriteAttr(elem, "size", 4, phf->size); - if (!phf->file_.empty()) { - WriteAttrTxt(elem, "content_type", phf->content_type_); - WriteAttrTxt(elem, "file", phf->file_); + WriteAttrTxt(elem, "name", hfield->name); + WriteAttr(elem, "size", 4, hfield->size); + if (!hfield->file_.empty()) { + WriteAttrTxt(elem, "content_type", hfield->content_type_); + WriteAttrTxt(elem, "file", hfield->file_); } else { - WriteAttrInt(elem, "nrow", phf->nrow); - WriteAttrInt(elem, "ncol", phf->ncol); - if (!phf->get_userdata().empty()) { + WriteAttrInt(elem, "nrow", hfield->nrow); + WriteAttrInt(elem, "ncol", hfield->ncol); + if (!hfield->get_userdata().empty()) { std::string text; - Vector2String(text, phf->get_userdata(), phf->ncol); + Vector2String(text, hfield->get_userdata(), hfield->ncol); WriteAttrTxt(elem, "elevation", text); } } @@ -1734,21 +1734,21 @@ void mjXWriter::Contact(XMLElement* root) { // write all geom pairs for (int i=0; iGetObject(mjOBJ_PAIR, i); + mjCPair* pair = (mjCPair*)model->GetObject(mjOBJ_PAIR, i); elem = InsertEnd(section, "pair"); - OnePair(elem, ppair, model->def_map[ppair->classname]); + OnePair(elem, pair, model->def_map[pair->classname]); } // write all exclude pairs for (int i=0; iGetObject(mjOBJ_EXCLUDE, i); + mjCBodyPair* exclude = (mjCBodyPair*)model->GetObject(mjOBJ_EXCLUDE, i); elem = InsertEnd(section, "exclude"); // write attributes - WriteAttrTxt(elem, "name", pexclude->name); - WriteAttrTxt(elem, "body1", pexclude->get_bodyname1()); - WriteAttrTxt(elem, "body2", pexclude->get_bodyname2()); + WriteAttrTxt(elem, "name", exclude->name); + WriteAttrTxt(elem, "body1", exclude->get_bodyname1()); + WriteAttrTxt(elem, "body2", exclude->get_bodyname2()); } } @@ -1767,9 +1767,9 @@ void mjXWriter::Equality(XMLElement* root) { // write all constraints for (int i=0; iGetObject(mjOBJ_EQUALITY, i); - XMLElement* elem = InsertEnd(section, FindValue(equality_map, equality_sz, peq->type).c_str()); - OneEquality(elem, peq, model->def_map[peq->classname]); + mjCEquality* equality = (mjCEquality*)model->GetObject(mjOBJ_EQUALITY, i); + XMLElement* elem = InsertEnd(section, FindValue(equality_map, equality_sz, equality->type).c_str()); + OneEquality(elem, equality, model->def_map[equality->classname]); } } @@ -1794,17 +1794,17 @@ void mjXWriter::Deformable(XMLElement* root) { // write flexes for (int i=0; iGetObject(mjOBJ_FLEX, i); + mjCFlex* flex = (mjCFlex*)model->GetObject(mjOBJ_FLEX, i); elem = InsertEnd(section, "flex"); - OneFlex(elem, pflex); + OneFlex(elem, flex); } // write skins for (int i=0; iGetObject(mjOBJ_SKIN, i); + mjCSkin* skin = (mjCSkin*)model->GetObject(mjOBJ_SKIN, i); elem = InsertEnd(section, "skin"); - OneSkin(elem, pskin); + OneSkin(elem, skin); } } @@ -1824,42 +1824,42 @@ void mjXWriter::Tendon(XMLElement* root) { // write all tendons for (int i=0; iGetObject(mjOBJ_TENDON, i); - if (!pten->NumWraps()) { // SHOULD NOT OCCUR + mjCTendon* tendon = (mjCTendon*)model->GetObject(mjOBJ_TENDON, i); + if (!tendon->NumWraps()) { // SHOULD NOT OCCUR continue; } XMLElement* elem = InsertEnd(section, - pten->GetWrap(0)->type==mjWRAP_JOINT ? "fixed" : "spatial"); - OneTendon(elem, pten, model->def_map[pten->classname]); + tendon->GetWrap(0)->type==mjWRAP_JOINT ? "fixed" : "spatial"); + OneTendon(elem, tendon, model->def_map[tendon->classname]); // write wraps - XMLElement* wrap; - for (int j=0; jNumWraps(); j++) { - const mjCWrap* pw = pten->GetWrap(j); - switch (pw->type) { + XMLElement* wrapelem; + for (int j=0; jNumWraps(); j++) { + const mjCWrap* wrap = tendon->GetWrap(j); + switch (wrap->type) { case mjWRAP_JOINT: - wrap = InsertEnd(elem, "joint"); - WriteAttrTxt(wrap, "joint", pw->obj->name); - WriteAttr(wrap, "coef", 1, &pw->prm); + wrapelem = InsertEnd(elem, "joint"); + WriteAttrTxt(wrapelem, "joint", wrap->obj->name); + WriteAttr(wrapelem, "coef", 1, &wrap->prm); break; case mjWRAP_SITE: - wrap = InsertEnd(elem, "site"); - WriteAttrTxt(wrap, "site", pw->obj->name); + wrapelem = InsertEnd(elem, "site"); + WriteAttrTxt(wrapelem, "site", wrap->obj->name); break; case mjWRAP_SPHERE: case mjWRAP_CYLINDER: - wrap = InsertEnd(elem, "geom"); - WriteAttrTxt(wrap, "geom", pw->obj->name); - if (!pw->sidesite.empty()) { - WriteAttrTxt(wrap, "sidesite", pw->sidesite); + wrapelem = InsertEnd(elem, "geom"); + WriteAttrTxt(wrapelem, "geom", wrap->obj->name); + if (!wrap->sidesite.empty()) { + WriteAttrTxt(wrapelem, "sidesite", wrap->sidesite); } break; case mjWRAP_PULLEY: - wrap = InsertEnd(elem, "pulley"); - WriteAttr(wrap, "divisor", 1, &pw->prm); + wrapelem = InsertEnd(elem, "pulley"); + WriteAttr(wrapelem, "divisor", 1, &wrap->prm); break; default: @@ -1884,14 +1884,14 @@ void mjXWriter::Actuator(XMLElement* root) { // write all actuators for (int i=0; iGetObject(mjOBJ_ACTUATOR, i); + mjCActuator* actuator = (mjCActuator*)model->GetObject(mjOBJ_ACTUATOR, i); XMLElement* elem; - if (pact->plugin.active) { + if (actuator->plugin.active) { elem = InsertEnd(section, "plugin"); } else { elem = InsertEnd(section, "general"); } - OneActuator(elem, pact, model->def_map[pact->classname]); + OneActuator(elem, actuator, model->def_map[actuator->classname]); } } @@ -1913,231 +1913,231 @@ void mjXWriter::Sensor(XMLElement* root) { // write all sensors for (int i=0; iSensors()[i]; + mjCSensor* sensor = model->Sensors()[i]; std::string instance_name = ""; std::string plugin_name = ""; // write sensor type and type-specific attributes - switch (psen->type) { + switch (sensor->type) { // common robotic sensors, attached to a site case mjSENS_TOUCH: elem = InsertEnd(section, "touch"); - WriteAttrTxt(elem, "site", psen->get_objname()); + WriteAttrTxt(elem, "site", sensor->get_objname()); break; case mjSENS_ACCELEROMETER: elem = InsertEnd(section, "accelerometer"); - WriteAttrTxt(elem, "site", psen->get_objname()); + WriteAttrTxt(elem, "site", sensor->get_objname()); break; case mjSENS_VELOCIMETER: elem = InsertEnd(section, "velocimeter"); - WriteAttrTxt(elem, "site", psen->get_objname()); + WriteAttrTxt(elem, "site", sensor->get_objname()); break; case mjSENS_GYRO: elem = InsertEnd(section, "gyro"); - WriteAttrTxt(elem, "site", psen->get_objname()); + WriteAttrTxt(elem, "site", sensor->get_objname()); break; case mjSENS_FORCE: elem = InsertEnd(section, "force"); - WriteAttrTxt(elem, "site", psen->get_objname()); + WriteAttrTxt(elem, "site", sensor->get_objname()); break; case mjSENS_TORQUE: elem = InsertEnd(section, "torque"); - WriteAttrTxt(elem, "site", psen->get_objname()); + WriteAttrTxt(elem, "site", sensor->get_objname()); break; case mjSENS_MAGNETOMETER: elem = InsertEnd(section, "magnetometer"); - WriteAttrTxt(elem, "site", psen->get_objname()); + WriteAttrTxt(elem, "site", sensor->get_objname()); break; case mjSENS_RANGEFINDER: elem = InsertEnd(section, "rangefinder"); - WriteAttrTxt(elem, "site", psen->get_objname()); + WriteAttrTxt(elem, "site", sensor->get_objname()); break; case mjSENS_CAMPROJECTION: elem = InsertEnd(section, "camprojection"); - WriteAttrTxt(elem, "site", psen->get_objname()); - WriteAttrTxt(elem, "camera", psen->get_refname()); + WriteAttrTxt(elem, "site", sensor->get_objname()); + WriteAttrTxt(elem, "camera", sensor->get_refname()); break; // sensors related to scalar joints, tendons, actuators case mjSENS_JOINTPOS: elem = InsertEnd(section, "jointpos"); - WriteAttrTxt(elem, "joint", psen->get_objname()); + WriteAttrTxt(elem, "joint", sensor->get_objname()); break; case mjSENS_JOINTVEL: elem = InsertEnd(section, "jointvel"); - WriteAttrTxt(elem, "joint", psen->get_objname()); + WriteAttrTxt(elem, "joint", sensor->get_objname()); break; case mjSENS_TENDONPOS: elem = InsertEnd(section, "tendonpos"); - WriteAttrTxt(elem, "tendon", psen->get_objname()); + WriteAttrTxt(elem, "tendon", sensor->get_objname()); break; case mjSENS_TENDONVEL: elem = InsertEnd(section, "tendonvel"); - WriteAttrTxt(elem, "tendon", psen->get_objname()); + WriteAttrTxt(elem, "tendon", sensor->get_objname()); break; case mjSENS_ACTUATORPOS: elem = InsertEnd(section, "actuatorpos"); - WriteAttrTxt(elem, "actuator", psen->get_objname()); + WriteAttrTxt(elem, "actuator", sensor->get_objname()); break; case mjSENS_ACTUATORVEL: elem = InsertEnd(section, "actuatorvel"); - WriteAttrTxt(elem, "actuator", psen->get_objname()); + WriteAttrTxt(elem, "actuator", sensor->get_objname()); break; case mjSENS_ACTUATORFRC: elem = InsertEnd(section, "actuatorfrc"); - WriteAttrTxt(elem, "actuator", psen->get_objname()); + WriteAttrTxt(elem, "actuator", sensor->get_objname()); break; case mjSENS_JOINTACTFRC: elem = InsertEnd(section, "jointactuatorfrc"); - WriteAttrTxt(elem, "joint", psen->get_objname()); + WriteAttrTxt(elem, "joint", sensor->get_objname()); break; // sensors related to ball joints case mjSENS_BALLQUAT: elem = InsertEnd(section, "ballquat"); - WriteAttrTxt(elem, "joint", psen->get_objname()); + WriteAttrTxt(elem, "joint", sensor->get_objname()); break; case mjSENS_BALLANGVEL: elem = InsertEnd(section, "ballangvel"); - WriteAttrTxt(elem, "joint", psen->get_objname()); + WriteAttrTxt(elem, "joint", sensor->get_objname()); break; // joint and tendon limit sensors case mjSENS_JOINTLIMITPOS: elem = InsertEnd(section, "jointlimitpos"); - WriteAttrTxt(elem, "joint", psen->get_objname()); + WriteAttrTxt(elem, "joint", sensor->get_objname()); break; case mjSENS_JOINTLIMITVEL: elem = InsertEnd(section, "jointlimitvel"); - WriteAttrTxt(elem, "joint", psen->get_objname()); + WriteAttrTxt(elem, "joint", sensor->get_objname()); break; case mjSENS_JOINTLIMITFRC: elem = InsertEnd(section, "jointlimitfrc"); - WriteAttrTxt(elem, "joint", psen->get_objname()); + WriteAttrTxt(elem, "joint", sensor->get_objname()); break; case mjSENS_TENDONLIMITPOS: elem = InsertEnd(section, "tendonlimitpos"); - WriteAttrTxt(elem, "tendon", psen->get_objname()); + WriteAttrTxt(elem, "tendon", sensor->get_objname()); break; case mjSENS_TENDONLIMITVEL: elem = InsertEnd(section, "tendonlimitvel"); - WriteAttrTxt(elem, "tendon", psen->get_objname()); + WriteAttrTxt(elem, "tendon", sensor->get_objname()); break; case mjSENS_TENDONLIMITFRC: elem = InsertEnd(section, "tendonlimitfrc"); - WriteAttrTxt(elem, "tendon", psen->get_objname()); + WriteAttrTxt(elem, "tendon", sensor->get_objname()); break; // sensors attached to an object with spatial frame: (x)body, geom, site, camera case mjSENS_FRAMEPOS: elem = InsertEnd(section, "framepos"); - WriteAttrTxt(elem, "objtype", mju_type2Str(psen->objtype)); - WriteAttrTxt(elem, "objname", psen->get_objname()); - if (psen->reftype != mjOBJ_UNKNOWN) { - WriteAttrTxt(elem, "reftype", mju_type2Str(psen->reftype)); - WriteAttrTxt(elem, "refname", psen->get_refname()); + WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype)); + WriteAttrTxt(elem, "objname", sensor->get_objname()); + if (sensor->reftype != mjOBJ_UNKNOWN) { + WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype)); + WriteAttrTxt(elem, "refname", sensor->get_refname()); } break; case mjSENS_FRAMEQUAT: elem = InsertEnd(section, "framequat"); - WriteAttrTxt(elem, "objtype", mju_type2Str(psen->objtype)); - WriteAttrTxt(elem, "objname", psen->get_objname()); - if (psen->reftype != mjOBJ_UNKNOWN) { - WriteAttrTxt(elem, "reftype", mju_type2Str(psen->reftype)); - WriteAttrTxt(elem, "refname", psen->get_refname()); + WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype)); + WriteAttrTxt(elem, "objname", sensor->get_objname()); + if (sensor->reftype != mjOBJ_UNKNOWN) { + WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype)); + WriteAttrTxt(elem, "refname", sensor->get_refname()); } break; case mjSENS_FRAMEXAXIS: elem = InsertEnd(section, "framexaxis"); - WriteAttrTxt(elem, "objtype", mju_type2Str(psen->objtype)); - WriteAttrTxt(elem, "objname", psen->get_objname()); - if (psen->reftype != mjOBJ_UNKNOWN) { - WriteAttrTxt(elem, "reftype", mju_type2Str(psen->reftype)); - WriteAttrTxt(elem, "refname", psen->get_refname()); + WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype)); + WriteAttrTxt(elem, "objname", sensor->get_objname()); + if (sensor->reftype != mjOBJ_UNKNOWN) { + WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype)); + WriteAttrTxt(elem, "refname", sensor->get_refname()); } break; case mjSENS_FRAMEYAXIS: elem = InsertEnd(section, "frameyaxis"); - WriteAttrTxt(elem, "objtype", mju_type2Str(psen->objtype)); - WriteAttrTxt(elem, "objname", psen->get_objname()); - if (psen->reftype != mjOBJ_UNKNOWN) { - WriteAttrTxt(elem, "reftype", mju_type2Str(psen->reftype)); - WriteAttrTxt(elem, "refname", psen->get_refname()); + WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype)); + WriteAttrTxt(elem, "objname", sensor->get_objname()); + if (sensor->reftype != mjOBJ_UNKNOWN) { + WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype)); + WriteAttrTxt(elem, "refname", sensor->get_refname()); } break; case mjSENS_FRAMEZAXIS: elem = InsertEnd(section, "framezaxis"); - WriteAttrTxt(elem, "objtype", mju_type2Str(psen->objtype)); - WriteAttrTxt(elem, "objname", psen->get_objname()); - if (psen->reftype != mjOBJ_UNKNOWN) { - WriteAttrTxt(elem, "reftype", mju_type2Str(psen->reftype)); - WriteAttrTxt(elem, "refname", psen->get_refname()); + WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype)); + WriteAttrTxt(elem, "objname", sensor->get_objname()); + if (sensor->reftype != mjOBJ_UNKNOWN) { + WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype)); + WriteAttrTxt(elem, "refname", sensor->get_refname()); } break; case mjSENS_FRAMELINVEL: elem = InsertEnd(section, "framelinvel"); - WriteAttrTxt(elem, "objtype", mju_type2Str(psen->objtype)); - WriteAttrTxt(elem, "objname", psen->get_objname()); - if (psen->reftype != mjOBJ_UNKNOWN) { - WriteAttrTxt(elem, "reftype", mju_type2Str(psen->reftype)); - WriteAttrTxt(elem, "refname", psen->get_refname()); + WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype)); + WriteAttrTxt(elem, "objname", sensor->get_objname()); + if (sensor->reftype != mjOBJ_UNKNOWN) { + WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype)); + WriteAttrTxt(elem, "refname", sensor->get_refname()); } break; case mjSENS_FRAMEANGVEL: elem = InsertEnd(section, "frameangvel"); - WriteAttrTxt(elem, "objtype", mju_type2Str(psen->objtype)); - WriteAttrTxt(elem, "objname", psen->get_objname()); - if (psen->reftype != mjOBJ_UNKNOWN) { - WriteAttrTxt(elem, "reftype", mju_type2Str(psen->reftype)); - WriteAttrTxt(elem, "refname", psen->get_refname()); + WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype)); + WriteAttrTxt(elem, "objname", sensor->get_objname()); + if (sensor->reftype != mjOBJ_UNKNOWN) { + WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype)); + WriteAttrTxt(elem, "refname", sensor->get_refname()); } break; case mjSENS_FRAMELINACC: elem = InsertEnd(section, "framelinacc"); - WriteAttrTxt(elem, "objtype", mju_type2Str(psen->objtype)); - WriteAttrTxt(elem, "objname", psen->get_objname()); - if (psen->reftype != mjOBJ_UNKNOWN) { - WriteAttrTxt(elem, "reftype", mju_type2Str(psen->reftype)); - WriteAttrTxt(elem, "refname", psen->get_refname()); + WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype)); + WriteAttrTxt(elem, "objname", sensor->get_objname()); + if (sensor->reftype != mjOBJ_UNKNOWN) { + WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype)); + WriteAttrTxt(elem, "refname", sensor->get_refname()); } break; case mjSENS_FRAMEANGACC: elem = InsertEnd(section, "frameangacc"); - WriteAttrTxt(elem, "objtype", mju_type2Str(psen->objtype)); - WriteAttrTxt(elem, "objname", psen->get_objname()); - if (psen->reftype != mjOBJ_UNKNOWN) { - WriteAttrTxt(elem, "reftype", mju_type2Str(psen->reftype)); - WriteAttrTxt(elem, "refname", psen->get_refname()); + WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype)); + WriteAttrTxt(elem, "objname", sensor->get_objname()); + if (sensor->reftype != mjOBJ_UNKNOWN) { + WriteAttrTxt(elem, "reftype", mju_type2Str(sensor->reftype)); + WriteAttrTxt(elem, "refname", sensor->get_refname()); } break; // sensors related to kinematic subtrees; attached to a body (which is the subtree root) case mjSENS_SUBTREECOM: elem = InsertEnd(section, "subtreecom"); - WriteAttrTxt(elem, "body", psen->get_objname()); + WriteAttrTxt(elem, "body", sensor->get_objname()); break; case mjSENS_SUBTREELINVEL: elem = InsertEnd(section, "subtreelinvel"); - WriteAttrTxt(elem, "body", psen->get_objname()); + WriteAttrTxt(elem, "body", sensor->get_objname()); break; case mjSENS_SUBTREEANGMOM: elem = InsertEnd(section, "subtreeangmom"); - WriteAttrTxt(elem, "body", psen->get_objname()); + WriteAttrTxt(elem, "body", sensor->get_objname()); break; case mjSENS_GEOMDIST: elem = InsertEnd(section, "distance"); - WriteAttrTxt(elem, psen->objtype == mjOBJ_BODY ? "body1" : "geom1", psen->get_objname()); - WriteAttrTxt(elem, psen->reftype == mjOBJ_BODY ? "body2" : "geom2", psen->get_refname()); + WriteAttrTxt(elem, sensor->objtype == mjOBJ_BODY ? "body1" : "geom1", sensor->get_objname()); + WriteAttrTxt(elem, sensor->reftype == mjOBJ_BODY ? "body2" : "geom2", sensor->get_refname()); break; case mjSENS_GEOMNORMAL: elem = InsertEnd(section, "normal"); - WriteAttrTxt(elem, psen->objtype == mjOBJ_BODY ? "body1" : "geom1", psen->get_objname()); - WriteAttrTxt(elem, psen->reftype == mjOBJ_BODY ? "body2" : "geom2", psen->get_refname()); + WriteAttrTxt(elem, sensor->objtype == mjOBJ_BODY ? "body1" : "geom1", sensor->get_objname()); + WriteAttrTxt(elem, sensor->reftype == mjOBJ_BODY ? "body2" : "geom2", sensor->get_refname()); break; case mjSENS_GEOMFROMTO: elem = InsertEnd(section, "fromto"); - WriteAttrTxt(elem, psen->objtype == mjOBJ_BODY ? "body1" : "geom1", psen->get_objname()); - WriteAttrTxt(elem, psen->reftype == mjOBJ_BODY ? "body2" : "geom2", psen->get_refname()); + WriteAttrTxt(elem, sensor->objtype == mjOBJ_BODY ? "body1" : "geom1", sensor->get_objname()); + WriteAttrTxt(elem, sensor->reftype == mjOBJ_BODY ? "body2" : "geom2", sensor->get_refname()); break; // global sensors @@ -2149,21 +2149,21 @@ void mjXWriter::Sensor(XMLElement* root) { // plugin-controlled sensor case mjSENS_PLUGIN: elem = InsertEnd(section, "plugin"); - if (psen->objtype != mjOBJ_UNKNOWN) { - WriteAttrTxt(elem, "objtype", mju_type2Str(psen->objtype)); - WriteAttrTxt(elem, "objname", psen->get_objname()); + if (sensor->objtype != mjOBJ_UNKNOWN) { + WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype)); + WriteAttrTxt(elem, "objname", sensor->get_objname()); } - OnePlugin(elem, &psen->plugin); + OnePlugin(elem, &sensor->plugin); break; // user-defined sensor case mjSENS_USER: elem = InsertEnd(section, "user"); - if (mju_type2Str(psen->objtype)) WriteAttrTxt(elem, "objtype", mju_type2Str(psen->objtype)); - WriteAttrTxt(elem, "objname", psen->get_objname()); - WriteAttrInt(elem, "dim", psen->dim); - WriteAttrKey(elem, "needstage", stage_map, stage_sz, (int)psen->needstage); - WriteAttrKey(elem, "datatype", datatype_map, datatype_sz, (int)psen->datatype); + if (mju_type2Str(sensor->objtype)) WriteAttrTxt(elem, "objtype", mju_type2Str(sensor->objtype)); + WriteAttrTxt(elem, "objname", sensor->get_objname()); + WriteAttrInt(elem, "dim", sensor->dim); + WriteAttrKey(elem, "needstage", stage_map, stage_sz, (int)sensor->needstage); + WriteAttrKey(elem, "datatype", datatype_map, datatype_sz, (int)sensor->datatype); break; default: @@ -2171,12 +2171,12 @@ void mjXWriter::Sensor(XMLElement* root) { } // write name, noise, userdata - WriteAttrTxt(elem, "name", psen->name); - WriteAttr(elem, "cutoff", 1, &psen->cutoff, &zero); - if (psen->type != mjSENS_PLUGIN) { - WriteAttr(elem, "noise", 1, &psen->noise, &zero); + WriteAttrTxt(elem, "name", sensor->name); + WriteAttr(elem, "cutoff", 1, &sensor->cutoff, &zero); + if (sensor->type != mjSENS_PLUGIN) { + WriteAttr(elem, "noise", 1, &sensor->noise, &zero); } - WriteVector(elem, "user", psen->get_userdata()); + WriteVector(elem, "user", sensor->get_userdata()); } // remove section if empty @@ -2197,24 +2197,24 @@ void mjXWriter::Keyframe(XMLElement* root) { XMLElement* elem = InsertEnd(section, "key"); bool change = false; - mjCKey* pk = model->Keys()[i]; + mjCKey* key = model->Keys()[i]; // check name and write - if (!pk->name.empty()) { - WriteAttrTxt(elem, "name", pk->name); + if (!key->name.empty()) { + WriteAttrTxt(elem, "name", key->name); change = true; } // check time and write - if (pk->time!=0) { - WriteAttr(elem, "time", 1, &pk->time); + if (key->time!=0) { + WriteAttr(elem, "time", 1, &key->time); change = true; } // check qpos and write for (int j=0; jnq; j++) { - if (pk->qpos_[j]!=model->qpos0[j]) { - WriteAttr(elem, "qpos", model->nq, pk->qpos_.data()); + if (key->qpos_[j]!=model->qpos0[j]) { + WriteAttr(elem, "qpos", model->nq, key->qpos_.data()); change = true; break; } @@ -2222,8 +2222,8 @@ void mjXWriter::Keyframe(XMLElement* root) { // check qvel and write for (int j=0; jnv; j++) { - if (pk->qvel_[j]!=0) { - WriteAttr(elem, "qvel", model->nv, pk->qvel_.data()); + if (key->qvel_[j]!=0) { + WriteAttr(elem, "qvel", model->nv, key->qvel_.data()); change = true; break; } @@ -2231,8 +2231,8 @@ void mjXWriter::Keyframe(XMLElement* root) { // check act and write for (int j=0; jna; j++) { - if (pk->act_[j]!=0) { - WriteAttr(elem, "act", model->na, pk->act_.data()); + if (key->act_[j]!=0) { + WriteAttr(elem, "act", model->na, key->act_.data()); change = true; break; } @@ -2242,12 +2242,12 @@ void mjXWriter::Keyframe(XMLElement* root) { if (model->nmocap) { for (int j=0; jnbody; j++) { if (model->Bodies()[j]->mocap) { - mjCBody* pb = model->Bodies()[j]; - int id = pb->mocapid; - if (pb->pos[0] != pk->mpos_[3*id] || - pb->pos[1] != pk->mpos_[3*id+1] || - pb->pos[2] != pk->mpos_[3*id+2]) { - WriteAttr(elem, "mpos", 3*model->nmocap, pk->mpos_.data()); + mjCBody* body = model->Bodies()[j]; + int id = body->mocapid; + if (body->pos[0] != key->mpos_[3*id] || + body->pos[1] != key->mpos_[3*id+1] || + body->pos[2] != key->mpos_[3*id+2]) { + WriteAttr(elem, "mpos", 3*model->nmocap, key->mpos_.data()); change = true; break; } @@ -2259,13 +2259,13 @@ void mjXWriter::Keyframe(XMLElement* root) { if (model->nmocap) { for (int j=0; jnbody; j++) { if (model->Bodies()[j]->mocap) { - mjCBody* pb = model->Bodies()[j]; - int id = pb->mocapid; - if (pb->quat[0] != pk->mquat_[4*id] || - pb->quat[1] != pk->mquat_[4*id+1] || - pb->quat[2] != pk->mquat_[4*id+2] || - pb->quat[3] != pk->mquat_[4*id+3]) { - WriteAttr(elem, "mquat", 4*model->nmocap, pk->mquat_.data()); + mjCBody* body = model->Bodies()[j]; + int id = body->mocapid; + if (body->quat[0] != key->mquat_[4*id] || + body->quat[1] != key->mquat_[4*id+1] || + body->quat[2] != key->mquat_[4*id+2] || + body->quat[3] != key->mquat_[4*id+3]) { + WriteAttr(elem, "mquat", 4*model->nmocap, key->mquat_.data()); change = true; break; } @@ -2275,8 +2275,8 @@ void mjXWriter::Keyframe(XMLElement* root) { // check ctrl and write for (int j=0; jnu; j++) { - if (pk->ctrl_[j]!=0) { - WriteAttr(elem, "ctrl", model->nu, pk->ctrl_.data()); + if (key->ctrl_[j]!=0) { + WriteAttr(elem, "ctrl", model->nu, key->ctrl_.data()); change = true; break; }