Gui: Fold widget #880

engine/includes/components/animator.h

@@ -3,6 +3,8 @@
 
 #include "nativebehaviour.h"
 
+#include "animationstatemachine.h"
+
 class AnimationClip;
 class AnimationStateMachine;
 class AnimationState;

engine/includes/editor/viewport/viewport.h

@@ -23,7 +23,7 @@ class ENGINE_EXPORT Viewport : public QWidget {
 
     virtual void init();
 
-    CameraController *controllder();
+    CameraController *controller();
     void setController(CameraController *ctrl);
     virtual void setWorld(World *world);
 

engine/includes/resources/resource.h

@@ -5,8 +5,6 @@
 
 #include <mutex>
 
-
-
 class ENGINE_EXPORT Resource : public Object {
     A_REGISTER(Resource, Object, General)
 

engine/src/components/actor.cpp

@@ -105,6 +105,10 @@ void Actor::setEnabled(const bool enabled) {
     }
 
     setHierarchyEnabled(enabled);
+
+    if(m_transform) {
+        m_transform->setEnabled(enabled);
+    }
 }
 /*!
     Returns a set of Actor::HideFlags applied to this Actor.

engine/src/components/transform.cpp

@@ -147,6 +147,11 @@ void Transform::setParentTransform(Transform *parent, bool force) {
         return;
     }
 
+    if(parent && actor()->parent() != parent->actor()) {
+        actor()->setParent(parent->actor());
+        return;
+    }
+
     Vector3 p;
     Vector3 e;
     Vector3 s;
@@ -185,60 +190,42 @@ void Transform::setParentTransform(Transform *parent, bool force) {
     Returns current transform matrix in local space.
 */
 const Matrix4 &Transform::localTransform() const {
-    if(m_dirty) {
-        std::unique_lock<std::mutex> locker(m_mutex);
-        cleanDirty();
-    }
+    cleanDirty();
     return m_transform;
 }
 /*!
     Returns current transform matrix in world space.
 */
 const Matrix4 &Transform::worldTransform() const {
-    if(m_dirty) {
-        std::unique_lock<std::mutex> locker(m_mutex);
-        cleanDirty();
-    }
+    cleanDirty();
     return m_worldTransform;
 }
 /*!
     Returns current position of the transform in world space.
 */
 Vector3 Transform::worldPosition() const {
-    if(m_dirty) {
-        std::unique_lock<std::mutex> locker(m_mutex);
-        cleanDirty();
-    }
+    cleanDirty();
     return Vector3(m_worldTransform[12], m_worldTransform[13], m_worldTransform[14]);
 }
 /*!
     Returns current rotation of the transform in world space as Euler angles in degrees.
 */
 Vector3 Transform::worldRotation() const {
-    if(m_dirty) {
-        std::unique_lock<std::mutex> locker(m_mutex);
-        cleanDirty();
-    }
+    cleanDirty();
     return m_worldRotation;
 }
 /*!
     Returns current rotation of the transform in world space as Quaternion.
 */
 Quaternion Transform::worldQuaternion() const {
-    if(m_dirty) {
-        std::unique_lock<std::mutex> locker(m_mutex);
-        cleanDirty();
-    }
+    cleanDirty();
     return m_worldQuaternion;
 }
 /*!
     Returns current scale of the transform in world space.
 */
 Vector3 Transform::worldScale() const {
-    if(m_dirty) {
-        std::unique_lock<std::mutex> locker(m_mutex);
-        cleanDirty();
-    }
+    cleanDirty();
     return m_worldScale;
 }
 /*!
@@ -261,10 +248,7 @@ void Transform::setParent(Object *parent, int32_t position, bool force) {
     \internal
 */
 uint32_t Transform::hash() const {
-    if(m_dirty) {
-        std::unique_lock<std::mutex> locker(m_mutex);
-        cleanDirty();
-    }
+    cleanDirty();
     return m_hash;
 }
 /*!
@@ -275,20 +259,24 @@ const std::list<Transform *> &Transform::children() const {
 }
 
 void Transform::cleanDirty() const {
-    m_transform = Matrix4(m_position, m_quaternion, m_scale);
-    m_worldTransform = m_transform;
-    m_worldRotation = m_rotation;
-    m_worldQuaternion = m_quaternion;
-    m_worldScale = m_scale;
-    if(m_parent) {
-        m_worldScale = m_parent->worldScale() * m_worldScale;
-        m_worldRotation = m_parent->worldRotation() + m_worldRotation;
-        m_worldQuaternion = m_parent->worldQuaternion() * m_worldQuaternion;
-        m_worldTransform = m_parent->worldTransform() * m_worldTransform;
-    }
-    m_hash = 16;
-    for(int i = 0; i < 16; i++) {
-        Mathf::hashCombine(m_hash, m_worldTransform[i]);
+    if(m_dirty) {
+        std::unique_lock<std::mutex> locker(m_mutex);
+
+        m_transform = Matrix4(m_position, m_quaternion, m_scale);
+        m_worldTransform = m_transform;
+        m_worldRotation = m_rotation;
+        m_worldQuaternion = m_quaternion;
+        m_worldScale = m_scale;
+        if(m_parent) {
+            m_worldScale = m_parent->worldScale() * m_worldScale;
+            m_worldRotation = m_parent->worldRotation() + m_worldRotation;
+            m_worldQuaternion = m_parent->worldQuaternion() * m_worldQuaternion;
+            m_worldTransform = m_parent->worldTransform() * m_worldTransform;
+        }
+        m_hash = 16;
+        for(int i = 0; i < 16; i++) {
+            Mathf::hashCombine(m_hash, m_worldTransform[i]);
+        }
+        m_dirty = false;
     }
-    m_dirty = false;
 }

engine/src/editor/viewport/viewport.cpp

@@ -530,7 +530,7 @@ void Viewport::init() {
     }
 }
 
-CameraController *Viewport::controllder() {
+CameraController *Viewport::controller() {
     return m_controller;
 }
 

engine/src/engine.cpp

@@ -34,29 +34,8 @@
 #else
     #include "adapters/desktopadaptor.h"
 #endif
-#include "resources/text.h"
-#include "resources/texture.h"
-#include "resources/rendertarget.h"
-#include "resources/material.h"
-#include "resources/mesh.h"
-#include "resources/font.h"
-#include "resources/animationclip.h"
-#include "resources/animationstatemachine.h"
-#include "resources/translator.h"
-#include "resources/particleeffect.h"
-#include "resources/pipeline.h"
-#include "resources/pose.h"
-#include "resources/prefab.h"
-#include "resources/map.h"
-#include "resources/computebuffer.h"
-#include "resources/computeshader.h"
-
-#include "resources/meshgroup.h"
 
-#include "resources/controlscheme.h"
-
-#include "resources/tileset.h"
-#include "resources/tilemap.h"
+#include "resources/translator.h"
 
 #include "systems/resourcesystem.h"
 #include "systems/rendersystem.h"
@@ -157,37 +136,6 @@ Engine::Engine(File *file, const char *path) {
 
     m_file = file;
 
-    // The order is critical for the import
-    Resource::registerClassFactory(m_resourceSystem);
-
-    Text::registerClassFactory(m_resourceSystem);
-    Texture::registerClassFactory(m_resourceSystem);
-    Material::registerClassFactory(m_resourceSystem);
-    Mesh::registerClassFactory(m_resourceSystem);
-    MeshGroup::registerClassFactory(m_resourceSystem);
-    Sprite::registerClassFactory(m_resourceSystem);
-    Font::registerClassFactory(m_resourceSystem);
-    AnimationClip::registerClassFactory(m_resourceSystem);
-    RenderTarget::registerClassFactory(m_resourceSystem);
-
-    Translator::registerClassFactory(m_resourceSystem);
-    Pose::registerSuper(m_resourceSystem);
-
-    Prefab::registerClassFactory(m_resourceSystem);
-    Map::registerClassFactory(m_resourceSystem);
-
-    TileSet::registerClassFactory(m_resourceSystem);
-    TileMap::registerClassFactory(m_resourceSystem);
-
-    ParticleEffect::registerClassFactory(m_resourceSystem);
-
-    AnimationStateMachine::registerSuper(m_resourceSystem);
-
-    Pipeline::registerClassFactory(m_resourceSystem);
-
-    ComputeBuffer::registerClassFactory(m_resourceSystem);
-    ComputeShader::registerClassFactory(m_resourceSystem);
-
     World::registerClassFactory(m_instance);
     Scene::registerClassFactory(m_instance);
     Actor::registerClassFactory(m_instance);
@@ -201,7 +149,6 @@ Engine::Engine(File *file, const char *path) {
 
     Armature::registerClassFactory(m_instance);
 
-    ControlScheme::registerClassFactory(m_resourceSystem);
     PlayerInput::registerClassFactory(m_instance);
 
     m_world = ObjectSystem::objectCreate<World>("World");

engine/src/systems/resourcesystem.cpp

@@ -10,9 +10,65 @@
 
 #include "resources/resource.h"
 
+#include "resources/text.h"
+#include "resources/texture.h"
+#include "resources/rendertarget.h"
+#include "resources/material.h"
+#include "resources/mesh.h"
+#include "resources/font.h"
+#include "resources/animationclip.h"
+#include "resources/animationstatemachine.h"
+#include "resources/translator.h"
+#include "resources/particleeffect.h"
+#include "resources/pipeline.h"
+#include "resources/pose.h"
+#include "resources/prefab.h"
+#include "resources/map.h"
+#include "resources/computebuffer.h"
+#include "resources/computeshader.h"
+
+#include "resources/meshgroup.h"
+
+#include "resources/controlscheme.h"
+
+#include "resources/tileset.h"
+#include "resources/tilemap.h"
+
 ResourceSystem::ResourceSystem() {
     setName("ResourceSystem");
 
+    // The order is critical for the import
+    Resource::registerClassFactory(this);
+
+    Text::registerClassFactory(this);
+    Texture::registerClassFactory(this);
+    Material::registerClassFactory(this);
+    Mesh::registerClassFactory(this);
+    MeshGroup::registerClassFactory(this);
+    Sprite::registerClassFactory(this);
+    Font::registerClassFactory(this);
+    AnimationClip::registerClassFactory(this);
+    RenderTarget::registerClassFactory(this);
+
+    Translator::registerClassFactory(this);
+    Pose::registerSuper(this);
+
+    Prefab::registerClassFactory(this);
+    Map::registerClassFactory(this);
+
+    TileSet::registerClassFactory(this);
+    TileMap::registerClassFactory(this);
+
+    ParticleEffect::registerClassFactory(this);
+
+    AnimationStateMachine::registerSuper(this);
+
+    Pipeline::registerClassFactory(this);
+
+    ComputeBuffer::registerClassFactory(this);
+    ComputeShader::registerClassFactory(this);
+
+    ControlScheme::registerClassFactory(this);
 }
 
 bool ResourceSystem::init() {

modules/editor/grapheditor/editor/graph/graphview.cpp

@@ -50,7 +50,7 @@ class ObjectObserver : public Object {
 
     void onNodePressed() {
         if(m_view) {
-            GraphController *ctrl = dynamic_cast<GraphController *>(m_view->controllder());
+            GraphController *ctrl = dynamic_cast<GraphController *>(m_view->controller());
             if(ctrl) {
                 ctrl->setFocusNode(dynamic_cast<NodeWidget *>(sender()));
             }
@@ -339,6 +339,10 @@ void GraphView::showMenu() {
     }
 }
 
+void GraphView::selectNode(GraphNode *node) {
+    static_cast<GraphController *>(m_controller)->setSelected({node});
+}
+
 void GraphView::onComponentSelected() {
     AbstractNodeGraph *g = graph();
 

modules/editor/grapheditor/editor/graph/graphview.h

@@ -39,6 +39,8 @@ class NODEGRAPH_EXPORT GraphView : public Viewport {
 
     void showMenu();
 
+    void selectNode(GraphNode *node);
+
 signals:
     void itemsSelected(const QList<QObject *> &);
 

modules/editor/grapheditor/editor/graph/graphwidgets/nodewidget.cpp

@@ -49,6 +49,8 @@ void NodeWidget::setGraphNode(GraphNode *node) {
         m_title->setColor(m_node->color());
     }
 
+    rectTransform()->setSize(m_node->defaultSize());
+
     // Call ports
     for(NodePort &port : m_node->ports()) {
         if(port.m_call) {
@@ -69,20 +71,6 @@ void NodeWidget::setGraphNode(GraphNode *node) {
             composePort(port);
         }
     }
-
-    RectTransform *rect = rectTransform();
-    Layout *layout = rect->layout();
-
-    Vector2 size = m_node->defaultSize();
-    if(!m_node->ports().empty()) {
-        size.y = (m_node->ports().size() + 2.0f) * row;
-        if(layout) {
-            size.y = layout->sizeHint().y;
-            layout->update();
-        }
-    }
-
-    rect->setSize(size);
 }
 
 void NodeWidget::updateName() {
@@ -164,6 +152,8 @@ void NodeWidget::composeComponent() {
     RectTransform *rect = rectTransform();
     rect->setPivot(Vector2(0.0f, 1.0f));
     rect->setLayout(layout);
+    rect->setVerticalPolicy(RectTransform::Preferred);
+    rect->setHorizontalPolicy(RectTransform::Fixed);
 
     Actor *title = Engine::composeActor(gFrame, "Title", actor());
     if(title) {
@@ -194,7 +184,7 @@ void NodeWidget::composeComponent() {
 }
 
 void NodeWidget::composePort(NodePort &port) {
-    Actor *portActor = Engine::composeActor(gPortWidget, port.m_name.c_str(), actor());
+    Actor *portActor = Engine::composeActor(gPortWidget, port.m_name, actor());
     if(portActor) {
 
         PortWidget *portWidget = static_cast<PortWidget *>(portActor->component(gPortWidget));