Add mjmMesh to C API.

PiperOrigin-RevId: 606642150
Change-Id: Iae69ce8426729b1e2394d9da9f349a2f0f7ccf98

src/xml/xml_native_reader.cc

@@ -1346,18 +1346,26 @@ void mjXReader::OneFlex(XMLElement* elem, mjmFlex* pflex) {
 
 
 // mesh element parser
-void mjXReader::OneMesh(XMLElement* elem, mjCMesh* pmesh) {
+void mjXReader::OneMesh(XMLElement* elem, mjmMesh* pmesh) {
   int n;
-  string text;
+  string text, name, classname, content_type, file;
 
   // read attributes
-  ReadAttrTxt(elem, "name", pmesh->name);
-  ReadAttrTxt(elem, "class", pmesh->classname);
-  pmesh->set_content_type(ReadAttrStr(elem, "content_type"));
-  pmesh->set_file(ReadAttrStr(elem, "file"));
-  pmesh->set_refpos(ReadAttrArr<double, 3>(elem, "refpos"));
-  pmesh->set_refquat(ReadAttrArr<double, 4>(elem, "refquat"));
-  pmesh->set_scale(ReadAttrArr<double, 3>(elem, "scale"));
+  if (ReadAttrTxt(elem, "name", name)) {
+    mjm_setString(pmesh->name, name.c_str());
+  }
+  if (ReadAttrTxt(elem, "class", classname)) {
+    mjm_setString(pmesh->classname, classname.c_str());
+  }
+  if (ReadAttrTxt(elem, "content_type", content_type)) {
+    mjm_setString(pmesh->content_type, content_type.c_str());
+  }
+  if (ReadAttrTxt(elem, "file", file)) {
+    mjm_setString(pmesh->file, file.c_str());
+  }
+  ReadAttr(elem, "refpos", 3, pmesh->refpos, text);
+  ReadAttr(elem, "refpos", 4, pmesh->refquat, text);
+  ReadAttr(elem, "scale", 3, pmesh->scale, text);
 
   XMLElement* eplugin = FirstChildElement(elem, "plugin");
   if (eplugin) {
@@ -1365,22 +1373,44 @@ void mjXReader::OneMesh(XMLElement* elem, mjCMesh* pmesh) {
   }
 
   if (MapValue(elem, "smoothnormal", &n, bool_map, 2)) {
-    pmesh->set_smoothnormal((n==1));
+    pmesh->smoothnormal = (n==1);
   }
 
   // read user vertex data
-  pmesh->set_uservert(ReadAttrVec<float>(elem, "vertex"));
+  if (ReadAttrTxt(elem, "vertex", text)) {
+    auto uservert = ReadAttrVec<float>(elem, "vertex");
+    if (uservert.has_value()) {
+      mjm_setFloat(pmesh->uservert, uservert->data(), uservert->size());
+    }
+  }
 
   // read user normal data
-  pmesh->set_usernormal(ReadAttrVec<float>(elem, "normal"));
+  if (ReadAttrTxt(elem, "normal", text)) {
+    auto usernormal = ReadAttrVec<float>(elem, "normal");
+    if (usernormal.has_value()) {
+      mjm_setFloat(pmesh->usernormal, usernormal->data(), usernormal->size());
+    }
+  }
 
   // read user texcoord data
-  pmesh->set_usertexcoord(ReadAttrVec<float>(elem, "texcoord"));
+  if (ReadAttrTxt(elem, "texcoord", text)) {
+    auto usertexcoord = ReadAttrVec<float>(elem, "texcoord");
+    if (usertexcoord.has_value()) {
+      mjm_setFloat(pmesh->usertexcoord, usertexcoord->data(), usertexcoord->size());
+    }
+  }
 
   // read user face data
-  pmesh->set_userface(ReadAttrVec<int>(elem, "face"));
+  if (ReadAttrTxt(elem, "face", text)) {
+    auto userface = ReadAttrVec<int>(elem, "face");
+    if (userface.has_value()) {
+      mjm_setInt(pmesh->userface, userface->data(), userface->size());
+    }
+  }
 
-  GetXMLPos(elem, pmesh);
+  // write error info
+  mjm_setString(pmesh->info,
+      std::string("line = " + std::to_string(elem->GetLineNum()) + ", column = -1").c_str());
 }
 
 
@@ -2608,7 +2638,7 @@ void mjXReader::Default(XMLElement* section, int parentid) {
     name = elem->Value();
 
     // read mesh
-    if (name=="mesh") OneMesh(elem, &def->mesh);
+    if (name=="mesh") OneMesh(elem, &def->mesh.spec);
 
     // read material
     else if (name=="material") OneMaterial(elem, &def->material.spec);
@@ -3073,7 +3103,7 @@ void mjXReader::Asset(XMLElement* section) {
     // mesh sub-element
     else if (name=="mesh") {
       // create mesh and parse
-      mjCMesh* pmesh = model->AddMesh(def);
+      mjmMesh* pmesh = mjm_addMesh(model, def);
       OneMesh(elem, pmesh);
     }
 

src/xml/xml_native_reader.h

@@ -59,7 +59,7 @@ class mjXReader : public mjXBase {
 
   // single element parsers, used in defaults and main body
   void OneFlex(tinyxml2::XMLElement* elem, mjmFlex* pflex);
-  void OneMesh(tinyxml2::XMLElement* elem, mjCMesh* pmesh);
+  void OneMesh(tinyxml2::XMLElement* elem, mjmMesh* pmesh);
   void OneSkin(tinyxml2::XMLElement* elem, mjCSkin* pskin);
   void OneMaterial(tinyxml2::XMLElement* elem, mjmMaterial* pmaterial);
   void OneJoint(tinyxml2::XMLElement* elem, mjmJoint* pjoint);

src/xml/xml_native_writer.cc

@@ -159,39 +159,40 @@ void mjXWriter::OneMesh(XMLElement* elem, mjCMesh* pmesh, mjCDef* def) {
   if (!writingdefaults) {
     WriteAttrTxt(elem, "name", pmesh->name);
     WriteAttrTxt(elem, "class", pmesh->classname);
-    WriteAttrTxt(elem, "content_type", pmesh->content_type());
-    WriteAttrTxt(elem, "file", pmesh->file());
+    WriteAttrTxt(elem, "content_type", pmesh->get_content_type());
+    WriteAttrTxt(elem, "file", pmesh->get_file());
 
     // write vertex data
-    if (!pmesh->uservert().empty()) {
-      Vector2String(text, pmesh->uservert());
+    if (!pmesh->get_uservert().empty()) {
+      Vector2String(text, pmesh->get_uservert());
       WriteAttrTxt(elem, "vertex", text);
     }
 
     // write normal data
-    if (!pmesh->usernormal().empty()) {
-      Vector2String(text, pmesh->usernormal());
+    if (!pmesh->get_usernormal().empty()) {
+      Vector2String(text, pmesh->get_usernormal());
       WriteAttrTxt(elem, "normal", text);
     }
 
     // write texcoord data
-    if (!pmesh->usertexcoord().empty()) {
-      Vector2String(text, pmesh->usertexcoord());
+    if (!pmesh->get_usertexcoord().empty()) {
+      Vector2String(text, pmesh->get_usertexcoord());
       WriteAttrTxt(elem, "texcoord", text);
     }
 
     // write face data
-    if (!pmesh->userface().empty()) {
-      Vector2String(text, pmesh->userface());
+    if (!pmesh->get_userface().empty()) {
+      Vector2String(text, pmesh->get_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(), def->mesh.smoothnormal());
+  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->get_smoothnormal(),
+               def->mesh.get_smoothnormal());
 }
 
 

src/xml/xml_urdf.cc

@@ -571,26 +571,34 @@ mjmGeom* mjXURDF::Geom(XMLElement* geom_elem, mjmBody* pbody, bool collision) {
     meshname = mjuu_stripext(meshname);
 
     // look for existing mesh
-    mjCMesh* pmesh = (mjCMesh*)model->FindObject(mjOBJ_MESH, meshname);
+    mjCMesh* mesh = (mjCMesh*)model->FindObject(mjOBJ_MESH, meshname);
+    mjmMesh* pmesh = 0;
 
     // does not exist: create
-    if (!pmesh) {
-      pmesh = model->AddMesh();
+    if (!mesh) {
+      pmesh = mjm_addMesh(model, 0);
     }
 
     // exists with different scale: append name with '1', create
-    else if (pmesh->scale()[0]!=meshscale[0] ||
-             pmesh->scale()[1]!=meshscale[1] ||
-             pmesh->scale()[2]!=meshscale[2]) {
-      pmesh = model->AddMesh();
+    else if (mesh->spec.scale[0]!=meshscale[0] ||
+             mesh->spec.scale[1]!=meshscale[1] ||
+             mesh->spec.scale[2]!=meshscale[2]) {
+      pmesh = mjm_addMesh(model, 0);
       meshname = meshname + "1";
     }
 
+    // point to already existing spec
+    else {
+      pmesh = &mesh->spec;
+    }
+
     // set fields
-    pmesh->set_file(meshfile);
-    pmesh->name = meshname;
+    mjm_setString(pmesh->file, meshfile.c_str());
+    mjm_setString(pmesh->name, meshname.c_str());
     mjm_setString(pgeom->meshname, meshname.c_str());
-    pmesh->set_scale(meshscale);
+    pmesh->scale[0] = meshscale[0];
+    pmesh->scale[1] = meshscale[1];
+    pmesh->scale[2] = meshscale[2];
   }
 
   else {