omar/panopainter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
omigamedev
2017-05-05 21:57:02 +01:00
parent 484bf6fab4
commit 427dd66976
7 changed files with 147 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
engine/canvas.cpp
View File

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

8
engine/canvas.h
View File

@@ -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[];
CanvasMode* m_mode;
static std::vector<CanvasMode*> modes[];
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;

151
engine/canvas_modes.cpp
View File

@@ -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);
m_dragging = true;
node->mouse_capture();
switch (me->m_type)
{
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();
m_dragging = false;
node->mouse_release();
switch (ge->m_type)
{
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;
m_dragR_start = me->m_pos;
m_pan_start = m_pan;
node->mouse_capture();
switch (me->m_type)
{
case kEventType::MouseDownL:
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;
node->mouse_release();
}
void CanvasModePen::on_MouseMove(MouseEvent* me, glm::vec2& loc)
{
if (m_dragging)
canvas->stroke_update(loc, 1.f);
if (m_draggingR)
m_pan = m_pan_start + (me->m_pos - m_dragR_start) * glm::vec2(-1, -1);
m_cur = loc;
canvas->m_cam_rot = m_pan * 0.003f;
}
void CanvasModePen::on_MouseScroll(MouseEvent* me, glm::vec2& loc)
{
m_zoom_canvas += me->m_scroll_delta * 0.1f;
canvas->m_cam_fov -= me->m_scroll_delta * 20.1f;
}
void CanvasModePen::on_MouseCancel(MouseEvent* me, glm::vec2& loc)
{
m_dragging = false;
node->mouse_release();
}
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;
switch (me->m_type)
{
case kEventType::MouseDownL:
if (m_stage == 0)
{
canvas->stroke_start(loc, 1.f, node->m_brush);
node->mouse_capture();
m_stage = 1;
}
else
{
canvas->stroke_update(loc, 1.f);
//canvas->stroke_end();
node->mouse_release();
m_stage = 0;
}
break;
case kEventType::MouseCancel:
node->mouse_release();
break;
default:
break;
}
}

46
engine/canvas_modes.h
View File

@@ -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_MouseUpL(MouseEvent* me, glm::vec2& loc) {}
virtual void on_MouseDownR(MouseEvent* me, glm::vec2& loc) {}
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) {}
virtual void on_MouseCancel(MouseEvent* me, glm::vec2& loc) {}
virtual void on_KeyDown(KeyEvent* ke) {}
virtual void on_KeyUp(KeyEvent* ke) {}
virtual void on_GestureStart(GestureEvent* ge) {}
virtual void on_GestureMove(GestureEvent* ge) {}
virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) {}
virtual void on_KeyEvent(KeyEvent* ke) {}
virtual void on_GestureEvent(GestureEvent* ge) {}
};
class CanvasModeBasicCamera : public CanvasMode
{
bool m_draggingR = false;
glm::vec2 m_dragR_start;
glm::vec2 m_pan_start;
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_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;
virtual void on_MouseMove(MouseEvent* me, glm::vec2& loc) override;
virtual void on_MouseScroll(MouseEvent* me, glm::vec2& loc) override;
virtual void on_MouseCancel(MouseEvent* me, glm::vec2& loc) override;
virtual void on_GestureStart(GestureEvent* ge) override;
virtual void on_GestureMove(GestureEvent* ge) override;
virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) override;
};
class CanvasModeLine : public CanvasMode
{
int m_stage{0};
public:
virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) override;
};

20
engine/layout.h
View File

@@ -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;