Engine: Skinned Sprite Render #1238

editor/includes/viewport/cameracontroller.h

@@ -61,7 +61,7 @@ class EDITOR_EXPORT CameraController : public QObject {
     void blockRotations(bool flag) { m_blockRotation = flag; }
 
     bool isPickingBlocked() const { return m_blockPicking; }
-    void blockPicking(bool flag) { m_blockPicking = flag; }
+    void blockPicking(bool flag) { m_blockPicking = flag; m_blockPickingBack = flag; }
 
     bool isPickingOverlaped() const { return m_overlapPicking; }
     void overlapPicking(bool flag) { m_overlapPicking = flag; }

editor/src/viewport/cameracontroller.cpp

@@ -134,7 +134,6 @@ void CameraController::update() {
 
                 if(m_mouseSaved != p) {
                     m_cameraInMove = true;
-                    m_blockPickingBack = m_blockPicking;
                     m_blockPicking = true;
                 }
                 m_mouseSaved = p;

engine/includes/components/skinnedspriterender.h

@@ -0,0 +1,45 @@
+#ifndef SKINNEDSPRITERENDER_H
+#define SKINNEDSPRITERENDER_H
+
+#include <spriterender.h>
+
+#include <armature.h>
+
+class ENGINE_EXPORT SkinnedSpriteRender : public SpriteRender {
+    A_OBJECT(SkinnedSpriteRender, SpriteRender, Components/2D)
+
+    A_PROPERTIES(
+        A_PROPERTYEX(Armature *, armature, SkinnedSpriteRender::armature, SkinnedSpriteRender::setArmature, "editor=Component"),
+        A_PROPERTY(Vector3, boundsCenter, SkinnedSpriteRender::boundsCenter, SkinnedSpriteRender::setBoundsCenter),
+        A_PROPERTY(Vector3, boundsExtent, SkinnedSpriteRender::boundsExtent, SkinnedSpriteRender::setBoundsExtent)
+    )
+    A_NOMETHODS()
+    A_NOENUMS()
+
+public:
+    SkinnedSpriteRender();
+
+    Vector3 boundsCenter() const;
+    void setBoundsCenter(const Vector3 &center);
+
+    Vector3 boundsExtent() const;
+    void setBoundsExtent(const Vector3 &extent);
+
+    Armature *armature() const;
+    void setArmature(Armature *armature);
+
+private:
+    void setMaterialsList(const std::list<Material *> &materials) override;
+
+    AABBox localBound() override;
+
+    void onReferenceDestroyed() override;
+
+private:
+    AABBox m_bounds;
+
+    Armature *m_armature;
+
+};
+
+#endif // SKINNEDSPRITERENDER_H

engine/includes/components/spriterender.h

@@ -65,7 +65,7 @@ class ENGINE_EXPORT SpriteRender : public Renderable {
 
     MaterialInstance *materialInstance(int index) override;
 
-private:
+protected:
     Mesh *meshToDraw() override;
 
     void setMaterialsList(const std::list<Material *> &materials) override;

engine/src/components/actor.cpp

@@ -37,6 +37,17 @@ static Component *componentInChildHelper(const TString &type, Object *parent) {
     return nullptr;
 }
 
+static void componentsInChildHelper(const TString &type, Object *parent, std::list<Component *> &result) {
+    PROFILE_FUNCTION();
+    for(auto it : parent->getChildren()) {
+        const MetaObject *meta = it->metaObject();
+        if(meta->canCastTo(type.data())) {
+            result.push_back(static_cast<Component *>(it));
+        }
+        componentsInChildHelper(type, it, result);
+    }
+}
+
 /*!
     \class Actor
     \brief Base class for all entities in Thunder Engine.
@@ -272,10 +283,7 @@ std::list<Component *> Actor::componentsInChild(const TString &type) const {
     PROFILE_FUNCTION();
     std::list<Component *> result;
     for(auto it : getChildren()) {
-        Component *component = componentInChildHelper(type, it);
-        if(component) {
-            result.push_back(component);
-        }
+        componentsInChildHelper(type, it, result);
     }
     return result;
 }

engine/src/components/animator.cpp

@@ -9,11 +9,12 @@
 #include "timer.h"
 #include <log.h>
 
-enum TransformFlags {
+enum class TransformFlags {
     Position = 1,
     Rotation,
     Scale,
-    Quat
+    Quat,
+    Object
 };
 
 /*!
@@ -58,10 +59,14 @@ void Animator::process(float dt) {
     for(auto &it : m_bindProperties) {
         TargetProperty &target = it.second;
 
-        switch(target.defaultValue.type()) {
-            case MetaType::QUATERNION: sampleQuaternion(dt, target); break;
-            case MetaType::STRING: sampleString(dt, target); break;
-            default: sampleVector4(dt, target); break;
+        if(static_cast<TransformFlags>(target.flag) == TransformFlags::Object) {
+            sampleString(dt, target);
+        } else {
+            switch(target.defaultValue.type()) {
+                case MetaType::QUATERNION: sampleQuaternion(dt, target); break;
+                case MetaType::STRING: sampleString(dt, target); break;
+                default: sampleVector4(dt, target); break;
+            }
         }
     }
 
@@ -109,7 +114,7 @@ void Animator::sampleVector4(float dt, TargetProperty &target) {
             case MetaType::FLOAT: target.property.write(target.object, vec4.x); break;
             case MetaType::VECTOR2: target.property.write(target.object, Vector2(vec4)); break;
             case MetaType::VECTOR3: {
-                switch(target.flag) {
+                switch(static_cast<TransformFlags>(target.flag)) {
                     case TransformFlags::Position: static_cast<Transform *>(target.object)->setPosition(vec4); break;
                     case TransformFlags::Rotation: static_cast<Transform *>(target.object)->setRotation(vec4); break;
                     case TransformFlags::Scale: static_cast<Transform *>(target.object)->setScale(vec4); break;
@@ -154,7 +159,7 @@ void Animator::sampleQuaternion(float dt, TargetProperty &target) {
     }
 
     if(updated) {
-        if(target.flag == TransformFlags::Quat) {
+        if(static_cast<TransformFlags>(target.flag) == TransformFlags::Quat) {
             static_cast<Transform *>(target.object)->setQuaternion(quat);
         } else {
             target.property.write(target.object, quat);
@@ -195,7 +200,15 @@ void Animator::sampleString(float dt, TargetProperty &target) {
     }
 
     if(updated) {
-        target.property.write(target.object, str);
+        if(static_cast<TransformFlags>(target.flag) == TransformFlags::Object) {
+            Resource *resource = nullptr;
+            if(!str.isEmpty()) {
+                resource = Engine::loadResourceAsync(str);
+            }
+            target.property.write(target.object, Variant(target.defaultValue.userType(), &resource));
+        } else {
+            target.property.write(target.object, str);
+        }
     }
 }
 
@@ -353,7 +366,12 @@ Animator::TargetProperty *Animator::bindTrack(const AnimationTrack &track) {
                 if(t) {
                     auto transformIt = tranformFlags.find(track.property());
                     if(transformIt != tranformFlags.end()) {
-                        data.flag = transformIt->second;
+                        data.flag = static_cast<int>(transformIt->second);
+                    }
+                } else {
+                    int flags = MetaType::table(data.defaultValue.userType())->flags;
+                    if(flags & MetaType::BASE_OBJECT) {
+                        data.flag = static_cast<int>(TransformFlags::Object);
                     }
                 }
 

engine/src/components/skinnedspriterender.cpp

@@ -0,0 +1,109 @@
+#include "components/skinnedspriterender.h"
+
+#include "resources/material.h"
+
+/*!
+    \class SkinnedSpriteRender
+    \brief Draws an animated skeletal sprite for the 2D graphics.
+    \inmodule Components
+
+    The SkinnedSpriteRender component allows you to display 2D Skeletal Sprite to use in both 2D and 3D scenes.
+*/
+
+SkinnedSpriteRender::SkinnedSpriteRender() :
+        m_armature(nullptr) {
+
+    m_bounds.radius = 0.0f;
+    m_surfaceType = Material::Skinned;
+}
+/*!
+    \internal
+*/
+AABBox SkinnedSpriteRender::localBound() {
+    return m_bounds;
+}
+/*!
+    Returns the center of the local bounding box.
+*/
+Vector3 SkinnedSpriteRender::boundsCenter() const {
+    return m_bounds.center;
+}
+/*!
+    Sets the \a center of the local bounding box.
+*/
+void SkinnedSpriteRender::setBoundsCenter(const Vector3 &center) {
+    m_bounds.center = center;
+}
+/*!
+    Returns the extent of the local bounding box.
+*/
+Vector3 SkinnedSpriteRender::boundsExtent() const {
+    return m_bounds.extent;
+}
+/*!
+    Sets the \a extent of the local bounding box.
+*/
+void SkinnedSpriteRender::setBoundsExtent(const Vector3 &extent) {
+    m_bounds.extent = extent;
+}
+/*!
+    Returns a Armature component for the attached skeleton.
+*/
+Armature *SkinnedSpriteRender::armature() const {
+    return m_armature;
+}
+/*!
+    Attaches an \a armature skeleton.
+*/
+void SkinnedSpriteRender::setArmature(Armature *armature) {
+    if(m_armature != armature) {
+        if(m_armature) {
+            disconnect(m_armature, _SIGNAL(destroyed()), this, _SLOT(onReferenceDestroyed()));
+
+            for(auto it : m_materials) {
+                m_armature->removeInstance(it);
+            }
+        }
+
+        m_armature = armature;
+        if(m_armature) {
+            connect(m_armature, _SIGNAL(destroyed()), this, _SLOT(onReferenceDestroyed()));
+
+            for(auto it : m_materials) {
+                m_armature->addInstance(it);
+            }
+
+            m_armature->update();
+        }
+    }
+}
+/*!
+    \internal
+*/
+void SkinnedSpriteRender::setMaterialsList(const std::list<Material *> &materials) {
+    if(m_armature) {
+        for(auto it : m_materials) {
+            m_armature->removeInstance(it);
+        }
+    }
+
+    SpriteRender::setMaterialsList(materials);
+
+    for(auto it : m_materials) {
+        if(it) {
+            if(m_armature) {
+                m_armature->addInstance(it);
+            }
+        }
+    }
+}
+/*!
+    \internal
+*/
+void SkinnedSpriteRender::onReferenceDestroyed() {
+    SpriteRender::onReferenceDestroyed();
+
+    if(sender() == m_armature) {
+        m_armature = nullptr;
+    }
+}

engine/src/components/spriterender.cpp

@@ -35,7 +35,7 @@ SpriteRender::SpriteRender() :
         m_size(1.0f),
         m_sprite(nullptr),
         m_texture(nullptr),
-        m_mesh(PipelineContext::defaultPlane()),
+        m_mesh(nullptr),
         m_customMesh(Engine::objectCreate<Mesh>()),
         m_customMeshInstance(nullptr),
         m_drawMode(Simple),
@@ -68,15 +68,14 @@ Mesh *SpriteRender::meshToDraw() {
                     if(m_drawMode == Sprite::Simple) {
                         m_size = mesh->bound().extent * 2.0f;
                     }
-
                 } else {
                     m_mesh = PipelineContext::defaultPlane();
                 }
             } else {
                 m_useCustom = true;
             }
         } else {
-            m_mesh = PipelineContext::defaultPlane();
+            m_mesh = m_texture ? PipelineContext::defaultPlane() : nullptr;
         }
 
         m_dirtyMesh = false;
@@ -286,10 +285,7 @@ Mesh *SpriteRender::ensureMeshInstance() {
         m_customMeshInstance = Engine::objectCreate<Mesh>();
         m_customMeshInstance->setIndices(m_customMesh->indices());
         m_customMeshInstance->setVertices(m_customMesh->vertices());
-        m_customMeshInstance->setNormals(m_customMesh->normals());
-        m_customMeshInstance->setTangents(m_customMesh->tangents());
         m_customMeshInstance->setUv0(m_customMesh->uv0());
-        m_customMeshInstance->setUv1(m_customMesh->uv1());
         m_customMeshInstance->setColors(m_customMesh->colors());
         m_customMeshInstance->setBones(m_customMesh->bones());
         m_customMeshInstance->setWeights(m_customMesh->weights());

engine/src/systems/rendersystem.cpp

@@ -4,6 +4,7 @@
 #include "components/meshrender.h"
 #include "components/textrender.h"
 #include "components/spriterender.h"
+#include "components/skinnedspriterender.h"
 #include "components/effectrender.h"
 #include "components/directlight.h"
 #include "components/pointlight.h"
@@ -44,6 +45,7 @@ RenderSystem::RenderSystem() :
     MeshRender::registerClassFactory(this);
     TextRender::registerClassFactory(this);
     SpriteRender::registerClassFactory(this);
+    SkinnedSpriteRender::registerClassFactory(this);
     SkinnedMeshRender::registerClassFactory(this);
 
     BaseLight::registerClassFactory(this);
@@ -86,6 +88,7 @@ RenderSystem::~RenderSystem() {
     MeshRender::unregisterClassFactory(this);
     TextRender::unregisterClassFactory(this);
     SpriteRender::unregisterClassFactory(this);
+    SkinnedSpriteRender::unregisterClassFactory(this);
     SkinnedMeshRender::unregisterClassFactory(this);
 
     BaseLight::unregisterClassFactory(this);