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

implement pen and erase as strategy pattern introducing the CanvasMode classes

Browse Source
This commit is contained in:
omigamedev
2017-05-04 23:32:02 +01:00
parent 773ff61f92
commit 484bf6fab4
6 changed files with 162 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
engine/app.cpp
View File

@@ -445,7 +445,7 @@ void App::initLayout()
};
layers->on_layer_change = [this](Node*, int old_idx, int new_idx) {
canvas->m_canvas->m_current_layer_idx = new_idx;
canvas->m_canvas->m_current_layer_idx = canvas->m_canvas->m_order[new_idx];
};
layers->on_layer_order = [this](Node*, int old_idx, int new_idx) {
@@ -453,7 +453,7 @@ void App::initLayout()
};
layers->on_layer_opacity_changed = [this](Node*, int idx, float value) {
canvas->m_canvas->m_layers[idx].m_opacity = value;
canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]].m_opacity = value;
};
layers->on_layer_visibility_changed = [this](Node*, int idx, bool visible) {
@@ -472,10 +472,10 @@ void App::initLayout()
layout[main_id]->find<NodeButton>("btn-erase")->set_color(color_button_normal);
layout[main_id]->find<NodeButton>("btn-line")->set_color(color_button_normal);
layout[main_id]->find<NodeButton>("btn-cam")->set_color(color_button_normal);
Canvas::I->m_state = Canvas::kPenState::Draw;
Canvas::set_mode(Canvas::kCanvasMode::Draw);
};
layout[main_id]->find<NodeButton>("btn-pen")->set_color(color_button_hlight);
Canvas::I->m_state = Canvas::kPenState::Draw;
Canvas::set_mode(Canvas::kCanvasMode::Draw);
}
if (auto* button = layout[main_id]->find<NodeButton>("btn-erase"))
{
@@ -484,7 +484,7 @@ void App::initLayout()
layout[main_id]->find<NodeButton>("btn-erase")->set_color(color_button_hlight);
layout[main_id]->find<NodeButton>("btn-line")->set_color(color_button_normal);
layout[main_id]->find<NodeButton>("btn-cam")->set_color(color_button_normal);
Canvas::I->m_state = Canvas::kPenState::Erase;
Canvas::set_mode(Canvas::kCanvasMode::Erase);
};
}
if (auto* button = layout[main_id]->find<NodeButton>("btn-line"))
@@ -494,7 +494,7 @@ void App::initLayout()
layout[main_id]->find<NodeButton>("btn-erase")->set_color(color_button_normal);
layout[main_id]->find<NodeButton>("btn-line")->set_color(color_button_hlight);
layout[main_id]->find<NodeButton>("btn-cam")->set_color(color_button_normal);
Canvas::I->m_state = Canvas::kPenState::Line;
Canvas::set_mode(Canvas::kCanvasMode::Line);
};
}
if (auto* button = layout[main_id]->find<NodeButton>("btn-cam"))
@@ -504,7 +504,7 @@ void App::initLayout()
layout[main_id]->find<NodeButton>("btn-erase")->set_color(color_button_normal);
layout[main_id]->find<NodeButton>("btn-line")->set_color(color_button_normal);
layout[main_id]->find<NodeButton>("btn-cam")->set_color(color_button_hlight);
Canvas::I->m_state = Canvas::kPenState::Camera;
Canvas::set_mode(Canvas::kCanvasMode::Camera);
};
}
if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-bucket"))

10
engine/canvas.cpp
View File

@@ -3,6 +3,10 @@
#include "canvas.h"
ui::Canvas* ui::Canvas::I;
CanvasMode* ui::Canvas::modes[] = {
new CanvasModePen,
new CanvasModePen,
};
glm::vec3 ui::Canvas::m_plane_origin[6] = {
{ 0, 0,-1}, // front
{ 1, 0, 0}, // right
@@ -88,7 +92,7 @@ void ui::Canvas::stroke_draw()
else
{
glDisable(GL_BLEND);
if (m_state == kPenState::Erase)
if (m_state == kCanvasMode::Erase)
{
ShaderManager::use(ui::kShader::StrokeErase);
//ShaderManager::u_vec4(kShaderUniform::Col, m_brush.m_tip_color);
@@ -275,7 +279,7 @@ void ui::Canvas::stroke_commit()
m_tex2[i].bind();
m_sampler.bind(0);
m_sampler_bg.bind(1);
if (m_state == kPenState::Erase)
if (m_state == kCanvasMode::Erase)
{
ShaderManager::use(ui::kShader::Texture);
}
@@ -324,7 +328,7 @@ void ui::Canvas::stroke_start(glm::vec2 point, float pressure, const ui::Brush&
m_dirty_box[i] = glm::vec4(m_width, m_height, 0, 0); // reset bounding box
m_dirty_face[i] = false;
if (m_state == kPenState::Erase)
if (m_state == kCanvasMode::Erase)
{
m_layers[m_current_layer_idx].m_rtt[i].bindFramebuffer();
m_tmp[i].bindTexture();

15
engine/canvas.h
View File

@@ -5,6 +5,7 @@
#include "shape.h"
#include "brush.h"
#include "action.h"
#include "canvas_modes.h"
NS_START
@@ -66,8 +67,17 @@ public:
Sampler m_sampler_mask;
glm::vec2 m_cam_rot;
float m_cam_fov = 85;
enum class kPenState { Draw, Erase, Line, Camera };
kPenState m_state{ kPenState::Draw };
enum class kCanvasMode { Draw, Erase, Line, Camera };
kCanvasMode m_state{ kCanvasMode::Draw };
static CanvasMode* modes[];
CanvasMode* m_mode;
static void set_mode(kCanvasMode mode)
{
I->m_mode = modes[(int)mode];
I->m_state = mode;
I->m_mode->canvas = I;
}
GLuint cube_id;
RTT m_latlong;
@@ -96,7 +106,6 @@ public:
void preview_generate();
};
class ActionStroke : public Action
{
public:

64
engine/canvas_modes.cpp Normal file
View File

@@ -0,0 +1,64 @@
#include "pch.h"
#include "log.h"
#include "canvas_modes.h"
#include "layout.h"
#include "canvas.h"
NodeCanvas* CanvasMode::node;
ui::Canvas* CanvasMode::canvas;
void CanvasModePen::on_MouseDownL(MouseEvent* me, glm::vec2& loc)
{
canvas->stroke_start(loc, 1.f, node->m_brush);
m_dragging = true;
node->mouse_capture();
}
void CanvasModePen::on_MouseUpL(MouseEvent* me, glm::vec2& loc)
{
canvas->stroke_end();
m_dragging = false;
node->mouse_release();
}
void CanvasModePen::on_MouseDownR(MouseEvent* me, glm::vec2& loc)
{
m_draggingR = true;
m_dragR_start = me->m_pos;
m_pan_start = m_pan;
node->mouse_capture();
}
void CanvasModePen::on_MouseUpR(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;
}

47
engine/canvas_modes.h Normal file
View File

@@ -0,0 +1,47 @@
#pragma once
#include "event.h"
NS_START
class Canvas;
NS_END
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) {}
};
class CanvasModePen : public CanvasMode
{
bool m_dragging = false;
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;
};

80
engine/layout.h
View File

@@ -1967,15 +1967,6 @@ public:
class NodeCanvas : public Node
{
bool m_dragging = false;
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:
std::string data_path;
std::unique_ptr<ui::Canvas> m_canvas;
@@ -1987,9 +1978,9 @@ public:
{
m_mouse_ignore = false;
m_canvas = std::make_unique<ui::Canvas>();
CanvasMode::node = this;
CanvasMode::canvas = m_canvas.get();
m_canvas->create(1024, 1024);
//m_canvas->layer_add("asd");
//m_canvas->clear();
m_sampler.create();
m_face_plane.create<1>(2, 2);
}
@@ -1998,7 +1989,6 @@ public:
Node::restore_context();
m_canvas->create(1024, 1024);
m_sampler.create();
//m_canvas->clear();
m_face_plane.create<1>(2, 2);
m_canvas->snapshot_restore();
}
@@ -2023,7 +2013,7 @@ public:
glm::ivec4 c = (glm::ivec4)glm::vec4(box.x, (int)(vp[3] - box.y - box.w), box.z, box.w);
glViewport(c.x, c.y, c.z, c.w);
m_canvas->m_cam_rot = m_pan * 0.003f;
//m_canvas->m_cam_rot = m_pan * 0.003f;
//glm::mat4 proj = glm::ortho(0.f, box.z, 0.f, box.w, -1000.f, 1000.f);
glm::mat4 proj = glm::perspective(glm::radians(m_canvas->m_cam_fov), box.z / box.w, 0.1f, 1000.f);
@@ -2054,7 +2044,7 @@ public:
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
for (auto layer_index : m_canvas->m_order)
{
if (!(m_canvas->m_state == ui::Canvas::kPenState::Erase &&
if (!(m_canvas->m_state == ui::Canvas::kCanvasMode::Erase &&
m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index))
{
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity);
@@ -2104,67 +2094,47 @@ public:
switch (e->m_type)
{
case kEventType::MouseDownL:
{
m_canvas->stroke_start(loc, 1.f, m_brush);
m_dragging = true;
mouse_capture();
m_canvas->m_mode->on_MouseDownL(me, loc);
break;
}
case kEventType::MouseUpL:
m_canvas->stroke_end();
m_dragging = false;
mouse_release();
m_canvas->m_mode->on_MouseUpL(me, loc);
break;
case kEventType::MouseDownR:
m_draggingR = true;
m_dragR_start = me->m_pos;
m_pan_start = m_pan;
mouse_capture();
m_canvas->m_mode->on_MouseDownR(me, loc);
break;
case kEventType::MouseUpR:
m_draggingR = false;
mouse_release();
m_canvas->m_mode->on_MouseUpR(me, loc);
break;
case kEventType::MouseMove:
if (m_dragging)
m_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;
m_canvas->m_mode->on_MouseMove(me, loc);
break;
case kEventType::MouseScroll:
m_zoom_canvas += me->m_scroll_delta * 0.1f;
m_canvas->m_cam_fov -= me->m_scroll_delta * 20.1f;
m_canvas->m_mode->on_MouseScroll(me, loc);
break;
case kEventType::MouseCancel:
m_dragging = false;
mouse_release();
m_canvas->m_mode->on_MouseCancel(me, loc);
break;
case kEventType::KeyDown:
if (ke->m_key == kKey::KeyE)
m_canvas->m_state = ui::Canvas::kPenState::Erase;
if (ke->m_key == kKey::KeySpacebar)
m_canvas->m_alpha_lock = true;
if (ke->m_key == kKey::AndroidVolumeUp)
m_zoom_canvas *= 0.9f;
if (ke->m_key == kKey::AndroidVolumeDown)
m_zoom_canvas *= 1.1f;
// if (ke->m_key == kKey::KeyE)
// m_canvas->m_state = ui::Canvas::kPenState::Erase;
// if (ke->m_key == kKey::KeySpacebar)
// m_canvas->m_alpha_lock = true;
// if (ke->m_key == kKey::AndroidVolumeUp)
// m_zoom_canvas *= 0.9f;
// if (ke->m_key == kKey::AndroidVolumeDown)
// m_zoom_canvas *= 1.1f;
break;
case kEventType::KeyUp:
if (ke->m_key == kKey::KeyE)
m_canvas->m_state = ui::Canvas::kPenState::Draw;
if (ke->m_key == kKey::KeySpacebar)
m_canvas->m_alpha_lock = false;
// if (ke->m_key == kKey::KeyE)
// m_canvas->m_state = ui::Canvas::kPenState::Draw;
// if (ke->m_key == kKey::KeySpacebar)
// m_canvas->m_alpha_lock = false;
break;
case kEventType::GestureStart:
m_pan_start = m_pan;
m_zoom_start = m_zoom_canvas;
m_camera_fov = m_canvas->m_cam_fov;
m_canvas->m_mode->on_GestureStart(ge);
break;
case kEventType::GestureMove:
m_pan = m_pan_start + ge->m_pos_delta * glm::vec2(-1, -1) * 0.3f;
m_canvas->m_cam_fov = m_camera_fov - ge->m_distance_delta * .05f;
//m_zoom_canvas = m_zoom_start + ge->m_distance_delta * .001f;
m_canvas->m_mode->on_GestureMove(ge);
break;
default:
return kEventResult::Available;