separate pen mode and camera in different modes to be composed, start implementing line draw mode

android/CMakeLists.txt

@@ -39,6 +39,7 @@ add_library(
 	../engine/app.cpp
 	../engine/brush.cpp
 	../engine/canvas.cpp
+	../engine/canvas_mode.cpp
 	../engine/log.cpp
 	../engine/action.cpp
 )

engine.xcodeproj/project.pbxproj

@@ -28,6 +28,7 @@
 		AD58E0761E3421F2006ACC15 /* YGNodeList.c in Sources */ = {isa = PBXBuildFile; fileRef = AD58E0741E3421F2006ACC15 /* YGNodeList.c */; };
 		AD58E0771E3421F2006ACC15 /* Yoga.c in Sources */ = {isa = PBXBuildFile; fileRef = AD58E0751E3421F2006ACC15 /* Yoga.c */; };
 		AD58E0791E342205006ACC15 /* tinyxml2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AD58E0781E342205006ACC15 /* tinyxml2.cpp */; };
+		AD744B6E1EBC9EF800B66E30 /* canvas_modes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AD744B6C1EBC9EF700B66E30 /* canvas_modes.cpp */; };
 		AD8CF7211E913F0500083FFD /* log.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AD8CF71F1E913F0500083FFD /* log.cpp */; };
 		AD8CF7231E914DE400083FFD /* libcurl.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = AD8CF7221E914DE400083FFD /* libcurl.tbd */; };
 		AD95AEC61E41EDEC002DD03A /* font.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AD95AEC31E41EDEC002DD03A /* font.cpp */; };
@@ -85,6 +86,8 @@
 		AD58E0741E3421F2006ACC15 /* YGNodeList.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = YGNodeList.c; path = libs/yoga/yoga/YGNodeList.c; sourceTree = "<group>"; };
 		AD58E0751E3421F2006ACC15 /* Yoga.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = Yoga.c; path = libs/yoga/yoga/Yoga.c; sourceTree = "<group>"; };
 		AD58E0781E342205006ACC15 /* tinyxml2.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = tinyxml2.cpp; path = libs/tinyxml2/tinyxml2.cpp; sourceTree = "<group>"; };
+		AD744B6C1EBC9EF700B66E30 /* canvas_modes.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = canvas_modes.cpp; sourceTree = "<group>"; };
+		AD744B6D1EBC9EF800B66E30 /* canvas_modes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = canvas_modes.h; sourceTree = "<group>"; };
 		AD8CF71F1E913F0500083FFD /* log.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = log.cpp; sourceTree = "<group>"; };
 		AD8CF7201E913F0500083FFD /* log.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = log.h; sourceTree = "<group>"; };
 		AD8CF7221E914DE400083FFD /* libcurl.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libcurl.tbd; path = usr/lib/libcurl.tbd; sourceTree = SDKROOT; };
@@ -140,6 +143,8 @@
 		AD58E0511E107411006ACC15 /* engine */ = {
 			isa = PBXGroup;
 			children = (
+				AD744B6C1EBC9EF700B66E30 /* canvas_modes.cpp */,
+				AD744B6D1EBC9EF800B66E30 /* canvas_modes.h */,
 				ADB1C3DB1EA531B0009A65BD /* keymap.h */,
 				ADB1C3D81EA3A156009A65BD /* event.cpp */,
 				ADB1C3D91EA3A156009A65BD /* event.h */,
@@ -252,6 +257,7 @@
 				AD58E0651E2A76FD006ACC15 /* shader.cpp in Sources */,
 				AD4C08DA1E89BD0F0051D85F /* bezier.cpp in Sources */,
 				AD58E0761E3421F2006ACC15 /* YGNodeList.c in Sources */,
+				AD744B6E1EBC9EF800B66E30 /* canvas_modes.cpp in Sources */,
 				ADB61C821E3D38450093280F /* util.cpp in Sources */,
 				AD4C08DD1E89BD0F0051D85F /* rtt.cpp in Sources */,
 				AD58E06B1E2A774F006ACC15 /* texture.cpp in Sources */,

engine/canvas.cpp

@@ -3,9 +3,10 @@
 #include "canvas.h"
 
 ui::Canvas* ui::Canvas::I;
-CanvasMode* ui::Canvas::modes[] = {
+std::vector<CanvasMode*> ui::Canvas::modes[] = {
-    new CanvasModePen,
+    { new CanvasModePen, new CanvasModeBasicCamera },
-    new CanvasModePen,
+    { new CanvasModePen, new CanvasModeBasicCamera },
+    { new CanvasModeLine, new CanvasModeBasicCamera },
 };
 glm::vec3 ui::Canvas::m_plane_origin[6] = {
     { 0, 0,-1}, // front

engine/canvas.h

@@ -45,6 +45,7 @@ public:
     glm::mat4 m_mv;
     glm::mat4 m_proj;
     glm::vec4 m_box;
+    glm::vec2 m_pan;
     int m_width;
     int m_height;
     bool m_use_instanced = false;
@@ -70,13 +71,12 @@ public:
 
     enum class kCanvasMode { Draw, Erase, Line, Camera };
     kCanvasMode m_state{ kCanvasMode::Draw };
-    static CanvasMode* modes[];
+    static std::vector<CanvasMode*> modes[];
-    CanvasMode* m_mode;
+    std::vector<CanvasMode*>* m_mode;
     static void set_mode(kCanvasMode mode)
     {
-        I->m_mode = modes[(int)mode];
+        I->m_mode = &modes[(int)mode];
         I->m_state = mode;
-        I->m_mode->canvas = I;
     }
 
     GLuint cube_id;

engine/canvas_modes.cpp

@@ -7,58 +7,115 @@
 NodeCanvas* CanvasMode::node;
 ui::Canvas* CanvasMode::canvas; 
 
-void CanvasModePen::on_MouseDownL(MouseEvent* me, glm::vec2& loc)
+void CanvasModeBasicCamera::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
 {
-    canvas->stroke_start(loc, 1.f, node->m_brush);
+    switch (me->m_type)
-    m_dragging = true;
+    {
-    node->mouse_capture();
+        case kEventType::MouseDownL:
+            break;
+        case kEventType::MouseUpL:
+            break;
+        case kEventType::MouseDownR:
+            m_draggingR = true;
+            m_dragR_start = me->m_pos;
+            m_pan_start = canvas->m_pan;
+            node->mouse_capture();
+            break;
+        case kEventType::MouseUpR:
+            m_draggingR = false;
+            node->mouse_release();
+            break;
+        case kEventType::MouseMove:
+            if (m_draggingR)
+                canvas->m_pan = m_pan_start + (me->m_pos - m_dragR_start) * glm::vec2(-1, -1);
+            canvas->m_cam_rot = canvas->m_pan * 0.003f;
+            break;
+        case kEventType::MouseScroll:
+            m_zoom_canvas += me->m_scroll_delta * 0.1f;
+            canvas->m_cam_fov -= me->m_scroll_delta * 20.1f;
+            break;
+        case kEventType::MouseCancel:
+            m_draggingR = false;
+            node->mouse_release();
+            break;
+        default:
+            break;
+    }
 }
-void CanvasModePen::on_MouseUpL(MouseEvent* me, glm::vec2& loc)
+
+void CanvasModeBasicCamera::on_GestureEvent(GestureEvent* ge)
 {
-    canvas->stroke_end();
+    switch (ge->m_type)
-    m_dragging = false;
+    {
-    node->mouse_release();
+        case kEventType::GestureStart:
+            m_pan_start = canvas->m_pan;
+            m_zoom_start = m_zoom_canvas;
+            m_camera_fov = canvas->m_cam_fov;
+            break;
+        case kEventType::GestureMove:
+            canvas->m_pan = m_pan_start + ge->m_pos_delta * glm::vec2(-1, -1) * 0.3f;
+            canvas->m_cam_fov = m_camera_fov - ge->m_distance_delta * .05f;
+            canvas->m_cam_rot = canvas->m_pan * 0.003f;
+            break;
+        default:
+            break;
+    }
 }
-void CanvasModePen::on_MouseDownR(MouseEvent* me, glm::vec2& loc)
+
+////////////////////////////////////////////////////////////////////
+
+void CanvasModePen::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
 {
-    m_draggingR = true;
+    switch (me->m_type)
-    m_dragR_start = me->m_pos;
+    {
-    m_pan_start = m_pan;
+        case kEventType::MouseDownL:
-    node->mouse_capture();
+            canvas->stroke_start(loc, 1.f, node->m_brush);
+            m_dragging = true;
+            node->mouse_capture();
+            break;
+        case kEventType::MouseUpL:
+            canvas->stroke_end();
+            m_dragging = false;
+            node->mouse_release();
+            break;
+        case kEventType::MouseMove:
+            if (m_dragging)
+                canvas->stroke_update(loc, 1.f);
+            break;
+        case kEventType::MouseCancel:
+            m_dragging = false;
+            node->mouse_release();
+            break;
+        default:
+            break;
+    }
 }
-void CanvasModePen::on_MouseUpR(MouseEvent* me, glm::vec2& loc)
+
+////////////////////////////////////////////////////////////////////
+
+void CanvasModeLine::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
 {
-    m_draggingR = false;
+    switch (me->m_type)
-    node->mouse_release();
+    {
-}
+        case kEventType::MouseDownL:
-void CanvasModePen::on_MouseMove(MouseEvent* me, glm::vec2& loc)
+            if (m_stage == 0)
-{
+            {
-    if (m_dragging)
+                canvas->stroke_start(loc, 1.f, node->m_brush);
-        canvas->stroke_update(loc, 1.f);
+                node->mouse_capture();
-    if (m_draggingR)
+                m_stage = 1;
-        m_pan = m_pan_start + (me->m_pos - m_dragR_start) * glm::vec2(-1, -1);
+            }
-    m_cur = loc;
+            else
-    canvas->m_cam_rot = m_pan * 0.003f;
+            {
-}
+                canvas->stroke_update(loc, 1.f);
-void CanvasModePen::on_MouseScroll(MouseEvent* me, glm::vec2& loc)
+                //canvas->stroke_end();
-{
+                node->mouse_release();
-    m_zoom_canvas += me->m_scroll_delta * 0.1f;
+                m_stage = 0;
-    canvas->m_cam_fov -= me->m_scroll_delta * 20.1f;
+            }
-}
+            break;
-void CanvasModePen::on_MouseCancel(MouseEvent* me, glm::vec2& loc)
+        case kEventType::MouseCancel:
-{
+            node->mouse_release();
-    m_dragging = false;
+            break;
-    node->mouse_release();
+        default:
-}
+            break;
-void CanvasModePen::on_GestureStart(GestureEvent* ge)
+    }
-{
-    m_pan_start = m_pan;
-    m_zoom_start = m_zoom_canvas;
-    m_camera_fov = canvas->m_cam_fov;
-}
-void CanvasModePen::on_GestureMove(GestureEvent* ge)
-{
-    m_pan = m_pan_start + ge->m_pos_delta * glm::vec2(-1, -1) * 0.3f;
-    canvas->m_cam_fov = m_camera_fov - ge->m_distance_delta * .05f;
-    canvas->m_cam_rot = m_pan * 0.003f;
 }

engine/canvas_modes.h

@@ -10,17 +10,22 @@ class CanvasMode
 public:
     static class NodeCanvas* node;
     static ui::Canvas* canvas;
-    virtual void on_MouseDownL(MouseEvent* me, glm::vec2& loc) {}
+    virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) {}
-    virtual void on_MouseUpL(MouseEvent* me, glm::vec2& loc) {}
+    virtual void on_KeyEvent(KeyEvent* ke) {}
-    virtual void on_MouseDownR(MouseEvent* me, glm::vec2& loc) {}
+    virtual void on_GestureEvent(GestureEvent* ge) {}
-    virtual void on_MouseUpR(MouseEvent* me, glm::vec2& loc) {}
+};
-    virtual void on_MouseMove(MouseEvent* me, glm::vec2& loc) {}
+
-    virtual void on_MouseScroll(MouseEvent* me, glm::vec2& loc) {}
+class CanvasModeBasicCamera : public CanvasMode
-    virtual void on_MouseCancel(MouseEvent* me, glm::vec2& loc) {}
+{
-    virtual void on_KeyDown(KeyEvent* ke) {}
+    bool m_draggingR = false;
-    virtual void on_KeyUp(KeyEvent* ke) {}
+    glm::vec2 m_dragR_start;
-    virtual void on_GestureStart(GestureEvent* ge) {}
+    glm::vec2 m_pan_start;
-    virtual void on_GestureMove(GestureEvent* ge) {}
+    float m_camera_fov;
+    float m_zoom_canvas = 1.f;
+    float m_zoom_start;
+public:
+    virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) override;
+    virtual void on_GestureEvent(GestureEvent* ge) override;
 };
 
 class CanvasModePen : public CanvasMode
@@ -29,19 +34,16 @@ class CanvasModePen : public CanvasMode
     bool m_draggingR = false;
     glm::vec2 m_dragR_start;
     glm::vec2 m_pan_start;
-    glm::vec2 m_pan;
-    glm::vec2 m_cur;
     float m_camera_fov;
     float m_zoom_canvas = 1.f;
     float m_zoom_start;
 public:
-    virtual void on_MouseDownL(MouseEvent* me, glm::vec2& loc) override;
+    virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) override;
-    virtual void on_MouseUpL(MouseEvent* me, glm::vec2& loc) override;
+};
-    virtual void on_MouseDownR(MouseEvent* me, glm::vec2& loc) override;
+
-    virtual void on_MouseUpR(MouseEvent* me, glm::vec2& loc) override;
+class CanvasModeLine : public CanvasMode
-    virtual void on_MouseMove(MouseEvent* me, glm::vec2& loc) override;
+{
-    virtual void on_MouseScroll(MouseEvent* me, glm::vec2& loc) override;
+    int m_stage{0};
-    virtual void on_MouseCancel(MouseEvent* me, glm::vec2& loc) override;
+public:
-    virtual void on_GestureStart(GestureEvent* ge) override;
+    virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) override;
-    virtual void on_GestureMove(GestureEvent* ge) override;
 };

engine/layout.h

@@ -2094,25 +2094,14 @@ public:
         switch (e->m_type)
         {
         case kEventType::MouseDownL:
-            m_canvas->m_mode->on_MouseDownL(me, loc);
-            break;
         case kEventType::MouseUpL:
-            m_canvas->m_mode->on_MouseUpL(me, loc);
-            break;
         case kEventType::MouseDownR:
-            m_canvas->m_mode->on_MouseDownR(me, loc);
-            break;
         case kEventType::MouseUpR:
-            m_canvas->m_mode->on_MouseUpR(me, loc);
-            break;
         case kEventType::MouseMove:
-            m_canvas->m_mode->on_MouseMove(me, loc);
-            break;
         case kEventType::MouseScroll:
-            m_canvas->m_mode->on_MouseScroll(me, loc);
-            break;
         case kEventType::MouseCancel:
-            m_canvas->m_mode->on_MouseCancel(me, loc);
+            for (auto& mode : *m_canvas->m_mode)
+                mode->on_MouseEvent(me, loc);
             break;
         case kEventType::KeyDown:
 //             if (ke->m_key == kKey::KeyE)
@@ -2131,10 +2120,9 @@ public:
 //                 m_canvas->m_alpha_lock = false;
             break;
         case kEventType::GestureStart:
-            m_canvas->m_mode->on_GestureStart(ge);
-            break;
         case kEventType::GestureMove:
-            m_canvas->m_mode->on_GestureMove(ge);
+            for (auto& mode : *m_canvas->m_mode)
+                mode->on_GestureEvent(ge);
             break;
         default:
             return kEventResult::Available;