misc

examples/geometries/box_geometry.cpp

@@ -16,8 +16,8 @@ namespace {
         auto geometry = BoxGeometry::create(params);
         auto material = MeshBasicMaterial::create();
 
-        Mesh mesh(geometry, material);
-        mesh.add(createWireframe(*geometry));
+        auto mesh = Mesh::create(geometry, material);
+        mesh->add(createWireframe(*geometry));
 
         return mesh;
     }
@@ -79,16 +79,16 @@ int main() {
     canvas.animate([&]() {
         float dt = clock.getDelta();
 
-        mesh.rotation.y += 0.8f * dt;
-        mesh.rotation.x += 0.5f * dt;
+        mesh->rotation.y += 0.8f * dt;
+        mesh->rotation.x += 0.5f * dt;
 
         renderer.render(scene, camera);
 
         ui.render();
 
         if (paramsChanged) {
             paramsChanged = false;
-            updateGroupGeometry(mesh, params);
+            updateGroupGeometry(*mesh, params);
         }
     });
 }

examples/misc/morphtargets_sphere.cpp

@@ -43,7 +43,7 @@ int main() {
 
         mesh->material()->as<MaterialWithMorphTargets>()->morphTargets = true;
 
-        auto points = Points::create(mesh->shared_geometry(), pointsMaterial);
+        auto points = Points::create(mesh->geometry()->shared_from_this(), pointsMaterial);
         points->copyMorphTargetInfluences(&mesh->morphTargetInfluences());
         mesh->add(points);
     });

examples/objects/decal.cpp

@@ -192,7 +192,7 @@ int main() {
 
                 Vector3 scale = Vector3::ONES() * math::randFloat(0.6f, 1.2f);
 
-                auto mat = decalMat->clone()->as<MeshPhongMaterial>();
+                auto mat = decalMat->clone()->as_shared<MeshPhongMaterial>();
                 mat->color.randomize();
                 orientation.z = math::PI * math::randFloat();
                 auto m = Mesh::create(DecalGeometry::create(*mesh, position, orientation, scale), mat);

examples/objects/sprite.cpp

@@ -78,7 +78,7 @@ int main() {
     material->map = loader.load("data/textures/three.png");
     material->map->offset.set(0.5, 0.5);
 
-    auto pickMaterial = material->clone()->as<SpriteMaterial>();
+    auto pickMaterial = material->clone()->as_shared<SpriteMaterial>();
 
     auto sprites = createSprites(material);
     scene->add(sprites);

include/threepp/core/BufferGeometry.hpp

@@ -15,7 +15,7 @@
 
 namespace threepp {
 
-    class BufferGeometry: public EventDispatcher {
+    class BufferGeometry: public EventDispatcher, public std::enable_shared_from_this<BufferGeometry> {
 
     public:
         const unsigned int id{++_id};
@@ -35,6 +35,11 @@ namespace threepp {
 
         BufferGeometry();
 
+        BufferGeometry(const BufferGeometry&) = delete;
+        BufferGeometry& operator=(const BufferGeometry&) = delete;
+        BufferGeometry(BufferGeometry&&) = delete;
+        BufferGeometry& operator=(BufferGeometry&&) = delete;
+
         [[nodiscard]] virtual std::string type() const {
 
             return "BufferGeometry";

include/threepp/core/Object3D.hpp

@@ -105,7 +105,7 @@ namespace threepp {
         Object3D();
 
         Object3D(Object3D&& source) noexcept;
-        Object3D& operator=(Object3D&& other) = delete;
+        Object3D& operator=(Object3D&&) = delete;
         Object3D(const Object3D&) = delete;
         Object3D& operator=(const Object3D&) = delete;
 
@@ -231,6 +231,9 @@ namespace threepp {
         template<class T>
         T* as() {
 
+            static_assert(std::is_base_of<T, typename std::remove_cv<typename std::remove_pointer<T>::type>::type>::value,
+                          "T must be a base class of the current class");
+
             return dynamic_cast<T*>(this);
         }
 

include/threepp/materials/Material.hpp

@@ -76,12 +76,15 @@ namespace threepp {
 
         std::unordered_map<std::string, UniformValue> defaultAttributeValues;
 
-        unsigned int version = 0;
-
+        Material(Material&&) = delete;
+        Material& operator=(Material&&) = delete;
         Material(const Material&) = delete;
+        Material& operator=(const Material&) = delete;
 
         std::string uuid() const;
 
+        [[nodiscard]] unsigned int version() const;
+
         void setValues(const std::unordered_map<std::string, MaterialValue>& values);
 
         void dispose();
@@ -91,7 +94,19 @@ namespace threepp {
         [[nodiscard]] virtual std::string type() const = 0;
 
         template<class T>
-        std::shared_ptr<T> as() {
+        T* as() {
+
+            static_assert(std::is_base_of<T, typename std::remove_cv<typename std::remove_pointer<T>::type>::type>::value,
+                          "T must be a base class of the current class");
+
+            return dynamic_cast<T*>(this);
+        }
+
+        template<class T>
+        std::shared_ptr<T> as_shared() {
+
+            static_assert(std::is_base_of<T, typename std::remove_cv<typename std::remove_pointer<T>::type>::type>::value,
+                          "T must be a base class of the current class");
 
             auto m = shared_from_this();
             return std::dynamic_pointer_cast<T>(m);
@@ -112,15 +127,15 @@ namespace threepp {
 
         void copyInto(Material* m) const;
 
-        Color extractColor(const MaterialValue& value) {
+        static Color extractColor(const MaterialValue& value) {
             if (std::holds_alternative<int>(value)) {
                 return std::get<int>(value);
             } else {
                 return std::get<Color>(value);
             }
         }
 
-        float extractFloat(const MaterialValue& value) {
+        static float extractFloat(const MaterialValue& value) {
             if (std::holds_alternative<int>(value)) {
                 return std::get<int>(value);
             } else {
@@ -133,6 +148,7 @@ namespace threepp {
     private:
         bool disposed_ = false;
         std::string uuid_;
+        unsigned int version_ = 0;
         inline static unsigned int materialId = 0;
     };
 

include/threepp/objects/Line.hpp

@@ -19,6 +19,8 @@ namespace threepp {
     public:
         Line(std::shared_ptr<BufferGeometry> geometry, std::shared_ptr<Material> material);
 
+        Line(Line&&) = delete;
+
         [[nodiscard]] std::string type() const override;
 
         BufferGeometry* geometry() override;

include/threepp/objects/Mesh.hpp

@@ -19,17 +19,12 @@ namespace threepp {
         explicit Mesh(std::shared_ptr<BufferGeometry> geometry = nullptr, std::shared_ptr<Material> material = nullptr);
         Mesh(std::shared_ptr<BufferGeometry> geometry, std::vector<std::shared_ptr<Material>> materials);
 
-        Mesh(Mesh&& other) noexcept;
+        Mesh(Mesh&& other) = delete;
 
         [[nodiscard]] std::string type() const override;
 
         BufferGeometry* geometry() override;
 
-        std::shared_ptr<BufferGeometry> shared_geometry() {
-
-            return geometry_;
-        }
-
         [[nodiscard]] const BufferGeometry* geometry() const;
 
         void setGeometry(const std::shared_ptr<BufferGeometry>& geometry);

include/threepp/objects/Points.hpp

@@ -16,6 +16,8 @@ namespace threepp {
     public:
         Points(std::shared_ptr<BufferGeometry> geometry, std::shared_ptr<Material> material);
 
+        Points(Points&&) = delete;
+
         [[nodiscard]] std::string type() const override;
 
         BufferGeometry* geometry() override;

include/threepp/objects/Sprite.hpp

@@ -16,6 +16,8 @@ namespace threepp {
 
         explicit Sprite(const std::shared_ptr<SpriteMaterial>& material);
 
+        Sprite(Sprite&&) = delete;
+
         [[nodiscard]] std::string type() const override;
 
         void raycast(const Raycaster& raycaster, std::vector<Intersection>& intersects) override;

include/threepp/textures/Texture.hpp

@@ -64,7 +64,9 @@ namespace threepp {
         Encoding encoding{Encoding::Linear};
 
         Texture(const Texture&) = delete;
-        Texture operator=(const Texture&) = delete;
+        Texture& operator=(const Texture&) = delete;
+        Texture(Texture&&) = delete;
+        Texture& operator=(Texture&&) = delete;
 
         std::optional<std::function<void(Texture&)>> onUpdate;
 

src/threepp/lights/PointLightShadow.cpp

@@ -8,7 +8,7 @@ using namespace threepp;
 
 
 PointLightShadow::PointLightShadow()
-    : LightShadow(std::make_unique<PerspectiveCamera>(90, 1, 0.5f, 500)),
+    : LightShadow(std::make_unique<PerspectiveCamera>(90.f, 1.f, 0.5f, 500.f)),
       _cubeDirections({Vector3(1, 0, 0), Vector3(-1, 0, 0), Vector3(0, 0, 1),
                        Vector3(0, 0, -1), Vector3(0, 1, 0), Vector3(0, -1, 0)}),
       _cubeUps({Vector3(0, 1, 0), Vector3(0, 1, 0), Vector3(0, 1, 0),

src/threepp/materials/Material.cpp

@@ -8,14 +8,21 @@
 
 using namespace threepp;
 
+
 Material::Material()
     : uuid_(math::generateUUID()) {}
 
+
 std::string Material::uuid() const {
 
     return uuid_;
 }
 
+unsigned int Material::version() const {
+
+    return version_;
+}
+
 void Material::dispose() {
     if (!disposed_) {
         disposed_ = true;
@@ -25,7 +32,7 @@ void Material::dispose() {
 
 void Material::needsUpdate() {
 
-    this->version++;
+    this->version_++;
 }
 
 void Material::copyInto(Material* m) const {

src/threepp/objects/Mesh.cpp

@@ -180,10 +180,6 @@ Mesh::Mesh(std::shared_ptr<BufferGeometry> geometry, std::vector<std::shared_ptr
     : geometry_(std::move(geometry)), ObjectWithMaterials{std::move(materials)} {
 }
 
-Mesh::Mesh(Mesh&& other) noexcept: Object3D(std::move(other)), ObjectWithMaterials(std::move(other)) {
-    geometry_ = std::move(other.geometry_);
-}
-
 void Mesh::raycast(const Raycaster& raycaster, std::vector<Intersection>& intersects) {
 
     if (material() == nullptr) return;

src/threepp/renderers/GLRenderer.cpp

@@ -754,7 +754,7 @@ struct GLRenderer::Impl {
         bool isInstancedMesh = object->type() == "InstancedMesh";
         bool isSkinnedMesh = object->type() == "SkinnedMesh";
 
-        if (material->version == materialProperties->version) {
+        if (material->version() == materialProperties->version) {
 
             if (materialProperties->needsLights && (materialProperties->lightsStateVersion != lights.state.version)) {
 
@@ -802,7 +802,7 @@ struct GLRenderer::Impl {
         } else {
 
             needsProgramChange = true;
-            materialProperties->version = material->version;
+            materialProperties->version = material->version();
         }
 
         //

src/threepp/renderers/gl/GLMaterials.cpp

@@ -484,54 +484,54 @@ struct GLMaterials::Impl {
 
         } else if (type == "MeshLambertMaterial") {
 
-            auto m = material->as<MeshLambertMaterial>().get();
+            auto m = material->as<MeshLambertMaterial>();
             refreshUniformsCommon(uniforms, m);
             refreshUniformsLambert(uniforms, m);
 
         } else if (type == "MeshToonMaterial") {
 
-            auto m = material->as<MeshToonMaterial>().get();
+            auto m = material->as<MeshToonMaterial>();
             refreshUniformsCommon(uniforms, m);
             refreshUniformsToon(uniforms, m);
 
         } else if (type == "MeshPhongMaterial") {
 
-            auto m = material->as<MeshPhongMaterial>().get();
+            auto m = material->as<MeshPhongMaterial>();
             refreshUniformsCommon(uniforms, m);
             refreshUniformsPhong(uniforms, m);
 
         } else if (type == "MeshStandardMaterial") {
 
-            auto m = material->as<MeshStandardMaterial>().get();
+            auto m = material->as<MeshStandardMaterial>();
             refreshUniformsCommon(uniforms, material);
             refreshUniformsStandard(uniforms, m);
 
         } else if (type == "MeshMatcapMaterial") {
 
-            auto m = material->as<MeshMatcapMaterial>().get();
+            auto m = material->as<MeshMatcapMaterial>();
             refreshUniformsCommon(uniforms, m);
             refreshUniformsMatcap(uniforms, m);
 
         } else if (type == "MeshDepthMaterial") {
 
-            auto m = material->as<MeshDepthMaterial>().get();
+            auto m = material->as<MeshDepthMaterial>();
             refreshUniformsCommon(uniforms, m);
             refreshUniformsDepth(uniforms, m);
 
         } else if (type == "MeshDistanceMaterial") {
 
             auto m = material->as<MeshDistanceMaterial>();
-            refreshUniformsCommon(uniforms, m.get());
-            refreshUniformsDistance(uniforms, m.get());
+            refreshUniformsCommon(uniforms, m);
+            refreshUniformsDistance(uniforms, m);
 
         } else if (type == "LineBasicMaterial") {
 
             auto m = material->as<LineBasicMaterial>();
-            refreshUniformsLine(uniforms, m.get());
+            refreshUniformsLine(uniforms, m);
 
         } else if (type == "PointsMaterial") {
 
-            auto m = material->as<PointsMaterial>().get();
+            auto m = material->as<PointsMaterial>();
             refreshUniformsPoints(uniforms, m, pixelRatio, static_cast<float>(height));
 
         } else if (type == "ShadowMaterial") {
@@ -543,7 +543,7 @@ struct GLMaterials::Impl {
         } else if (type == "SpriteMaterial") {
 
             auto m = material->as<SpriteMaterial>();
-            refreshUniformsSprites(uniforms, m.get());
+            refreshUniformsSprites(uniforms, m);
 
 
         } else if (type == "ShaderMaterial") {