cleanup

Author: markaren

examples/loaders/urdf_loader.cpp

@@ -74,7 +74,7 @@ int main(int argc, char** argv) {
         for (auto i = 0; i < robot->numDOF(); i++) {
             const auto type = info[i].type;
             const auto minmax = robot->getJointRange(i, true);
-            bool isRevolute = type == JointType::Revolute;
+            bool isRevolute = type == Robot::JointType::Revolute;
             float min = minmax.first > (isRevolute ? -360.f : -1.f) ? minmax.first : (isRevolute ? -360.f : -1.f);
             float max = minmax.second < (isRevolute ? 360.f : 1.f) ? minmax.second : (isRevolute ? 360.f : 1.f);
             if (ImGui::SliderFloat(labels[i].c_str(), &jointValues[i], min, max)) {
@@ -100,12 +100,11 @@ int main(int argc, char** argv) {
 
     Clock clock;
     canvas.animate([&]() {
-        const auto dt = clock.getDelta();
 
         if (animate) {
             for (auto i = 0; i < robot->numDOF(); ++i) {
                 jointValues[i] = robot->getJointValue(i, true);
-                robot->setJointValue(i, std::sin(clock.elapsedTime) * 0.5f);
+                robot->setJointValue(i, std::sin(clock.getElapsedTime()) * 0.5f);
             }
         }
 

include/threepp/objects/Robot.hpp

@@ -9,33 +9,33 @@
 
 namespace threepp {
 
-    struct JointRange {
-        float min;
-        float max;
+    class Robot: public Object3D {
 
-        [[nodiscard]] float clamp(float value) const {
-            return std::clamp(value, min, max);
-        }
-    };
+    public:
+        struct JointRange {
+            float min;
+            float max;
 
-    enum class JointType {
-        Revolute,
-        Prismatic,
-        Fixed
-    };
+            [[nodiscard]] float clamp(float value) const {
+                return std::clamp(value, min, max);
+            }
+        };
 
-    struct JointInfo {
-        Vector3 axis;
-        JointType type;
-        std::optional<JointRange> range;
+        enum class JointType {
+            Revolute,
+            Prismatic,
+            Fixed
+        };
 
-        std::string parent;
-        std::string child;
-    };
+        struct JointInfo {
+            Vector3 axis;
+            JointType type;
+            std::optional<JointRange> range;
 
-    class Robot: public Object3D {
+            std::string parent;
+            std::string child;
+        };
 
-    public:
         Robot() = default;
 
         void showColliders(bool flag) {
@@ -56,7 +56,7 @@ namespace threepp {
             joints_.emplace_back(joint);
             jointInfos_.emplace_back(info);
             if (info.type != JointType::Fixed) {
-                size_t idx = joints_.size() -1;
+                size_t idx = joints_.size() - 1;
                 articulatedJoints_.emplace(idx, std::make_pair(joint.get(), info));
                 origPose_.emplace(idx, std::make_pair(joint->position.clone(), joint->quaternion.clone()));
             }
@@ -122,10 +122,7 @@ namespace threepp {
                 }
             }
 
-            for (const auto& l : links_) {
-
-                if (!l->parent) add(*l);
-            }
+            add(links_.front());
 
             jointValues_.resize(numDOF());
         }
@@ -223,14 +220,14 @@ namespace threepp {
         }
 
     private:
+        std::vector<float> jointValues_;
+
         std::vector<JointInfo> jointInfos_;
         std::vector<std::shared_ptr<Object3D>> links_;
         std::vector<std::shared_ptr<Object3D>> colliders_;
         std::vector<std::shared_ptr<Object3D>> joints_;
         std::unordered_map<size_t, std::pair<Object3D*, JointInfo>> articulatedJoints_;
         std::unordered_map<size_t, std::pair<Vector3, Quaternion>> origPose_;
-
-        std::vector<float> jointValues_;
     };
 
 }// namespace threepp

src/threepp/loaders/URDFLoader.cpp

@@ -57,27 +57,27 @@ namespace {
         return mtl;
     }
 
-    JointType getType(const std::string& type) {
+    Robot::JointType getType(const std::string& type) {
         if (type == "revolute" || type == "continuous") {
-            return JointType::Revolute;
+            return Robot::JointType::Revolute;
         }
         if (type == "prismatic") {
-            return JointType::Prismatic;
+            return Robot::JointType::Prismatic;
         }
-        return JointType::Fixed;
+        return Robot::JointType::Fixed;
     }
 
-    std::optional<JointRange> getRange(const pugi::xml_node& node) {
+    std::optional<Robot::JointRange> getRange(const pugi::xml_node& node) {
         const auto limit = node.child("limit");
         if (!limit || !limit.attribute("lower") || !limit.attribute("upper")) return {};
         const auto min = utils::parseFloat(limit.attribute("lower").value());
         const auto max = utils::parseFloat(limit.attribute("upper").value());
-        return JointRange{
+        return Robot::JointRange{
                 .min = min,
                 .max = max};
     }
 
-    JointInfo parseInfo(const pugi::xml_node& node) {
+    Robot::JointInfo parseInfo(const pugi::xml_node& node) {
 
         auto axis = parseTupleString(node.child("axis")
                                              .attribute("xyz")