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

Extract node canvas events and preview/node geometry shells

Browse Source
This commit is contained in:
omigamedev
2026-06-16 23:31:30 +02:00
parent dde6123598
commit 6b337b2d87
11 changed files with 446 additions and 333 deletions
Download Patch File Download Diff File Expand all files Collapse all files

157
src/legacy_canvas_tool_services.cpp
View File

@@ -4,6 +4,8 @@
#include "app.h"
#include "legacy_history_services.h"
#include "legacy_ui_overlay_services.h"
#include "node_canvas.h"
namespace pp::panopainter {
namespace {
@@ -196,6 +198,156 @@ public:
}
};
pp::app::CanvasHotkeyKey canvas_hotkey_key(kKey key) noexcept
{
switch (key) {
case kKey::AndroidBack:
return pp::app::CanvasHotkeyKey::android_back;
case kKey::KeyAlt:
return pp::app::CanvasHotkeyKey::alt;
case kKey::KeyE:
return pp::app::CanvasHotkeyKey::e;
case kKey::KeyS:
return pp::app::CanvasHotkeyKey::s;
case kKey::KeyTab:
return pp::app::CanvasHotkeyKey::tab;
case kKey::KeyZ:
return pp::app::CanvasHotkeyKey::z;
case kKey::KeyBracketLeft:
return pp::app::CanvasHotkeyKey::bracket_left;
case kKey::KeyBracketRight:
return pp::app::CanvasHotkeyKey::bracket_right;
default:
return pp::app::CanvasHotkeyKey::other;
}
}
pp::app::CanvasHotkeyState canvas_hotkey_state(bool mouse_focused, int touch_finger_count = 0) noexcept
{
pp::app::CanvasHotkeyState state;
state.ctrl_down = App::I && App::I->keys[(int)kKey::KeyCtrl];
state.shift_down = App::I && App::I->keys[(int)kKey::KeyShift];
state.mouse_focused = mouse_focused;
const auto history = pp::panopainter::legacy_history_snapshot();
state.undo_count = history.undo_count;
state.redo_count = history.redo_count;
state.touch_finger_count = touch_finger_count;
return state;
}
void execute_canvas_hotkey_plan(const pp::app::CanvasHotkeyPlan& plan)
{
const auto status = pp::panopainter::execute_legacy_canvas_hotkey_plan(plan);
if (!status.ok())
LOG("Canvas hotkey action failed: %s", status.message);
}
void run_canvas_hotkey(
pp::app::CanvasHotkeyEvent event,
kKey key,
bool mouse_focused,
int touch_finger_count = 0)
{
const auto plan = pp::app::plan_canvas_hotkey(
event,
canvas_hotkey_key(key),
canvas_hotkey_state(mouse_focused, touch_finger_count));
if (plan)
execute_canvas_hotkey_plan(plan.value());
else
LOG("Canvas hotkey planning failed: %s", plan.status().message);
}
void run_canvas_tool_mode(pp::app::CanvasToolMode mode)
{
const auto plan = pp::app::plan_canvas_tool_select(mode);
const auto status = pp::panopainter::execute_legacy_canvas_input_tool_plan(plan);
if (!status.ok())
LOG("Canvas input tool action failed: %s", status.message);
}
[[nodiscard]] kEventResult execute_node_canvas_handle_event(NodeCanvas& node_canvas, Event* e)
{
static bool stylus_eraser = false;
MouseEvent* me = static_cast<MouseEvent*>(e);
KeyEvent* ke = static_cast<KeyEvent*>(e);
GestureEvent* ge = static_cast<GestureEvent*>(e);
TouchEvent* te = static_cast<TouchEvent*>(e);
auto loc = (me->m_pos - node_canvas.m_pos) * node_canvas.root()->m_zoom;
switch (e->m_type)
{
case kEventType::MouseMove:
if (stylus_eraser != me->m_eraser)
{
run_canvas_tool_mode(me->m_eraser ?
pp::app::CanvasToolMode::erase :
pp::app::CanvasToolMode::draw);
stylus_eraser = me->m_eraser;
}
case kEventType::MouseScroll:
case kEventType::MouseDownL:
case kEventType::MouseUpL:
case kEventType::MouseDownR:
case kEventType::MouseUpR:
case kEventType::MouseCancel:
node_canvas.m_canvas->m_cur_pos = loc;
node_canvas.update_cursor();
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_MouseEvent(me, loc);
break;
case kEventType::MouseUnfocus:
(*node_canvas.m_canvas->m_mode)[0]->m_draw_tip = false;
App::I->show_cursor();
break;
case kEventType::MouseFocus:
node_canvas.update_cursor();
break;
case kEventType::KeyDown:
run_canvas_hotkey(
pp::app::CanvasHotkeyEvent::key_down,
ke->m_key,
node_canvas.m_mouse_focus);
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_KeyEvent(ke);
break;
case kEventType::KeyUp:
node_canvas.update_cursor();
run_canvas_hotkey(
pp::app::CanvasHotkeyEvent::key_up,
ke->m_key,
node_canvas.m_mouse_focus);
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_KeyEvent(ke);
break;
case kEventType::GestureStart:
node_canvas.mouse_capture();
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_GestureEvent(ge);
break;
case kEventType::GestureMove:
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_GestureEvent(ge);
break;
case kEventType::GestureEnd:
pp::panopainter::release_legacy_mouse_capture(node_canvas);
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_GestureEvent(ge);
break;
case kEventType::TouchTap:
run_canvas_hotkey(
pp::app::CanvasHotkeyEvent::touch_tap,
kKey::Unknown,
node_canvas.m_mouse_focus,
te->m_finger_count);
break;
default:
return kEventResult::Available;
break;
}
return kEventResult::Consumed;
}
} // namespace
pp::foundation::Status execute_legacy_canvas_tool_plan(
@@ -221,4 +373,9 @@ pp::foundation::Status execute_legacy_canvas_hotkey_plan(
return pp::app::execute_canvas_hotkey_plan(plan, services);
}
kEventResult handle_legacy_node_canvas_event(NodeCanvas& node_canvas, Event* e)
{
return execute_node_canvas_handle_event(node_canvas, e);
}
} // namespace pp::panopainter

6
src/legacy_canvas_tool_services.h
View File

@@ -1,11 +1,16 @@
#pragma once
#include <cstdint>
#include "app_core/canvas_hotkey.h"
#include "app_core/canvas_tool_ui.h"
#include "foundation/result.h"
class App;
class NodeCanvas;
class Node;
class Event;
enum class kEventResult : uint8_t;
namespace pp::panopainter {
@@ -17,5 +22,6 @@ namespace pp::panopainter {
const pp::app::CanvasToolPlan& plan);
[[nodiscard]] pp::foundation::Status execute_legacy_canvas_hotkey_plan(
const pp::app::CanvasHotkeyPlan& plan);
[[nodiscard]] kEventResult handle_legacy_node_canvas_event(NodeCanvas& node_canvas, Event* e);
} // namespace pp::panopainter

112
src/legacy_node_stroke_preview_runtime_services.cpp
View File

@@ -24,6 +24,118 @@
namespace pp::panopainter {
pp::renderer::RenderDeviceFeatures stroke_preview_render_device_features() noexcept
{
return ShaderManager::render_device_features();
}
void apply_legacy_node_stroke_preview_viewport(std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height)
{
pp::legacy::ui_gl::apply_viewport(x, y, width, height, "NodeStrokePreview");
}
pp::renderer::gl::OpenGlViewportRect query_legacy_node_stroke_preview_viewport()
{
return pp::legacy::ui_gl::query_viewport_rect("NodeStrokePreview");
}
std::array<float, 4> query_legacy_node_stroke_preview_clear_color()
{
return pp::legacy::ui_gl::query_clear_color("NodeStrokePreview");
}
void apply_legacy_node_stroke_preview_clear_color(std::array<float, 4> color)
{
pp::legacy::ui_gl::set_clear_color(color, "NodeStrokePreview");
}
void apply_legacy_node_stroke_preview_scissor(std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height)
{
pp::legacy::ui_gl::apply_scissor_rect(x, y, width, height, "NodeStrokePreview");
}
void apply_legacy_node_stroke_preview_capability(std::uint32_t state, bool enabled)
{
pp::legacy::ui_gl::set_capability(state, enabled, "NodeStrokePreview");
}
namespace {
namespace stroke_preview_live_slots {
constexpr std::uint32_t kTip = 0U;
constexpr std::uint32_t kDestination = 1U;
constexpr std::uint32_t kPattern = 2U;
constexpr std::uint32_t kMixer = 3U;
constexpr std::uint32_t kReservedLinear = 4U;
}
void set_active_texture_unit(std::uint32_t unit_index)
{
pp::legacy::ui_gl::activate_texture_unit(unit_index, "NodeStrokePreview");
}
void unbind_texture_2d()
{
pp::legacy::ui_gl::unbind_texture_2d("NodeStrokePreview");
}
} // namespace
void bind_legacy_node_stroke_preview_live_samplers(
Sampler& mipmap_sampler,
Sampler& linear_sampler,
Sampler& repeat_sampler)
{
mipmap_sampler.bind(stroke_preview_live_slots::kTip);
linear_sampler.bind(stroke_preview_live_slots::kDestination);
repeat_sampler.bind(stroke_preview_live_slots::kPattern);
linear_sampler.bind(stroke_preview_live_slots::kMixer);
linear_sampler.bind(stroke_preview_live_slots::kReservedLinear);
}
void bind_legacy_node_stroke_preview_dual_pass_textures(const Brush& dual_brush)
{
set_active_texture_unit(stroke_preview_live_slots::kTip);
dual_brush.m_tip_texture ?
dual_brush.m_tip_texture->bind() :
unbind_texture_2d();
}
void bind_legacy_node_stroke_preview_pattern_texture(const Brush& brush)
{
set_active_texture_unit(stroke_preview_live_slots::kPattern);
brush.m_pattern_texture ? brush.m_pattern_texture->bind() : unbind_texture_2d();
}
void bind_legacy_node_stroke_preview_destination_texture(Texture2D& texture)
{
set_active_texture_unit(stroke_preview_live_slots::kDestination);
texture.bind();
}
void unbind_legacy_node_stroke_preview_destination_texture(Texture2D& texture)
{
set_active_texture_unit(stroke_preview_live_slots::kDestination);
texture.unbind();
}
void unbind_legacy_node_stroke_preview_mixer_texture(RTT& mixer_rtt)
{
set_active_texture_unit(stroke_preview_live_slots::kMixer);
mixer_rtt.unbindTexture();
}
void copy_legacy_node_stroke_preview_destination_texture_region(
int src_x,
int src_y,
int dst_x,
int dst_y,
int width,
int height)
{
copy_framebuffer_to_texture_2d(src_x, src_y, dst_x, dst_y, width, height);
}
void execute_legacy_node_stroke_preview_background_capture_pass(
const LegacyNodeStrokePreviewBackgroundCaptureRequest& request)
{

28
src/legacy_node_stroke_preview_runtime_services.h
View File

@@ -9,13 +9,41 @@
#include "rtt.h"
#include "texture.h"
#include <array>
#include <cmath>
#include <cstdint>
#include <functional>
#include <memory>
#include <vector>
namespace pp::panopainter {
[[nodiscard]] pp::renderer::RenderDeviceFeatures stroke_preview_render_device_features() noexcept;
void apply_legacy_node_stroke_preview_viewport(std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height);
[[nodiscard]] pp::renderer::gl::OpenGlViewportRect query_legacy_node_stroke_preview_viewport();
[[nodiscard]] std::array<float, 4> query_legacy_node_stroke_preview_clear_color();
void apply_legacy_node_stroke_preview_clear_color(std::array<float, 4> color);
void apply_legacy_node_stroke_preview_scissor(std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height);
void apply_legacy_node_stroke_preview_capability(std::uint32_t state, bool enabled);
void bind_legacy_node_stroke_preview_live_samplers(
Sampler& mipmap_sampler,
Sampler& linear_sampler,
Sampler& repeat_sampler);
void bind_legacy_node_stroke_preview_dual_pass_textures(const Brush& dual_brush);
void bind_legacy_node_stroke_preview_pattern_texture(const Brush& brush);
void bind_legacy_node_stroke_preview_destination_texture(Texture2D& texture);
void unbind_legacy_node_stroke_preview_destination_texture(Texture2D& texture);
void unbind_legacy_node_stroke_preview_mixer_texture(RTT& mixer_rtt);
void copy_legacy_node_stroke_preview_destination_texture_region(
int src_x,
int src_y,
int dst_x,
int dst_y,
int width,
int height);
struct LegacyNodeStrokePreviewBackgroundCaptureRequest {
glm::vec2 size {};
bool colorize = false;

77
src/legacy_ui_node_style.cpp
View File

@@ -36,6 +36,41 @@ void legacy_ui_node_set_height_percent(Node& node, float value)
node.app_redraw();
}
void legacy_ui_node_set_size(Node& node, float w, float h)
{
legacy_ui_node_set_width(node, w);
legacy_ui_node_set_height(node, h);
node.m_size = { w, h };
node.app_redraw();
}
void legacy_ui_node_set_size(Node& node, glm::vec2 value)
{
legacy_ui_node_set_size(node, value.x, value.y);
}
void legacy_ui_node_set_min_size(Node& node, float w, float h)
{
legacy_ui_node_set_min_width(node, w);
legacy_ui_node_set_min_height(node, h);
}
void legacy_ui_node_set_min_size(Node& node, glm::vec2 value)
{
legacy_ui_node_set_min_size(node, value.x, value.y);
}
void legacy_ui_node_set_max_size(Node& node, float w, float h)
{
legacy_ui_node_set_max_width(node, w);
legacy_ui_node_set_max_height(node, h);
}
void legacy_ui_node_set_max_size(Node& node, glm::vec2 value)
{
legacy_ui_node_set_max_size(node, value.x, value.y);
}
void legacy_ui_node_set_max_width(Node& node, float value)
{
YGNodeStyleSetMaxWidth(node.y_node, value);
@@ -137,6 +172,13 @@ void legacy_ui_node_set_position(Node& node, float l, float t, float r, float b)
node.app_redraw();
}
void legacy_ui_node_set_position(Node& node, glm::vec2 value)
{
legacy_ui_node_set_position(node, value.x, value.y);
node.m_pos = value;
node.app_redraw();
}
void legacy_ui_node_set_flex_grow(Node& node, float value)
{
YGNodeStyleSetFlexGrow(node.y_node, value);
@@ -248,3 +290,38 @@ YGDirection legacy_ui_node_get_rtl(const Node& node)
}
} // namespace pp::panopainter
void Node::SetSize(float w, float h)
{
pp::panopainter::legacy_ui_node_set_size(*this, w, h);
}
void Node::SetSize(glm::vec2 value)
{
pp::panopainter::legacy_ui_node_set_size(*this, value);
}
void Node::SetMinSize(float w, float h)
{
pp::panopainter::legacy_ui_node_set_min_size(*this, w, h);
}
void Node::SetMinSize(glm::vec2 value)
{
pp::panopainter::legacy_ui_node_set_min_size(*this, value);
}
void Node::SetMaxSize(float w, float h)
{
pp::panopainter::legacy_ui_node_set_max_size(*this, w, h);
}
void Node::SetMaxSize(glm::vec2 value)
{
pp::panopainter::legacy_ui_node_set_max_size(*this, value);
}
void Node::SetPosition(const glm::vec2 pos)
{
pp::panopainter::legacy_ui_node_set_position(*this, pos);
}

7
src/legacy_ui_node_style.h
View File

@@ -12,6 +12,12 @@ void legacy_ui_node_set_width(Node& node, float value);
void legacy_ui_node_set_width_percent(Node& node, float value);
void legacy_ui_node_set_height(Node& node, float value);
void legacy_ui_node_set_height_percent(Node& node, float value);
void legacy_ui_node_set_size(Node& node, float w, float h);
void legacy_ui_node_set_size(Node& node, glm::vec2 value);
void legacy_ui_node_set_min_size(Node& node, float w, float h);
void legacy_ui_node_set_min_size(Node& node, glm::vec2 value);
void legacy_ui_node_set_max_size(Node& node, float w, float h);
void legacy_ui_node_set_max_size(Node& node, glm::vec2 value);
void legacy_ui_node_set_max_width(Node& node, float value);
void legacy_ui_node_set_max_width_percent(Node& node, float value);
void legacy_ui_node_set_max_height(Node& node, float value);
@@ -26,6 +32,7 @@ void legacy_ui_node_set_margin(Node& node, float t, float r, float b, float l);
glm::vec4 legacy_ui_node_get_margin(const Node& node);
void legacy_ui_node_set_position(Node& node, float l, float t);
void legacy_ui_node_set_position(Node& node, float l, float t, float r, float b);
void legacy_ui_node_set_position(Node& node, glm::vec2 value);
void legacy_ui_node_set_flex_grow(Node& node, float value);
void legacy_ui_node_set_flex_shrink(Node& node, float value);
void legacy_ui_node_set_flex_dir(Node& node, YGFlexDirection value);

45
src/node.cpp
View File

@@ -89,44 +89,6 @@ void Node::SetHeightP(float value)
pp::panopainter::legacy_ui_node_set_height_percent(*this, value);
}
void Node::SetSize(float w, float h)
{
SetWidth(w); SetHeight(h);
m_size = {w, h};
app_redraw();
}
void Node::SetSize(glm::vec2 value)
{
SetWidth(value.x); SetHeight(value.y);
m_size = value;
app_redraw();
}
void Node::SetMinSize(float w, float h)
{
SetMinWidth(w);
SetMinHeight(h);
}
void Node::SetMinSize(glm::vec2 value)
{
SetMinWidth(value.x);
SetMinHeight(value.y);
}
void Node::SetMaxSize(float w, float h)
{
SetMaxWidth(w);
SetMaxHeight(h);
}
void Node::SetMaxSize(glm::vec2 value)
{
SetMaxWidth(value.x);
SetMaxHeight(value.y);
}
void Node::SetMaxWidth(float value)
{
pp::panopainter::legacy_ui_node_set_max_width(*this, value);
@@ -187,13 +149,6 @@ glm::vec4 Node::GetMargin() const
return pp::panopainter::legacy_ui_node_get_margin(*this);
}
void Node::SetPosition(const glm::vec2 pos)
{
SetPosition(pos.x, pos.y);
m_pos = pos;
app_redraw();
}
void Node::SetPosition(float l, float t)
{
pp::panopainter::legacy_ui_node_set_position(*this, l, t);

161
src/node_canvas.cpp
View File

@@ -6,172 +6,13 @@
#include <memory>
#include <vector>
#include "app_core/canvas_hotkey.h"
#include "app_core/canvas_tool_ui.h"
#include "app_core/document_animation.h"
#include "app.h"
#include "legacy_node_canvas_draw_services.h"
#include "legacy_node_canvas_state_services.h"
#include "legacy_ui_overlay_services.h"
#include "legacy_canvas_tool_services.h"
#include "legacy_history_services.h"
#include "log.h"
#include "node_canvas.h"
namespace {
pp::app::CanvasHotkeyKey canvas_hotkey_key(kKey key) noexcept
{
switch (key) {
case kKey::AndroidBack:
return pp::app::CanvasHotkeyKey::android_back;
case kKey::KeyAlt:
return pp::app::CanvasHotkeyKey::alt;
case kKey::KeyE:
return pp::app::CanvasHotkeyKey::e;
case kKey::KeyS:
return pp::app::CanvasHotkeyKey::s;
case kKey::KeyTab:
return pp::app::CanvasHotkeyKey::tab;
case kKey::KeyZ:
return pp::app::CanvasHotkeyKey::z;
case kKey::KeyBracketLeft:
return pp::app::CanvasHotkeyKey::bracket_left;
case kKey::KeyBracketRight:
return pp::app::CanvasHotkeyKey::bracket_right;
default:
return pp::app::CanvasHotkeyKey::other;
}
}
pp::app::CanvasHotkeyState canvas_hotkey_state(bool mouse_focused, int touch_finger_count = 0) noexcept
{
pp::app::CanvasHotkeyState state;
state.ctrl_down = App::I && App::I->keys[(int)kKey::KeyCtrl];
state.shift_down = App::I && App::I->keys[(int)kKey::KeyShift];
state.mouse_focused = mouse_focused;
const auto history = pp::panopainter::legacy_history_snapshot();
state.undo_count = history.undo_count;
state.redo_count = history.redo_count;
state.touch_finger_count = touch_finger_count;
return state;
}
void execute_canvas_hotkey_plan(const pp::app::CanvasHotkeyPlan& plan)
{
const auto status = pp::panopainter::execute_legacy_canvas_hotkey_plan(plan);
if (!status.ok())
LOG("Canvas hotkey action failed: %s", status.message);
}
void run_canvas_hotkey(
pp::app::CanvasHotkeyEvent event,
kKey key,
bool mouse_focused,
int touch_finger_count = 0)
{
const auto plan = pp::app::plan_canvas_hotkey(
event,
canvas_hotkey_key(key),
canvas_hotkey_state(mouse_focused, touch_finger_count));
if (plan)
execute_canvas_hotkey_plan(plan.value());
else
LOG("Canvas hotkey planning failed: %s", plan.status().message);
}
void run_canvas_tool_mode(pp::app::CanvasToolMode mode)
{
const auto plan = pp::app::plan_canvas_tool_select(mode);
const auto status = pp::panopainter::execute_legacy_canvas_input_tool_plan(plan);
if (!status.ok())
LOG("Canvas input tool action failed: %s", status.message);
}
[[nodiscard]] kEventResult execute_node_canvas_handle_event(NodeCanvas& node_canvas, Event* e)
{
static bool stylus_eraser = false;
MouseEvent* me = static_cast<MouseEvent*>(e);
KeyEvent* ke = static_cast<KeyEvent*>(e);
GestureEvent* ge = static_cast<GestureEvent*>(e);
TouchEvent* te = static_cast<TouchEvent*>(e);
auto loc = (me->m_pos - node_canvas.m_pos) * node_canvas.root()->m_zoom;
switch (e->m_type)
{
case kEventType::MouseMove:
if (stylus_eraser != me->m_eraser)
{
run_canvas_tool_mode(me->m_eraser ?
pp::app::CanvasToolMode::erase :
pp::app::CanvasToolMode::draw);
stylus_eraser = me->m_eraser;
}
case kEventType::MouseScroll:
case kEventType::MouseDownL:
case kEventType::MouseUpL:
case kEventType::MouseDownR:
case kEventType::MouseUpR:
case kEventType::MouseCancel:
node_canvas.m_canvas->m_cur_pos = loc;
node_canvas.update_cursor();
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_MouseEvent(me, loc);
break;
case kEventType::MouseUnfocus:
(*node_canvas.m_canvas->m_mode)[0]->m_draw_tip = false;
App::I->show_cursor();
break;
case kEventType::MouseFocus:
node_canvas.update_cursor();
break;
case kEventType::KeyDown:
run_canvas_hotkey(
pp::app::CanvasHotkeyEvent::key_down,
ke->m_key,
node_canvas.m_mouse_focus);
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_KeyEvent(ke);
break;
case kEventType::KeyUp:
node_canvas.update_cursor();
run_canvas_hotkey(
pp::app::CanvasHotkeyEvent::key_up,
ke->m_key,
node_canvas.m_mouse_focus);
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_KeyEvent(ke);
break;
case kEventType::GestureStart:
node_canvas.mouse_capture();
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_GestureEvent(ge);
break;
case kEventType::GestureMove:
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_GestureEvent(ge);
break;
case kEventType::GestureEnd:
pp::panopainter::release_legacy_mouse_capture(node_canvas);
for (auto& mode : *node_canvas.m_canvas->m_mode)
mode->on_GestureEvent(ge);
break;
case kEventType::TouchTap:
run_canvas_hotkey(
pp::app::CanvasHotkeyEvent::touch_tap,
kKey::Unknown,
node_canvas.m_mouse_focus,
te->m_finger_count);
break;
default:
return kEventResult::Available;
break;
}
return kEventResult::Consumed;
}
}
Node* NodeCanvas::clone_instantiate() const
{
return new NodeCanvas();
@@ -205,7 +46,7 @@ void NodeCanvas::handle_resize(glm::vec2 old_size, glm::vec2 new_size, float zoo
kEventResult NodeCanvas::handle_event(Event* e)
{
Node::handle_event(e);
return execute_node_canvas_handle_event(*this, e);
return pp::panopainter::handle_legacy_node_canvas_event(*this, e);
}
void NodeCanvas::reset_camera()

133
src/node_stroke_preview.cpp
View File

@@ -2,118 +2,14 @@
#include "log.h"
#include "node_stroke_preview.h"
#include "texture.h"
#include "shader.h"
#include "canvas.h"
#include "app.h"
#include "legacy_canvas_stroke_shader_services.h"
#include "legacy_node_stroke_preview_execution_services.h"
#include "legacy_node_stroke_preview_runtime_services.h"
#include "legacy_node_stroke_preview_sample_services.h"
#include "legacy_ui_gl_dispatch.h"
#include "renderer_gl/opengl_capabilities.h"
#include "util.h"
#include <array>
#include <cstdint>
namespace {
pp::renderer::RenderDeviceFeatures stroke_preview_render_device_features() noexcept
{
return ShaderManager::render_device_features();
}
void set_active_texture_unit(std::uint32_t unit_index)
{
pp::legacy::ui_gl::activate_texture_unit(unit_index, "NodeStrokePreview");
}
void unbind_texture_2d()
{
pp::legacy::ui_gl::unbind_texture_2d("NodeStrokePreview");
}
void apply_stroke_preview_viewport(std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height)
{
pp::legacy::ui_gl::apply_viewport(x, y, width, height, "NodeStrokePreview");
}
pp::renderer::gl::OpenGlViewportRect query_stroke_preview_viewport()
{
return pp::legacy::ui_gl::query_viewport_rect("NodeStrokePreview");
}
std::array<float, 4> query_stroke_preview_clear_color()
{
return pp::legacy::ui_gl::query_clear_color("NodeStrokePreview");
}
void apply_stroke_preview_clear_color(std::array<float, 4> color)
{
pp::legacy::ui_gl::set_clear_color(color, "NodeStrokePreview");
}
void apply_stroke_preview_scissor(std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height)
{
pp::legacy::ui_gl::apply_scissor_rect(x, y, width, height, "NodeStrokePreview");
}
void apply_stroke_preview_capability(std::uint32_t state, bool enabled)
{
pp::legacy::ui_gl::set_capability(state, enabled, "NodeStrokePreview");
}
namespace stroke_preview_live_slots {
constexpr std::uint32_t kTip = 0U;
constexpr std::uint32_t kDestination = 1U;
constexpr std::uint32_t kPattern = 2U;
constexpr std::uint32_t kMixer = 3U;
constexpr std::uint32_t kReservedLinear = 4U;
}
void bind_stroke_preview_live_samplers(
Sampler& mipmap_sampler,
Sampler& linear_sampler,
Sampler& repeat_sampler)
{
mipmap_sampler.bind(stroke_preview_live_slots::kTip);
linear_sampler.bind(stroke_preview_live_slots::kDestination);
repeat_sampler.bind(stroke_preview_live_slots::kPattern);
linear_sampler.bind(stroke_preview_live_slots::kMixer);
linear_sampler.bind(stroke_preview_live_slots::kReservedLinear);
}
void bind_stroke_preview_dual_pass_textures(const Brush& dual_brush)
{
set_active_texture_unit(stroke_preview_live_slots::kTip);
dual_brush.m_tip_texture ?
dual_brush.m_tip_texture->bind() :
unbind_texture_2d();
}
void bind_stroke_preview_destination_texture(Texture2D& texture)
{
set_active_texture_unit(stroke_preview_live_slots::kDestination);
texture.bind();
}
void unbind_stroke_preview_destination_texture(Texture2D& texture)
{
set_active_texture_unit(stroke_preview_live_slots::kDestination);
texture.unbind();
}
void copy_stroke_preview_destination_texture_region(
int src_x,
int src_y,
int dst_x,
int dst_y,
int width,
int height)
{
copy_framebuffer_to_texture_2d(src_x, src_y, dst_x, dst_y, width, height);
}
}
Node* NodeStrokePreview::clone_instantiate() const
{
@@ -176,7 +72,7 @@ glm::vec4 NodeStrokePreview::stroke_draw_samples(
.brush_shape = m_brush_shape,
.copy_stroke_destination = copy_stroke_destination,
.bind_destination_texture = [&] {
bind_stroke_preview_destination_texture(blend_tex);
pp::panopainter::bind_legacy_node_stroke_preview_destination_texture(blend_tex);
},
.copy_framebuffer_to_destination_texture = [](
int src_x,
@@ -185,7 +81,7 @@ glm::vec4 NodeStrokePreview::stroke_draw_samples(
int dst_y,
int width,
int height) {
copy_stroke_preview_destination_texture_region(
pp::panopainter::copy_legacy_node_stroke_preview_destination_texture_region(
src_x,
src_y,
dst_x,
@@ -194,7 +90,7 @@ glm::vec4 NodeStrokePreview::stroke_draw_samples(
height);
},
.unbind_destination_texture = [&] {
unbind_stroke_preview_destination_texture(blend_tex);
pp::panopainter::unbind_legacy_node_stroke_preview_destination_texture(blend_tex);
},
});
}
@@ -227,8 +123,8 @@ void NodeStrokePreview::draw_stroke_immediate()
return;
}
const auto vp = query_stroke_preview_viewport();
const auto cc = query_stroke_preview_clear_color();
const auto vp = pp::panopainter::query_legacy_node_stroke_preview_viewport();
const auto cc = pp::panopainter::query_legacy_node_stroke_preview_clear_color();
const glm::vec2 size = { m_rtt.getWidth(), m_rtt.getHeight() };
const float zoom = root()->m_zoom;
const bool sequence_ok = pp::panopainter::execute_legacy_node_stroke_preview_immediate_runtime(
@@ -241,7 +137,7 @@ void NodeStrokePreview::draw_stroke_immediate()
.pad_override = m_pad_override,
.camera_fov = Canvas::I->m_cam_fov,
.camera_rot = Canvas::I->m_cam_rot,
.render_device_features = stroke_preview_render_device_features(),
.render_device_features = pp::panopainter::stroke_preview_render_device_features(),
.preview_rtt = m_rtt,
.preview_rtt_mixer = m_rtt_mixer,
.preview_stroke_texture = m_tex,
@@ -251,10 +147,10 @@ void NodeStrokePreview::draw_stroke_immediate()
.linear_sampler = m_sampler_linear,
.repeat_sampler = m_sampler_linear_repeat,
.prepare_render_target = [&] {
apply_stroke_preview_viewport(0, 0, m_rtt.getWidth(), m_rtt.getHeight());
pp::panopainter::apply_legacy_node_stroke_preview_viewport(0, 0, m_rtt.getWidth(), m_rtt.getHeight());
m_rtt.bindFramebuffer();
m_rtt.clear();
bind_stroke_preview_live_samplers(
pp::panopainter::bind_legacy_node_stroke_preview_live_samplers(
m_sampler_mipmap,
m_sampler_linear,
m_sampler_linear_repeat);
@@ -263,13 +159,13 @@ void NodeStrokePreview::draw_stroke_immediate()
m_rtt.unbindFramebuffer();
},
.set_blend_enabled = [&](bool enabled) {
apply_stroke_preview_capability(pp::renderer::gl::blend_state(), enabled);
pp::panopainter::apply_legacy_node_stroke_preview_capability(pp::renderer::gl::blend_state(), enabled);
},
.setup_stroke_shader = [](const pp::panopainter::LegacyStrokeShaderSetupUniforms& uniforms) {
pp::panopainter::setup_legacy_stroke_shader(uniforms);
},
.bind_dual_pass_textures = [](const Brush& dual_brush) {
bind_stroke_preview_dual_pass_textures(dual_brush);
pp::panopainter::bind_legacy_node_stroke_preview_dual_pass_textures(dual_brush);
},
.capture_background = [&](bool colorize) {
pp::panopainter::execute_legacy_node_stroke_preview_background_capture_pass(
@@ -292,11 +188,10 @@ void NodeStrokePreview::draw_stroke_immediate()
stroke_draw_mix(bb_min, bb_sz);
},
.unbind_mixer_texture = [&] {
set_active_texture_unit(3U);
m_rtt_mixer.unbindTexture();
pp::panopainter::unbind_legacy_node_stroke_preview_mixer_texture(m_rtt_mixer);
},
.bind_pattern_texture = [&] {
m_brush->m_pattern_texture ? m_brush->m_pattern_texture->bind() : unbind_texture_2d();
pp::panopainter::bind_legacy_node_stroke_preview_pattern_texture(*m_brush);
},
.draw_composite = [&] {
m_plane.draw_fill();
@@ -304,6 +199,6 @@ void NodeStrokePreview::draw_stroke_immediate()
});
assert(sequence_ok);
apply_stroke_preview_viewport(vp.x, vp.y, vp.width, vp.height);
apply_stroke_preview_clear_color(cc);
pp::panopainter::apply_legacy_node_stroke_preview_viewport(vp.x, vp.y, vp.width, vp.height);
pp::panopainter::apply_legacy_node_stroke_preview_clear_color(cc);
}