Rework how clone/copy works (#254)

examples/objects/lod.cpp

@@ -16,17 +16,25 @@ int main() {
 
     OrbitControls controls{camera, canvas};
 
-    LOD lod;
-    scene.add(lod);
+    LOD lod1;
+    scene.add(lod1);
 
     float radius = 0.5;
     auto material = MeshBasicMaterial::create({{"wireframe", true}});
     for (int z = 0; z <= 5; z++) {
         int detail = 6 - z;
         auto obj = Mesh::create(IcosahedronGeometry::create(radius, detail), material);
-        lod.addLevel(obj, static_cast<float>(z));
+        lod1.addLevel(obj, static_cast<float>(z));
     }
 
+    LOD lod2;
+    lod2.copy(lod1);
+    scene.add(lod2);
+
+    float spacing = 1;
+    lod1.position.x = spacing;
+    lod2.position.x = -spacing;
+
     canvas.onWindowResize([&](WindowSize size) {
         camera.aspect = size.aspect();
         camera.updateProjectionMatrix();
@@ -38,12 +46,18 @@ int main() {
     const auto font = *fontLoader.load("data/fonts/gentilis_bold.typeface.json");
 
     TextGeometry::Options opts(font, 20, 5);
-    auto handle = Text2D(opts, "");
-    handle.setColor(Color::gray);
-    hud.add(handle);
+
+    Text2D handle1(opts);
+    handle1.setColor(Color::gray);
+    hud.add(handle1, HUD::Options().setNormalizedPosition({0.f, 0.05f}));
+
+    Text2D handle2(opts);
+    handle2.setColor(Color::gray);
+    hud.add(handle2);
 
     canvas.animate([&]() {
-        handle.setText("LOD level: " + std::to_string(lod.getCurrentLevel()), opts);
+        handle1.setText("LOD1 level: " + std::to_string(lod1.getCurrentLevel()));
+        handle2.setText("LOD2 level: " + std::to_string(lod2.getCurrentLevel()));
 
         renderer.clear();
         renderer.render(scene, camera);

include/threepp/core/Object3D.hpp

@@ -240,18 +240,40 @@ namespace threepp {
             return dynamic_cast<T*>(this);
         }
 
+        template<class T>
+        const T* as() const {
+
+            static_assert(std::is_base_of<Object3D, typename std::remove_cv<typename std::remove_pointer<T>::type>::type>::value,
+                          "T must be a base class of Object3D");
+
+            return dynamic_cast<const T*>(this);
+        }
+
         template<class T>
         [[nodiscard]] bool is() const {
 
             return dynamic_cast<const T*>(this) != nullptr;
         }
 
-        void copy(const Object3D& source, bool recursive = true);
+        virtual void copy(const Object3D& source, bool recursive = true);
 
-        virtual std::shared_ptr<Object3D> clone(bool recursive = true);
+        template<class T = Object3D>
+        std::shared_ptr<T> clone(bool recursive = true) {
+
+            auto clone = createDefault();
+            clone->copy(*this, recursive);
+
+            return std::dynamic_pointer_cast<T>(clone);
+        }
 
         ~Object3D() override;
 
+    protected:
+        virtual std::shared_ptr<Object3D> createDefault() {
+
+            return std::make_shared<Object3D>();
+        }
+
     private:
         inline static unsigned int _object3Did{0};
 

include/threepp/objects/Bone.hpp

@@ -18,6 +18,12 @@ namespace threepp {
 
             return std::make_shared<Bone>();
         }
+
+    protected:
+        std::shared_ptr<Object3D> createDefault() override {
+
+            return create();
+        }
     };
 
 }// namespace threepp

include/threepp/objects/Group.hpp

@@ -12,11 +12,12 @@ namespace threepp {
     public:
         [[nodiscard]] std::string type() const override;
 
-        std::shared_ptr<Object3D> clone(bool recursive = true) override;
-
         static std::shared_ptr<Group> create();
 
         ~Group() override = default;
+
+    protected:
+        std::shared_ptr<Object3D> createDefault() override;
     };
 
 }// namespace threepp

include/threepp/objects/LOD.hpp

@@ -35,8 +35,13 @@ namespace threepp {
 
         void update(Camera& camera);
 
+        void copy(const Object3D& source, bool recursive = false) override;
+
         static std::shared_ptr<LOD> create();
 
+    protected:
+        std::shared_ptr<Object3D> createDefault() override;
+
     private:
         size_t _currentLevel = 0;
         std::vector<Level> levels;

include/threepp/objects/Line.hpp

@@ -27,14 +27,16 @@ namespace threepp {
 
         virtual void computeLineDistances();
 
-        void raycast(const Raycaster& raycaster, std::vector<Intersection>& intersects) override;
+        void copy(const Object3D& source, bool recursive = true) override;
 
-        std::shared_ptr<Object3D> clone(bool recursive = true) override;
+        void raycast(const Raycaster& raycaster, std::vector<Intersection>& intersects) override;
 
         static std::shared_ptr<Line> create(const std::shared_ptr<BufferGeometry>& geometry = nullptr, const std::shared_ptr<Material>& material = nullptr);
 
     protected:
         std::shared_ptr<BufferGeometry> geometry_;
+
+        std::shared_ptr<Object3D> createDefault() override;
     };
 
 }// namespace threepp

include/threepp/objects/LineLoop.hpp

@@ -14,8 +14,6 @@ namespace threepp {
 
         [[nodiscard]] std::string type() const override;
 
-        std::shared_ptr<Object3D> clone(bool recursive = true) override;
-
         static std::shared_ptr<LineLoop> create(
                 const std::shared_ptr<BufferGeometry>& geometry = nullptr,
                 const std::shared_ptr<Material>& material = nullptr);

include/threepp/objects/LineSegments.hpp

@@ -18,8 +18,6 @@ namespace threepp {
 
         void computeLineDistances() override;
 
-        std::shared_ptr<Object3D> clone(bool recursive = true) override;
-
         static std::shared_ptr<LineSegments> create(
                 const std::shared_ptr<BufferGeometry>& geometry = nullptr,
                 const std::shared_ptr<Material>& material = nullptr);

include/threepp/objects/Mesh.hpp

@@ -29,7 +29,7 @@ namespace threepp {
 
         void raycast(const Raycaster& raycaster, std::vector<Intersection>& intersects) override;
 
-        std::shared_ptr<Object3D> clone(bool recursive = true) override;
+        void copy(const Object3D& source, bool recursive = true) override;
 
         static std::shared_ptr<Mesh> create(
                 std::shared_ptr<BufferGeometry> geometry = nullptr,
@@ -43,6 +43,8 @@ namespace threepp {
 
     protected:
         std::shared_ptr<BufferGeometry> geometry_;
+
+        std::shared_ptr<Object3D> createDefault() override;
     };
 
 }// namespace threepp

include/threepp/objects/Points.hpp

@@ -22,16 +22,18 @@ namespace threepp {
 
         void setGeometry(const std::shared_ptr<BufferGeometry>& geometry);
 
-        std::shared_ptr<Object3D> clone(bool recursive = true) override;
-
         void raycast(const Raycaster& raycaster, std::vector<Intersection>& intersects) override;
 
+        void copy(const Object3D& source, bool recursive = true) override;
+
         static std::shared_ptr<Points> create(
                 std::shared_ptr<BufferGeometry> geometry = BufferGeometry::create(),
                 std::shared_ptr<Material> material = PointsMaterial::create());
 
     protected:
         std::shared_ptr<BufferGeometry> geometry_;
+
+        std::shared_ptr<Object3D> createDefault() override;
     };
 
 }// namespace threepp

include/threepp/objects/Sprite.hpp

@@ -26,8 +26,13 @@ namespace threepp {
 
         void setMaterial(const std::shared_ptr<SpriteMaterial>& material);
 
+        void copy(const Object3D& source, bool recursive = true) override;
+
         static std::shared_ptr<Sprite> create(const std::shared_ptr<SpriteMaterial>& material = nullptr);
 
+    protected:
+        std::shared_ptr<Object3D> createDefault() override;
+
     private:
         std::shared_ptr<BufferGeometry> _geometry;
         std::shared_ptr<SpriteMaterial> _material;

src/threepp/core/Object3D.cpp

@@ -442,22 +442,14 @@ void Object3D::copy(const Object3D& source, bool recursive) {
 
     if (recursive) {
 
-        for (auto& child : source.children) {
+        for (const auto& child : source.children) {
 
             auto clone = child->clone();
             this->add(clone);
         }
     }
 }
 
-std::shared_ptr<Object3D> Object3D::clone(bool recursive) {
-
-    auto clone = std::make_shared<Object3D>();
-    clone->copy(*this, recursive);
-
-    return clone;
-}
-
 Object3D::Object3D(Object3D&& source) noexcept: Object3D() {
 
     this->name = std::move(source.name);

src/threepp/loaders/OBJLoader.cpp

@@ -295,7 +295,7 @@ struct OBJLoader::Impl {
 
             auto cached = cache_[path.string()];
             if (!cached.expired()) {
-                return std::dynamic_pointer_cast<Group>(cached.lock()->clone());
+                return cached.lock()->clone<Group>();
             } else {
                 cache_.erase(path.string());
             }

src/threepp/objects/Group.cpp

@@ -10,14 +10,12 @@ std::string Group::type() const {
     return "Group";
 }
 
-std::shared_ptr<Object3D> Group::clone(bool recursive) {
-    auto clone = create();
-    clone->copy(*this, recursive);
+std::shared_ptr<Group> Group::create() {
 
-    return clone;
+    return std::make_shared<Group>();
 }
 
-std::shared_ptr<Group> Group::create() {
+std::shared_ptr<Object3D> Group::createDefault() {
 
-    return std::make_shared<Group>();
+    return create();
 }

src/threepp/objects/LOD.cpp

@@ -101,3 +101,22 @@ void LOD::update(Camera& camera) {
         }
     }
 }
+
+void LOD::copy(const Object3D& source, bool recursive) {
+    Object3D::copy(source, false);
+
+    if (const auto l = source.as<LOD>()) {
+
+        for (auto level : l->levels) {
+
+            this->addLevel(level.object->clone(), level.distance);
+        }
+
+        this->autoUpdate = l->autoUpdate;
+    }
+}
+
+std::shared_ptr<Object3D> LOD::createDefault() {
+
+    return create();
+}

src/threepp/objects/Line.cpp

@@ -36,13 +36,6 @@ void Line::setGeometry(const std::shared_ptr<BufferGeometry>& geometry) {
     this->geometry_ = geometry;
 }
 
-std::shared_ptr<Object3D> Line::clone(bool recursive) {
-    auto clone = create(geometry_, materials_.front());
-    clone->copy(*this, recursive);
-
-    return clone;
-}
-
 std::shared_ptr<Line> Line::create(const std::shared_ptr<BufferGeometry>& geometry, const std::shared_ptr<Material>& material) {
 
     return std::make_shared<Line>(geometry, (material));
@@ -172,3 +165,18 @@ void Line::raycast(const Raycaster& raycaster, std::vector<Intersection>& inters
         }
     }
 }
+
+void Line::copy(const Object3D& source, bool recursive) {
+    Object3D::copy(source, recursive);
+
+    if (const auto l = source.as<Line>()) {
+
+        materials_ = l->materials_;
+        geometry_ = l->geometry_;
+    }
+}
+
+std::shared_ptr<Object3D> Line::createDefault() {
+
+    return create();
+}

src/threepp/objects/LineLoop.cpp

@@ -17,13 +17,6 @@ std::string LineLoop::type() const {
     return "LineLoop";
 }
 
-std::shared_ptr<Object3D> LineLoop::clone(bool recursive) {
-    auto clone = create();
-    clone->copy(*this, recursive);
-
-    return clone;
-}
-
 std::shared_ptr<LineLoop> LineLoop::create(const std::shared_ptr<BufferGeometry>& geometry, const std::shared_ptr<Material>& material) {
 
     return std::make_shared<LineLoop>(geometry, (material));

src/threepp/objects/LineSegments.cpp

@@ -46,13 +46,6 @@ void LineSegments::computeLineDistances() {
     }
 }
 
-std::shared_ptr<Object3D> LineSegments::clone(bool recursive) {
-    auto clone = create();
-    clone->copy(*this, recursive);
-
-    return clone;
-}
-
 std::shared_ptr<LineSegments> LineSegments::create(
         const std::shared_ptr<BufferGeometry>& geometry,
         const std::shared_ptr<Material>& material) {

src/threepp/objects/Mesh.cpp

@@ -333,14 +333,6 @@ void Mesh::raycast(const Raycaster& raycaster, std::vector<Intersection>& inters
     }
 }
 
-std::shared_ptr<Object3D> Mesh::clone(bool recursive) {
-
-    auto clone = create(geometry_, materials_);
-    clone->copy(*this, recursive);
-
-    return clone;
-}
-
 std::string Mesh::type() const {
 
     return "Mesh";
@@ -370,3 +362,19 @@ std::shared_ptr<Mesh> Mesh::create(std::shared_ptr<BufferGeometry> geometry, std
 
     return std::make_shared<Mesh>(std::move(geometry), std::move(materials));
 }
+
+void Mesh::copy(const Object3D& source, bool recursive) {
+    Object3D::copy(source, recursive);
+
+    if (const auto m = source.as<Mesh>()) {
+
+        // TODO morphs
+
+        materials_ = m->materials_;
+        geometry_ = m->geometry_;
+    }
+}
+
+std::shared_ptr<Object3D> Mesh::createDefault() {
+    return create();
+}