Improved Geometry view source manipulation; added cursor change and

fixed-size handles on frame.

Mesh.cpp

@@ -9,6 +9,7 @@
 #include <glad/glad.h>
 
 #include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtx/vector_angle.hpp>
 
 #include "RenderingManager.h"
 #include "Primitives.h"
@@ -474,8 +475,8 @@ Handles::Handles(Type type) : Node(), type_(type)
     }
     else {
 //        handle_ = new LineSquare(color, int ( 2.1f * Rendering::manager().DPIScale()) );
-        handle_ = new Mesh("mesh/border_handles_sharp.ply");
+        handle_ = new Mesh("mesh/border_handles_overlay.ply");
-        handle_->scale_ = glm::vec3( 0.05f, 0.05f, 1.f);
+//        handle_->scale_ = glm::vec3( 0.05f, 0.05f, 1.f);
     }
 
 }
@@ -506,35 +507,55 @@ void Handles::draw(glm::mat4 modelview, glm::mat4 projection)
         handle_->shader()->color = color;
 
         glm::mat4 ctm;
+        glm::vec3 rot(0.f);
+        glm::vec4 vec = modelview * glm::vec4(1.f, 0.f, 0.f, 0.f);
+        rot.z = glm::orientedAngle( glm::vec3(1.f, 0.f, 0.f), glm::normalize(glm::vec3(vec)), glm::vec3(0.f, 0.f, 1.f) );
 
         if ( type_ == RESIZE ) {
+
             // 4 corners
-            ctm =  modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, -1.f, 0.f) ) ;
+//            ctm =  modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, -1.f, 0.f));
+            vec = modelview * glm::vec4(1.f, -1.f, 0.f, 1.f);
+            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
             handle_->draw( ctm, projection );
 
-            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, +1.f, 0.f));
+//            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, +1.f, 0.f));
+            vec = modelview * glm::vec4(1.f, 1.f, 0.f, 1.f);
+            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
             handle_->draw( ctm, projection );
 
-            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, -1.f, 0.f));
+//            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, -1.f, 0.f));
+            vec = modelview * glm::vec4(-1.f, -1.f, 0.f, 1.f);
+            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
             handle_->draw( ctm, projection );
 
-            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, +1.f, 0.f));
+//            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, +1.f, 0.f));
+            vec = modelview * glm::vec4(-1.f, 1.f, 0.f, 1.f);
+            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
             handle_->draw( ctm, projection );
         }
         else if ( type_ == RESIZE_H ){
             // left and right
-            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, 0.f, 0.f) );
+//            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(1.f, 0.f, 0.f));
+            vec = modelview * glm::vec4(1.f, 0.f, 0.f, 1.f);
+            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
             handle_->draw( ctm, projection );
 
-            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, 0.f, 0.f));
+//            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(-1.f, 0.f, 0.f));
+            vec = modelview * glm::vec4(-1.f, 0.f, 0.f, 1.f);
+            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
             handle_->draw( ctm, projection );
         }
         else if ( type_ == RESIZE_V ){
             // top and bottom
-            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(0.f, +1.f, 0.f) );
+//            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(0.f, +1.f, 0.f));
+            vec = modelview * glm::vec4(0.f, 1.f, 0.f, 1.f);
+            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
             handle_->draw( ctm, projection );
 
-            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(0.f, -1.f, 0.f));
+//            ctm = modelview * glm::translate(glm::identity<glm::mat4>(), glm::vec3(0.f, -1.f, 0.f));
+            vec = modelview * glm::vec4(0.f, -1.f, 0.f, 1.f);
+            ctm = GlmToolkit::transform(vec, rot, glm::vec3(1.f));
             handle_->draw( ctm, projection );
         }
         else if ( type_ == ROTATE ){

Mixer.cpp

@@ -293,7 +293,6 @@ void Mixer::insertSource(Source *s)
 
         // update view to show source created
         current_view_->update(0);
-//        current_view_->makeVisible(s);
         current_view_->restoreSettings();
     }
 }

PickingVisitor.cpp

@@ -78,7 +78,7 @@ void PickingVisitor::visit(Handles &n)
     glm::vec4 P = glm::inverse(modelview_) * glm::vec4( point_, 0.f, 1.f );
 
     // get the bounding box of a handle
-    GlmToolkit::AxisAlignedBoundingBox bb = n.handle()->bbox().scaled(n.handle()->scale_);
+    GlmToolkit::AxisAlignedBoundingBox bb = n.handle()->bbox();
 
     // test picking depending on type of handle
     bool picked = false;

Primitives.cpp

@@ -113,7 +113,6 @@ void ImageSurface::init()
         textureindex_ = Resource::getTextureImage(resource_, &ar);
         scale_.x = ar;
     }
-
 }
 
 void ImageSurface::accept(Visitor& v)
@@ -139,7 +138,6 @@ void MediaSurface::init()
 
     mediaplayer_->open(path_);
     mediaplayer_->play(true);
-
 }
 
 void MediaSurface::draw(glm::mat4 modelview, glm::mat4 projection)
@@ -153,7 +151,6 @@ void MediaSurface::draw(glm::mat4 modelview, glm::mat4 projection)
         textureindex_ = mediaplayer_->texture();
 
     Surface::draw(modelview, projection);
-
 }
 
 void MediaSurface::update( float dt )

Scene.cpp

@@ -409,19 +409,20 @@ void Animation::accept(Visitor& v)
     v.visit(*this);
 }
 
-Scene::Scene(): root_(nullptr), foreground_(nullptr), background_(nullptr)
+Scene::Scene()
 {
     root_ = new Group;
 
     background_ = new Group;
     background_->translation_.z = 0.f;
+    root_->attach(background_);
+
     workspace_  = new Group;
     workspace_->translation_.z  = 1.f;
+    root_->attach(workspace_);
+
     foreground_ = new Group;
     foreground_->translation_.z = SCENE_DEPTH -0.1f;
-
-    root_->attach(background_);
-    root_->attach(workspace_);
     root_->attach(foreground_);
 }
 
@@ -446,7 +447,7 @@ void Scene::clearForeground()
 
 void Scene::clearWorkspace()
 {
-    foreground_->clear();
+    workspace_->clear();
 }
 
 void Scene::clearBackground()

Scene.h

@@ -51,7 +51,7 @@ public:
     inline int id () const { return id_; }
 
     // must initialize the node before draw
-    virtual void init() { initialized_ = true; }
+    virtual void init () { initialized_ = true; }
     virtual bool initialized () { return initialized_; }
 
     // pure virtual draw : to be instanciated to define node behavior
@@ -63,7 +63,7 @@ public:
     // accept all kind of visitors
     virtual void accept (Visitor& v);
 
-    void copyTransform(Node *other);
+    void copyTransform (Node *other);
 
     // public members, to manipulate with care
     bool      visible_;

UserInterfaceManager.cpp

@@ -309,9 +309,9 @@ void UserInterface::handleMouse()
         if ( ImGui::IsMouseDragging(ImGuiMouseButton_Right, 10.0f) )
         {
             // right mouse drag => drag current view
-            Mixer::manager().currentView()->drag( mouseclic[ImGuiMouseButton_Right], mousepos);
+            int c = Mixer::manager().currentView()->drag( mouseclic[ImGuiMouseButton_Right], mousepos);
 
-            ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeAll);
+            ImGui::SetMouseCursor(c);
         }
         else {
             ImGui::SetMouseCursor(ImGuiMouseCursor_Arrow);
@@ -335,7 +335,8 @@ void UserInterface::handleMouse()
             if (current)
             {
                 // drag current source
-                Mixer::manager().currentView()->grab( mouseclic[ImGuiMouseButton_Left], mousepos, current, pick);
+                int c = Mixer::manager().currentView()->grab( mouseclic[ImGuiMouseButton_Left], mousepos, current, pick);
+                ImGui::SetMouseCursor(c);
             }
             else {
 //                Log::Info("Mouse drag (%.1f,%.1f)(%.1f,%.1f)", io.MouseClickedPos[0].x, io.MouseClickedPos[0].y, io.MousePos.x, io.MousePos.y);

View.cpp

@@ -58,7 +58,7 @@ void View::update(float dt)
     }
 }
 
-void View::drag (glm::vec2 from, glm::vec2 to)
+View::Cursor View::drag (glm::vec2 from, glm::vec2 to)
 {
     static glm::vec3 start_translation = glm::vec3(0.f);
     static glm::vec2 start_position = glm::vec2(0.f);
@@ -74,6 +74,8 @@ void View::drag (glm::vec2 from, glm::vec2 to)
 
     // compute delta translation
     scene.root()->translation_ = start_translation + gl_Position_to - gl_Position_from;
+
+    return Cursor_ResizeAll;
 }
 
 MixingView::MixingView() : View(MIXING)
@@ -106,10 +108,10 @@ void MixingView::zoom( float factor )
     scene.root()->scale_.y = z;
 }
 
-void MixingView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2>)
+View::Cursor MixingView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2>)
 {
     if (!s)
-        return;
+        return Cursor_Arrow;
 
     Group *sourceNode = s->group(mode_);
 
@@ -130,6 +132,8 @@ void MixingView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *
 
     // request update
     s->touch();
+
+    return Cursor_ResizeAll;
 }
 
 uint MixingView::textureMixingQuadratic()
@@ -262,11 +266,13 @@ void GeometryView::zoom( float factor )
     scene.root()->scale_.y = z;
 }
 
-void GeometryView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick)
+View::Cursor GeometryView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick)
 {
+    View::Cursor ret = Cursor_Arrow;
+
     // work on the given source
     if (!s)
-        return;
+        return ret;
     Group *sourceNode = s->group(mode_);
 
     // remember source transform at moment of clic at position 'from'
@@ -303,7 +309,7 @@ void GeometryView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node
                 S_resize.y = S_resize.x;
             sourceNode->scale_ = start_scale * S_resize;
 
-            Log::Info(" resize            ( %.1f, %.1f ) ", S_resize.x, S_resize.y);
+//            Log::Info(" resize            ( %.1f, %.1f ) ", S_resize.x, S_resize.y);
 //            glm::vec3 factor = S_resize * glm::vec3(0.5f, 0.5f, 1.f);
 ////            glm::vec3 factor = S_resize * glm::vec3(1.f, 1.f, 1.f);
 ////            factor *= glm::sign( glm::vec3(pick.second, 1.f) );
@@ -312,32 +318,45 @@ void GeometryView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node
 //            sourceNode->translation_ = start_translation + factor;
 ////            sourceNode->translation_ = start_translation + S_resize * factor;
 
+            // select cursor depending on diagonal
+            glm::vec2 axis = glm::sign(pick.second);
+            ret = axis.x * axis.y > 0.f ? Cursor_ResizeNESW : Cursor_ResizeNWSE;
         }
         // picking on the resizing handles left or right
         else if ( pick.first == s->handleNode(Handles::RESIZE_H) ) {
             sourceNode->scale_ = start_scale * glm::vec3(S_resize.x, 1.f, 1.f);
+            ret = Cursor_ResizeEW;
         }
         // picking on the resizing handles top or bottom
         else if ( pick.first == s->handleNode(Handles::RESIZE_V) ) {
             sourceNode->scale_ = start_scale * glm::vec3(1.f, S_resize.y, 1.f);
+            ret = Cursor_ResizeNS;
         }
         // picking on the rotating handle
         else if ( pick.first == s->handleNode(Handles::ROTATE) ) {
             float angle = glm::orientedAngle( glm::normalize(glm::vec2(S_from)), glm::normalize(glm::vec2(S_to)));
+
+            if (UserInterface::manager().keyboardModifier())
+                angle = float ( int(angle * 30.f) ) / 30.f;
             sourceNode->rotation_ = start_rotation + glm::vec3(0.f, 0.f, angle);
+            ret = Cursor_Hand;
         }
         // picking anywhere but on a handle: user wants to move the source
         else {
             sourceNode->translation_ = start_translation + gl_Position_to - gl_Position_from;
+            ret = Cursor_ResizeAll;
         }
     }
     // don't have a handle, we can only move the source
     else {
         sourceNode->translation_ = start_translation + gl_Position_to - gl_Position_from;
+        ret = Cursor_ResizeAll;
     }
 
     // request update
     s->touch();
+
+    return ret;
 }
 
 LayerView::LayerView() : View(LAYER), aspect_ratio(1.f)
@@ -428,10 +447,10 @@ void LayerView::setDepth (Source *s, float d)
     View::need_deep_update_ = true;
 }
 
-void LayerView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick)
+View::Cursor LayerView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick)
 {
     if (!s)
-        return;
+        return Cursor_Arrow;
 
     static glm::vec3 start_translation = glm::vec3(0.f);
     static glm::vec2 start_position = glm::vec2(0.f);
@@ -450,5 +469,7 @@ void LayerView::grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *,
 
     // apply change
     setDepth( s,  MAX( -dest_translation.x, 0.f) );
+
+    return Cursor_ResizeAll;
 }
 

View.h

@@ -21,8 +21,23 @@ public:
     virtual void update (float dt);
     virtual void draw ();
     virtual void zoom (float) {}
-    virtual void drag (glm::vec2, glm::vec2);
+
-    virtual void grab (glm::vec2, glm::vec2, Source*, std::pair<Node *, glm::vec2>) {}
+    typedef enum {
+        Cursor_Arrow = 0,
+        Cursor_TextInput,
+        Cursor_ResizeAll,
+        Cursor_ResizeNS,
+        Cursor_ResizeEW,
+        Cursor_ResizeNESW,
+        Cursor_ResizeNWSE,
+        Cursor_Hand,
+        Cursor_NotAllowed
+    } Cursor;
+
+    virtual Cursor drag (glm::vec2, glm::vec2);
+    virtual Cursor grab (glm::vec2, glm::vec2, Source*, std::pair<Node *, glm::vec2>) {
+        return Cursor_Arrow;
+    }
 
     virtual void restoreSettings();
     virtual void saveSettings();
@@ -43,7 +58,7 @@ public:
     MixingView();
 
     void zoom (float factor) override;
-    void grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2>) override;
+    Cursor grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2>) override;
 
 private:
     uint textureMixingQuadratic();
@@ -72,7 +87,7 @@ public:
 
     void update (float dt) override;
     void zoom (float factor) override;
-    void grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick) override;
+    Cursor grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick) override;
 
 };
 
@@ -83,7 +98,7 @@ public:
 
     void update (float dt) override;
     void zoom (float factor) override;
-    void grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick) override;
+    Cursor grab (glm::vec2 from, glm::vec2 to, Source *s, std::pair<Node *, glm::vec2> pick) override;
 
     void setDepth (Source *, float d = -1.f);