Editor: Resize Tool for the sprites thunder-engine#338

Author: eprikazchikov

engine/includes/editor/editortool.h

@@ -8,14 +8,20 @@
 #include <QCursor>
 
 class Actor;
+class Renderable;
 
 class NEXT_LIBRARY_EXPORT EditorTool {
 public:
-    struct Select {
+    struct NEXT_LIBRARY_EXPORT Select {
+        Select();
+
         Actor *object;
+        Renderable *renderable;
         Vector3 position;
         Vector3 scale;
         Vector3 euler;
+        Vector3 pivot;
+        AABBox box;
     };
 
     typedef QMap<uint32_t, Select> SelectMap;
@@ -27,6 +33,7 @@ class NEXT_LIBRARY_EXPORT EditorTool {
 
     virtual void beginControl();
     virtual void endControl();
+    virtual void cancelControl();
 
     virtual QString icon() const = 0;
     virtual QString name() const = 0;
@@ -36,9 +43,13 @@ class NEXT_LIBRARY_EXPORT EditorTool {
     Vector3 objectPosition();
     AABBox objectBound();
 
+    const VariantList &cache() const;
+
 protected:
     SelectMap &m_Selected;
 
+    VariantList m_PropertiesCache;
+
     QCursor m_Cursor;
 
 };

engine/includes/editor/handles.h

@@ -49,7 +49,7 @@ class NEXT_LIBRARY_EXPORT Handles {
     static Vector3 moveTool(const Vector3 &position, const Quaternion &rotation, bool locked);
     static float rotationTool(const Vector3 &position, const Quaternion &rotation, bool locked);
     static Vector3 scaleTool(const Vector3 &position, const Quaternion &rotation, bool locked);
-    static void rectTool(const Vector3 &position, const Vector2 &size, const Quaternion &rotation, bool locked);
+    static Vector3 rectTool(const Vector3 &position, const Vector3 &box, int &axis, bool locked);
 
 public:
     static Vector4 s_Color;
@@ -96,6 +96,8 @@ class NEXT_LIBRARY_EXPORT Handles {
     static MaterialInstance *s_Solid;
     static MaterialInstance *s_Sprite;
 
+    static Texture *s_Corner;
+
 };
 
 #endif // HANDLES_H

engine/src/components/actor.cpp

@@ -563,7 +563,6 @@ VariantMap Actor::saveUserData() const {
                 }
             }
 
-
             VariantList fixed;
 
             for(auto it : objects) {

engine/src/editor/editortool.cpp

@@ -4,6 +4,12 @@
 #include "components/transform.h"
 #include "components/renderable.h"
 
+EditorTool::Select::Select() :
+    object(nullptr),
+    renderable(nullptr) {
+
+}
+
 EditorTool::EditorTool(EditorTool::SelectMap &selection) :
     m_Selected(selection) {
 
@@ -14,43 +20,84 @@ void EditorTool::update() {
 }
 
 void EditorTool::beginControl() {
+    m_PropertiesCache.clear();
 
+    for(auto &it : m_Selected) {
+        Transform *t = it.object->transform();
+        it.position = t->position();
+        it.scale    = t->scale();
+        it.euler    = t->rotation();
+
+        VariantMap components;
+        for(auto &child : it.object->getChildren()) {
+            Component *component = dynamic_cast<Component *>(child);
+            if(component) {
+                VariantMap properies;
+                const MetaObject *meta = component->metaObject();
+                for(int i = 0; i < meta->propertyCount(); i++) {
+                    MetaProperty property = meta->property(i);
+                    properies[property.name()] = property.read(component);
+                }
+                components[to_string(component->uuid())] = properies;
+            }
+        }
+        m_PropertiesCache.push_back(components);
+    }
 }
 
 void EditorTool::endControl() {
 
 }
 
+void EditorTool::cancelControl() {
+    auto cache = m_PropertiesCache.begin();
+    for(auto &it : m_Selected) {
+        VariantMap components = (*cache).toMap();
+        for(auto &child : it.object->getChildren()) {
+            Component *component = dynamic_cast<Component *>(child);
+            if(component) {
+                VariantMap properties = components[to_string(component->uuid())].toMap();
+                const MetaObject *meta = component->metaObject();
+                for(int i = 0; i < meta->propertyCount(); i++) {
+                    MetaProperty property = meta->property(i);
+                    property.write(component, properties[property.name()]);
+                }
+            }
+        }
+
+        ++cache;
+    }
+}
+
 QCursor EditorTool::cursor() const {
     return m_Cursor;
 }
 
 Vector3 EditorTool::objectPosition() {
-    Vector3 result;
-    if(!m_Selected.empty()) {
-        for(auto &it : m_Selected) {
-            result += it.object->transform()->worldPosition();
-        }
-        result = result / m_Selected.size();
-    }
-    return result;
+    return objectBound().center;
 }
 
 AABBox EditorTool::objectBound() {
     AABBox result;
     bool first = true;
     if(!m_Selected.empty()) {
         for(auto &it : m_Selected) {
-            Renderable *renderable = dynamic_cast<Renderable *>(it.object->component("Renderable"));
-            if(renderable) {
+            if(it.renderable == nullptr) {
+                it.renderable = dynamic_cast<Renderable *>(it.object->component("Renderable"));
+            }
+            if(it.renderable) {
                 if(first) {
-                    result = renderable->bound();
+                    result = it.renderable->bound();
                     first = false;
                 } else {
-                    result.encapsulate(renderable->bound());
+                    result.encapsulate(it.renderable->bound());
                 }
             }
         }
     }
     return result;
 }
+
+const VariantList &EditorTool::cache() const {
+    return m_PropertiesCache;
+}

engine/src/editor/handles.cpp

@@ -63,6 +63,8 @@ Mesh *Handles::s_Rectangle = nullptr;
 Mesh *Handles::s_Box = nullptr;
 Mesh *Handles::s_Bone = nullptr;
 
+Texture *Handles::s_Corner = nullptr;
+
 enum {
     AXIS,
     SCALE,
@@ -107,6 +109,10 @@ void Handles::init() {
         }
     }
 
+    if(s_Corner == nullptr) {
+        s_Corner = Engine::loadResource<Texture>(".embedded/corner.png");
+    }
+
     if(s_Lines == nullptr) {
         s_Lines = Engine::objectCreate<Mesh>("Lines");
         s_Lines->makeDynamic();
@@ -667,6 +673,7 @@ float Handles::rotationTool(const Vector3 &position, const Quaternion &rotation,
 }
 
 Vector3 Handles::scaleTool(const Vector3 &position, const Quaternion &rotation, bool locked) {
+    Vector3 result;
     if(ICommandBuffer::isInited()) {
         Camera *camera = Camera::current();
         if(camera) {
@@ -787,51 +794,150 @@ Vector3 Handles::scaleTool(const Vector3 &position, const Quaternion &rotation,
             }
             s_Color = s_Normal;
         }
+
+        Plane plane;
+        plane.point = position;
+        plane.normal = camera->actor()->transform()->quaternion() * Vector3(0.0f, 0.0f, 1.0f);
+        if(s_Axes == AXIS_X) {
+            plane.normal = Vector3(0.0f, plane.normal.y, plane.normal.z);
+        } else if(s_Axes == AXIS_Z) {
+            plane.normal = Vector3(plane.normal.x, plane.normal.y, 0.0f);
+        } else if(s_Axes == (AXIS_X | AXIS_Z)) {
+            plane.normal = Vector3(0.0f, 1.0f, 0.0f);
+        } else if(s_Axes == (AXIS_X | AXIS_Y)) {
+            plane.normal = Vector3(0.0f, 0.0f, 1.0f);
+        } else if(s_Axes == (AXIS_Z | AXIS_Y)) {
+            plane.normal = Vector3(1.0f, 0.0f, 0.0f);
+        } else if(s_Axes == AXIS_Y || s_Axes == (AXIS_X | AXIS_Y | AXIS_Z)) {
+            plane.normal = Vector3(plane.normal.x, 0.0f, plane.normal.z);
+        }
+        plane.normal.normalize();
+        plane.d = plane.normal.dot(plane.point);
+
+        Ray ray = camera->castRay(s_Mouse.x, s_Mouse.y);
+        Vector3 point;
+        ray.intersect(plane, &point, true);
+        if(s_Axes & AXIS_X) {
+            result.x = point.x;
+        }
+        if(s_Axes & AXIS_Y) {
+            result.y = point.y;
+        }
+        if(s_Axes & AXIS_Z) {
+            result.z = point.z;
+        }
     }
-    return Vector3(s_Mouse, 1.0) * 500;
+    return result;
 }
 
-void Handles::rectTool(const Vector3 &position, const Vector2 &size, const Quaternion &rotation, bool locked) {
+Vector3 Handles::rectTool(const Vector3 &position, const Vector3 &box, int &axis, bool locked) {
+    Vector3 result;
     if(ICommandBuffer::isInited()) {
-        Matrix4 model(position, rotation, Vector3(1.0f));
-
-        Vector3 tr(size.x * 0.5f, size.y * 0.5f, 0.0f);
-        Vector3 tl(size.x *-0.5f, size.y * 0.5f, 0.0f);
-        Vector3 br(size.x * 0.5f, size.y *-0.5f, 0.0f);
-        Vector3 bl(size.x *-0.5f, size.y *-0.5f, 0.0f);
-
-        drawRectangle(position, rotation, size.x, size.y);
-
-        if(!locked) {
-            float sence = Handles::s_Sense * 0.25f;
-
-            Handles::s_Axes = 0;
-            if(HandleTools::distanceToPoint(model, tr) <= sence) {
-                Handles::s_Axes = Handles::POINT_T | Handles::POINT_R;
-            } else if(HandleTools::distanceToPoint(model, tl) <= sence) {
-                Handles::s_Axes = Handles::POINT_T | Handles::POINT_L;
-            } else if(HandleTools::distanceToPoint(model, br) <= sence) {
-                Handles::s_Axes = Handles::POINT_B | Handles::POINT_R;
-            } else if(HandleTools::distanceToPoint(model, bl) <= sence) {
-                Handles::s_Axes = Handles::POINT_B | Handles::POINT_L;
-            } else if(HandleTools::distanceToPath(model, {tr, tl}) <= sence) {
-                Handles::s_Axes = Handles::POINT_T;
-            } else if(HandleTools::distanceToPath(model, {br, bl}) <= sence) {
-                Handles::s_Axes = Handles::POINT_B;
-            } else if(HandleTools::distanceToPath(model, {tr, br}) <= sence) {
-                Handles::s_Axes = Handles::POINT_R;
-            } else if(HandleTools::distanceToPath(model, {tl, bl}) <= sence) {
-                Handles::s_Axes = Handles::POINT_L;
+        Camera *camera = Camera::current();
+
+        if(camera) {
+            axis = Handles::AXIS_Z;
+
+            Plane plane;
+            plane.normal = Vector3(0.0f, 0.0f, 1.0f);
+
+            Vector2 size(box.x, box.y);
+
+            Quaternion q;
+
+            Vector3 normal = camera->actor()->transform()->quaternion() * plane.normal;
+            normal.normalize();
+            if(abs(normal.x) > abs(normal.z)) {
+                axis = Handles::AXIS_X;
+                plane.normal = Vector3(1.0f, 0.0f, 0.0f);
+                size = Vector2(box.z, box.y);
+                q = Quaternion(Vector3(0.0f, 90.0f, 0.0f));
+            }
+            if(abs(normal.y) > abs(normal.x) && abs(normal.y) > abs(normal.x)) {
+                axis = Handles::AXIS_Y;
+                plane.normal = Vector3(0.0f, 1.0f, 0.0f);
+                size = Vector2(box.x, box.z);
+                q = Quaternion(Vector3(90.0f, 0.0f, 0.0f));
+            }
+
+            plane.point = position;
+            plane.d = plane.normal.dot(plane.point);
+
+
+            Matrix4 model(position, q, Vector3(1.0f));
+
+            Vector3 tr(size.x * 0.5f, size.y * 0.5f, 0.0f);
+            Vector3 tl(size.x *-0.5f, size.y * 0.5f, 0.0f);
+            Vector3 br(size.x * 0.5f, size.y *-0.5f, 0.0f);
+            Vector3 bl(size.x *-0.5f, size.y *-0.5f, 0.0f);
+
+            drawRectangle(position, q, size.x, size.y);
+
+            Transform *t = camera->actor()->transform();
+            normal = position - t->position();
+            float scale = 1.0f;
+            if(!camera->orthographic()) {
+                scale = normal.length();
             } else {
-                Camera *camera = Camera::current();
-                if(camera) {
+                scale = camera->orthoSize();
+            }
+            scale *= (CONTROL_SIZE / s_Screen.y);
+
+            drawBillboard(model * tr, Vector2(scale * 0.05f), s_Corner);
+            drawBillboard(model * tl, Vector2(scale * 0.05f), s_Corner);
+            drawBillboard(model * br, Vector2(scale * 0.05f), s_Corner);
+            drawBillboard(model * bl, Vector2(scale * 0.05f), s_Corner);
+
+            if(!locked) {
+                float sence = Handles::s_Sense * 0.25f;
+
+                Handles::s_Axes = 0;
+                if(HandleTools::distanceToPoint(model, tr) <= sence) {
+                    Handles::s_Axes = Handles::POINT_T | Handles::POINT_R;
+                } else if(HandleTools::distanceToPoint(model, tl) <= sence) {
+                    Handles::s_Axes = Handles::POINT_T | Handles::POINT_L;
+                } else if(HandleTools::distanceToPoint(model, br) <= sence) {
+                    Handles::s_Axes = Handles::POINT_B | Handles::POINT_R;
+                } else if(HandleTools::distanceToPoint(model, bl) <= sence) {
+                    Handles::s_Axes = Handles::POINT_B | Handles::POINT_L;
+                } else if(HandleTools::distanceToPath(model, {tr, tl}) <= sence) {
+                    Handles::s_Axes = Handles::POINT_T;
+                } else if(HandleTools::distanceToPath(model, {br, bl}) <= sence) {
+                    Handles::s_Axes = Handles::POINT_B;
+                } else if(HandleTools::distanceToPath(model, {tr, br}) <= sence) {
+                    Handles::s_Axes = Handles::POINT_R;
+                } else if(HandleTools::distanceToPath(model, {tl, bl}) <= sence) {
+                    Handles::s_Axes = Handles::POINT_L;
+                } else {
                     Ray ray = camera->castRay(Handles::s_Mouse.x, Handles::s_Mouse.y);
                     if(ray.intersect(model * tr, model * tl, model * bl, nullptr, true) ||
                        ray.intersect(model * bl, model * br, model * tr, nullptr, true)) {
                         Handles::s_Axes = Handles::POINT_B | Handles::POINT_T | Handles::POINT_L | Handles::POINT_R;
                     }
                 }
             }
+
+            Ray ray = camera->castRay(Handles::s_Mouse.x, Handles::s_Mouse.y);
+            Vector3 point;
+
+            ray.intersect(plane, &point, true);
+            if(Handles::s_Axes & Handles::POINT_L || Handles::s_Axes & Handles::POINT_R) {
+                switch(axis) {
+                    case Handles::AXIS_X: result.z = point.z; break;
+                    case Handles::AXIS_Y: result.x = point.x; break;
+                    case Handles::AXIS_Z: result.x = point.x; break;
+                    default: break;
+                }
+            }
+            if(Handles::s_Axes & Handles::POINT_T || Handles::s_Axes & Handles::POINT_B) {
+                switch(axis) {
+                    case Handles::AXIS_X: result.y = point.y; break;
+                    case Handles::AXIS_Y: result.z = point.z; break;
+                    case Handles::AXIS_Z: result.y = point.y; break;
+                    default: break;
+                }
+            }
         }
     }
+    return result;
 }