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

remove ui namespace which is not really used, move CameraData in camera_modes.h to avoid the inclusion of canva.h

Browse Source
This commit is contained in:
omigamedev
2018-11-27 14:24:01 +01:00
parent f34ffa825d
commit 0c6b409606
57 changed files with 538 additions and 597 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/action.cpp
View File

@@ -20,11 +20,11 @@ void ActionManager::undo()
return; return;
I.m_redos.emplace(I.m_actions.top()->get_redo()); I.m_redos.emplace(I.m_actions.top()->get_redo());
I.m_redos.top()->was_saved = !ui::Canvas::I->m_unsaved; I.m_redos.top()->was_saved = !Canvas::I->m_unsaved;
I.m_actions.top()->undo(); I.m_actions.top()->undo();
I.m_memory -= I.m_actions.top()->memory(); I.m_memory -= I.m_actions.top()->memory();
ui::Canvas::I->m_unsaved = !I.m_actions.top()->was_saved; Canvas::I->m_unsaved = !I.m_actions.top()->was_saved;
I.m_actions.pop(); I.m_actions.pop();
//LOG("History: %.2f KB", I.m_memory / 1024.f); //LOG("History: %.2f KB", I.m_memory / 1024.f);
App::I.update_memory_usage(I.m_memory); App::I.update_memory_usage(I.m_memory);
@@ -37,11 +37,11 @@ void ActionManager::redo()
return; return;
I.m_actions.emplace(I.m_redos.top()->get_redo()); I.m_actions.emplace(I.m_redos.top()->get_redo());
I.m_actions.top()->was_saved = !ui::Canvas::I->m_unsaved; I.m_actions.top()->was_saved = !Canvas::I->m_unsaved;
I.m_memory += I.m_actions.top()->memory(); I.m_memory += I.m_actions.top()->memory();
I.m_redos.top()->undo(); I.m_redos.top()->undo();
ui::Canvas::I->m_unsaved = !I.m_redos.top()->was_saved; Canvas::I->m_unsaved = !I.m_redos.top()->was_saved;
I.m_redos.pop(); I.m_redos.pop();
//LOG("History: %.2f KB", I.m_memory / 1024.f); //LOG("History: %.2f KB", I.m_memory / 1024.f);
App::I.update_memory_usage(I.m_memory); App::I.update_memory_usage(I.m_memory);

12
src/app.cpp
View File

@@ -21,8 +21,6 @@ void async_unlock();
void destroy_window(); void destroy_window();
#endif #endif
using namespace ui;
App App::I; // singleton App App::I; // singleton
void App::create() void App::create()
@@ -65,7 +63,7 @@ void App::open_document(std::string path)
bool App::request_close() bool App::request_close()
{ {
static bool dialog_already_opened = false; static bool dialog_already_opened = false;
if (!ui::Canvas::I->m_unsaved) if (!Canvas::I->m_unsaved)
return true; return true;
if (!dialog_already_opened) if (!dialog_already_opened)
{ {
@@ -82,7 +80,7 @@ bool App::request_close()
#ifdef __OSX__ #ifdef __OSX__
[osx_view close]; [osx_view close];
#endif #endif
ui::Canvas::I->m_unsaved = false; Canvas::I->m_unsaved = false;
}; };
m->btn_cancel->m_text->set_text("No"); m->btn_cancel->m_text->set_text("No");
m->btn_cancel->on_click = [this,m](Node*) { m->btn_cancel->on_click = [this,m](Node*) {
@@ -517,9 +515,9 @@ void App::update(float dt)
// glEnable(GL_BLEND); // glEnable(GL_BLEND);
// sampler.bind(0); // sampler.bind(0);
// ui::ShaderManager::use(kShader::Texture); // ShaderManager::use(kShader::Texture);
// ui::ShaderManager::u_int(kShaderUniform::Tex, 0); // ShaderManager::u_int(kShaderUniform::Tex, 0);
// ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-1.f, 1.f, -1.f, 1.f)); // ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-1.f, 1.f, -1.f, 1.f));
// glActiveTexture(GL_TEXTURE0); // glActiveTexture(GL_TEXTURE0);
// uirtt.bindTexture(); // uirtt.bindTexture();
// m_face_plane.draw_fill(); // m_face_plane.draw_fill();

4
src/app.h
View File

@@ -51,8 +51,8 @@ public:
Sampler sampler; Sampler sampler;
Sampler sampler_stencil; Sampler sampler_stencil;
Sampler sampler_linear; Sampler sampler_linear;
ui::Plane m_face_plane; Plane m_face_plane;
//ui::Sphere sphere; //Sphere sphere;
LayoutManager layout; LayoutManager layout;
NodeMessageBox* msgbox; NodeMessageBox* msgbox;
NodeSettings* settings; NodeSettings* settings;

6
src/app_cloud.cpp
View File

@@ -4,13 +4,11 @@
#include "node_progress_bar.h" #include "node_progress_bar.h"
#include "node_dialog_cloud.h" #include "node_dialog_cloud.h"
using namespace ui;
void App::cloud_upload() void App::cloud_upload()
{ {
if (!canvas) if (!canvas)
return; return;
if (ui::Canvas::I->m_newdoc) if (Canvas::I->m_newdoc)
{ {
auto msgbox = new NodeMessageBox(); auto msgbox = new NodeMessageBox();
msgbox->m_manager = &layout; msgbox->m_manager = &layout;
@@ -23,7 +21,7 @@ void App::cloud_upload()
else else
{ {
auto upload_thread = [this] { auto upload_thread = [this] {
if (ui::Canvas::I->m_unsaved) if (Canvas::I->m_unsaved)
{ {
Canvas::I->project_save_thread(doc_path); Canvas::I->project_save_thread(doc_path);
} }

2
src/app_commands.cpp
View File

@@ -9,7 +9,7 @@ void App::cmd_convert(std::string pano_path, std::string out_path)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendEquation(GL_FUNC_ADD); glBlendEquation(GL_FUNC_ADD);
ui::Canvas* canvas = new ui::Canvas; Canvas* canvas = new Canvas;
canvas->create(CANVAS_RES, CANVAS_RES); canvas->create(CANVAS_RES, CANVAS_RES);
canvas->project_open_thread(pano_path); canvas->project_open_thread(pano_path);
canvas->export_equirectangular_thread(out_path); canvas->export_equirectangular_thread(out_path);

12
src/app_dialogs.cpp
View File

@@ -154,7 +154,7 @@ void App::dialog_newdoc()
if (canvas) if (canvas)
{ {
if (ui::Canvas::I->m_unsaved) if (Canvas::I->m_unsaved)
{ {
auto m = layout[main_id]->add_child<NodeMessageBox>(); auto m = layout[main_id]->add_child<NodeMessageBox>();
m->m_title->set_text("Unsaved document"); m->m_title->set_text("Unsaved document");
@@ -162,7 +162,7 @@ void App::dialog_newdoc()
m->btn_ok->m_text->set_text("Yes"); m->btn_ok->m_text->set_text("Yes");
m->btn_cancel->m_text->set_text("No"); m->btn_cancel->m_text->set_text("No");
m->btn_ok->on_click = [this, m, show_dialog](Node*) { m->btn_ok->on_click = [this, m, show_dialog](Node*) {
ui::Canvas::I->project_save([this, m, show_dialog](bool success){ Canvas::I->project_save([this, m, show_dialog](bool success){
if (success) if (success)
show_dialog(); show_dialog();
else else
@@ -218,7 +218,7 @@ void App::dialog_open()
if (canvas) if (canvas)
{ {
if (ui::Canvas::I->m_unsaved) if (Canvas::I->m_unsaved)
{ {
auto m = layout[main_id]->add_child<NodeMessageBox>(); auto m = layout[main_id]->add_child<NodeMessageBox>();
m->m_title->set_text("Unsaved document"); m->m_title->set_text("Unsaved document");
@@ -226,7 +226,7 @@ void App::dialog_open()
m->btn_ok->m_text->set_text("Yes"); m->btn_ok->m_text->set_text("Yes");
m->btn_cancel->m_text->set_text("No"); m->btn_cancel->m_text->set_text("No");
m->btn_ok->on_click = [this,m,show_dialog](Node*){ m->btn_ok->on_click = [this,m,show_dialog](Node*){
ui::Canvas::I->project_save([this,m,show_dialog](bool success){ Canvas::I->project_save([this,m,show_dialog](bool success){
if (success) if (success)
show_dialog(); show_dialog();
else else
@@ -278,7 +278,7 @@ void App::dialog_browse()
if (canvas) if (canvas)
{ {
if (ui::Canvas::I->m_unsaved) if (Canvas::I->m_unsaved)
{ {
auto m = layout[main_id]->add_child<NodeMessageBox>(); auto m = layout[main_id]->add_child<NodeMessageBox>();
m->m_title->set_text("Unsaved document"); m->m_title->set_text("Unsaved document");
@@ -286,7 +286,7 @@ void App::dialog_browse()
m->btn_ok->m_text->set_text("Yes"); m->btn_ok->m_text->set_text("Yes");
m->btn_cancel->m_text->set_text("No"); m->btn_cancel->m_text->set_text("No");
m->btn_ok->on_click = [this, m, show_dialog](Node*) { m->btn_ok->on_click = [this, m, show_dialog](Node*) {
ui::Canvas::I->project_save([this, m, show_dialog](bool success){ Canvas::I->project_save([this, m, show_dialog](bool success){
if (success) if (success)
show_dialog(); show_dialog();
else else

2
src/app_events.cpp
View File

@@ -10,8 +10,6 @@ std::string win32_open_dir();
#endif #endif
using namespace ui;
void App::tick(float dt) void App::tick(float dt)
{ {
layout[main_id]->tick(dt); layout[main_id]->tick(dt);

38
src/app_layout.cpp
View File

@@ -6,8 +6,6 @@
#include "node_progress_bar.h" #include "node_progress_bar.h"
#include "node_dialog_picker.h" #include "node_dialog_picker.h"
using namespace ui;
static glm::vec4 color_button_normal{ .1, .1, .1, 1 }; static glm::vec4 color_button_normal{ .1, .1, .1, 1 };
static glm::vec4 color_button_hlight{ 1, .0, .0, 1 }; static glm::vec4 color_button_hlight{ 1, .0, .0, 1 };
@@ -139,26 +137,26 @@ void App::init_sidebar()
// if (canvas) // if (canvas)
// { // {
// ui::Canvas::I->m_current_brush.m_tip_color = color->m_color; // Canvas::I->m_current_brush.m_tip_color = color->m_color;
// stroke->m_canvas->draw_stroke(); // stroke->m_canvas->draw_stroke();
// } // }
brushes->on_brush_changed = [this](Node* target, int index) { brushes->on_brush_changed = [this](Node* target, int index) {
ui::Canvas::I->m_current_brush.m_tex_id = brushes->get_texture_id(index); Canvas::I->m_current_brush.m_tex_id = brushes->get_texture_id(index);
ui::Canvas::I->m_current_brush.id = brushes->get_brush_id(index); Canvas::I->m_current_brush.id = brushes->get_brush_id(index);
stroke->m_preview->draw_stroke(); stroke->m_preview->draw_stroke();
}; };
presets->on_brush_changed = [this](Node* target, int index) { presets->on_brush_changed = [this](Node* target, int index) {
auto b = presets->get_brush(index); auto b = presets->get_brush(index);
// don't change some params // don't change some params
b.m_tip_size = ui::Canvas::I->m_current_brush.m_tip_size; b.m_tip_size = Canvas::I->m_current_brush.m_tip_size;
b.m_tip_color = ui::Canvas::I->m_current_brush.m_tip_color; b.m_tip_color = Canvas::I->m_current_brush.m_tip_color;
ui::Canvas::I->m_current_brush = b; Canvas::I->m_current_brush = b;
stroke->m_preview->draw_stroke(); stroke->m_preview->draw_stroke();
}; };
color->on_color_changed = [this](Node* target, glm::vec4 color) { color->on_color_changed = [this](Node* target, glm::vec4 color) {
ui::Canvas::I->m_current_brush.m_tip_color = color; Canvas::I->m_current_brush.m_tip_color = color;
}; };
// //
// stroke->on_stroke_change = [this](Node*target) { // stroke->on_stroke_change = [this](Node*target) {
@@ -224,7 +222,7 @@ void App::init_sidebar()
panels->fix_scroll(); panels->fix_scroll();
button->set_color(panels->get_child_index(color.get()) == -1 ? color_button_normal : color_button_hlight); button->set_color(panels->get_child_index(color.get()) == -1 ? color_button_normal : color_button_hlight);
// auto pick = layout[main_id]->add_child<NodeColorPicker>(); // auto pick = layout[main_id]->add_child<NodeColorPicker>();
// pick->m_color_cur->m_color = ui::Canvas::I->m_current_brush.m_tip_color; // pick->m_color_cur->m_color = Canvas::I->m_current_brush.m_tip_color;
}; };
} }
if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-layer")) if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-layer"))
@@ -318,7 +316,7 @@ void App::init_toolbar_draw()
{ {
button->on_click = [this, button](Node*) { button->on_click = [this, button](Node*) {
select_button(layout[main_id], button); select_button(layout[main_id], button);
auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)ui::Canvas::kCanvasMode::Transform][0]); auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)Canvas::kCanvasMode::Transform][0]);
m->m_action = CanvasModeTransform::ActionType::Copy; m->m_action = CanvasModeTransform::ActionType::Copy;
Canvas::set_mode(Canvas::kCanvasMode::Transform); Canvas::set_mode(Canvas::kCanvasMode::Transform);
}; };
@@ -327,7 +325,7 @@ void App::init_toolbar_draw()
{ {
button->on_click = [this, button](Node*) { button->on_click = [this, button](Node*) {
select_button(layout[main_id], button); select_button(layout[main_id], button);
auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)ui::Canvas::kCanvasMode::Transform][0]); auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)Canvas::kCanvasMode::Transform][0]);
m->m_action = CanvasModeTransform::ActionType::Cut; m->m_action = CanvasModeTransform::ActionType::Cut;
Canvas::set_mode(Canvas::kCanvasMode::Transform); Canvas::set_mode(Canvas::kCanvasMode::Transform);
}; };
@@ -356,7 +354,7 @@ void App::init_toolbar_draw()
if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-bucket")) if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-bucket"))
{ {
button->on_click = [this](Node*) { button->on_click = [this](Node*) {
canvas->m_canvas->clear(ui::Canvas::I->m_current_brush.m_tip_color); canvas->m_canvas->clear(Canvas::I->m_current_brush.m_tip_color);
}; };
} }
} }
@@ -397,7 +395,7 @@ void App::init_menu_file()
} }
else else
{ {
auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)ui::Canvas::kCanvasMode::Transform][0]); auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)Canvas::kCanvasMode::Transform][0]);
m->m_action = CanvasModeTransform::ActionType::Import; m->m_action = CanvasModeTransform::ActionType::Import;
m->m_source_image = std::move(img); m->m_source_image = std::move(img);
Canvas::set_mode(Canvas::kCanvasMode::Transform); Canvas::set_mode(Canvas::kCanvasMode::Transform);
@@ -423,11 +421,11 @@ void App::init_menu_file()
}; };
if (auto b = popup->find<NodeButtonCustom>("file-save")) if (auto b = popup->find<NodeButtonCustom>("file-save"))
b->on_click = [this](Node*) { b->on_click = [this](Node*) {
if (ui::Canvas::I->m_newdoc) if (Canvas::I->m_newdoc)
{ {
dialog_save(); dialog_save();
} }
else if(ui::Canvas::I->m_unsaved) else if(Canvas::I->m_unsaved)
{ {
canvas->m_canvas->project_save(); canvas->m_canvas->project_save();
} }
@@ -442,7 +440,7 @@ void App::init_menu_file()
}; };
if (auto b = popup->find<NodeButtonCustom>("file-save-ver")) if (auto b = popup->find<NodeButtonCustom>("file-save-ver"))
b->on_click = [this](Node*) { b->on_click = [this](Node*) {
ui::Canvas::I->m_newdoc ? dialog_save() : dialog_save_ver(); Canvas::I->m_newdoc ? dialog_save() : dialog_save_ver();
popup->mouse_release(); popup->mouse_release();
popup->destroy(); popup->destroy();
}; };
@@ -632,7 +630,7 @@ void App::init_menu_layer()
popup->m_flood_events = true; popup->m_flood_events = true;
popup->m_capture_children = false; popup->m_capture_children = false;
popup->find<NodeButtonCustom>("clear-grids")->on_click = [this](Node*) { popup->find<NodeButtonCustom>("clear-grids")->on_click = [this](Node*) {
CanvasModeGrid* mode = (CanvasModeGrid*)ui::Canvas::modes[(int)ui::Canvas::kCanvasMode::Grid][0]; CanvasModeGrid* mode = (CanvasModeGrid*)Canvas::modes[(int)Canvas::kCanvasMode::Grid][0];
mode->clear(); mode->clear();
popup->mouse_release(); popup->mouse_release();
popup->destroy(); popup->destroy();
@@ -746,7 +744,7 @@ void App::initLayout()
b.m_tip_flow = .5f; b.m_tip_flow = .5f;
b.m_tip_spacing = .1f; b.m_tip_spacing = .1f;
b.m_tip_opacity = 1.f; b.m_tip_opacity = 1.f;
ui::Canvas::I->m_current_brush = b; Canvas::I->m_current_brush = b;
brush_update(); brush_update();
@@ -782,7 +780,7 @@ void App::initLayout()
auto frame_text = layout[main_id]->find<NodeText>("timeline-frame"); auto frame_text = layout[main_id]->find<NodeText>("timeline-frame");
slider->on_value_changed = [this, frame_text](Node*, float value) slider->on_value_changed = [this, frame_text](Node*, float value)
{ {
auto& c = *ui::Canvas::I; auto& c = *Canvas::I;
for (int i = 0; i < c.m_layers.size(); i++) for (int i = 0; i < c.m_layers.size(); i++)
{ {

2
src/app_shaders.cpp
View File

@@ -2,8 +2,6 @@
#include "app.h" #include "app.h"
#include "shader.h" #include "shader.h"
using namespace ui;
void App::initShaders() void App::initShaders()
{ {
static const char* shader_v = static const char* shader_v =

110
src/app_vr.cpp
View File

@@ -3,8 +3,6 @@
void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat4& pose) void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat4& pose)
{ {
using namespace ui;
//glm::mat4 ortho_proj = glm::ortho(0.f, box.z, 0.f, box.w, -1000.f, 1000.f); //glm::mat4 ortho_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.01f, 1000.f); //glm::mat4 proj = glm::perspective(glm::radians(m_canvas->m_cam_fov), box.z / box.w, 0.01f, 1000.f);
//glm::mat4 camera = glm::eulerAngleXY(m_canvas->m_cam_rot.y, m_canvas->m_cam_rot.x) * //glm::mat4 camera = glm::eulerAngleXY(m_canvas->m_cam_rot.y, m_canvas->m_cam_rot.x) *
@@ -34,8 +32,8 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
canvas->m_canvas->m_plane_transform[plane_index] * canvas->m_canvas->m_plane_transform[plane_index] *
glm::translate(glm::vec3(0, 0, -1)); glm::translate(glm::vec3(0, 0, -1));
ui::ShaderManager::use(kShader::Checkerboard); ShaderManager::use(kShader::Checkerboard);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
m_face_plane.draw_fill(); m_face_plane.draw_fill();
} }
@@ -58,17 +56,17 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
canvas->m_canvas->m_plane_transform[plane_index] * canvas->m_canvas->m_plane_transform[plane_index] *
glm::translate(glm::vec3(0, 0, -1)); glm::translate(glm::vec3(0, 0, -1));
if (canvas->m_canvas->m_state == ui::Canvas::kCanvasMode::Erase && canvas->m_canvas->m_show_tmp && canvas->m_canvas->m_current_layer_idx == layer_index) if (canvas->m_canvas->m_state == Canvas::kCanvasMode::Erase && canvas->m_canvas->m_show_tmp && canvas->m_canvas->m_current_layer_idx == layer_index)
{ {
sampler.bind(0); sampler.bind(0);
ui::ShaderManager::use(kShader::CompErase); ShaderManager::use(kShader::CompErase);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1); ShaderManager::u_int(kShaderUniform::TexStroke, 1);
//ui::ShaderManager::u_int(kShaderUniform::TexMask, 2); //ShaderManager::u_int(kShaderUniform::TexMask, 2);
ui::ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_stroke->m_brush.m_tip_opacity); ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_stroke->m_brush.m_tip_opacity);
//ui::ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked); //ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
//ui::ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active); //ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture(); canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1); glActiveTexture(GL_TEXTURE1);
@@ -86,17 +84,17 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
{ {
sampler.bind(0); sampler.bind(0);
auto& paper = TextureManager::get(const_hash("data/paper.jpg")); auto& paper = TextureManager::get(const_hash("data/paper.jpg"));
ui::ShaderManager::use(kShader::CompDraw); ShaderManager::use(kShader::CompDraw);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1); ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ui::ShaderManager::u_int(kShaderUniform::TexMask, 2); ShaderManager::u_int(kShaderUniform::TexMask, 2);
ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, canvas->m_canvas->m_size); ShaderManager::u_vec2(kShaderUniform::Resolution, canvas->m_canvas->m_size);
//ui::ShaderManager::u_int(kShaderUniform::TexStencil, 3); //ShaderManager::u_int(kShaderUniform::TexStencil, 3);
ui::ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_stroke->m_brush.m_tip_opacity); ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_stroke->m_brush.m_tip_opacity);
ui::ShaderManager::u_int(kShaderUniform::Lock, canvas->m_canvas->m_layers[layer_index].m_alpha_locked); ShaderManager::u_int(kShaderUniform::Lock, canvas->m_canvas->m_layers[layer_index].m_alpha_locked);
ui::ShaderManager::u_int(kShaderUniform::Mask, canvas->m_canvas->m_smask_active); ShaderManager::u_int(kShaderUniform::Mask, canvas->m_canvas->m_smask_active);
ui::ShaderManager::u_int(kShaderUniform::BlendMode, canvas->m_canvas->m_current_stroke->m_brush.m_blend_mode); ShaderManager::u_int(kShaderUniform::BlendMode, canvas->m_canvas->m_current_stroke->m_brush.m_blend_mode);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture(); canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1); glActiveTexture(GL_TEXTURE1);
@@ -118,12 +116,12 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
{ {
sampler.bind(0); sampler.bind(0);
sampler_linear.bind(1); sampler_linear.bind(1);
ui::ShaderManager::use(kShader::TextureAlphaSep); ShaderManager::use(kShader::TextureAlphaSep);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexA, 1); ShaderManager::u_int(kShaderUniform::TexA, 1);
ui::ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_layers[layer_index].m_opacity); ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_layers[layer_index].m_opacity);
ui::ShaderManager::u_int(kShaderUniform::Highlight, canvas->m_canvas->m_layers[layer_index].m_hightlight); ShaderManager::u_int(kShaderUniform::Highlight, canvas->m_canvas->m_layers[layer_index].m_hightlight);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture(); canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
@@ -150,9 +148,9 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
glm::transpose(canvas->m_canvas->m_cam_rot) * glm::transpose(canvas->m_canvas->m_cam_rot) *
glm::translate(glm::vec3(0, 0, -1)) * glm::translate(glm::vec3(0, 0, -1)) *
glm::scale(aspect * tan_fov); glm::scale(aspect * tan_fov);
ui::ShaderManager::use(kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp); ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
m_face_plane.draw_stroke(); m_face_plane.draw_stroke();
} }
@@ -164,12 +162,12 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
pos.x = pos.x - canvas->m_canvas->m_current_brush.m_tip_size * 500; pos.x = pos.x - canvas->m_canvas->m_current_brush.m_tip_size * 500;
auto cur = (glm::vec2(pos.x / width, 1.f - pos.y / height) - 0.5f) * 2.f; auto cur = (glm::vec2(pos.x / width, 1.f - pos.y / height) - 0.5f) * 2.f;
ui::ShaderManager::use(ui::kShader::StrokePreview); ShaderManager::use(kShader::StrokePreview);
ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_float(ui::kShaderUniform::Alpha, canvas->m_canvas->m_current_brush.m_tip_flow); ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_brush.m_tip_flow);
auto tip_color = glm::vec4(glm::vec3(canvas->m_canvas->m_current_brush.m_tip_color), 1); auto tip_color = glm::vec4(glm::vec3(canvas->m_canvas->m_current_brush.m_tip_color), 1);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, tip_color); ShaderManager::u_vec4(kShaderUniform::Col, tip_color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, ShaderManager::u_mat4(kShaderUniform::MVP,
proj * camera * proj * camera *
glm::scale(glm::vec3(100)) * glm::scale(glm::vec3(100)) *
glm::transpose(canvas->m_canvas->m_cam_rot) * glm::transpose(canvas->m_canvas->m_cam_rot) *
@@ -195,9 +193,9 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
glm::translate(glm::vec3(0, 0, -1)) * glm::translate(glm::vec3(0, 0, -1)) *
glm::scale(aspect * tan_fov); glm::scale(aspect * tan_fov);
sampler_linear.bind(0); sampler_linear.bind(0);
ui::ShaderManager::use(kShader::Texture); ShaderManager::use(kShader::Texture);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp); ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
uirtt.bindTexture(); uirtt.bindTexture();
m_face_plane.draw_fill(); m_face_plane.draw_fill();
@@ -211,12 +209,12 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
glm::scale(glm::vec3(100)) * glm::scale(glm::vec3(100)) *
glm::transpose(canvas->m_canvas->m_cam_rot) * glm::transpose(canvas->m_canvas->m_cam_rot) *
glm::translate(glm::vec3(cur * glm::vec2(aspect * tan_fov), -1)); glm::translate(glm::vec3(cur * glm::vec2(aspect * tan_fov), -1));
ui::ShaderManager::use(kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.01))); ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.01)));
m_face_plane.draw_fill(); m_face_plane.draw_fill();
ui::ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, 1 }); ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, 1 });
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.005))); ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.005)));
m_face_plane.draw_fill(); m_face_plane.draw_fill();
} }
@@ -224,9 +222,9 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
/* /*
{ {
auto mvp = proj * camera * glm::translate(glm::normalize(vr_controller_pos)); auto mvp = proj * camera * glm::translate(glm::normalize(vr_controller_pos));
ui::ShaderManager::use(kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.025))); ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.025)));
sphere.draw_fill(); sphere.draw_fill();
} }
*/ */
@@ -234,12 +232,12 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
// draw the motion controller brush // draw the motion controller brush
{ {
auto pos = glm::translate(glm::normalize(vr_controller_pos)); auto pos = glm::translate(glm::normalize(vr_controller_pos));
ui::ShaderManager::use(ui::kShader::StrokePreview); ShaderManager::use(kShader::StrokePreview);
ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_float(ui::kShaderUniform::Alpha, canvas->m_canvas->m_current_brush.m_tip_flow); ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_brush.m_tip_flow);
auto tip_color = glm::vec4(glm::vec3(canvas->m_canvas->m_current_brush.m_tip_color), 1); auto tip_color = glm::vec4(glm::vec3(canvas->m_canvas->m_current_brush.m_tip_color), 1);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, tip_color); ShaderManager::u_vec4(kShaderUniform::Col, tip_color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, ShaderManager::u_mat4(kShaderUniform::MVP,
proj * camera * pos * proj * camera * pos *
glm::inverse(glm::lookAt({ 0, 0, 0 }, vr_controller_pos, { 0, 1, 0 })) * glm::inverse(glm::lookAt({ 0, 0, 0 }, vr_controller_pos, { 0, 1, 0 })) *
//glm::scale(glm::vec3(0.1)) * //glm::scale(glm::vec3(0.1)) *
@@ -267,8 +265,8 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
} }
// keep drawing the grids // keep drawing the grids
if (m_canvas->m_state != ui::Canvas::kCanvasMode::Grid) if (m_canvas->m_state != Canvas::kCanvasMode::Grid)
for (auto& mode : ui::Canvas::modes[(int)ui::Canvas::kCanvasMode::Grid]) for (auto& mode : Canvas::modes[(int)Canvas::kCanvasMode::Grid])
mode->on_Draw(ortho_proj, proj, camera); mode->on_Draw(ortho_proj, proj, camera);
*/ */

16
src/brush.cpp
View File

@@ -2,7 +2,7 @@
#include "log.h" #include "log.h"
#include "brush.h" #include "brush.h"
void ui::BrushMesh::draw(const std::vector<StrokeSample>& samples, const glm::mat4& proj) void BrushMesh::draw(const std::vector<StrokeSample>& samples, const glm::mat4& proj)
{ {
std::vector<instance_t> attributes; std::vector<instance_t> attributes;
attributes.reserve(samples.size()); attributes.reserve(samples.size());
@@ -65,7 +65,7 @@ void ui::BrushMesh::draw(const std::vector<StrokeSample>& samples, const glm::ma
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
#endif // USE_VBO #endif // USE_VBO
} }
bool ui::BrushMesh::create() bool BrushMesh::create()
{ {
static GLushort idx[6]{ 0, 1, 2, 0, 2, 3 }; static GLushort idx[6]{ 0, 1, 2, 0, 2, 3 };
static vertex_t vertices[4]{ static vertex_t vertices[4]{
@@ -126,7 +126,7 @@ bool ui::BrushMesh::create()
return true; return true;
} }
ui::StrokeSample ui::Stroke::randomize_sample(const glm::vec3& pos, float pressure, float curve_angle) StrokeSample Stroke::randomize_sample(const glm::vec3& pos, float pressure, float curve_angle)
{ {
auto rnd_nor = [&] { return float((double)prng() / (double)prng.max()); }; // normalized [0, +1] auto rnd_nor = [&] { return float((double)prng() / (double)prng.max()); }; // normalized [0, +1]
//auto rnd_neg = [&] { return float((double)prng() / (double)prng.max() * 2.0 - 1.0); }; // normalized [-1, +1] //auto rnd_neg = [&] { return float((double)prng() / (double)prng.max() * 2.0 - 1.0); }; // normalized [-1, +1]
@@ -150,7 +150,7 @@ ui::StrokeSample ui::Stroke::randomize_sample(const glm::vec3& pos, float pressu
s.col = convert_hsv2rgb(m_hsv_jitter.average()); s.col = convert_hsv2rgb(m_hsv_jitter.average());
return s; return s;
} }
std::vector<ui::StrokeSample> ui::Stroke::compute_samples() std::vector<StrokeSample> Stroke::compute_samples()
{ {
if (m_keypoints.empty()) return {}; if (m_keypoints.empty()) return {};
int nsamples = (int)glm::floor((m_keypoints.back().dist - m_dist) / m_step); int nsamples = (int)glm::floor((m_keypoints.back().dist - m_dist) / m_step);
@@ -188,19 +188,19 @@ std::vector<ui::StrokeSample> ui::Stroke::compute_samples()
} }
return samples; return samples;
} }
bool ui::Stroke::has_sample() bool Stroke::has_sample()
{ {
return m_keypoints.empty() ? false : // no keypoints return m_keypoints.empty() ? false : // no keypoints
(m_keypoints.back().dist > (m_dist + m_step)); // check if next kp is closer than spacing (m_keypoints.back().dist > (m_dist + m_step)); // check if next kp is closer than spacing
} }
void ui::Stroke::reset(bool clear_keypoints /*= false*/) void Stroke::reset(bool clear_keypoints /*= false*/)
{ {
m_last_kp = 0; m_last_kp = 0;
m_dist = 0.f; m_dist = 0.f;
if (clear_keypoints) if (clear_keypoints)
m_keypoints.clear(); m_keypoints.clear();
} }
void ui::Stroke::add_point(glm::vec3 pos, float pressure) void Stroke::add_point(glm::vec3 pos, float pressure)
{ {
#ifdef __IOS__ #ifdef __IOS__
m_curve = glm::min(m_curve + 0.1f, 1.f); m_curve = glm::min(m_curve + 0.1f, 1.f);
@@ -229,7 +229,7 @@ void ui::Stroke::add_point(glm::vec3 pos, float pressure)
kp.dist = dist; kp.dist = dist;
m_keypoints.push_back(kp); m_keypoints.push_back(kp);
} }
void ui::Stroke::start(const ui::Brush& brush) void Stroke::start(const Brush& brush)
{ {
m_hold_points.clear(); m_hold_points.clear();
m_curve = 0.f; m_curve = 0.f;

8
src/brush.h
View File

@@ -2,8 +2,6 @@
#include "rtt.h" #include "rtt.h"
#include "shader.h" #include "shader.h"
NS_START
class Brush class Brush
{ {
public: public:
@@ -89,7 +87,7 @@ public:
float m_dist = 0; float m_dist = 0;
float m_step = 0; float m_step = 0;
Camera m_camera; Camera m_camera;
ui::Brush m_brush; Brush m_brush;
cbuffer<float, 3> m_curve_angles; cbuffer<float, 3> m_curve_angles;
cbuffer<float, 10> m_pressure_buff; cbuffer<float, 10> m_pressure_buff;
cbuffer<glm::vec3, 3> m_hsv_jitter; cbuffer<glm::vec3, 3> m_hsv_jitter;
@@ -99,12 +97,10 @@ public:
std::vector<StrokeSample> m_samples; std::vector<StrokeSample> m_samples;
int m_last_kp; int m_last_kp;
std::minstd_rand prng; std::minstd_rand prng;
void start(const ui::Brush& brush); void start(const Brush& brush);
void add_point(glm::vec3 pos, float pressure); void add_point(glm::vec3 pos, float pressure);
void reset(bool clear_keypoints = false); void reset(bool clear_keypoints = false);
bool has_sample(); bool has_sample();
std::vector<StrokeSample> compute_samples(); std::vector<StrokeSample> compute_samples();
StrokeSample randomize_sample(const glm::vec3& pos, float pressure, float curve_angle); StrokeSample randomize_sample(const glm::vec3& pos, float pressure, float curve_angle);
}; };
NS_END

282
src/canvas.cpp
View File

@@ -11,8 +11,8 @@
#endif #endif
ui::Canvas* ui::Canvas::I; Canvas* Canvas::I;
std::vector<CanvasMode*> ui::Canvas::modes[] = { std::vector<CanvasMode*> Canvas::modes[] = {
{ new CanvasModePen, new CanvasModeBasicCamera }, { new CanvasModePen, new CanvasModeBasicCamera },
{ new CanvasModePen, new CanvasModeBasicCamera }, { new CanvasModePen, new CanvasModeBasicCamera },
{ new CanvasModeLine, new CanvasModeBasicCamera }, { new CanvasModeLine, new CanvasModeBasicCamera },
@@ -23,7 +23,7 @@ std::vector<CanvasMode*> ui::Canvas::modes[] = {
{ new CanvasModeMaskFree, new CanvasModeBasicCamera }, { new CanvasModeMaskFree, new CanvasModeBasicCamera },
{ new CanvasModeMaskLine, new CanvasModeBasicCamera }, { new CanvasModeMaskLine, new CanvasModeBasicCamera },
}; };
glm::vec3 ui::Canvas::m_plane_origin[6] = { glm::vec3 Canvas::m_plane_origin[6] = {
{ 0, 0,-1}, // front { 0, 0,-1}, // front
{ 1, 0, 0}, // right { 1, 0, 0}, // right
{ 0, 0, 1}, // back { 0, 0, 1}, // back
@@ -31,7 +31,7 @@ glm::vec3 ui::Canvas::m_plane_origin[6] = {
{ 0, 1, 0}, // top { 0, 1, 0}, // top
{ 0,-1, 0}, // bottom { 0,-1, 0}, // bottom
}; };
glm::vec3 ui::Canvas::m_plane_normal[6] = { glm::vec3 Canvas::m_plane_normal[6] = {
{ 0, 0, 1}, // front { 0, 0, 1}, // front
{-1, 0, 0}, // right {-1, 0, 0}, // right
{ 0, 0,-1}, // back { 0, 0,-1}, // back
@@ -39,7 +39,7 @@ glm::vec3 ui::Canvas::m_plane_normal[6] = {
{ 0,-1, 0}, // top { 0,-1, 0}, // top
{ 0, 1, 0}, // bottom { 0, 1, 0}, // bottom
}; };
glm::vec3 ui::Canvas::m_plane_tangent[6] = { glm::vec3 Canvas::m_plane_tangent[6] = {
{0, 1, 0}, // front {0, 1, 0}, // front
{0, 1, 0}, // right {0, 1, 0}, // right
{0, 1, 0}, // back {0, 1, 0}, // back
@@ -48,7 +48,7 @@ glm::vec3 ui::Canvas::m_plane_tangent[6] = {
{0, 0, 1}, // bottom {0, 0, 1}, // bottom
}; };
// only rotation // only rotation
glm::mat4 ui::Canvas::m_plane_transform[6] = { glm::mat4 Canvas::m_plane_transform[6] = {
glm::lookAt(glm::vec3(), { 0, 0,-1}, {0, 1, 0}), // front glm::lookAt(glm::vec3(), { 0, 0,-1}, {0, 1, 0}), // front
glm::lookAt(glm::vec3(), {-1, 0, 0}, {0, 1, 0}), // right glm::lookAt(glm::vec3(), {-1, 0, 0}, {0, 1, 0}), // right
glm::lookAt(glm::vec3(), { 0, 0, 1}, {0, 1, 0}), // back glm::lookAt(glm::vec3(), { 0, 0, 1}, {0, 1, 0}), // back
@@ -57,12 +57,12 @@ glm::mat4 ui::Canvas::m_plane_transform[6] = {
glm::lookAt(glm::vec3(), { 0,-1, 0}, {0, 0, 1}), // bottom glm::lookAt(glm::vec3(), { 0,-1, 0}, {0, 0, 1}), // bottom
}; };
void ui::Canvas::pick_start() void Canvas::pick_start()
{ {
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
m_pick_ready[i] = false; m_pick_ready[i] = false;
} }
void ui::Canvas::pick_update(int plane) void Canvas::pick_update(int plane)
{ {
// check if already updated // check if already updated
if (m_pick_ready[plane]) if (m_pick_ready[plane])
@@ -83,7 +83,7 @@ void ui::Canvas::pick_update(int plane)
m_tmp[i].bindFramebuffer(); m_tmp[i].bindFramebuffer();
m_tmp[i].clear({ 1, 1, 1, 1 }); m_tmp[i].clear({ 1, 1, 1, 1 });
ShaderManager::use(ui::kShader::TextureAlpha); ShaderManager::use(kShader::TextureAlpha);
ShaderManager::u_int(kShaderUniform::Highlight, false); ShaderManager::u_int(kShaderUniform::Highlight, false);
ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f)); ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
@@ -112,7 +112,7 @@ void ui::Canvas::pick_update(int plane)
m_pick_ready[plane] = true; m_pick_ready[plane] = true;
} }
glm::vec4 ui::Canvas::pick_get(glm::vec2 canvas_loc) glm::vec4 Canvas::pick_get(glm::vec2 canvas_loc)
{ {
glm::vec3 ray_origin; glm::vec3 ray_origin;
glm::vec3 ray_dir; glm::vec3 ray_dir;
@@ -128,23 +128,23 @@ glm::vec4 ui::Canvas::pick_get(glm::vec2 canvas_loc)
} }
return {0,0,0,1}; return {0,0,0,1};
} }
void ui::Canvas::pick_end() void Canvas::pick_end()
{ {
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
m_pick_data[i].release(); m_pick_data[i].release();
} }
void ui::Canvas::clear(const glm::vec4& c/*={0,0,0,1}*/) void Canvas::clear(const glm::vec4& c/*={0,0,0,1}*/)
{ {
snap_history({ 0, 1, 2, 3, 4, 5 }); snap_history({ 0, 1, 2, 3, 4, 5 });
m_layers[m_current_layer_idx].clear(c); m_layers[m_current_layer_idx].clear(c);
m_unsaved = true; m_unsaved = true;
} }
void ui::Canvas::clear_all() void Canvas::clear_all()
{ {
for (auto& l : m_layers) for (auto& l : m_layers)
l.clear({0, 0, 0, 0}); l.clear({0, 0, 0, 0});
} }
void ui::Canvas::snap_history(const std::vector<int>& planes) void Canvas::snap_history(const std::vector<int>& planes)
{ {
auto action = new ActionStroke; auto action = new ActionStroke;
action->was_saved = !m_unsaved; action->was_saved = !m_unsaved;
@@ -174,7 +174,7 @@ void ui::Canvas::snap_history(const std::vector<int>& planes)
action->clear_layer = true; action->clear_layer = true;
ActionManager::add(action); ActionManager::add(action);
} }
ui::ActionStroke* ui::Canvas::create_action(int layer) ActionStroke* Canvas::create_action(int layer)
{ {
auto action = new ActionStroke; auto action = new ActionStroke;
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
@@ -203,7 +203,7 @@ ui::ActionStroke* ui::Canvas::create_action(int layer)
action->clear_layer = true; action->clear_layer = true;
return action; return action;
} }
void ui::Canvas::stroke_end() void Canvas::stroke_end()
{ {
if (!m_current_stroke) if (!m_current_stroke)
return; return;
@@ -218,14 +218,14 @@ void ui::Canvas::stroke_end()
m_show_tmp = false; m_show_tmp = false;
} }
} }
void ui::Canvas::stroke_cancel() void Canvas::stroke_cancel()
{ {
if (!m_current_stroke) if (!m_current_stroke)
return; return;
m_current_stroke = nullptr; m_current_stroke = nullptr;
m_show_tmp = false; m_show_tmp = false;
} }
void ui::Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz) void Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz)
{ {
m_mixer.bindFramebuffer(); m_mixer.bindFramebuffer();
@@ -252,12 +252,12 @@ void ui::Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz
m_plane_transform[plane_index] * m_plane_transform[plane_index] *
glm::translate(glm::vec3(0, 0, -1)); glm::translate(glm::vec3(0, 0, -1));
ui::ShaderManager::use(kShader::TextureAlphaSep); ShaderManager::use(kShader::TextureAlphaSep);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexA, 1); ShaderManager::u_int(kShaderUniform::TexA, 1);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity); ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity);
ui::ShaderManager::u_int(kShaderUniform::Highlight, false); ShaderManager::u_int(kShaderUniform::Highlight, false);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glEnable(GL_BLEND); glEnable(GL_BLEND);
@@ -286,19 +286,19 @@ void ui::Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz
m_sampler.bind(1); m_sampler.bind(1);
m_sampler.bind(2); m_sampler.bind(2);
auto& paper = TextureManager::get(const_hash("data/paper.jpg")); auto& paper = TextureManager::get(const_hash("data/paper.jpg"));
ui::ShaderManager::use(kShader::CompDraw); ShaderManager::use(kShader::CompDraw);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
//ui::ShaderManager::u_int(kShaderUniform::TexA, 0); //ShaderManager::u_int(kShaderUniform::TexA, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1); ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ui::ShaderManager::u_int(kShaderUniform::TexMask, 2); ShaderManager::u_int(kShaderUniform::TexMask, 2);
//ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, m_size); //ShaderManager::u_vec2(kShaderUniform::Resolution, m_size);
//ui::ShaderManager::u_int(kShaderUniform::TexStencil, 3); //ShaderManager::u_int(kShaderUniform::TexStencil, 3);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity); ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
ui::ShaderManager::u_int(kShaderUniform::Lock, m_layers[layer_index].m_alpha_locked); ShaderManager::u_int(kShaderUniform::Lock, m_layers[layer_index].m_alpha_locked);
ui::ShaderManager::u_int(kShaderUniform::Mask, m_smask_active); ShaderManager::u_int(kShaderUniform::Mask, m_smask_active);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false); ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
ui::ShaderManager::u_int(kShaderUniform::BlendMode, m_current_stroke->m_brush.m_blend_mode); ShaderManager::u_int(kShaderUniform::BlendMode, m_current_stroke->m_brush.m_blend_mode);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
m_layers[layer_index].m_rtt[plane_index].bindTexture(); m_layers[layer_index].m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1); glActiveTexture(GL_TEXTURE1);
@@ -320,7 +320,7 @@ void ui::Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz
m_mixer.unbindFramebuffer(); m_mixer.unbindFramebuffer();
glDisable(GL_SCISSOR_TEST); glDisable(GL_SCISSOR_TEST);
} }
void ui::Canvas::stroke_draw() void Canvas::stroke_draw()
{ {
if (!(m_current_stroke && m_current_stroke->has_sample())) if (!(m_current_stroke && m_current_stroke->has_sample()))
{ {
@@ -409,7 +409,7 @@ void ui::Canvas::stroke_draw()
m_mixer.bindTexture(); m_mixer.bindTexture();
glDisable(GL_BLEND); glDisable(GL_BLEND);
ShaderManager::use(ui::kShader::Stroke); ShaderManager::use(kShader::Stroke);
ShaderManager::u_int(kShaderUniform::Tex, 0); // brush ShaderManager::u_int(kShaderUniform::Tex, 0); // brush
#ifndef __IOS__ #ifndef __IOS__
ShaderManager::u_int(kShaderUniform::TexBG, 1); // bg ShaderManager::u_int(kShaderUniform::TexBG, 1); // bg
@@ -523,7 +523,7 @@ void ui::Canvas::stroke_draw()
glm::max(zw(m_dirty_box[i]), (glm::vec2)(tex_pos + tex_sz)) glm::max(zw(m_dirty_box[i]), (glm::vec2)(tex_pos + tex_sz))
); );
ShaderManager::use(ui::kShader::Stroke); ShaderManager::use(kShader::Stroke);
ShaderManager::u_mat4(kShaderUniform::MVP, ortho_proj); ShaderManager::u_mat4(kShaderUniform::MVP, ortho_proj);
ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(s.col, m_brush.m_tip_color.a)); ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(s.col, m_brush.m_tip_color.a));
ShaderManager::u_float(kShaderUniform::Alpha, s.flow); ShaderManager::u_float(kShaderUniform::Alpha, s.flow);
@@ -592,7 +592,7 @@ void ui::Canvas::stroke_draw()
m_commit_delayed = false; m_commit_delayed = false;
} }
} }
bool ui::Canvas::point_trace(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ray_dir, bool Canvas::point_trace(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ray_dir,
glm::vec3& hit_pos, glm::vec2& fb_pos, glm::vec3& hit_normal, int& out_plane_id) glm::vec3& hit_pos, glm::vec2& fb_pos, glm::vec3& hit_normal, int& out_plane_id)
{ {
point_unproject(loc, { 0, 0, zw(m_box) }, m_mv, m_proj, ray_origin, ray_dir); point_unproject(loc, { 0, 0, zw(m_box) }, m_mv, m_proj, ray_origin, ray_dir);
@@ -620,7 +620,7 @@ bool ui::Canvas::point_trace(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ra
return false; return false;
} }
/* /*
bool ui::Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& hit_pos, glm::vec2& hit_fb_pos, int plane_id) bool Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& hit_pos, glm::vec2& hit_fb_pos, int plane_id)
{ {
auto ln = (loc / zw(m_box)) * 2.f - 1.f; auto ln = (loc / zw(m_box)) * 2.f - 1.f;
auto p = m_plane_unproject[plane_id] * glm::vec4(ln, 1, 1); auto p = m_plane_unproject[plane_id] * glm::vec4(ln, 1, 1);
@@ -632,7 +632,7 @@ bool ui::Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& hit_pos, glm::vec2&
return false; return false;
} }
*/ */
bool ui::Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ray_dir, bool Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ray_dir,
glm::vec3& hit_pos, glm::vec3& hit_normal, glm::vec2& hit_fb_pos, int plane_id) glm::vec3& hit_pos, glm::vec3& hit_normal, glm::vec2& hit_fb_pos, int plane_id)
{ {
/* /*
@@ -661,7 +661,7 @@ bool ui::Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& ray_origin, glm::ve
} }
return false; return false;
} }
void ui::Canvas::point_unproject(glm::vec2 loc, glm::vec4 vp, glm::mat4 camera, glm::mat4 proj, void Canvas::point_unproject(glm::vec2 loc, glm::vec4 vp, glm::mat4 camera, glm::mat4 proj,
glm::vec3& out_origin, glm::vec3& out_dir) glm::vec3& out_origin, glm::vec3& out_dir)
{ {
auto clip_space = glm::vec2(loc.x, vp.w - loc.y - 1.f) / zw(vp) * 2.f - 1.f; auto clip_space = glm::vec2(loc.x, vp.w - loc.y - 1.f) / zw(vp) * 2.f - 1.f;
@@ -671,7 +671,7 @@ void ui::Canvas::point_unproject(glm::vec2 loc, glm::vec4 vp, glm::mat4 camera,
out_origin = xyz(wp0 / wp0.w); out_origin = xyz(wp0 / wp0.w);
out_dir = glm::normalize(xyz(wp1 / wp1.w) - out_origin); out_dir = glm::normalize(xyz(wp1 / wp1.w) - out_origin);
}; };
void ui::Canvas::point_unproject(glm::vec2 loc, glm::vec3& out_origin, glm::vec3& out_dir) void Canvas::point_unproject(glm::vec2 loc, glm::vec3& out_origin, glm::vec3& out_dir)
{ {
auto clip_space = glm::vec2(loc.x, m_vp.w - loc.y - 1.f) / zw(m_vp) * 2.f - 1.f; auto clip_space = glm::vec2(loc.x, m_vp.w - loc.y - 1.f) / zw(m_vp) * 2.f - 1.f;
auto inv = glm::inverse(m_proj * m_mv); auto inv = glm::inverse(m_proj * m_mv);
@@ -680,7 +680,7 @@ void ui::Canvas::point_unproject(glm::vec2 loc, glm::vec3& out_origin, glm::vec3
out_origin = xyz(wp0 / wp0.w); out_origin = xyz(wp0 / wp0.w);
out_dir = glm::normalize(xyz(wp1 / wp1.w) - out_origin); out_dir = glm::normalize(xyz(wp1 / wp1.w) - out_origin);
} }
glm::vec3 ui::Canvas::point_trace(glm::vec2 loc) glm::vec3 Canvas::point_trace(glm::vec2 loc)
{ {
glm::vec3 ray_origin; glm::vec3 ray_origin;
glm::vec3 ray_dir; glm::vec3 ray_dir;
@@ -692,7 +692,7 @@ glm::vec3 ui::Canvas::point_trace(glm::vec2 loc)
return hit_pos; return hit_pos;
return glm::vec3(0); return glm::vec3(0);
} }
void ui::Canvas::stroke_commit() void Canvas::stroke_commit()
{ {
if (!m_dirty || m_layers.empty()) if (!m_dirty || m_layers.empty())
return; return;
@@ -759,12 +759,12 @@ void ui::Canvas::stroke_commit()
m_sampler_stencil.bind(3); m_sampler_stencil.bind(3);
if (m_state == kCanvasMode::Erase) if (m_state == kCanvasMode::Erase)
{ {
ui::ShaderManager::use(kShader::CompErase); ShaderManager::use(kShader::CompErase);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1); ShaderManager::u_int(kShaderUniform::TexStroke, 1);
//ui::ShaderManager::u_int(kShaderUniform::TexMask, 2); //ShaderManager::u_int(kShaderUniform::TexMask, 2);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false); ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity); ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f)); ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
@@ -784,16 +784,16 @@ void ui::Canvas::stroke_commit()
{ {
auto& paper = TextureManager::get(const_hash("data/paper.jpg")); auto& paper = TextureManager::get(const_hash("data/paper.jpg"));
ui::ShaderManager::use(kShader::CompDraw); ShaderManager::use(kShader::CompDraw);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1); ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ui::ShaderManager::u_int(kShaderUniform::TexMask, 2); ShaderManager::u_int(kShaderUniform::TexMask, 2);
//ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, m_size); //ShaderManager::u_vec2(kShaderUniform::Resolution, m_size);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity); ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
ui::ShaderManager::u_int(kShaderUniform::Mask, m_smask_active); ShaderManager::u_int(kShaderUniform::Mask, m_smask_active);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false); ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
ui::ShaderManager::u_int(kShaderUniform::BlendMode, m_current_stroke->m_brush.m_blend_mode); ShaderManager::u_int(kShaderUniform::BlendMode, m_current_stroke->m_brush.m_blend_mode);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f)); ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
m_tex2[i].bind(); m_tex2[i].bind();
@@ -814,7 +814,7 @@ void ui::Canvas::stroke_commit()
} }
// else // else
// { // {
// ShaderManager::use(ui::kShader::StrokeLayer); // ShaderManager::use(kShader::StrokeLayer);
// ShaderManager::u_int(kShaderUniform::TexBG, 1); // ShaderManager::u_int(kShaderUniform::TexBG, 1);
// ShaderManager::u_int(kShaderUniform::Lock, m_layers[m_current_layer_idx].m_alpha_locked); // ShaderManager::u_int(kShaderUniform::Lock, m_layers[m_current_layer_idx].m_alpha_locked);
// ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity); // ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
@@ -843,11 +843,11 @@ void ui::Canvas::stroke_commit()
action->m_stroke = std::move(m_current_stroke); action->m_stroke = std::move(m_current_stroke);
ActionManager::add(action); ActionManager::add(action);
} }
void ui::Canvas::stroke_update(glm::vec3 point, float pressure) void Canvas::stroke_update(glm::vec3 point, float pressure)
{ {
m_current_stroke->add_point(point, pressure); m_current_stroke->add_point(point, pressure);
} }
void ui::Canvas::stroke_start(glm::vec3 point, float pressure, const ui::Brush& brush) void Canvas::stroke_start(glm::vec3 point, float pressure, const Brush& brush)
{ {
// need to commit this now before starting a new stroke // need to commit this now before starting a new stroke
if (m_current_stroke && m_commit_delayed) if (m_current_stroke && m_commit_delayed)
@@ -888,7 +888,7 @@ void ui::Canvas::stroke_start(glm::vec3 point, float pressure, const ui::Brush&
} }
m_show_tmp = true; m_show_tmp = true;
} }
void ui::Canvas::layer_add(std::string name) void Canvas::layer_add(std::string name)
{ {
int idx = (int)m_layers.size(); int idx = (int)m_layers.size();
m_layers.emplace_back(); m_layers.emplace_back();
@@ -896,7 +896,7 @@ void ui::Canvas::layer_add(std::string name)
m_order.push_back(idx); m_order.push_back(idx);
m_current_layer_idx = idx; m_current_layer_idx = idx;
} }
void ui::Canvas::layer_remove(int idx) // m_order index void Canvas::layer_remove(int idx) // m_order index
{ {
int n = m_order[idx]; int n = m_order[idx];
for (auto& i : m_order) for (auto& i : m_order)
@@ -906,11 +906,11 @@ void ui::Canvas::layer_remove(int idx) // m_order index
m_order.erase(m_order.begin() + idx); m_order.erase(m_order.begin() + idx);
m_current_layer_idx = m_order[std::min<int>((int)m_layers.size() - 1, idx)]; m_current_layer_idx = m_order[std::min<int>((int)m_layers.size() - 1, idx)];
} }
void ui::Canvas::layer_order(int idx, int pos) // m_order index void Canvas::layer_order(int idx, int pos) // m_order index
{ {
std::swap(m_order[idx], m_order[pos]); std::swap(m_order[idx], m_order[pos]);
} }
void ui::Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index void Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
{ {
m_dirty = false; m_dirty = false;
@@ -962,15 +962,15 @@ void ui::Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
m_sampler.bind(0); m_sampler.bind(0);
m_sampler_bg.bind(1); m_sampler_bg.bind(1);
{ {
ui::ShaderManager::use(kShader::CompDraw); ShaderManager::use(kShader::CompDraw);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); // dest ShaderManager::u_int(kShaderUniform::Tex, 0); // dest
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1); // source ShaderManager::u_int(kShaderUniform::TexStroke, 1); // source
//ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, m_size); //ShaderManager::u_vec2(kShaderUniform::Resolution, m_size);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false); ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_layers[source_idx].m_opacity); ShaderManager::u_float(kShaderUniform::Alpha, m_layers[source_idx].m_opacity);
ui::ShaderManager::u_int(kShaderUniform::Lock, false); ShaderManager::u_int(kShaderUniform::Lock, false);
ui::ShaderManager::u_int(kShaderUniform::BlendMode, 0); // TODO: defaulted to normal, change to layer blend mode when implemented ShaderManager::u_int(kShaderUniform::BlendMode, 0); // TODO: defaulted to normal, change to layer blend mode when implemented
ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f)); ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
m_tex2[i].bind(); m_tex2[i].bind();
@@ -999,7 +999,7 @@ void ui::Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
ActionManager::add(action); ActionManager::add(action);
*/ */
} }
void ui::Canvas::resize(int width, int height) void Canvas::resize(int width, int height)
{ {
m_width = width; m_width = width;
m_height = height; m_height = height;
@@ -1020,7 +1020,7 @@ void ui::Canvas::resize(int width, int height)
m_smask.create(width, height, "mask"); m_smask.create(width, height, "mask");
m_unsaved = true; m_unsaved = true;
} }
bool ui::Canvas::create(int width, int height) bool Canvas::create(int width, int height)
{ {
m_width = width; m_width = width;
m_height = height; m_height = height;
@@ -1059,7 +1059,7 @@ bool ui::Canvas::create(int width, int height)
return true; return true;
} }
void ui::Canvas::snapshot_save() void Canvas::snapshot_save()
{ {
LOG("SAVE SNAPSHOT"); LOG("SAVE SNAPSHOT");
m_layers_snapshot.clear(); m_layers_snapshot.clear();
@@ -1068,7 +1068,7 @@ void ui::Canvas::snapshot_save()
m_layers_snapshot[i] = m_layers[i].snapshot(); m_layers_snapshot[i] = m_layers[i].snapshot();
} }
void ui::Canvas::snapshot_restore() void Canvas::snapshot_restore()
{ {
LOG("RESTORE SNAPSHOT"); LOG("RESTORE SNAPSHOT");
for (int i = 0; i < m_layers.size(); i++) for (int i = 0; i < m_layers.size(); i++)
@@ -1076,7 +1076,7 @@ void ui::Canvas::snapshot_restore()
m_layers_snapshot.clear(); m_layers_snapshot.clear();
} }
void ui::Canvas::clear_context() void Canvas::clear_context()
{ {
LOG("Canvas CLEAR CONTEXT"); LOG("Canvas CLEAR CONTEXT");
for (auto& layer : m_layers) for (auto& layer : m_layers)
@@ -1089,13 +1089,13 @@ void ui::Canvas::clear_context()
} }
}; };
void ui::Canvas::import_equirectangular(std::string file_path) void Canvas::import_equirectangular(std::string file_path)
{ {
std::thread t(&ui::Canvas::import_equirectangular_thread, this, file_path); std::thread t(&Canvas::import_equirectangular_thread, this, file_path);
t.detach(); t.detach();
} }
void ui::Canvas::import_equirectangular_thread(std::string file_path) void Canvas::import_equirectangular_thread(std::string file_path)
{ {
App::I.async_start(); App::I.async_start();
@@ -1115,14 +1115,14 @@ void ui::Canvas::import_equirectangular_thread(std::string file_path)
static GLint iformats[] = { GL_R8, GL_RG8, GL_RGB8, GL_RGBA8 }; static GLint iformats[] = { GL_R8, GL_RG8, GL_RGB8, GL_RGBA8 };
tex.create(img.width, img.width, iformats[img.comp - 1], formats[img.comp - 1]); tex.create(img.width, img.width, iformats[img.comp - 1], formats[img.comp - 1]);
int stride = img.width * img.width * img.comp; int stride = img.width * img.width * img.comp;
ui::Plane plane; Plane plane;
plane.create<1>(2, 2); plane.create<1>(2, 2);
draw_objects([&](const glm::mat4& camera, const glm::mat4& proj, int i) { draw_objects([&](const glm::mat4& camera, const glm::mat4& proj, int i) {
tex.update(img.m_data.get() + indices[i] * stride); tex.update(img.m_data.get() + indices[i] * stride);
m_sampler.bind(0); m_sampler.bind(0);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
tex.bind(); tex.bind();
ShaderManager::use(ui::kShader::Texture); ShaderManager::use(kShader::Texture);
ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(-1, -1, 1))); ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(-1, -1, 1)));
plane.draw_fill(); plane.draw_fill();
@@ -1134,14 +1134,14 @@ void ui::Canvas::import_equirectangular_thread(std::string file_path)
{ {
Texture2D tex; Texture2D tex;
tex.load_file(file_path); tex.load_file(file_path);
ui::Sphere sphere; Sphere sphere;
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
sphere.create<64, 64>(2.f); sphere.create<64, 64>(2.f);
draw_objects([&](const glm::mat4& camera, const glm::mat4& proj, int i) { draw_objects([&](const glm::mat4& camera, const glm::mat4& proj, int i) {
m_sampler.bind(0); m_sampler.bind(0);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
tex.bind(); tex.bind();
ShaderManager::use(ui::kShader::Texture); ShaderManager::use(kShader::Texture);
ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera * ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera *
glm::eulerAngleY(glm::radians(180.f)) * glm::scale(glm::vec3(1, -1, 1))); glm::eulerAngleY(glm::radians(180.f)) * glm::scale(glm::vec3(1, -1, 1)));
@@ -1160,7 +1160,7 @@ void ui::Canvas::import_equirectangular_thread(std::string file_path)
App::I.async_end(); App::I.async_end();
} }
void ui::Canvas::export_equirectangular(std::string file_path, std::function<void()> on_complete) void Canvas::export_equirectangular(std::string file_path, std::function<void()> on_complete)
{ {
if (App::I.check_license()) if (App::I.check_license())
{ {
@@ -1173,7 +1173,7 @@ void ui::Canvas::export_equirectangular(std::string file_path, std::function<voi
} }
} }
void ui::Canvas::export_equirectangular_thread(std::string file_path) void Canvas::export_equirectangular_thread(std::string file_path)
{ {
gl_state gl; gl_state gl;
@@ -1226,7 +1226,7 @@ void ui::Canvas::export_equirectangular_thread(std::string file_path)
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
{ {
ShaderManager::use(ui::kShader::TextureAlpha); ShaderManager::use(kShader::TextureAlpha);
ShaderManager::u_int(kShaderUniform::Highlight, false); ShaderManager::u_int(kShaderUniform::Highlight, false);
ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f)); ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
@@ -1279,9 +1279,9 @@ void ui::Canvas::export_equirectangular_thread(std::string file_path)
glViewport(0, 0, m_latlong.getWidth(), m_latlong.getHeight()); glViewport(0, 0, m_latlong.getWidth(), m_latlong.getHeight());
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
m_latlong.bindFramebuffer(); m_latlong.bindFramebuffer();
ui::ShaderManager::use(kShader::Equirect); ShaderManager::use(kShader::Equirect);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f)); ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id); glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id);
m_sampler_mask.bind(0); m_sampler_mask.bind(0);
m_plane.draw_fill(); m_plane.draw_fill();
@@ -1360,7 +1360,7 @@ void ui::Canvas::export_equirectangular_thread(std::string file_path)
App::I.async_end(); App::I.async_end();
} }
void ui::Canvas::inject_xmp(std::string jpg_path) void Canvas::inject_xmp(std::string jpg_path)
{ {
static const char xmp[] = static const char xmp[] =
"http://ns.adobe.com/xap/1.0/\0" R"(<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?> "http://ns.adobe.com/xap/1.0/\0" R"(<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>
@@ -1408,7 +1408,7 @@ void ui::Canvas::inject_xmp(std::string jpg_path)
} }
void ui::Canvas::export_anim() void Canvas::export_anim()
{ {
if (!App::I.check_license()) if (!App::I.check_license())
return; return;
@@ -1450,8 +1450,8 @@ void ui::Canvas::export_anim()
if (seq == 0) if (seq == 0)
{ {
m_tmp[i].clear({ 1, 1, 1, 1 }); m_tmp[i].clear({ 1, 1, 1, 1 });
ui::ShaderManager::use(kShader::Checkerboard); ShaderManager::use(kShader::Checkerboard);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f)); ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
m_plane.draw_fill(); m_plane.draw_fill();
glEnable(GL_BLEND); glEnable(GL_BLEND);
} }
@@ -1462,7 +1462,7 @@ void ui::Canvas::export_anim()
} }
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
ShaderManager::use(ui::kShader::TextureAlpha); ShaderManager::use(kShader::TextureAlpha);
ShaderManager::u_float(kShaderUniform::Alpha, 1); ShaderManager::u_float(kShaderUniform::Alpha, 1);
ShaderManager::u_int(kShaderUniform::Highlight, false); ShaderManager::u_int(kShaderUniform::Highlight, false);
ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
@@ -1487,9 +1487,9 @@ void ui::Canvas::export_anim()
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
m_latlong.bindFramebuffer(); m_latlong.bindFramebuffer();
m_latlong.clear({ 1, 1, 1, 0 }); m_latlong.clear({ 1, 1, 1, 0 });
ui::ShaderManager::use(kShader::Equirect); ShaderManager::use(kShader::Equirect);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f)); ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id); glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id);
glDisable(GL_BLEND); glDisable(GL_BLEND);
m_sampler_mask.bind(0); m_sampler_mask.bind(0);
@@ -1521,7 +1521,7 @@ void ui::Canvas::export_anim()
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
} }
void ui::Canvas::export_cubes() void Canvas::export_cubes()
{ {
if (!App::I.check_license()) if (!App::I.check_license())
return; return;
@@ -1603,7 +1603,7 @@ void ui::Canvas::export_cubes()
#endif #endif
} }
void ui::Canvas::project_save(std::function<void(bool)> on_complete) void Canvas::project_save(std::function<void(bool)> on_complete)
{ {
if (App::I.check_license()) if (App::I.check_license())
{ {
@@ -1616,7 +1616,7 @@ void ui::Canvas::project_save(std::function<void(bool)> on_complete)
} }
} }
void ui::Canvas::project_save(std::string file_path, std::function<void(bool)> on_complete) void Canvas::project_save(std::string file_path, std::function<void(bool)> on_complete)
{ {
if (App::I.check_license()) if (App::I.check_license())
{ {
@@ -1629,7 +1629,7 @@ void ui::Canvas::project_save(std::string file_path, std::function<void(bool)> o
} }
} }
bool ui::Canvas::project_save_thread(std::string file_path) bool Canvas::project_save_thread(std::string file_path)
{ {
gl_state gl; gl_state gl;
@@ -1794,7 +1794,7 @@ bool ui::Canvas::project_save_thread(std::string file_path)
return success; return success;
} }
void ui::Canvas::project_open(std::string file_path, std::function<void(bool)> on_complete) void Canvas::project_open(std::string file_path, std::function<void(bool)> on_complete)
{ {
std::thread t([=] { std::thread t([=] {
bool result = project_open_thread(file_path); bool result = project_open_thread(file_path);
@@ -1804,7 +1804,7 @@ void ui::Canvas::project_open(std::string file_path, std::function<void(bool)> o
t.detach(); t.detach();
} }
bool ui::Canvas::project_open_thread(std::string file_path) bool Canvas::project_open_thread(std::string file_path)
{ {
FILE* fp = fopen(file_path.c_str(), "rb"); FILE* fp = fopen(file_path.c_str(), "rb");
if (!fp) if (!fp)
@@ -1958,7 +1958,7 @@ bool ui::Canvas::project_open_thread(std::string file_path)
return true; return true;
} }
ui::Image ui::Canvas::thumbnail_generate(int w, int h) Image Canvas::thumbnail_generate(int w, int h)
{ {
// save viewport and clear color states // save viewport and clear color states
@@ -1975,7 +1975,7 @@ ui::Image ui::Canvas::thumbnail_generate(int w, int h)
fb.create(w, h); fb.create(w, h);
fb.bindFramebuffer(); fb.bindFramebuffer();
fb.clear({ 1, 1, 1, 1 }); fb.clear({ 1, 1, 1, 1 });
ui::Plane m_face_plane; Plane m_face_plane;
m_face_plane.create<1>(2, 2); m_face_plane.create<1>(2, 2);
// recalculate because of different aspect ratio than the m_proj matrix // recalculate because of different aspect ratio than the m_proj matrix
@@ -1986,17 +1986,17 @@ ui::Image ui::Canvas::thumbnail_generate(int w, int h)
{ {
auto plane_mvp = proj * m_mv * m_plane_transform[plane_index] * glm::translate(glm::vec3(0, 0, -1)); auto plane_mvp = proj * m_mv * m_plane_transform[plane_index] * glm::translate(glm::vec3(0, 0, -1));
ui::ShaderManager::use(kShader::Checkerboard); ShaderManager::use(kShader::Checkerboard);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
m_face_plane.draw_fill(); m_face_plane.draw_fill();
ui::ShaderManager::use(kShader::TextureAlpha); ShaderManager::use(kShader::TextureAlpha);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::Highlight, false); ShaderManager::u_int(kShaderUniform::Highlight, false);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
for (auto layer_index : m_order) for (auto layer_index : m_order)
{ {
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity); ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity);
m_layers[layer_index].m_rtt[plane_index].bindTexture(); m_layers[layer_index].m_rtt[plane_index].bindTexture();
m_face_plane.draw_fill(); m_face_plane.draw_fill();
m_layers[layer_index].m_rtt[plane_index].unbindTexture(); m_layers[layer_index].m_rtt[plane_index].unbindTexture();
@@ -2006,7 +2006,7 @@ ui::Image ui::Canvas::thumbnail_generate(int w, int h)
fb.unbindFramebuffer(); fb.unbindFramebuffer();
// read the rendered image // read the rendered image
ui::Image image; Image image;
image.create(w, h); image.create(w, h);
fb.readTextureData((uint8_t*)image.data()); fb.readTextureData((uint8_t*)image.data());
@@ -2021,7 +2021,7 @@ ui::Image ui::Canvas::thumbnail_generate(int w, int h)
return image; return image;
} }
ui::Image ui::Canvas::thumbnail_read(std::string file_path) Image Canvas::thumbnail_read(std::string file_path)
{ {
// static char name[128]; // static char name[128];
// sprintf(name, "%s/latlong.ppi", data_path.c_str()); // sprintf(name, "%s/latlong.ppi", data_path.c_str());
@@ -2048,7 +2048,7 @@ ui::Image ui::Canvas::thumbnail_read(std::string file_path)
return thumb; return thumb;
} }
void ui::Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer, Layer& layer) void Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer, Layer& layer)
{ {
// save viewport and clear color states // save viewport and clear color states
GLint vp[4]; GLint vp[4];
@@ -2079,12 +2079,12 @@ void ui::Canvas::draw_objects(std::function<void(const glm::mat4& camera, const
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
} }
void ui::Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer) void Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer)
{ {
draw_objects(observer, m_layers[m_current_layer_idx]); draw_objects(observer, m_layers[m_current_layer_idx]);
} }
void ui::Canvas::project2Dpoints(std::vector<vertex_t>& vertices) void Canvas::project2Dpoints(std::vector<vertex_t>& vertices)
{ {
for (auto& p : vertices) for (auto& p : vertices)
{ {
@@ -2096,7 +2096,7 @@ void ui::Canvas::project2Dpoints(std::vector<vertex_t>& vertices)
} }
} }
glm::vec3 ui::Canvas::project2Dpoint(glm::vec2 pt) glm::vec3 Canvas::project2Dpoint(glm::vec2 pt)
{ {
glm::vec3 ro, rd, hit_o, hit_d; glm::vec3 ro, rd, hit_o, hit_d;
glm::vec2 hit_fb; glm::vec2 hit_fb;
@@ -2110,7 +2110,7 @@ glm::vec3 ui::Canvas::project2Dpoint(glm::vec2 pt)
// return the 2d shape of the faces based on the current camera // return the 2d shape of the faces based on the current camera
// this can be used for screen space shapes clipping // this can be used for screen space shapes clipping
std::vector<glm::vec2> ui::Canvas::face_to_shape2D(int plane_index) std::vector<glm::vec2> Canvas::face_to_shape2D(int plane_index)
{ {
static std::array<glm::vec4, 4> corners{ static std::array<glm::vec4, 4> corners{
glm::vec4(-1.f, +1.f, -1.f, 1.f), // A top-left glm::vec4(-1.f, +1.f, -1.f, 1.f), // A top-left
@@ -2143,12 +2143,12 @@ std::vector<glm::vec2> ui::Canvas::face_to_shape2D(int plane_index)
return points; return points;
} }
void ui::Canvas::push_camera() void Canvas::push_camera()
{ {
m_camera_stack.push(get_camera()); m_camera_stack.push(get_camera());
} }
void ui::Canvas::pop_camera() void Canvas::pop_camera()
{ {
if (!m_camera_stack.empty()) if (!m_camera_stack.empty())
{ {
@@ -2157,7 +2157,7 @@ void ui::Canvas::pop_camera()
} }
} }
ui::Canvas::CameraData ui::Canvas::get_camera() CameraData Canvas::get_camera()
{ {
CameraData c; CameraData c;
c.m_box = m_box; c.m_box = m_box;
@@ -2170,7 +2170,7 @@ ui::Canvas::CameraData ui::Canvas::get_camera()
return c; return c;
} }
void ui::Canvas::set_camera(const ui::Canvas::CameraData& c) void Canvas::set_camera(const CameraData& c)
{ {
m_box = c.m_box; m_box = c.m_box;
m_mv = c.m_mv; m_mv = c.m_mv;
@@ -2181,11 +2181,11 @@ void ui::Canvas::set_camera(const ui::Canvas::CameraData& c)
m_vp = c.m_vp; m_vp = c.m_vp;
} }
void ui::Canvas::reset_camera() void Canvas::reset_camera()
{ {
} }
std::vector<vertex_t> ui::Canvas::triangulate_simple(const std::vector<vertex_t>& vertices) std::vector<vertex_t> Canvas::triangulate_simple(const std::vector<vertex_t>& vertices)
{ {
std::vector<vertex_t> ret; std::vector<vertex_t> ret;
std::vector<p2t::Point> points(vertices.size()); std::vector<p2t::Point> points(vertices.size());
@@ -2212,7 +2212,7 @@ std::vector<vertex_t> ui::Canvas::triangulate_simple(const std::vector<vertex_t>
return ret; return ret;
} }
std::vector<vertex_t> ui::Canvas::triangulate(const std::vector<glm::vec2>& points) std::vector<vertex_t> Canvas::triangulate(const std::vector<glm::vec2>& points)
{ {
std::vector<vertex_t> tmp; std::vector<vertex_t> tmp;
for (auto pt : points) for (auto pt : points)
@@ -2220,7 +2220,7 @@ std::vector<vertex_t> ui::Canvas::triangulate(const std::vector<glm::vec2>& poin
return triangulate(tmp); return triangulate(tmp);
} }
std::vector<vertex_t> ui::Canvas::triangulate(const std::vector<vertex_t>& points) std::vector<vertex_t> Canvas::triangulate(const std::vector<vertex_t>& points)
{ {
struct Segment struct Segment
{ {
@@ -2355,13 +2355,13 @@ std::vector<vertex_t> ui::Canvas::triangulate(const std::vector<vertex_t>& point
/////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////
void ui::Layer::destroy() void Layer::destroy()
{ {
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
m_rtt[i].destroy(); m_rtt[i].destroy();
} }
void ui::Layer::restore(const Snapshot& snap) void Layer::restore(const Snapshot& snap)
{ {
//clear({ 0, 0, 0, 0 }); //clear({ 0, 0, 0, 0 });
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
@@ -2389,7 +2389,7 @@ void ui::Layer::restore(const Snapshot& snap)
} }
} }
ui::Layer::Snapshot ui::Layer::snapshot() Layer::Snapshot Layer::snapshot()
{ {
Snapshot snap; Snapshot snap;
static int counter = 0; static int counter = 0;
@@ -2416,7 +2416,7 @@ ui::Layer::Snapshot ui::Layer::snapshot()
return snap; return snap;
} }
void ui::Layer::clear(const glm::vec4& c) void Layer::clear(const glm::vec4& c)
{ {
// push clear color state // push clear color state
GLfloat cc[4]; GLfloat cc[4];
@@ -2447,7 +2447,7 @@ void ui::Layer::clear(const glm::vec4& c)
glClearColor(cc[0], cc[1], cc[2], cc[3]); glClearColor(cc[0], cc[1], cc[2], cc[3]);
} }
bool ui::Layer::create(int width, int height, std::string name) bool Layer::create(int width, int height, std::string name)
{ {
m_name = name; m_name = name;
w = width; w = width;
@@ -2464,7 +2464,7 @@ bool ui::Layer::create(int width, int height, std::string name)
return true; return true;
} }
void ui::Layer::resize(int width, int height) void Layer::resize(int width, int height)
{ {
glm::vec2 ratio = glm::vec2(width, height) / glm::vec2(w, h); glm::vec2 ratio = glm::vec2(width, height) / glm::vec2(w, h);
w = width; w = width;

23
src/canvas.h
View File

@@ -8,8 +8,6 @@
#include "canvas_modes.h" #include "canvas_modes.h"
#include <stack> #include <stack>
NS_START
#define CANVAS_RES 512 #define CANVAS_RES 512
class Layer class Layer
@@ -101,17 +99,6 @@ struct PPIHeader
} }
}; };
struct CameraData
{
glm::mat4 m_mv{ 1 };
glm::mat4 m_proj{ 1 };
glm::vec4 m_box{ 0 };
glm::vec4 m_vp{ 0 };
glm::vec2 m_pan{ 0 };
glm::mat4 m_plane_unproject[6] = SIXPLETTE(glm::mat4(1));
glm::vec3 m_plane_dir[6] = SIXPLETTE(glm::vec3(0));
};
class Canvas class Canvas
{ {
public: public:
@@ -153,7 +140,7 @@ public:
RTT m_tmp[6]; RTT m_tmp[6];
RTT m_mixer; RTT m_mixer;
float m_mixer_scale = 1; float m_mixer_scale = 1;
ui::StrokeSample m_mixer_sample; StrokeSample m_mixer_sample;
bool m_mixer_idle = true; bool m_mixer_idle = true;
Texture2D m_brush_mix; Texture2D m_brush_mix;
Texture2D m_tex[6]; Texture2D m_tex[6];
@@ -206,7 +193,7 @@ public:
void layer_add(std::string name); void layer_add(std::string name);
void layer_order(int idx, int pos); void layer_order(int idx, int pos);
void layer_merge(int source_idx, int dest_idx); void layer_merge(int source_idx, int dest_idx);
void stroke_start(glm::vec3 point, float pressure, const ui::Brush& brush); void stroke_start(glm::vec3 point, float pressure, const Brush& brush);
void stroke_update(glm::vec3 point, float pressure); void stroke_update(glm::vec3 point, float pressure);
void stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz); void stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz);
void stroke_draw(); void stroke_draw();
@@ -236,8 +223,8 @@ public:
void project_open(std::string file_path, std::function<void(bool)> on_complete = nullptr); void project_open(std::string file_path, std::function<void(bool)> on_complete = nullptr);
bool project_open_thread(std::string file_path); bool project_open_thread(std::string file_path);
void inject_xmp(std::string jpg_path); void inject_xmp(std::string jpg_path);
ui::Image thumbnail_generate(int w, int h); Image thumbnail_generate(int w, int h);
ui::Image thumbnail_read(std::string file_path); Image thumbnail_read(std::string file_path);
void draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)>); void draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)>);
void draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)>, Layer& layer); void draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)>, Layer& layer);
void point_unproject(glm::vec2 loc, glm::vec4 vp, glm::mat4 camera, glm::mat4 proj, void point_unproject(glm::vec2 loc, glm::vec4 vp, glm::mat4 camera, glm::mat4 proj,
@@ -315,5 +302,3 @@ public:
{ {
} }
}; };
NS_END

138
src/canvas_modes.cpp
View File

@@ -9,7 +9,7 @@
#include "util.h" #include "util.h"
NodeCanvas* CanvasMode::node; NodeCanvas* CanvasMode::node;
ui::Canvas* CanvasMode::canvas; Canvas* CanvasMode::canvas;
void CanvasModeBasicCamera::on_MouseEvent(MouseEvent* me, glm::vec2& loc) void CanvasModeBasicCamera::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
{ {
@@ -191,10 +191,10 @@ void CanvasModePen::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const
auto pos = m_resizing ? m_size_pos_start : m_cur_pos; auto pos = m_resizing ? m_size_pos_start : m_cur_pos;
if (App::I.keys[(int)kKey::KeyAlt] && !m_resizing) if (App::I.keys[(int)kKey::KeyAlt] && !m_resizing)
pos.x = pos.x - canvas->m_current_brush.m_tip_size * 500.f; pos.x = pos.x - canvas->m_current_brush.m_tip_size * 500.f;
ui::ShaderManager::use(ui::kShader::StrokePreview); ShaderManager::use(kShader::StrokePreview);
ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_float(ui::kShaderUniform::Alpha, canvas->m_current_brush.m_tip_flow); ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_current_brush.m_tip_flow);
float tip_scale_fix = 1.f / glm::tan(glm::radians(ui::Canvas::I->m_cam_fov * 0.5f)); float tip_scale_fix = 1.f / glm::tan(glm::radians(Canvas::I->m_cam_fov * 0.5f));
float tip_scale = canvas->m_current_brush.m_tip_size * 800.f * tip_scale_fix; float tip_scale = canvas->m_current_brush.m_tip_size * 800.f * tip_scale_fix;
float tip_angle = canvas->m_current_brush.m_tip_angle * (float)(M_PI * 2.0); float tip_angle = canvas->m_current_brush.m_tip_angle * (float)(M_PI * 2.0);
glm::vec2 tip_offset = glm::vec2(0); glm::vec2 tip_offset = glm::vec2(0);
@@ -210,8 +210,8 @@ void CanvasModePen::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const
tip_color = glm::vec4(s.col, s.flow); tip_color = glm::vec4(s.col, s.flow);
} }
} }
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, tip_color); ShaderManager::u_vec4(kShaderUniform::Col, tip_color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, ShaderManager::u_mat4(kShaderUniform::MVP,
glm::scale(glm::vec3(1, -1, 1)) * glm::scale(glm::vec3(1, -1, 1)) *
ortho * ortho *
glm::translate(glm::vec3(pos + tip_offset, 0)) * glm::translate(glm::vec3(pos + tip_offset, 0)) *
@@ -237,7 +237,7 @@ void CanvasModePen::leave()
void CanvasModePen::enter() void CanvasModePen::enter()
{ {
m_cur_pos = ui::Canvas::I->m_cur_pos; m_cur_pos = Canvas::I->m_cur_pos;
if (m_valid_brush) if (m_valid_brush)
{ {
canvas->m_current_brush = m_brush; canvas->m_current_brush = m_brush;
@@ -291,9 +291,9 @@ void CanvasModeLine::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, cons
{ {
if (m_dragging) if (m_dragging)
{ {
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, ortho); ShaderManager::u_mat4(kShaderUniform::MVP, ortho);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, canvas->m_current_brush.m_tip_color); ShaderManager::u_vec4(kShaderUniform::Col, canvas->m_current_brush.m_tip_color);
static glm::vec4 AB[2]; static glm::vec4 AB[2];
AB[0] = { m_drag_start, 0, 1 }; AB[0] = { m_drag_start, 0, 1 };
AB[1] = { m_drag_pos, 0, 1 }; AB[1] = { m_drag_pos, 0, 1 };
@@ -402,9 +402,9 @@ void CanvasModeGrid::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, cons
{ {
auto origin = l.o; auto origin = l.o;
auto dir = l.d; auto dir = l.d;
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera); ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 0, 0, 1}); ShaderManager::u_vec4(kShaderUniform::Col, {1, 0, 0, 1});
static glm::vec4 AB[2]; static glm::vec4 AB[2];
AB[0] = {origin - dir * 10.f, 1}; AB[0] = {origin - dir * 10.f, 1};
AB[1] = {origin + dir * 10.f, 1 }; AB[1] = {origin + dir * 10.f, 1 };
@@ -421,9 +421,9 @@ void CanvasModeGrid::init()
void CanvasModeGrid::commit() void CanvasModeGrid::commit()
{ {
auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj){ auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj){
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera); ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 0, 0, 1}); ShaderManager::u_vec4(kShaderUniform::Col, {1, 0, 0, 1});
static glm::vec4 AB[2]; static glm::vec4 AB[2];
AB[0] = {origin - dir * 10.f, 1}; AB[0] = {origin - dir * 10.f, 1};
AB[1] = {origin + dir * 10.f, 1 }; AB[1] = {origin + dir * 10.f, 1 };
@@ -497,9 +497,9 @@ void CanvasModeMaskFree::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
//m_points2d = poly_intersect(poly_remove_duplicate(m_points2d), canvas->face_to_shape2D(0)); //m_points2d = poly_intersect(poly_remove_duplicate(m_points2d), canvas->face_to_shape2D(0));
auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) { auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
//glEnable(GL_BLEND); //glEnable(GL_BLEND);
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera); ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 1, 1, 1}); ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
m_shape.draw_fill(); m_shape.draw_fill();
}; };
// use m_shape to render the mask polygon // use m_shape to render the mask polygon
@@ -579,17 +579,17 @@ void CanvasModeMaskFree::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
{ {
if (m_dragging) if (m_dragging)
{ {
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho); ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
//m_dragging ? m_shape.draw_stroke() : m_shape.draw_fill(); //m_dragging ? m_shape.draw_stroke() : m_shape.draw_fill();
m_shape.draw_stroke(); m_shape.draw_stroke();
} }
else else
{ {
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera); ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
m_shape.draw_stroke(); m_shape.draw_stroke();
} }
} }
@@ -621,9 +621,9 @@ void CanvasModeMaskLine::leave()
{ {
auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) { auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
//glEnable(GL_BLEND); //glEnable(GL_BLEND);
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera); ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 1, 1, 1}); ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
m_shape.draw_fill(); m_shape.draw_fill();
}; };
canvas->draw_objects(std::bind(drawer, std::placeholders::_1, std::placeholders::_2), canvas->m_smask); canvas->draw_objects(std::bind(drawer, std::placeholders::_1, std::placeholders::_2), canvas->m_smask);
@@ -715,17 +715,17 @@ void CanvasModeMaskLine::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
{ {
if (m_active_tool) if (m_active_tool)
{ {
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho); ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
//m_dragging ? m_shape.draw_stroke() : m_shape.draw_fill(); //m_dragging ? m_shape.draw_stroke() : m_shape.draw_fill();
m_shape.draw_stroke(); m_shape.draw_stroke();
} }
else else
{ {
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera); ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
m_shape.draw_stroke(); m_shape.draw_stroke();
} }
} }
@@ -743,9 +743,9 @@ void CanvasModeFill::leave()
if (m_points.size() > 2) if (m_points.size() > 2)
{ {
auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) { auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera); ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 1, 1, 1}); ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
m_shape.draw_fill(); m_shape.draw_fill();
}; };
canvas->draw_objects(std::bind(drawer, std::placeholders::_1, std::placeholders::_2), canvas->m_smask); canvas->draw_objects(std::bind(drawer, std::placeholders::_1, std::placeholders::_2), canvas->m_smask);
@@ -835,9 +835,9 @@ void CanvasModeFill::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, cons
{ {
if (!m_points.empty()) if (!m_points.empty())
{ {
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera); ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, .25 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, .25 });
m_dragging ? m_shape.draw_fill() : m_shape.draw_stroke(); m_dragging ? m_shape.draw_fill() : m_shape.draw_stroke();
} }
} }
@@ -906,7 +906,7 @@ void CanvasModeTransform::enter()
return; return;
} }
auto m = static_cast<CanvasModeMaskFree*>(canvas->modes[(int)ui::Canvas::kCanvasMode::MaskFree][0]); auto m = static_cast<CanvasModeMaskFree*>(canvas->modes[(int)Canvas::kCanvasMode::MaskFree][0]);
canvas->m_smask_active = false; canvas->m_smask_active = false;
auto points = m->m_points2d; auto points = m->m_points2d;
@@ -1013,17 +1013,17 @@ void CanvasModeTransform::enter()
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glm::mat4 proj = glm::perspective(glm::radians(90.f), 1.f, .01f, 1000.f); glm::mat4 proj = glm::perspective(glm::radians(90.f), 1.f, .01f, 1000.f);
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 0 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 0 });
auto action = new ui::ActionStroke; auto action = new ActionStroke;
action->was_saved = !canvas->m_unsaved; action->was_saved = !canvas->m_unsaved;
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
{ {
auto plane_camera = glm::lookAt(glm::vec3(0), canvas->m_plane_origin[i], canvas->m_plane_tangent[i]); auto plane_camera = glm::lookAt(glm::vec3(0), canvas->m_plane_origin[i], canvas->m_plane_tangent[i]);
auto mvp = proj * plane_camera * m_xform * m_xform_local; auto mvp = proj * plane_camera * m_xform * m_xform_local;
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, mvp); ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
layer.m_rtt[i].bindFramebuffer(); layer.m_rtt[i].bindFramebuffer();
@@ -1102,28 +1102,28 @@ void CanvasModeTransform::leave()
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glm::mat4 proj = glm::perspective(glm::radians(90.f), 1.f, .01f, 1000.f); glm::mat4 proj = glm::perspective(glm::radians(90.f), 1.f, .01f, 1000.f);
ui::ShaderManager::use(ui::kShader::CompDraw); ShaderManager::use(kShader::CompDraw);
ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(ui::kShaderUniform::TexStroke, 1); ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ui::ShaderManager::u_int(ui::kShaderUniform::TexMask, 2); ShaderManager::u_int(kShaderUniform::TexMask, 2);
ui::ShaderManager::u_float(ui::kShaderUniform::Alpha, 1); ShaderManager::u_float(kShaderUniform::Alpha, 1);
ui::ShaderManager::u_int(ui::kShaderUniform::Lock, false); ShaderManager::u_int(kShaderUniform::Lock, false);
ui::ShaderManager::u_int(ui::kShaderUniform::Mask, false); ShaderManager::u_int(kShaderUniform::Mask, false);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, true); ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, true);
ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, canvas->m_size); ShaderManager::u_vec2(kShaderUniform::Resolution, canvas->m_size);
ui::ShaderManager::u_int(ui::kShaderUniform::BlendMode, 0); ShaderManager::u_int(kShaderUniform::BlendMode, 0);
canvas->m_sampler_bg.bind(1); canvas->m_sampler_bg.bind(1);
canvas->m_sampler_bg.bind(0); canvas->m_sampler_bg.bind(0);
auto action = new ui::ActionStroke; auto action = new ActionStroke;
action->was_saved = !canvas->m_unsaved; action->was_saved = !canvas->m_unsaved;
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
{ {
auto plane_camera = glm::lookAt(glm::vec3(0), canvas->m_plane_origin[i], canvas->m_plane_tangent[i]); auto plane_camera = glm::lookAt(glm::vec3(0), canvas->m_plane_origin[i], canvas->m_plane_tangent[i]);
auto mvp = proj * plane_camera * m_xform * m_xform_local; auto mvp = proj * plane_camera * m_xform * m_xform_local;
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, mvp); ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
layer.m_rtt[i].bindFramebuffer(); layer.m_rtt[i].bindFramebuffer();
@@ -1188,7 +1188,7 @@ void CanvasModeTransform::leave()
//action->m_stroke = std::move(m_current_stroke); //action->m_stroke = std::move(m_current_stroke);
ActionManager::add(action); ActionManager::add(action);
//auto m = static_cast<CanvasModeMaskFree*>(canvas->modes[(int)ui::Canvas::kCanvasMode::MaskFree][0]); //auto m = static_cast<CanvasModeMaskFree*>(canvas->modes[(int)Canvas::kCanvasMode::MaskFree][0]);
//m->clear(); //m->clear();
} }
@@ -1200,14 +1200,14 @@ void CanvasModeTransform::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
glEnable(GL_BLEND); glEnable(GL_BLEND);
for (int i = 0; i < 6; i++) for (int i = 0; i < 6; i++)
{ {
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera * m_xform * m_xform_local); ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera * m_xform * m_xform_local);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 1, 1, .1 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 1, 1, .1 });
m_shape[i].draw_fill(); m_shape[i].draw_fill();
ui::ShaderManager::use(ui::kShader::Texture); ShaderManager::use(kShader::Texture);
ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera * m_xform * m_xform_local); ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera * m_xform * m_xform_local);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
m_tex[i].bind(); m_tex[i].bind();
canvas->m_sampler.bind(0); canvas->m_sampler.bind(0);
@@ -1215,7 +1215,7 @@ void CanvasModeTransform::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
m_tex[i].unbind(); m_tex[i].unbind();
} }
ui::ShaderManager::use(ui::kShader::Color); ShaderManager::use(kShader::Color);
auto m2d = canvas->m_proj * canvas->m_mv * m_xform * m_xform_local; auto m2d = canvas->m_proj * canvas->m_mv * m_xform * m_xform_local;
for (int i = 0; i < corners.size(); i++) for (int i = 0; i < corners.size(); i++)
{ {
@@ -1225,15 +1225,15 @@ void CanvasModeTransform::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
continue; continue;
auto c2d = (xy(c3d) * 0.5f + 0.5f) * zw(canvas->m_box); auto c2d = (xy(c3d) * 0.5f + 0.5f) * zw(canvas->m_box);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, ShaderManager::u_mat4(kShaderUniform::MVP,
ortho * glm::translate(glm::vec3(c2d, 0)) * glm::scale(glm::vec3(20.f) * App::I.zoom)); ortho * glm::translate(glm::vec3(c2d, 0)) * glm::scale(glm::vec3(20.f) * App::I.zoom));
// draw inside // draw inside
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 1, 1, 1, i == corner_hl ? 1.f : .1f }); ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, i == corner_hl ? 1.f : .1f });
m_circle.draw_fill(); m_circle.draw_fill();
// draw black border // draw black border
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
m_circle.draw_stroke(); m_circle.draw_stroke();
} }

40
src/canvas_modes.h
View File

@@ -3,18 +3,26 @@
#include "shape.h" #include "shape.h"
#include "brush.h" #include "brush.h"
#include "texture.h" #include "texture.h"
#include "canvas.h"
#include <poly2tri.h> #include <poly2tri.h>
// NS_START class Canvas;
// class Canvas;
// NS_END struct CameraData
{
glm::mat4 m_mv{ 1 };
glm::mat4 m_proj{ 1 };
glm::vec4 m_box{ 0 };
glm::vec4 m_vp{ 0 };
glm::vec2 m_pan{ 0 };
glm::mat4 m_plane_unproject[6] = SIXPLETTE(glm::mat4(1));
glm::vec3 m_plane_dir[6] = SIXPLETTE(glm::vec3(0));
};
class CanvasMode class CanvasMode
{ {
public: public:
static class NodeCanvas* node; static class NodeCanvas* node;
static ui::Canvas* canvas; static Canvas* canvas;
virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) {} virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) {}
virtual void on_KeyEvent(KeyEvent* ke) {} virtual void on_KeyEvent(KeyEvent* ke) {}
virtual void on_GestureEvent(GestureEvent* ge) {} virtual void on_GestureEvent(GestureEvent* ge) {}
@@ -53,7 +61,7 @@ class CanvasModePen : public CanvasMode
float m_zoom_canvas = 1.f; float m_zoom_canvas = 1.f;
float m_zoom_start; float m_zoom_start;
bool m_valid_brush = false; bool m_valid_brush = false;
ui::Brush m_brush; Brush m_brush;
// resizing the tip // resizing the tip
bool m_resizing = false; bool m_resizing = false;
public: public:
@@ -67,7 +75,7 @@ public:
class CanvasModeLine : public CanvasMode class CanvasModeLine : public CanvasMode
{ {
ui::LineSegment m_line; LineSegment m_line;
bool m_dragging = false; bool m_dragging = false;
glm::vec2 m_drag_start; glm::vec2 m_drag_start;
glm::vec2 m_drag_pos; glm::vec2 m_drag_pos;
@@ -79,7 +87,7 @@ public:
class CanvasModeGrid : public CanvasMode class CanvasModeGrid : public CanvasMode
{ {
ui::LineSegment m_line; LineSegment m_line;
glm::vec3 origin; glm::vec3 origin;
glm::vec3 dir; glm::vec3 dir;
int m_plane_id; int m_plane_id;
@@ -105,7 +113,7 @@ public:
class CanvasModeFill : public CanvasMode class CanvasModeFill : public CanvasMode
{ {
ui::DynamicShape m_shape; DynamicShape m_shape;
bool m_dragging = false; bool m_dragging = false;
std::vector<vertex_t> m_points; std::vector<vertex_t> m_points;
std::map<int, int> m_dirty_planes; std::map<int, int> m_dirty_planes;
@@ -119,11 +127,11 @@ public:
class CanvasModeMaskFree : public CanvasMode class CanvasModeMaskFree : public CanvasMode
{ {
friend class CanvasModeTransform; friend class CanvasModeTransform;
ui::DynamicShape m_shape; DynamicShape m_shape;
bool m_dragging = false; bool m_dragging = false;
std::vector<vertex_t> m_points; std::vector<vertex_t> m_points;
std::vector<glm::vec2> m_points2d; std::vector<glm::vec2> m_points2d;
struct ui::CameraData m_selection_cam; CameraData m_selection_cam;
public: public:
virtual void on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const glm::mat4& camera) override; virtual void on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const glm::mat4& camera) override;
virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) override; virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) override;
@@ -134,7 +142,7 @@ public:
class CanvasModeMaskLine : public CanvasMode class CanvasModeMaskLine : public CanvasMode
{ {
ui::DynamicShape m_shape; DynamicShape m_shape;
bool m_dragging = false; bool m_dragging = false;
std::vector<vertex_t> m_points; std::vector<vertex_t> m_points;
std::vector<glm::vec2> m_points2d; std::vector<glm::vec2> m_points2d;
@@ -150,9 +158,9 @@ public:
class CanvasModeTransform : public CanvasMode class CanvasModeTransform : public CanvasMode
{ {
ui::DynamicShape m_shape[6]{}; DynamicShape m_shape[6]{};
ui::Sphere m_sphere{}; Sphere m_sphere{};
ui::Circle m_circle{}; Circle m_circle{};
Texture2D m_tex[6]{}; Texture2D m_tex[6]{};
glm::vec3 m_origin{0, 0, 1 }; glm::vec3 m_origin{0, 0, 1 };
std::vector<glm::vec3> corners{}; std::vector<glm::vec3> corners{};
@@ -178,7 +186,7 @@ class CanvasModeTransform : public CanvasMode
public: public:
enum class ActionType : uint8_t { Copy, Cut, Import }; enum class ActionType : uint8_t { Copy, Cut, Import };
ActionType m_action; ActionType m_action;
ui::Image m_source_image; Image m_source_image;
CanvasModeTransform() = default; CanvasModeTransform() = default;
virtual void on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const glm::mat4& camera) override; virtual void on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const glm::mat4& camera) override;
virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) override; virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) override;

4
src/image.cpp
View File

@@ -5,8 +5,6 @@
#include <stb/stb_image.h> #include <stb/stb_image.h>
using namespace ui;
bool Image::load(std::string filename) bool Image::load(std::string filename)
{ {
stbi_set_flip_vertically_on_load(false); stbi_set_flip_vertically_on_load(false);
@@ -47,7 +45,7 @@ void Image::flip()
std::swap(m_data, flipped); std::swap(m_data, flipped);
} }
ui::Image ui::Image::resize(int w, int h) Image Image::resize(int w, int h)
{ {
Image ret; Image ret;
ret.create(w, h); ret.create(w, h);

4
src/image.h
View File

@@ -1,7 +1,5 @@
#pragma once #pragma once
namespace ui {
class Image class Image
{ {
public: public:
@@ -35,5 +33,3 @@ public:
void create() { m_data = std::make_unique<uint8_t[]>(size()); } void create() { m_data = std::make_unique<uint8_t[]>(size()); }
Image resize(int w, int h); Image resize(int w, int h);
}; };
}

2
src/log.h
View File

@@ -17,7 +17,7 @@ public:
bool m_running = false; bool m_running = false;
bool m_error = false; bool m_error = false;
std::thread m_thread; std::thread m_thread;
ui::BlockingQueue<std::string> m_mq; BlockingQueue<std::string> m_mq;
CURL *curl = nullptr; CURL *curl = nullptr;
CURLcode res; CURLcode res;
std::string readBuffer; std::string readBuffer;

10
src/main.cpp
View File

@@ -384,10 +384,10 @@ static void SetupExceptionHandler()
BT_AddLogFile(wpath); BT_AddLogFile(wpath);
BT_SetPreErrHandler([](INT_PTR){ BT_SetPreErrHandler([](INT_PTR){
if (ui::Canvas::I) if (Canvas::I)
{ {
auto path = App::I.data_path + "/recovery.ppi"; auto path = App::I.data_path + "/recovery.ppi";
ui::Canvas::I->project_save_thread(path); Canvas::I->project_save_thread(path);
static char abspath[MAX_PATH]; static char abspath[MAX_PATH];
GetFullPathNameA(path.c_str(), MAX_PATH, abspath, NULL); GetFullPathNameA(path.c_str(), MAX_PATH, abspath, NULL);
static char message[4096]; static char message[4096];
@@ -727,7 +727,7 @@ int main(int argc, char** argv)
if (a == Controller::Action::Press) if (a == Controller::Action::Press)
{ {
async_lock(); async_lock();
ui::Canvas::I->stroke_start(vive->controllers[0].pos * 800.f, vive->controllers[0].axis[1].x, ui::Canvas::I->m_current_brush); Canvas::I->stroke_start(vive->controllers[0].pos * 800.f, vive->controllers[0].axis[1].x, Canvas::I->m_current_brush);
async_unlock(); async_unlock();
controller_last_point = vive->controllers[0].pos * 800.f; controller_last_point = vive->controllers[0].pos * 800.f;
controller_points.clear(); controller_points.clear();
@@ -737,7 +737,7 @@ int main(int argc, char** argv)
{ {
trigger_down = false; trigger_down = false;
async_lock(); async_lock();
ui::Canvas::I->stroke_end(); Canvas::I->stroke_end();
async_unlock(); async_unlock();
} }
} }
@@ -763,7 +763,7 @@ int main(int argc, char** argv)
if (glm::distance(p, controller_last_point) > 1) if (glm::distance(p, controller_last_point) > 1)
{ {
async_lock(); async_lock();
ui::Canvas::I->stroke_update(p, vive->controllers[0].axis[1].x); Canvas::I->stroke_update(p, vive->controllers[0].axis[1].x);
async_unlock(); async_unlock();
controller_last_point = p; controller_last_point = p;
App::I.redraw = true; App::I.redraw = true;

11
src/node_border.cpp
View File

@@ -3,7 +3,7 @@
#include "node_border.h" #include "node_border.h"
#include "shader.h" #include "shader.h"
ui::Plane NodeBorder::m_plane; Plane NodeBorder::m_plane;
NodeBorder::NodeBorder() NodeBorder::NodeBorder()
{ {
@@ -60,14 +60,13 @@ void NodeBorder::parse_attributes(kAttribute ka, const tinyxml2::XMLAttribute* a
} }
void NodeBorder::draw() void NodeBorder::draw()
{ {
using namespace ui; ShaderManager::use(kShader::Color);
ui::ShaderManager::use(kShader::Color); ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
if (m_color.a > 0.f) if (m_color.a > 0.f)
{ {
m_color.a < 1.f ? glEnable(GL_BLEND) : glDisable(GL_BLEND); m_color.a < 1.f ? glEnable(GL_BLEND) : glDisable(GL_BLEND);
ui::ShaderManager::u_vec4(kShaderUniform::Col, m_color); ShaderManager::u_vec4(kShaderUniform::Col, m_color);
m_plane.draw_fill(); m_plane.draw_fill();
glDisable(GL_BLEND); glDisable(GL_BLEND);
} }
@@ -75,7 +74,7 @@ void NodeBorder::draw()
if (m_thinkness > 0 && m_border_color.a > 0.f) if (m_thinkness > 0 && m_border_color.a > 0.f)
{ {
glLineWidth(m_thinkness); glLineWidth(m_thinkness);
ui::ShaderManager::u_vec4(kShaderUniform::Col, m_border_color); ShaderManager::u_vec4(kShaderUniform::Col, m_border_color);
m_border_color.a < 1.f ? glEnable(GL_BLEND) : glDisable(GL_BLEND); m_border_color.a < 1.f ? glEnable(GL_BLEND) : glDisable(GL_BLEND);
m_plane.draw_stroke(); m_plane.draw_stroke();
glDisable(GL_BLEND); glDisable(GL_BLEND);

2
src/node_border.h
View File

@@ -5,7 +5,7 @@
class NodeBorder : public Node class NodeBorder : public Node
{ {
public: public:
static ui::Plane m_plane; static Plane m_plane;
glm::vec4 m_color{ 0, 0, 0, 1 }; glm::vec4 m_color{ 0, 0, 0, 1 };
glm::vec4 m_border_color{ 1, 1, 1, 1 }; glm::vec4 m_border_color{ 1, 1, 1, 1 };
float m_thinkness{ 0 }; float m_thinkness{ 0 };

137
src/node_canvas.cpp
View File

@@ -12,7 +12,7 @@ Node* NodeCanvas::clone_instantiate() const
void NodeCanvas::init() void NodeCanvas::init()
{ {
m_mouse_ignore = false; m_mouse_ignore = false;
m_canvas = std::make_unique<ui::Canvas>(); m_canvas = std::make_unique<Canvas>();
m_canvas->create(CANVAS_RES, CANVAS_RES); m_canvas->create(CANVAS_RES, CANVAS_RES);
m_canvas->m_unsaved = false; m_canvas->m_unsaved = false;
m_canvas->m_node = this; m_canvas->m_node = this;
@@ -26,8 +26,8 @@ void NodeCanvas::init()
m_line.create(); m_line.create();
CanvasMode::node = this; CanvasMode::node = this;
CanvasMode::canvas = m_canvas.get(); CanvasMode::canvas = m_canvas.get();
for (int i = 0; i < (int)ui::Canvas::kCanvasMode::COUNT; i++) for (int i = 0; i < (int)Canvas::kCanvasMode::COUNT; i++)
for (auto m : ui::Canvas::modes[i]) for (auto m : Canvas::modes[i])
m->init(); m->init();
m_grid.create(1, 1, m_grid_divs); m_grid.create(1, 1, m_grid_divs);
@@ -45,8 +45,8 @@ void NodeCanvas::restore_context()
m_canvas->snapshot_restore(); m_canvas->snapshot_restore();
CanvasMode::node = this; CanvasMode::node = this;
CanvasMode::canvas = m_canvas.get(); CanvasMode::canvas = m_canvas.get();
for (int i = 0; i < (int)ui::Canvas::kCanvasMode::COUNT; i++) for (int i = 0; i < (int)Canvas::kCanvasMode::COUNT; i++)
for (auto m : ui::Canvas::modes[i]) for (auto m : Canvas::modes[i])
m->init(); m->init();
} }
@@ -60,7 +60,6 @@ void NodeCanvas::clear_context()
void NodeCanvas::draw() void NodeCanvas::draw()
{ {
using namespace ui;
GLint vp[4]; GLint vp[4];
GLfloat cc[4]; GLfloat cc[4];
glGetIntegerv(GL_VIEWPORT, vp); glGetIntegerv(GL_VIEWPORT, vp);
@@ -109,8 +108,8 @@ void NodeCanvas::draw()
m_canvas->m_plane_transform[plane_index] * m_canvas->m_plane_transform[plane_index] *
glm::translate(glm::vec3(0, 0, -1)); glm::translate(glm::vec3(0, 0, -1));
ui::ShaderManager::use(kShader::Checkerboard); ShaderManager::use(kShader::Checkerboard);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
m_face_plane.draw_fill(); m_face_plane.draw_fill();
} }
@@ -144,18 +143,18 @@ void NodeCanvas::draw()
m_canvas->m_plane_transform[plane_index] * m_canvas->m_plane_transform[plane_index] *
glm::translate(glm::vec3(0, 0, -1)); glm::translate(glm::vec3(0, 0, -1));
if (m_canvas->m_current_stroke && m_canvas->m_state == ui::Canvas::kCanvasMode::Erase && m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index) if (m_canvas->m_current_stroke && m_canvas->m_state == Canvas::kCanvasMode::Erase && m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index)
{ {
m_sampler.bind(0); m_sampler.bind(0);
ui::ShaderManager::use(kShader::CompErase); ShaderManager::use(kShader::CompErase);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1); ShaderManager::u_int(kShaderUniform::TexStroke, 1);
//ui::ShaderManager::u_int(kShaderUniform::TexMask, 2); //ShaderManager::u_int(kShaderUniform::TexMask, 2);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_current_stroke->m_brush.m_tip_opacity); ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_current_stroke->m_brush.m_tip_opacity);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false); ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
//ui::ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked); //ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
//ui::ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active); //ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture(); m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1); glActiveTexture(GL_TEXTURE1);
@@ -173,18 +172,18 @@ void NodeCanvas::draw()
{ {
m_sampler.bind(0); m_sampler.bind(0);
auto& paper = TextureManager::get(const_hash("data/paper.jpg")); auto& paper = TextureManager::get(const_hash("data/paper.jpg"));
ui::ShaderManager::use(kShader::CompDraw); ShaderManager::use(kShader::CompDraw);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1); ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ui::ShaderManager::u_int(kShaderUniform::TexMask, 2); ShaderManager::u_int(kShaderUniform::TexMask, 2);
//ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, zw(m_canvas->m_box) / zoom); //ShaderManager::u_vec2(kShaderUniform::Resolution, zw(m_canvas->m_box) / zoom);
//ui::ShaderManager::u_int(kShaderUniform::TexStencil, 3); //ShaderManager::u_int(kShaderUniform::TexStencil, 3);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_current_stroke->m_brush.m_tip_opacity); ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_current_stroke->m_brush.m_tip_opacity);
ui::ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked); ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
ui::ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active); ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false); ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
ui::ShaderManager::u_int(kShaderUniform::BlendMode, m_canvas->m_current_stroke->m_brush.m_blend_mode); ShaderManager::u_int(kShaderUniform::BlendMode, m_canvas->m_current_stroke->m_brush.m_blend_mode);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture(); m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1); glActiveTexture(GL_TEXTURE1);
@@ -206,12 +205,12 @@ void NodeCanvas::draw()
{ {
m_sampler.bind(0); m_sampler.bind(0);
m_sampler_linear.bind(1); m_sampler_linear.bind(1);
ui::ShaderManager::use(kShader::TextureAlphaSep); ShaderManager::use(kShader::TextureAlphaSep);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexA, 1); ShaderManager::u_int(kShaderUniform::TexA, 1);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity); ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity);
ui::ShaderManager::u_int(kShaderUniform::Highlight, m_canvas->m_layers[layer_index].m_hightlight); ShaderManager::u_int(kShaderUniform::Highlight, m_canvas->m_layers[layer_index].m_hightlight);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture(); m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
@@ -229,11 +228,11 @@ void NodeCanvas::draw()
// if (m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index) // if (m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index)
// { // {
// glDisable(GL_BLEND); // glDisable(GL_BLEND);
// ui::ShaderManager::use(kShader::TextureAlpha); // ShaderManager::use(kShader::TextureAlpha);
// ui::ShaderManager::u_int(kShaderUniform::Tex, 0); // ShaderManager::u_int(kShaderUniform::Tex, 0);
// ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity); // ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity);
// ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z); // ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
// ui::ShaderManager::u_float(kShaderUniform::Alpha, 1); // ShaderManager::u_float(kShaderUniform::Alpha, 1);
// m_canvas->m_tmp[plane_index].bindTexture(); // m_canvas->m_tmp[plane_index].bindTexture();
// m_face_plane.draw_fill(); // m_face_plane.draw_fill();
// m_canvas->m_tmp[plane_index].unbindTexture(); // m_canvas->m_tmp[plane_index].unbindTexture();
@@ -253,11 +252,11 @@ void NodeCanvas::draw()
m_canvas->m_plane_transform[plane_index] * m_canvas->m_plane_transform[plane_index] *
glm::translate(glm::vec3(0, 0, -1)); glm::translate(glm::vec3(0, 0, -1));
ui::ShaderManager::use(kShader::TextureAlpha); ShaderManager::use(kShader::TextureAlpha);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_float(kShaderUniform::Alpha, 0.5f); ShaderManager::u_float(kShaderUniform::Alpha, 0.5f);
ui::ShaderManager::u_int(kShaderUniform::Highlight, 0); ShaderManager::u_int(kShaderUniform::Highlight, 0);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp); ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
m_canvas->m_smask.m_rtt[plane_index].bindTexture(); m_canvas->m_smask.m_rtt[plane_index].bindTexture();
m_face_plane.draw_fill(); m_face_plane.draw_fill();
@@ -276,8 +275,8 @@ void NodeCanvas::draw()
} }
// keep drawing the grids // keep drawing the grids
if (m_canvas->m_state != ui::Canvas::kCanvasMode::Grid) if (m_canvas->m_state != Canvas::kCanvasMode::Grid)
for (auto& mode : ui::Canvas::modes[(int)ui::Canvas::kCanvasMode::Grid]) for (auto& mode : Canvas::modes[(int)Canvas::kCanvasMode::Grid])
mode->on_Draw(ortho_proj, proj, camera); mode->on_Draw(ortho_proj, proj, camera);
@@ -287,7 +286,7 @@ void NodeCanvas::draw()
glClear(GL_DEPTH_BUFFER_BIT); glClear(GL_DEPTH_BUFFER_BIT);
// DRAW GRIDS // DRAW GRIDS
ui::ShaderManager::use(kShader::Color); ShaderManager::use(kShader::Color);
// ground grid // ground grid
int grid_divs = glm::floor(App::I.grid->m_groud_scale->get_value() * 100); int grid_divs = glm::floor(App::I.grid->m_groud_scale->get_value() * 100);
@@ -298,10 +297,10 @@ void NodeCanvas::draw()
} }
float grid_scale = m_grid_divs * 0.01f; float grid_scale = m_grid_divs * 0.01f;
ui::ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4( ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(
glm::vec3(App::I.grid->m_groud_value->get_value()), glm::vec3(App::I.grid->m_groud_value->get_value()),
App::I.grid->m_groud_opacity->get_value())); App::I.grid->m_groud_opacity->get_value()));
ui::ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera
* glm::translate(glm::vec3(0, glm::pow(App::I.grid->m_groud_height->get_value() - 0.5f, 3), 0)) * glm::translate(glm::vec3(0, glm::pow(App::I.grid->m_groud_height->get_value() - 0.5f, 3), 0))
* glm::eulerAngleX(glm::radians(90.f)) * glm::eulerAngleX(glm::radians(90.f))
* glm::scale(glm::vec3(grid_scale, grid_scale, 1)) * glm::scale(glm::vec3(grid_scale, grid_scale, 1))
@@ -315,10 +314,10 @@ void NodeCanvas::draw()
// box grid // box grid
// ceiling // ceiling
// ui::ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4( // ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(
// glm::vec3(App::I.grid->m_groud_value->get_value()), // glm::vec3(App::I.grid->m_groud_value->get_value()),
// App::I.grid->m_box_opacity->get_value())); // App::I.grid->m_box_opacity->get_value()));
// ui::ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera // ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera
// * glm::translate(glm::vec3(0, (App::I.grid->m_groud_height->get_value() + App::I.grid->m_box_height->get_value() - 0.5f) * 2.f, 0)) // * glm::translate(glm::vec3(0, (App::I.grid->m_groud_height->get_value() + App::I.grid->m_box_height->get_value() - 0.5f) * 2.f, 0))
// * glm::eulerAngleX(glm::radians(90.f)) // * glm::eulerAngleX(glm::radians(90.f))
// * glm::scale(glm::vec3(grid_scale, grid_scale, 1)) // * glm::scale(glm::vec3(grid_scale, grid_scale, 1))
@@ -326,16 +325,16 @@ void NodeCanvas::draw()
// m_grid.draw_stroke(); // m_grid.draw_stroke();
//ui::ShaderManager::use(kShader::Equirect); //ShaderManager::use(kShader::Equirect);
//ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(.5, .5, 1))); //ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(.5, .5, 1)));
//ui::ShaderManager::u_int(kShaderUniform::Tex, 0); //ShaderManager::u_int(kShaderUniform::Tex, 0);
//glBindTexture(GL_TEXTURE_CUBE_MAP, m_canvas->cube_id); //glBindTexture(GL_TEXTURE_CUBE_MAP, m_canvas->cube_id);
//m_face_plane.draw_fill(); //m_face_plane.draw_fill();
//glBindTexture(GL_TEXTURE_CUBE_MAP, 0); //glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
// ui::ShaderManager::use(kShader::Color); // ShaderManager::use(kShader::Color);
// ui::ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera); // ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
// ui::ShaderManager::u_vec4(kShaderUniform::Col, { 1, 0, 0, 1 }); // ShaderManager::u_vec4(kShaderUniform::Col, { 1, 0, 0, 1 });
// static glm::vec4 AB[4]{ {-.75, 0, -1, 1},{ -.75, 0, 1, 1 } }; // static glm::vec4 AB[4]{ {-.75, 0, -1, 1},{ -.75, 0, 1, 1 } };
// m_line.update_vertices(AB); // m_line.update_vertices(AB);
// m_line.draw_stroke(); // m_line.draw_stroke();
@@ -379,9 +378,9 @@ kEventResult NodeCanvas::handle_event(Event* e)
case kEventType::MouseMove: case kEventType::MouseMove:
if (stylus_eraser != me->m_eraser) if (stylus_eraser != me->m_eraser)
{ {
ui::Canvas::set_mode(me->m_eraser ? Canvas::set_mode(me->m_eraser ?
ui::Canvas::kCanvasMode::Erase : Canvas::kCanvasMode::Erase :
ui::Canvas::kCanvasMode::Draw); Canvas::kCanvasMode::Draw);
stylus_eraser = me->m_eraser; stylus_eraser = me->m_eraser;
} }
case kEventType::MouseScroll: case kEventType::MouseScroll:
@@ -396,7 +395,7 @@ kEventResult NodeCanvas::handle_event(Event* e)
break; break;
case kEventType::KeyDown: case kEventType::KeyDown:
if (ke->m_key == kKey::KeyE) if (ke->m_key == kKey::KeyE)
ui::Canvas::set_mode(ui::Canvas::kCanvasMode::Erase); Canvas::set_mode(Canvas::kCanvasMode::Erase);
if (ke->m_key == kKey::AndroidBack) if (ke->m_key == kKey::AndroidBack)
if (!ActionManager::empty()) if (!ActionManager::empty())
ActionManager::undo(); ActionManager::undo();
@@ -404,29 +403,29 @@ kEventResult NodeCanvas::handle_event(Event* e)
break; break;
case kEventType::KeyUp: case kEventType::KeyUp:
if (ke->m_key == kKey::KeyE) if (ke->m_key == kKey::KeyE)
ui::Canvas::set_mode(ui::Canvas::kCanvasMode::Draw); Canvas::set_mode(Canvas::kCanvasMode::Draw);
if (ke->m_key == kKey::KeyTab) if (ke->m_key == kKey::KeyTab)
App::I.toggle_ui(); App::I.toggle_ui();
if (ke->m_key == kKey::KeyZ && App::I.keys[(int)kKey::KeyCtrl]) if (ke->m_key == kKey::KeyZ && App::I.keys[(int)kKey::KeyCtrl])
App::I.keys[(int)kKey::KeyShift] ? ActionManager::redo() : ActionManager::undo(); App::I.keys[(int)kKey::KeyShift] ? ActionManager::redo() : ActionManager::undo();
if (ke->m_key == kKey::KeyS && App::I.keys[(int)kKey::KeyCtrl] && !App::I.keys[(int)kKey::KeyShift]) if (ke->m_key == kKey::KeyS && App::I.keys[(int)kKey::KeyCtrl] && !App::I.keys[(int)kKey::KeyShift])
{ {
if (ui::Canvas::I->m_newdoc) if (Canvas::I->m_newdoc)
{ {
App::I.dialog_save(); App::I.dialog_save();
} }
else if (ui::Canvas::I->m_unsaved) else if (Canvas::I->m_unsaved)
{ {
ui::Canvas::I->project_save(); Canvas::I->project_save();
} }
} }
if (ke->m_key == kKey::KeyS && App::I.keys[(int)kKey::KeyCtrl] && App::I.keys[(int)kKey::KeyShift]) if (ke->m_key == kKey::KeyS && App::I.keys[(int)kKey::KeyCtrl] && App::I.keys[(int)kKey::KeyShift])
{ {
if (ui::Canvas::I->m_newdoc) if (Canvas::I->m_newdoc)
{ {
App::I.dialog_save(); App::I.dialog_save();
} }
else if (ui::Canvas::I->m_unsaved) else if (Canvas::I->m_unsaved)
{ {
App::I.dialog_save_ver(); App::I.dialog_save_ver();
} }

8
src/node_canvas.h
View File

@@ -5,13 +5,13 @@
class NodeCanvas : public Node class NodeCanvas : public Node
{ {
public: public:
std::unique_ptr<ui::Canvas> m_canvas; std::unique_ptr<Canvas> m_canvas;
Sampler m_sampler; Sampler m_sampler;
Sampler m_sampler_linear; Sampler m_sampler_linear;
Sampler m_sampler_stencil; Sampler m_sampler_stencil;
ui::Plane m_face_plane; Plane m_face_plane;
ui::LineSegment m_line; LineSegment m_line;
ui::Plane m_grid; Plane m_grid;
int m_grid_divs = 30; int m_grid_divs = 30;
virtual Node* clone_instantiate() const override; virtual Node* clone_instantiate() const override;
virtual void init() override; virtual void init() override;

7
src/node_color_quad.cpp
View File

@@ -91,9 +91,8 @@ void NodeColorQuad::draw()
auto pos = glm::clamp(m_value * sz, { 0, 0 }, sz); auto pos = glm::clamp(m_value * sz, { 0, 0 }, sz);
m_picker->SetPosition(pos - m_picker->GetSize() * .5f); m_picker->SetPosition(pos - m_picker->GetSize() * .5f);
using namespace ui; ShaderManager::use(kShader::ColorQuad);
ui::ShaderManager::use(kShader::ColorQuad); ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp); ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(convert_rgb2hsv(glm::vec3(m_color)), 1));
ui::ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(convert_rgb2hsv(glm::vec3(m_color)), 1));
m_plane.draw_fill(); m_plane.draw_fill();
} }

6
src/node_colorwheel.cpp
View File

@@ -28,9 +28,9 @@ void NodeColorWheel::init_controls()
void NodeColorWheel::loaded() void NodeColorWheel::loaded()
{ {
m_circle.create<64>(.5, .4, ui::Circle::kUVMapping::Tube); m_circle.create<64>(.5, .4, Circle::kUVMapping::Tube);
m_cur_hue.create<16>(.05, 0.04); m_cur_hue.create<16>(.05, 0.04);
m_cur_quad.create<16>(.04, 0.03, ui::Circle::kUVMapping::Tube); m_cur_quad.create<16>(.04, 0.03, Circle::kUVMapping::Tube);
float quad_scale = glm::sin(glm::radians(45.f)) * 0.8f; float quad_scale = glm::sin(glm::radians(45.f)) * 0.8f;
m_quad.create<1>(quad_scale, quad_scale); m_quad.create<1>(quad_scale, quad_scale);
@@ -61,8 +61,6 @@ void NodeColorWheel::loaded()
void NodeColorWheel::draw() void NodeColorWheel::draw()
{ {
using namespace ui;
glDisable(GL_BLEND); glDisable(GL_BLEND);
ShaderManager::use(kShader::ColorHue); ShaderManager::use(kShader::ColorHue);
ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp * glm::eulerAngleZ(glm::radians(-90.f))); ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp * glm::eulerAngleZ(glm::radians(-90.f)));

8
src/node_colorwheel.h
View File

@@ -8,10 +8,10 @@
class NodeColorWheel : public Node class NodeColorWheel : public Node
{ {
public: public:
ui::Circle m_circle; Circle m_circle;
ui::Plane m_cur_hue; Plane m_cur_hue;
ui::Circle m_cur_quad; Circle m_cur_quad;
ui::Plane m_quad; Plane m_quad;
NodeBorder* m_color_cur; NodeBorder* m_color_cur;
glm::vec3 m_hsv; glm::vec3 m_hsv;
GLuint m_tri_vbo; GLuint m_tri_vbo;

2
src/node_dialog_browse.cpp
View File

@@ -135,7 +135,7 @@ void NodeDialogBrowse::init_list()
{ {
auto f_name = std::get<0>(f); auto f_name = std::get<0>(f);
auto f_path = std::get<1>(f); auto f_path = std::get<1>(f);
ui::Image thumb = ui::Canvas::I->thumbnail_read(f_path); Image thumb = Canvas::I->thumbnail_read(f_path);
if (thumb.width == 0 || thumb.height == 0) if (thumb.width == 0 || thumb.height == 0)
continue; continue;

2
src/node_dialog_cloud.cpp
View File

@@ -142,7 +142,7 @@ void NodeDialogCloud::load_thumbs_thread()
std::string rgb; std::string rgb;
rgb.resize(Base64::DecodedLength(info[3])); rgb.resize(Base64::DecodedLength(info[3]));
Base64::Decode(info[3], &rgb); Base64::Decode(info[3], &rgb);
ui::Image thumb; Image thumb;
thumb.create(width, height); thumb.create(width, height);
thumb.copy_from((uint8_t*)rgb.data()); thumb.copy_from((uint8_t*)rgb.data());

2
src/node_dialog_layer_rename.cpp
View File

@@ -36,7 +36,7 @@ void NodeDialogLayerRename::init_controls()
void NodeDialogLayerRename::loaded() void NodeDialogLayerRename::loaded()
{ {
// ui::Image thumb = ui::Canvas::I->thumbnail_read(data_path); // Image thumb = Canvas::I->thumbnail_read(data_path);
// auto image_tex = find<NodeImageTexture>("thumb-tex"); // auto image_tex = find<NodeImageTexture>("thumb-tex");
// image_tex->tex.create(thumb); // image_tex->tex.create(thumb);
} }

2
src/node_dialog_open.cpp
View File

@@ -81,7 +81,7 @@ void NodeDialogOpen::init_controls()
node->on_selected = [&](NodeDialogOpenItem* target) { node->on_selected = [&](NodeDialogOpenItem* target) {
if (target == current) if (target == current)
return; return;
ui::Image thumb = ui::Canvas::I->thumbnail_read(target->m_path); Image thumb = Canvas::I->thumbnail_read(target->m_path);
auto image_tex = find<NodeImageTexture>("thumb-tex"); auto image_tex = find<NodeImageTexture>("thumb-tex");
image_tex->tex.destroy(); image_tex->tex.destroy();
image_tex->tex.create(thumb); image_tex->tex.create(thumb);

2
src/node_dialog_picker.cpp
View File

@@ -25,7 +25,7 @@ void NodeColorPicker::init()
void NodeColorPicker::draw() void NodeColorPicker::draw()
{ {
NodeBorder::draw(); NodeBorder::draw();
// glm::vec3 rgb = glm::vec3(ui::Canvas::I->m_current_brush.m_tip_color); // glm::vec3 rgb = glm::vec3(Canvas::I->m_current_brush.m_tip_color);
// glm::vec3 hsv = convert_rgb2hsv(rgb); // glm::vec3 hsv = convert_rgb2hsv(rgb);
// m_slider_h->m_value.x = hsv.x; // m_slider_h->m_value.x = hsv.x;
// m_slider_s->m_value.x = hsv.y; // m_slider_s->m_value.x = hsv.y;

4
src/node_dialog_resize.cpp
View File

@@ -32,7 +32,7 @@ void NodeDialogResize::init_controls()
btn_cancel = find<NodeButton>("btn-cancel"); btn_cancel = find<NodeButton>("btn-cancel");
combo = find<NodeComboBox>("resolution"); combo = find<NodeComboBox>("resolution");
text = find<NodeText>("current-res"); text = find<NodeText>("current-res");
resolution = ui::Canvas::I->m_width; resolution = Canvas::I->m_width;
static char txt[128]; static char txt[128];
sprintf(txt, "Current: %s", App::I.res_to_string(resolution).c_str()); sprintf(txt, "Current: %s", App::I.res_to_string(resolution).c_str());
text->set_text(txt); text->set_text(txt);
@@ -43,7 +43,7 @@ void NodeDialogResize::init_controls()
void NodeDialogResize::loaded() void NodeDialogResize::loaded()
{ {
// ui::Image thumb = ui::Canvas::I->thumbnail_read(data_path); // Image thumb = Canvas::I->thumbnail_read(data_path);
// auto image_tex = find<NodeImageTexture>("thumb-tex"); // auto image_tex = find<NodeImageTexture>("thumb-tex");
// image_tex->tex.create(thumb); // image_tex->tex.create(thumb);
} }

15
src/node_image.cpp
View File

@@ -3,7 +3,7 @@
#include "node_image.h" #include "node_image.h"
#include "shader.h" #include "shader.h"
ui::Plane NodeImage::m_plane; Plane NodeImage::m_plane;
Sampler NodeImage::m_sampler; Sampler NodeImage::m_sampler;
Sampler NodeImage::m_sampler_mips; Sampler NodeImage::m_sampler_mips;
@@ -84,23 +84,22 @@ void NodeImage::parse_attributes(kAttribute ka, const tinyxml2::XMLAttribute* at
void NodeImage::draw() void NodeImage::draw()
{ {
using namespace ui;
TextureManager::get(m_tex_id).bind(); TextureManager::get(m_tex_id).bind();
auto& sampler = m_use_mipmaps ? m_sampler_mips : m_sampler; auto& sampler = m_use_mipmaps ? m_sampler_mips : m_sampler;
sampler.bind(0); sampler.bind(0);
glEnable(GL_BLEND); glEnable(GL_BLEND);
if (m_use_atlas) if (m_use_atlas)
{ {
ui::ShaderManager::use(kShader::Atlas); ShaderManager::use(kShader::Atlas);
ui::ShaderManager::u_vec2(kShaderUniform::Tof, m_off); ShaderManager::u_vec2(kShaderUniform::Tof, m_off);
ui::ShaderManager::u_vec2(kShaderUniform::Tsz, m_sz); ShaderManager::u_vec2(kShaderUniform::Tsz, m_sz);
} }
else else
{ {
ui::ShaderManager::use(kShader::Texture); ShaderManager::use(kShader::Texture);
} }
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp); ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
m_plane.draw_fill(); m_plane.draw_fill();
sampler.unbind(); sampler.unbind();
TextureManager::get(m_tex_id).unbind(); TextureManager::get(m_tex_id).unbind();

2
src/node_image.h
View File

@@ -6,7 +6,7 @@
class NodeImage : public Node class NodeImage : public Node
{ {
public: public:
static ui::Plane m_plane; static Plane m_plane;
static Sampler m_sampler; static Sampler m_sampler;
static Sampler m_sampler_mips; static Sampler m_sampler_mips;
bool m_use_atlas = false; bool m_use_atlas = false;

7
src/node_image_texture.cpp
View File

@@ -18,14 +18,13 @@ void NodeImageTexture::clone_copy(Node* dest) const
void NodeImageTexture::draw() void NodeImageTexture::draw()
{ {
using namespace ui;
tex.bind(); tex.bind();
auto& sampler = tex.has_mips ? NodeImage::m_sampler_mips : NodeImage::m_sampler; auto& sampler = tex.has_mips ? NodeImage::m_sampler_mips : NodeImage::m_sampler;
sampler.bind(0); sampler.bind(0);
glEnable(GL_BLEND); glEnable(GL_BLEND);
ui::ShaderManager::use(kShader::Texture); ShaderManager::use(kShader::Texture);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp); ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
NodeImage::m_plane.draw_fill(); NodeImage::m_plane.draw_fill();
sampler.unbind(); sampler.unbind();
tex.unbind(); tex.unbind();

2
src/node_panel_brush.cpp
View File

@@ -205,7 +205,7 @@ void NodePanelBrushPreset::handle_click(Node* target)
on_brush_changed(this, m_current->m_brushID); on_brush_changed(this, m_current->m_brushID);
} }
ui::Brush NodePanelBrushPreset::get_brush(int index) const Brush NodePanelBrushPreset::get_brush(int index) const
{ {
auto b = m_brushes[index]->m_brush; auto b = m_brushes[index]->m_brush;
TextureManager::load(m_brushes[index]->high_path.c_str(), true); TextureManager::load(m_brushes[index]->high_path.c_str(), true);

4
src/node_panel_brush.h
View File

@@ -43,7 +43,7 @@ class NodeBrushPresetItem : public NodeButtonCustom
{ {
public: public:
int m_brushID; int m_brushID;
ui::Brush m_brush; Brush m_brush;
std::string high_path; std::string high_path;
uint16_t high_id; uint16_t high_id;
bool m_selected = false; bool m_selected = false;
@@ -65,7 +65,7 @@ public:
virtual void init() override; virtual void init() override;
void handle_click(Node* target); void handle_click(Node* target);
uint16_t get_texture_id(int index) const; uint16_t get_texture_id(int index) const;
ui::Brush get_brush(int index) const; Brush get_brush(int index) const;
int get_brush_id(int index) const; int get_brush_id(int index) const;
}; };

2
src/node_panel_color.cpp
View File

@@ -55,5 +55,5 @@ void NodePanelColor::set_color(glm::vec3 rgb)
void NodePanelColor::added(Node* parent) void NodePanelColor::added(Node* parent)
{ {
set_color(ui::Canvas::I->m_current_brush.m_tip_color); set_color(Canvas::I->m_current_brush.m_tip_color);
} }

2
src/node_panel_grid.cpp
View File

@@ -49,7 +49,7 @@ void NodePanelGrid::init_controls()
m_hm_load->on_click = [this](Node*) { m_hm_load->on_click = [this](Node*) {
App::I.pick_image([this](std::string path) { App::I.pick_image([this](std::string path) {
ui::Image img; Image img;
if (img.load_file(path)) if (img.load_file(path))
{ {
m_hm_image = img.resize(128, 128); m_hm_image = img.resize(128, 128);

4
src/node_panel_grid.h
View File

@@ -25,8 +25,8 @@ public:
NodeButton* m_hm_load; NodeButton* m_hm_load;
NodeSliderH* m_hm_offset; NodeSliderH* m_hm_offset;
NodeSliderH* m_hm_height; NodeSliderH* m_hm_height;
ui::HeightmapPlane m_hm_plane; HeightmapPlane m_hm_plane;
ui::Image m_hm_image; Image m_hm_image;
virtual Node* clone_instantiate() const override; virtual Node* clone_instantiate() const override;
virtual void clone_finalize(Node* dest) const override; virtual void clone_finalize(Node* dest) const override;

74
src/node_panel_stroke.cpp
View File

@@ -22,7 +22,7 @@ void NodePanelStroke::init()
void NodePanelStroke::update_controls() void NodePanelStroke::update_controls()
{ {
const auto& b = ui::Canvas::I->m_current_brush; const auto& b = Canvas::I->m_current_brush;
m_tip_size->m_value.x = glm::pow(b.m_tip_size, 1.f/3.f); m_tip_size->m_value.x = glm::pow(b.m_tip_size, 1.f/3.f);
m_tip_spacing->m_value.x = glm::pow(b.m_tip_spacing, 1.f/2.f) / 4.f; m_tip_spacing->m_value.x = glm::pow(b.m_tip_spacing, 1.f/2.f) / 4.f;
m_tip_flow->m_value.x = glm::pow(b.m_tip_flow, 1.f/2.f); m_tip_flow->m_value.x = glm::pow(b.m_tip_flow, 1.f/2.f);
@@ -50,44 +50,44 @@ void NodePanelStroke::init_controls()
m_preview = find<NodeStrokePreview>("canvas"); m_preview = find<NodeStrokePreview>("canvas");
m_blend_mode = find<NodeComboBox>("blend-mode"); m_blend_mode = find<NodeComboBox>("blend-mode");
m_blend_mode->on_select = [](Node*, int index) { m_blend_mode->on_select = [](Node*, int index) {
ui::Canvas::I->m_current_brush.m_blend_mode = index; Canvas::I->m_current_brush.m_blend_mode = index;
}; };
init_slider(m_tip_size, "tip-size", &ui::Brush::m_tip_size); init_slider(m_tip_size, "tip-size", &Brush::m_tip_size);
init_slider(m_tip_spacing, "tip-spacing", &ui::Brush::m_tip_spacing); init_slider(m_tip_spacing, "tip-spacing", &Brush::m_tip_spacing);
init_slider(m_tip_flow, "tip-flow", &ui::Brush::m_tip_flow); init_slider(m_tip_flow, "tip-flow", &Brush::m_tip_flow);
init_slider(m_tip_opacity, "tip-opacity", &ui::Brush::m_tip_opacity); init_slider(m_tip_opacity, "tip-opacity", &Brush::m_tip_opacity);
init_slider(m_tip_angle, "tip-angle", &ui::Brush::m_tip_angle); init_slider(m_tip_angle, "tip-angle", &Brush::m_tip_angle);
init_slider(m_tip_mix, "tip-mix", &ui::Brush::m_tip_mix); init_slider(m_tip_mix, "tip-mix", &Brush::m_tip_mix);
init_slider(m_tip_stencil, "tip-stencil", &ui::Brush::m_tip_stencil); init_slider(m_tip_stencil, "tip-stencil", &Brush::m_tip_stencil);
init_slider(m_tip_wet, "tip-wet", &ui::Brush::m_tip_wet); init_slider(m_tip_wet, "tip-wet", &Brush::m_tip_wet);
init_slider(m_tip_noise, "tip-noise", &ui::Brush::m_tip_noise); init_slider(m_tip_noise, "tip-noise", &Brush::m_tip_noise);
init_slider(m_tip_hue, "tip-hue", &ui::Brush::m_tip_hue); init_slider(m_tip_hue, "tip-hue", &Brush::m_tip_hue);
init_slider(m_tip_sat, "tip-sat", &ui::Brush::m_tip_sat); init_slider(m_tip_sat, "tip-sat", &Brush::m_tip_sat);
init_slider(m_tip_val, "tip-val", &ui::Brush::m_tip_val); init_slider(m_tip_val, "tip-val", &Brush::m_tip_val);
init_slider(m_jitter_scale, "jitter-scale", &ui::Brush::m_jitter_scale); init_slider(m_jitter_scale, "jitter-scale", &Brush::m_jitter_scale);
init_slider(m_jitter_angle, "jitter-angle", &ui::Brush::m_jitter_angle); init_slider(m_jitter_angle, "jitter-angle", &Brush::m_jitter_angle);
init_slider(m_jitter_spread, "jitter-spread", &ui::Brush::m_jitter_spread); init_slider(m_jitter_spread, "jitter-spread", &Brush::m_jitter_spread);
init_slider(m_jitter_flow, "jitter-flow", &ui::Brush::m_jitter_flow); init_slider(m_jitter_flow, "jitter-flow", &Brush::m_jitter_flow);
init_slider(m_jitter_hue, "jitter-hue", &ui::Brush::m_jitter_hue); init_slider(m_jitter_hue, "jitter-hue", &Brush::m_jitter_hue);
init_slider(m_jitter_sat, "jitter-sat", &ui::Brush::m_jitter_sat); init_slider(m_jitter_sat, "jitter-sat", &Brush::m_jitter_sat);
init_slider(m_jitter_val, "jitter-val", &ui::Brush::m_jitter_val); init_slider(m_jitter_val, "jitter-val", &Brush::m_jitter_val);
m_curves[m_tip_size] = [](float v){ return glm::pow(v, 3.f); }; m_curves[m_tip_size] = [](float v){ return glm::pow(v, 3.f); };
m_curves[m_tip_spacing] = [](float v){ return glm::pow(v * 4.f, 2.f); }; m_curves[m_tip_spacing] = [](float v){ return glm::pow(v * 4.f, 2.f); };
m_curves[m_tip_flow] = [](float v){ return glm::pow(v, 2.f); }; m_curves[m_tip_flow] = [](float v){ return glm::pow(v, 2.f); };
init_checkbox(m_tip_angle_follow, "tip-angle-follow", &ui::Brush::m_tip_angle_follow); init_checkbox(m_tip_angle_follow, "tip-angle-follow", &Brush::m_tip_angle_follow);
init_checkbox(m_tip_flow_pressure, "tip-flow-pressure", &ui::Brush::m_tip_flow_pressure); init_checkbox(m_tip_flow_pressure, "tip-flow-pressure", &Brush::m_tip_flow_pressure);
init_checkbox(m_tip_size_pressure, "tip-size-pressure", &ui::Brush::m_tip_size_pressure); init_checkbox(m_tip_size_pressure, "tip-size-pressure", &Brush::m_tip_size_pressure);
init_checkbox(m_tip_hue_pressure, "tip-hue-pressure", &ui::Brush::m_tip_hue_pressure); init_checkbox(m_tip_hue_pressure, "tip-hue-pressure", &Brush::m_tip_hue_pressure);
init_checkbox(m_tip_sat_pressure, "tip-sat-pressure", &ui::Brush::m_tip_sat_pressure); init_checkbox(m_tip_sat_pressure, "tip-sat-pressure", &Brush::m_tip_sat_pressure);
init_checkbox(m_tip_val_pressure, "tip-val-pressure", &ui::Brush::m_tip_val_pressure); init_checkbox(m_tip_val_pressure, "tip-val-pressure", &Brush::m_tip_val_pressure);
m_preview->m_brush = ui::Canvas::I->m_current_brush; m_preview->m_brush = Canvas::I->m_current_brush;
m_preview->draw_stroke(); m_preview->draw_stroke();
} }
void NodePanelStroke::init_slider(NodeSliderH*& target, const char* id, float ui::Brush::* prop) void NodePanelStroke::init_slider(NodeSliderH*& target, const char* id, float Brush::* prop)
{ {
target = find<NodeSliderH>(id); target = find<NodeSliderH>(id);
target->on_value_changed = std::bind(&NodePanelStroke::handle_slide, target->on_value_changed = std::bind(&NodePanelStroke::handle_slide,
@@ -95,28 +95,28 @@ void NodePanelStroke::init_slider(NodeSliderH*& target, const char* id, float ui
//m_canvas->m_brush.*prop = target->m_value.x; //m_canvas->m_brush.*prop = target->m_value.x;
} }
void NodePanelStroke::handle_slide(float ui::Brush::* prop, Node* target, float value) void NodePanelStroke::handle_slide(float Brush::* prop, Node* target, float value)
{ {
auto curve = m_curves.find((NodeSliderH*)target); auto curve = m_curves.find((NodeSliderH*)target);
ui::Canvas::I->m_current_brush.*prop = curve != m_curves.end() ? curve->second(value) : value; Canvas::I->m_current_brush.*prop = curve != m_curves.end() ? curve->second(value) : value;
m_preview->m_brush = ui::Canvas::I->m_current_brush; m_preview->m_brush = Canvas::I->m_current_brush;
m_preview->draw_stroke(); m_preview->draw_stroke();
if (on_stroke_change) if (on_stroke_change)
on_stroke_change(this); on_stroke_change(this);
} }
void NodePanelStroke::init_checkbox(NodeCheckBox*& target, const char* id, bool ui::Brush::* prop) void NodePanelStroke::init_checkbox(NodeCheckBox*& target, const char* id, bool Brush::* prop)
{ {
target = find<NodeCheckBox>(id); target = find<NodeCheckBox>(id);
target->on_value_changed = std::bind(&NodePanelStroke::handle_checkbox, target->on_value_changed = std::bind(&NodePanelStroke::handle_checkbox,
this, prop, std::placeholders::_1, std::placeholders::_2); this, prop, std::placeholders::_1, std::placeholders::_2);
ui::Canvas::I->m_current_brush.*prop = target->checked; Canvas::I->m_current_brush.*prop = target->checked;
} }
void NodePanelStroke::handle_checkbox(bool ui::Brush::* prop, Node *target, bool value) void NodePanelStroke::handle_checkbox(bool Brush::* prop, Node *target, bool value)
{ {
ui::Canvas::I->m_current_brush.*prop = value; Canvas::I->m_current_brush.*prop = value;
m_preview->m_brush = ui::Canvas::I->m_current_brush; m_preview->m_brush = Canvas::I->m_current_brush;
m_preview->draw_stroke(); m_preview->draw_stroke();
if (on_stroke_change) if (on_stroke_change)
on_stroke_change(this); on_stroke_change(this);

8
src/node_panel_stroke.h
View File

@@ -45,9 +45,9 @@ public:
void init_controls(); void init_controls();
void update_controls(); void update_controls();
void init_slider(NodeSliderH*& slider, const char* id, float ui::Brush::* prop); void init_slider(NodeSliderH*& slider, const char* id, float Brush::* prop);
void handle_slide(float ui::Brush::* prop, Node* target, float value); void handle_slide(float Brush::* prop, Node* target, float value);
void init_checkbox(NodeCheckBox*& slider, const char* id, bool ui::Brush::* prop); void init_checkbox(NodeCheckBox*& slider, const char* id, bool Brush::* prop);
void handle_checkbox(bool ui::Brush::* prop, Node* target, bool value); void handle_checkbox(bool Brush::* prop, Node* target, bool value);
}; };

16
src/node_slider.cpp
View File

@@ -27,16 +27,15 @@ void NodeSliderH::draw()
{ {
NodeBorder::draw(); NodeBorder::draw();
using namespace ui;
auto sz = GetSize(); auto sz = GetSize();
glm::vec2 cur_size = sz * (1.f - m_mask) + m_mask * glm::vec2(10); glm::vec2 cur_size = sz * (1.f - m_mask) + m_mask * glm::vec2(10);
glm::mat4 scale = glm::scale(glm::vec3(cur_size, 1.f)); glm::mat4 scale = glm::scale(glm::vec3(cur_size, 1.f));
glm::mat4 pos = glm::translate(glm::vec3(m_value * m_mask * sz + m_pos + sz * .5f * (1.f - m_mask), 0)); glm::mat4 pos = glm::translate(glm::vec3(m_value * m_mask * sz + m_pos + sz * .5f * (1.f - m_mask), 0));
auto mvp = m_proj * pos * scale; auto mvp = m_proj * pos * scale;
ui::ShaderManager::use(kShader::Color); ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp); ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 }); ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
m_plane.draw_fill(); m_plane.draw_fill();
} }
@@ -149,11 +148,10 @@ glm::vec4 NodeSliderHue::get_hue()
void NodeSliderHue::draw() void NodeSliderHue::draw()
{ {
using namespace ui; ShaderManager::use(kShader::ColorHue);
ui::ShaderManager::use(kShader::ColorHue); ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp); //ShaderManager::u_vec4(kShaderUniform::Col, m_color);
//ui::ShaderManager::u_vec4(kShaderUniform::Col, m_color); ShaderManager::u_int(kShaderUniform::Direction, 1); // set vertical
ui::ShaderManager::u_int(kShaderUniform::Direction, 1); // set vertical
m_plane.draw_fill(); m_plane.draw_fill();
NodeBorder::m_color = glm::vec4(0); NodeBorder::m_color = glm::vec4(0);
NodeSliderH::draw(); NodeSliderH::draw();

14
src/node_stroke_preview.cpp
View File

@@ -34,7 +34,7 @@ void NodeStrokePreview::init_controls()
m_sampler_brush.create(); m_sampler_brush.create();
m_sampler_brush.set_filter(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR); m_sampler_brush.set_filter(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
// TextureManager::load("data/thumbs/Round-Hard.png"); // TextureManager::load("data/thumbs/Round-Hard.png");
// ui::Canvas::I->m_current_brush.m_tex_id = const_hash("data/thumbs/Round-Hard.png"); // Canvas::I->m_current_brush.m_tex_id = const_hash("data/thumbs/Round-Hard.png");
} }
void NodeStrokePreview::restore_context() void NodeStrokePreview::restore_context()
@@ -56,7 +56,6 @@ void NodeStrokePreview::draw_stroke()
{ {
m_rtt.bindFramebuffer(); m_rtt.bindFramebuffer();
{ {
using namespace ui;
GLint vp[4]; GLint vp[4];
GLfloat cc[4]; GLfloat cc[4];
glGetIntegerv(GL_VIEWPORT, vp); glGetIntegerv(GL_VIEWPORT, vp);
@@ -69,8 +68,8 @@ void NodeStrokePreview::draw_stroke()
glm::mat4 proj = glm::ortho<float>(0, (float)m_rtt.getWidth(), 0, (float)m_rtt.getHeight(), -1, 1); glm::mat4 proj = glm::ortho<float>(0, (float)m_rtt.getWidth(), 0, (float)m_rtt.getHeight(), -1, 1);
auto b = m_brush; auto b = m_brush;
m_stroke.m_camera.fov = ui::Canvas::I->m_cam_fov; m_stroke.m_camera.fov = Canvas::I->m_cam_fov;
m_stroke.m_camera.rot = ui::Canvas::I->m_cam_rot; m_stroke.m_camera.rot = Canvas::I->m_cam_rot;
m_stroke.reset(); m_stroke.reset();
m_stroke.start(b); m_stroke.start(b);
if (!m_stroke.m_keypoints.empty()) if (!m_stroke.m_keypoints.empty())
@@ -127,10 +126,9 @@ void NodeStrokePreview::draw_stroke()
void NodeStrokePreview::draw() void NodeStrokePreview::draw()
{ {
using namespace ui; ShaderManager::use(kShader::Texture);
ui::ShaderManager::use(kShader::Texture); ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
m_rtt.bindTexture(); m_rtt.bindTexture();
m_sampler.bind(0); m_sampler.bind(0);
m_plane.draw_fill(); m_plane.draw_fill();

6
src/node_stroke_preview.h
View File

@@ -9,10 +9,10 @@ class NodeStrokePreview : public NodeBorder
RTT m_rtt; RTT m_rtt;
Sampler m_sampler; Sampler m_sampler;
Sampler m_sampler_brush; Sampler m_sampler_brush;
ui::BrushMesh m_mesh; BrushMesh m_mesh;
public: public:
ui::Brush m_brush; Brush m_brush;
ui::Stroke m_stroke; Stroke m_stroke;
std::vector<glm::vec2> m_bez_points; std::vector<glm::vec2> m_bez_points;
virtual Node* clone_instantiate() const override; virtual Node* clone_instantiate() const override;
virtual void clone_copy(Node* dest) const override; virtual void clone_copy(Node* dest) const override;

9
src/node_text.cpp
View File

@@ -102,13 +102,12 @@ void NodeText::set_text_format(const char* fmt, ...)
void NodeText::draw() void NodeText::draw()
{ {
using namespace ui;
glm::mat4 pos = glm::translate(glm::vec3(glm::floor(m_pos), 0)); glm::mat4 pos = glm::translate(glm::vec3(glm::floor(m_pos), 0));
m_mvp = m_proj * pos; m_mvp = m_proj * pos;
ui::ShaderManager::use(kShader::Font); ShaderManager::use(kShader::Font);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp); ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ui::ShaderManager::u_vec4(kShaderUniform::Col, m_color); ShaderManager::u_vec4(kShaderUniform::Col, m_color);
glEnable(GL_BLEND); glEnable(GL_BLEND);
m_text_mesh.draw(); m_text_mesh.draw();
glDisable(GL_BLEND); glDisable(GL_BLEND);

9
src/node_viewport.cpp
View File

@@ -5,7 +5,6 @@
void NodeViewport::draw() void NodeViewport::draw()
{ {
using namespace ui;
glm::mat4 cam = glm::lookAt(glm::vec3(sinf(angle) * 10, 0, -10), glm::vec3(0, 0, 0), glm::vec3(0, -1, 0)); glm::mat4 cam = glm::lookAt(glm::vec3(sinf(angle) * 10, 0, -10), glm::vec3(0, 0, 0), glm::vec3(0, -1, 0));
glm::mat4 proj = glm::perspective<float>(glm::radians(45.f), m_clip.z / m_clip.w, .1f, 100); glm::mat4 proj = glm::perspective<float>(glm::radians(45.f), m_clip.z / m_clip.w, .1f, 100);
@@ -22,9 +21,9 @@ void NodeViewport::draw()
TextureManager::get(m_tex_id).bind(); TextureManager::get(m_tex_id).bind();
m_sampler->bind(0); m_sampler->bind(0);
glEnable(GL_BLEND); glEnable(GL_BLEND);
ui::ShaderManager::use(kShader::Texture); ShaderManager::use(kShader::Texture);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, proj * cam); ShaderManager::u_mat4(kShaderUniform::MVP, proj * cam);
m_faces->draw_fill(); m_faces->draw_fill();
m_sampler->unbind(); m_sampler->unbind();
TextureManager::get(m_tex_id).unbind(); TextureManager::get(m_tex_id).unbind();
@@ -39,7 +38,7 @@ Node* NodeViewport::clone_instantiate() const
} }
void NodeViewport::create() void NodeViewport::create()
{ {
m_faces = std::make_unique<ui::Plane>(); m_faces = std::make_unique<Plane>();
m_faces->create<1>(10, 10); m_faces->create<1>(10, 10);
m_sampler = std::make_unique<Sampler>(); m_sampler = std::make_unique<Sampler>();
m_sampler->create(); m_sampler->create();

2
src/node_viewport.h
View File

@@ -7,7 +7,7 @@
class NodeViewport : public Node class NodeViewport : public Node
{ {
public: public:
std::unique_ptr<ui::Plane> m_faces; std::unique_ptr<Plane> m_faces;
std::unique_ptr<Sampler> m_sampler; std::unique_ptr<Sampler> m_sampler;
uint16_t m_tex_id; uint16_t m_tex_id;
glm::vec2 drag_start; glm::vec2 drag_start;

2
src/pch.h
View File

@@ -72,8 +72,6 @@
#endif #endif
#define NS_START namespace ui {
#define NS_END }
#define SIXPLETTE(I) {I, I, I, I, I, I} #define SIXPLETTE(I) {I, I, I, I, I, I}
#ifdef __cplusplus #ifdef __cplusplus

8
src/shader.cpp
View File

@@ -2,8 +2,6 @@
#include "log.h" #include "log.h"
#include "shader.h" #include "shader.h"
using namespace ui;
std::map<kShader, Shader> ShaderManager::m_shaders; std::map<kShader, Shader> ShaderManager::m_shaders;
Shader* ShaderManager::m_current; Shader* ShaderManager::m_current;
@@ -146,7 +144,7 @@ void Shader::u_float(kShaderUniform id, float f)
LOG("UNIFORM float %d NOT FOUND in shader %d", (int)id, (int)name) LOG("UNIFORM float %d NOT FOUND in shader %d", (int)id, (int)name)
else glUniform1f(m_umap[id], f); else glUniform1f(m_umap[id], f);
} }
GLint ui::Shader::GetAttribLocation(const char* name) GLint Shader::GetAttribLocation(const char* name)
{ {
return glGetAttribLocation(prog, name); return glGetAttribLocation(prog, name);
} }
@@ -188,13 +186,13 @@ void ShaderManager::u_int(kShaderUniform id, int i)
m_current->u_int(id, i); m_current->u_int(id, i);
} }
Shader* ui::ShaderManager::get(kShader id) Shader* ShaderManager::get(kShader id)
{ {
auto it = m_shaders.find(id); auto it = m_shaders.find(id);
return (it == m_shaders.end()) ? nullptr : &it->second; return (it == m_shaders.end()) ? nullptr : &it->second;
} }
void ui::ShaderManager::u_float(kShaderUniform id, float f) void ShaderManager::u_float(kShaderUniform id, float f)
{ {
m_current->u_float(id, f); m_current->u_float(id, f);
} }

4
src/shader.h
View File

@@ -1,8 +1,6 @@
#pragma once #pragma once
#include "util.h" #include "util.h"
namespace ui {
enum class kShaderUniform : uint16_t enum class kShaderUniform : uint16_t
{ {
MVP = const_hash("mvp"), MVP = const_hash("mvp"),
@@ -88,5 +86,3 @@ public:
static void u_float(kShaderUniform id, float f); static void u_float(kShaderUniform id, float f);
static void invalidate(); static void invalidate();
}; };
}

14
src/shape.cpp
View File

@@ -2,16 +2,14 @@
#include "log.h" #include "log.h"
#include "shape.h" #include "shape.h"
using namespace ui; bool Shape::create_buffers(GLushort * idx, GLvoid * vertices, int isize, int vsize)
bool ui::Shape::create_buffers(GLushort * idx, GLvoid * vertices, int isize, int vsize)
{ {
index_type = GL_UNSIGNED_SHORT; index_type = GL_UNSIGNED_SHORT;
create_buffers_imp(idx, vertices, isize, vsize); create_buffers_imp(idx, vertices, isize, vsize);
return false; return false;
} }
bool ui::Shape::create_buffers(GLuint* idx, GLvoid * vertices, int isize, int vsize) bool Shape::create_buffers(GLuint* idx, GLvoid * vertices, int isize, int vsize)
{ {
index_type = GL_UNSIGNED_INT; index_type = GL_UNSIGNED_INT;
create_buffers_imp(idx, vertices, isize, vsize); create_buffers_imp(idx, vertices, isize, vsize);
@@ -239,7 +237,7 @@ void Plane::create_impl(float w, float h, int div, GLushort *idx, vertex_t *vert
} }
} }
bool ui::HeightmapPlane::create(float w, float h, const Image& img, float scale) bool HeightmapPlane::create(float w, float h, const Image& img, float scale)
{ {
int div = img.width - 1; // TODO: handle height also int div = img.width - 1; // TODO: handle height also
int idx_size = (div * div * 6) + (div * (div + 1) * 4); int idx_size = (div * div * 6) + (div * (div + 1) * 4);
@@ -313,7 +311,7 @@ bool ui::HeightmapPlane::create(float w, float h, const Image& img, float scale)
return create_buffers(idx.get(), vertices.get(), sizeof(GLuint) * idx_size, sizeof(vertex_t) * vertices_size); return create_buffers(idx.get(), vertices.get(), sizeof(GLuint) * idx_size, sizeof(vertex_t) * vertices_size);
} }
void ui::Plane::update_vertices(const glm::vec4* data, const glm::vec2* uvs, const glm::vec2* uvs2) void Plane::update_vertices(const glm::vec4* data, const glm::vec2* uvs, const glm::vec2* uvs2)
{ {
static vertex_t vertices[4]; static vertex_t vertices[4];
@@ -605,7 +603,7 @@ void Sphere::create_impl(int rings, int sectors, float radius,
*i++ = (r+1) * sectors + s; *i++ = (r+1) * sectors + s;
} }
} }
void ui::LineSegment::update_vertices(const glm::vec4 data[2]) void LineSegment::update_vertices(const glm::vec4 data[2])
{ {
static vertex_t vertices[2]; static vertex_t vertices[2];
vertices[0] = { data[0], { 0, 0 } }; // A vertices[0] = { data[0], { 0, 0 } }; // A
@@ -614,7 +612,7 @@ void ui::LineSegment::update_vertices(const glm::vec4 data[2])
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
} }
void ui::DynamicShape::update_vertices(vertex_t* vertices, int vcount) void DynamicShape::update_vertices(vertex_t* vertices, int vcount)
{ {
count[0] = vcount; count[0] = vcount;
count[1] = vcount; count[1] = vcount;

4
src/shape.h
View File

@@ -9,8 +9,6 @@ enum class kShapeType : uint16_t
Slice9 = const_hash("slice9"), Slice9 = const_hash("slice9"),
}; };
namespace ui {
class Shape class Shape
{ {
protected: protected:
@@ -221,5 +219,3 @@ public:
return create_buffers(idx.get(), vertices.get(), rings * sectors * 6 * sizeof(GLushort), rings * sectors * sizeof(vertex_t)); return create_buffers(idx.get(), vertices.get(), rings * sectors * 6 * sizeof(GLushort), rings * sectors * sizeof(vertex_t));
} }
}; };
}

6
src/texture.cpp
View File

@@ -53,7 +53,7 @@ bool Texture2D::create(int width, int height, GLint internal_format, GLint forma
unbind(); unbind();
return true; return true;
} }
bool Texture2D::create(const ui::Image& img) bool Texture2D::create(const Image& img)
{ {
static GLint formats[] = { GL_RED, GL_RG, GL_RGB, GL_RGBA }; static GLint formats[] = { GL_RED, GL_RG, GL_RGB, GL_RGBA };
static GLint iformats[] = { GL_R8, GL_RG8, GL_RGB8, GL_RGBA8 }; static GLint iformats[] = { GL_R8, GL_RG8, GL_RGB8, GL_RGBA8 };
@@ -80,7 +80,7 @@ void Texture2D::assign(GLuint tex, int w/* = -1*/, int h/* = -1*/, GLuint intern
bool Texture2D::load(std::string filename) bool Texture2D::load(std::string filename)
{ {
LOG("load texture %s", filename.c_str()); LOG("load texture %s", filename.c_str());
ui::Image img; Image img;
if (!img.load(filename)) if (!img.load(filename))
return false; return false;
return create(img); return create(img);
@@ -89,7 +89,7 @@ bool Texture2D::load(std::string filename)
bool Texture2D::load_file(std::string filename) bool Texture2D::load_file(std::string filename)
{ {
LOG("load texture %s", filename.c_str()); LOG("load texture %s", filename.c_str());
ui::Image img; Image img;
if (!img.load_file(filename)) if (!img.load_file(filename))
return false; return false;
return create(img); return create(img);

2
src/texture.h
View File

@@ -11,7 +11,7 @@ class Texture2D
public: public:
bool has_mips = false; bool has_mips = false;
bool create(int width, int height, GLint internal_format = GL_RGBA8, GLint format = GL_RGBA, const uint8_t* data = nullptr); bool create(int width, int height, GLint internal_format = GL_RGBA8, GLint format = GL_RGBA, const uint8_t* data = nullptr);
bool create(const ui::Image& img); bool create(const Image& img);
void assign(GLuint tex, int w = -1, int h = -1, GLuint internal_format = GL_RGBA8, GLuint format = GL_RGBA); void assign(GLuint tex, int w = -1, int h = -1, GLuint internal_format = GL_RGBA8, GLuint format = GL_RGBA);
bool load(std::string filename); bool load(std::string filename);
bool load_file(std::string filename); bool load_file(std::string filename);

3
src/util.h
View File

@@ -115,7 +115,6 @@ template<typename T, int N> struct cbuffer
} }
}; };
NS_START
template<typename T, int Max = 0> template<typename T, int Max = 0>
class BlockingQueue class BlockingQueue
{ {
@@ -216,5 +215,3 @@ struct gl_state
glBindTexture(GL_TEXTURE_CUBE_MAP, cube); glBindTexture(GL_TEXTURE_CUBE_MAP, cube);
} }
}; };
NS_END