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;
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_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();
//LOG("History: %.2f KB", I.m_memory / 1024.f);
App::I.update_memory_usage(I.m_memory);
@@ -37,11 +37,11 @@ void ActionManager::redo()
return;
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_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();
//LOG("History: %.2f KB", I.m_memory / 1024.f);
App::I.update_memory_usage(I.m_memory);

12
src/app.cpp
View File

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

4
src/app.h
View File

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

6
src/app_cloud.cpp
View File

@@ -4,13 +4,11 @@
#include "node_progress_bar.h"
#include "node_dialog_cloud.h"
using namespace ui;
void App::cloud_upload()
{
if (!canvas)
return;
if (ui::Canvas::I->m_newdoc)
if (Canvas::I->m_newdoc)
{
auto msgbox = new NodeMessageBox();
msgbox->m_manager = &layout;
@@ -23,7 +21,7 @@ void App::cloud_upload()
else
{
auto upload_thread = [this] {
if (ui::Canvas::I->m_unsaved)
if (Canvas::I->m_unsaved)
{
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);
glBlendEquation(GL_FUNC_ADD);
ui::Canvas* canvas = new ui::Canvas;
Canvas* canvas = new Canvas;
canvas->create(CANVAS_RES, CANVAS_RES);
canvas->project_open_thread(pano_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 (ui::Canvas::I->m_unsaved)
if (Canvas::I->m_unsaved)
{
auto m = layout[main_id]->add_child<NodeMessageBox>();
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_cancel->m_text->set_text("No");
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)
show_dialog();
else
@@ -218,7 +218,7 @@ void App::dialog_open()
if (canvas)
{
if (ui::Canvas::I->m_unsaved)
if (Canvas::I->m_unsaved)
{
auto m = layout[main_id]->add_child<NodeMessageBox>();
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_cancel->m_text->set_text("No");
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)
show_dialog();
else
@@ -278,7 +278,7 @@ void App::dialog_browse()
if (canvas)
{
if (ui::Canvas::I->m_unsaved)
if (Canvas::I->m_unsaved)
{
auto m = layout[main_id]->add_child<NodeMessageBox>();
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_cancel->m_text->set_text("No");
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)
show_dialog();
else

2
src/app_events.cpp
View File

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

38
src/app_layout.cpp
View File

@@ -6,8 +6,6 @@
#include "node_progress_bar.h"
#include "node_dialog_picker.h"
using namespace ui;
static glm::vec4 color_button_normal{ .1, .1, .1, 1 };
static glm::vec4 color_button_hlight{ 1, .0, .0, 1 };
@@ -139,26 +137,26 @@ void App::init_sidebar()
// 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();
// }
brushes->on_brush_changed = [this](Node* target, int index) {
ui::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.m_tex_id = brushes->get_texture_id(index);
Canvas::I->m_current_brush.id = brushes->get_brush_id(index);
stroke->m_preview->draw_stroke();
};
presets->on_brush_changed = [this](Node* target, int index) {
auto b = presets->get_brush(index);
// don't change some params
b.m_tip_size = ui::Canvas::I->m_current_brush.m_tip_size;
b.m_tip_color = ui::Canvas::I->m_current_brush.m_tip_color;
ui::Canvas::I->m_current_brush = b;
b.m_tip_size = Canvas::I->m_current_brush.m_tip_size;
b.m_tip_color = Canvas::I->m_current_brush.m_tip_color;
Canvas::I->m_current_brush = b;
stroke->m_preview->draw_stroke();
};
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) {
@@ -224,7 +222,7 @@ void App::init_sidebar()
panels->fix_scroll();
button->set_color(panels->get_child_index(color.get()) == -1 ? color_button_normal : color_button_hlight);
// 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"))
@@ -318,7 +316,7 @@ void App::init_toolbar_draw()
{
button->on_click = [this, button](Node*) {
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;
Canvas::set_mode(Canvas::kCanvasMode::Transform);
};
@@ -327,7 +325,7 @@ void App::init_toolbar_draw()
{
button->on_click = [this, button](Node*) {
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;
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"))
{
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
{
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_source_image = std::move(img);
Canvas::set_mode(Canvas::kCanvasMode::Transform);
@@ -423,11 +421,11 @@ void App::init_menu_file()
};
if (auto b = popup->find<NodeButtonCustom>("file-save"))
b->on_click = [this](Node*) {
if (ui::Canvas::I->m_newdoc)
if (Canvas::I->m_newdoc)
{
dialog_save();
}
else if(ui::Canvas::I->m_unsaved)
else if(Canvas::I->m_unsaved)
{
canvas->m_canvas->project_save();
}
@@ -442,7 +440,7 @@ void App::init_menu_file()
};
if (auto b = popup->find<NodeButtonCustom>("file-save-ver"))
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->destroy();
};
@@ -632,7 +630,7 @@ void App::init_menu_layer()
popup->m_flood_events = true;
popup->m_capture_children = false;
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();
popup->mouse_release();
popup->destroy();
@@ -746,7 +744,7 @@ void App::initLayout()
b.m_tip_flow = .5f;
b.m_tip_spacing = .1f;
b.m_tip_opacity = 1.f;
ui::Canvas::I->m_current_brush = b;
Canvas::I->m_current_brush = b;
brush_update();
@@ -782,7 +780,7 @@ void App::initLayout()
auto frame_text = layout[main_id]->find<NodeText>("timeline-frame");
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++)
{

2
src/app_shaders.cpp
View File

@@ -2,8 +2,6 @@
#include "app.h"
#include "shader.h"
using namespace ui;
void App::initShaders()
{
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)
{
using namespace ui;
//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 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] *
glm::translate(glm::vec3(0, 0, -1));
ui::ShaderManager::use(kShader::Checkerboard);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
ShaderManager::use(kShader::Checkerboard);
ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
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] *
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);
ui::ShaderManager::use(kShader::CompErase);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
//ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
ui::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);
//ui::ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
ShaderManager::use(kShader::CompErase);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_int(kShaderUniform::TexStroke, 1);
//ShaderManager::u_int(kShaderUniform::TexMask, 2);
ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_stroke->m_brush.m_tip_opacity);
//ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
//ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active);
ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0);
canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
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);
auto& paper = TextureManager::get(const_hash("data/paper.jpg"));
ui::ShaderManager::use(kShader::CompDraw);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, canvas->m_canvas->m_size);
//ui::ShaderManager::u_int(kShaderUniform::TexStencil, 3);
ui::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);
ui::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);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
ShaderManager::use(kShader::CompDraw);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ShaderManager::u_int(kShaderUniform::TexMask, 2);
ShaderManager::u_vec2(kShaderUniform::Resolution, canvas->m_canvas->m_size);
//ShaderManager::u_int(kShaderUniform::TexStencil, 3);
ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_stroke->m_brush.m_tip_opacity);
ShaderManager::u_int(kShaderUniform::Lock, canvas->m_canvas->m_layers[layer_index].m_alpha_locked);
ShaderManager::u_int(kShaderUniform::Mask, canvas->m_canvas->m_smask_active);
ShaderManager::u_int(kShaderUniform::BlendMode, canvas->m_canvas->m_current_stroke->m_brush.m_blend_mode);
ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0);
canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
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_linear.bind(1);
ui::ShaderManager::use(kShader::TextureAlphaSep);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexA, 1);
ui::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);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
ShaderManager::use(kShader::TextureAlphaSep);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_int(kShaderUniform::TexA, 1);
ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_layers[layer_index].m_opacity);
ShaderManager::u_int(kShaderUniform::Highlight, canvas->m_canvas->m_layers[layer_index].m_hightlight);
ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0);
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::translate(glm::vec3(0, 0, -1)) *
glm::scale(aspect * tan_fov);
ui::ShaderManager::use(kShader::Color);
ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
ShaderManager::use(kShader::Color);
ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
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;
auto cur = (glm::vec2(pos.x / width, 1.f - pos.y / height) - 0.5f) * 2.f;
ui::ShaderManager::use(ui::kShader::StrokePreview);
ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0);
ui::ShaderManager::u_float(ui::kShaderUniform::Alpha, canvas->m_canvas->m_current_brush.m_tip_flow);
ShaderManager::use(kShader::StrokePreview);
ShaderManager::u_int(kShaderUniform::Tex, 0);
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);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, tip_color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP,
ShaderManager::u_vec4(kShaderUniform::Col, tip_color);
ShaderManager::u_mat4(kShaderUniform::MVP,
proj * camera *
glm::scale(glm::vec3(100)) *
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::scale(aspect * tan_fov);
sampler_linear.bind(0);
ui::ShaderManager::use(kShader::Texture);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
ShaderManager::use(kShader::Texture);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
glActiveTexture(GL_TEXTURE0);
uirtt.bindTexture();
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::transpose(canvas->m_canvas->m_cam_rot) *
glm::translate(glm::vec3(cur * glm::vec2(aspect * tan_fov), -1));
ui::ShaderManager::use(kShader::Color);
ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.01)));
ShaderManager::use(kShader::Color);
ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.01)));
m_face_plane.draw_fill();
ui::ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, 1 });
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.005)));
ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, 1 });
ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.005)));
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));
ui::ShaderManager::use(kShader::Color);
ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.025)));
ShaderManager::use(kShader::Color);
ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.025)));
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
{
auto pos = glm::translate(glm::normalize(vr_controller_pos));
ui::ShaderManager::use(ui::kShader::StrokePreview);
ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0);
ui::ShaderManager::u_float(ui::kShaderUniform::Alpha, canvas->m_canvas->m_current_brush.m_tip_flow);
ShaderManager::use(kShader::StrokePreview);
ShaderManager::u_int(kShaderUniform::Tex, 0);
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);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, tip_color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP,
ShaderManager::u_vec4(kShaderUniform::Col, tip_color);
ShaderManager::u_mat4(kShaderUniform::MVP,
proj * camera * pos *
glm::inverse(glm::lookAt({ 0, 0, 0 }, vr_controller_pos, { 0, 1, 0 })) *
//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
if (m_canvas->m_state != ui::Canvas::kCanvasMode::Grid)
for (auto& mode : ui::Canvas::modes[(int)ui::Canvas::kCanvasMode::Grid])
if (m_canvas->m_state != Canvas::kCanvasMode::Grid)
for (auto& mode : Canvas::modes[(int)Canvas::kCanvasMode::Grid])
mode->on_Draw(ortho_proj, proj, camera);
*/

16
src/brush.cpp
View File

@@ -2,7 +2,7 @@
#include "log.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;
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);
#endif // USE_VBO
}
bool ui::BrushMesh::create()
bool BrushMesh::create()
{
static GLushort idx[6]{ 0, 1, 2, 0, 2, 3 };
static vertex_t vertices[4]{
@@ -126,7 +126,7 @@ bool ui::BrushMesh::create()
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_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());
return s;
}
std::vector<ui::StrokeSample> ui::Stroke::compute_samples()
std::vector<StrokeSample> Stroke::compute_samples()
{
if (m_keypoints.empty()) return {};
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;
}
bool ui::Stroke::has_sample()
bool Stroke::has_sample()
{
return m_keypoints.empty() ? false : // no keypoints
(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_dist = 0.f;
if (clear_keypoints)
m_keypoints.clear();
}
void ui::Stroke::add_point(glm::vec3 pos, float pressure)
void Stroke::add_point(glm::vec3 pos, float pressure)
{
#ifdef __IOS__
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;
m_keypoints.push_back(kp);
}
void ui::Stroke::start(const ui::Brush& brush)
void Stroke::start(const Brush& brush)
{
m_hold_points.clear();
m_curve = 0.f;

8
src/brush.h
View File

@@ -2,8 +2,6 @@
#include "rtt.h"
#include "shader.h"
NS_START
class Brush
{
public:
@@ -89,7 +87,7 @@ public:
float m_dist = 0;
float m_step = 0;
Camera m_camera;
ui::Brush m_brush;
Brush m_brush;
cbuffer<float, 3> m_curve_angles;
cbuffer<float, 10> m_pressure_buff;
cbuffer<glm::vec3, 3> m_hsv_jitter;
@@ -99,12 +97,10 @@ public:
std::vector<StrokeSample> m_samples;
int m_last_kp;
std::minstd_rand prng;
void start(const ui::Brush& brush);
void start(const Brush& brush);
void add_point(glm::vec3 pos, float pressure);
void reset(bool clear_keypoints = false);
bool has_sample();
std::vector<StrokeSample> compute_samples();
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
ui::Canvas* ui::Canvas::I;
std::vector<CanvasMode*> ui::Canvas::modes[] = {
Canvas* Canvas::I;
std::vector<CanvasMode*> Canvas::modes[] = {
{ new CanvasModePen, new CanvasModeBasicCamera },
{ new CanvasModePen, new CanvasModeBasicCamera },
{ new CanvasModeLine, new CanvasModeBasicCamera },
@@ -23,7 +23,7 @@ std::vector<CanvasMode*> ui::Canvas::modes[] = {
{ new CanvasModeMaskFree, 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
{ 1, 0, 0}, // right
{ 0, 0, 1}, // back
@@ -31,7 +31,7 @@ glm::vec3 ui::Canvas::m_plane_origin[6] = {
{ 0, 1, 0}, // top
{ 0,-1, 0}, // bottom
};
glm::vec3 ui::Canvas::m_plane_normal[6] = {
glm::vec3 Canvas::m_plane_normal[6] = {
{ 0, 0, 1}, // front
{-1, 0, 0}, // right
{ 0, 0,-1}, // back
@@ -39,7 +39,7 @@ glm::vec3 ui::Canvas::m_plane_normal[6] = {
{ 0,-1, 0}, // top
{ 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}, // right
{0, 1, 0}, // back
@@ -48,7 +48,7 @@ glm::vec3 ui::Canvas::m_plane_tangent[6] = {
{0, 0, 1}, // bottom
};
// 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(), {-1, 0, 0}, {0, 1, 0}), // right
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
};
void ui::Canvas::pick_start()
void Canvas::pick_start()
{
for (int i = 0; i < 6; i++)
m_pick_ready[i] = false;
}
void ui::Canvas::pick_update(int plane)
void Canvas::pick_update(int plane)
{
// check if already updated
if (m_pick_ready[plane])
@@ -83,7 +83,7 @@ void ui::Canvas::pick_update(int plane)
m_tmp[i].bindFramebuffer();
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::Tex, 0);
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;
}
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_dir;
@@ -128,23 +128,23 @@ glm::vec4 ui::Canvas::pick_get(glm::vec2 canvas_loc)
}
return {0,0,0,1};
}
void ui::Canvas::pick_end()
void Canvas::pick_end()
{
for (int i = 0; i < 6; i++)
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 });
m_layers[m_current_layer_idx].clear(c);
m_unsaved = true;
}
void ui::Canvas::clear_all()
void Canvas::clear_all()
{
for (auto& l : m_layers)
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;
action->was_saved = !m_unsaved;
@@ -174,7 +174,7 @@ void ui::Canvas::snap_history(const std::vector<int>& planes)
action->clear_layer = true;
ActionManager::add(action);
}
ui::ActionStroke* ui::Canvas::create_action(int layer)
ActionStroke* Canvas::create_action(int layer)
{
auto action = new ActionStroke;
for (int i = 0; i < 6; i++)
@@ -203,7 +203,7 @@ ui::ActionStroke* ui::Canvas::create_action(int layer)
action->clear_layer = true;
return action;
}
void ui::Canvas::stroke_end()
void Canvas::stroke_end()
{
if (!m_current_stroke)
return;
@@ -218,14 +218,14 @@ void ui::Canvas::stroke_end()
m_show_tmp = false;
}
}
void ui::Canvas::stroke_cancel()
void Canvas::stroke_cancel()
{
if (!m_current_stroke)
return;
m_current_stroke = nullptr;
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();
@@ -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] *
glm::translate(glm::vec3(0, 0, -1));
ui::ShaderManager::use(kShader::TextureAlphaSep);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexA, 1);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity);
ui::ShaderManager::u_int(kShaderUniform::Highlight, false);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
ShaderManager::use(kShader::TextureAlphaSep);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_int(kShaderUniform::TexA, 1);
ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity);
ShaderManager::u_int(kShaderUniform::Highlight, false);
ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
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(2);
auto& paper = TextureManager::get(const_hash("data/paper.jpg"));
ui::ShaderManager::use(kShader::CompDraw);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
//ui::ShaderManager::u_int(kShaderUniform::TexA, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
//ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, m_size);
//ui::ShaderManager::u_int(kShaderUniform::TexStencil, 3);
ui::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);
ui::ShaderManager::u_int(kShaderUniform::Mask, m_smask_active);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false);
ui::ShaderManager::u_int(kShaderUniform::BlendMode, m_current_stroke->m_brush.m_blend_mode);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
ShaderManager::use(kShader::CompDraw);
ShaderManager::u_int(kShaderUniform::Tex, 0);
//ShaderManager::u_int(kShaderUniform::TexA, 0);
ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ShaderManager::u_int(kShaderUniform::TexMask, 2);
//ShaderManager::u_vec2(kShaderUniform::Resolution, m_size);
//ShaderManager::u_int(kShaderUniform::TexStencil, 3);
ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
ShaderManager::u_int(kShaderUniform::Lock, m_layers[layer_index].m_alpha_locked);
ShaderManager::u_int(kShaderUniform::Mask, m_smask_active);
ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
ShaderManager::u_int(kShaderUniform::BlendMode, m_current_stroke->m_brush.m_blend_mode);
ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0);
m_layers[layer_index].m_rtt[plane_index].bindTexture();
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();
glDisable(GL_SCISSOR_TEST);
}
void ui::Canvas::stroke_draw()
void Canvas::stroke_draw()
{
if (!(m_current_stroke && m_current_stroke->has_sample()))
{
@@ -409,7 +409,7 @@ void ui::Canvas::stroke_draw()
m_mixer.bindTexture();
glDisable(GL_BLEND);
ShaderManager::use(ui::kShader::Stroke);
ShaderManager::use(kShader::Stroke);
ShaderManager::u_int(kShaderUniform::Tex, 0); // brush
#ifndef __IOS__
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))
);
ShaderManager::use(ui::kShader::Stroke);
ShaderManager::use(kShader::Stroke);
ShaderManager::u_mat4(kShaderUniform::MVP, ortho_proj);
ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(s.col, m_brush.m_tip_color.a));
ShaderManager::u_float(kShaderUniform::Alpha, s.flow);
@@ -592,7 +592,7 @@ void ui::Canvas::stroke_draw()
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)
{
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;
}
/*
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 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;
}
*/
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)
{
/*
@@ -661,7 +661,7 @@ bool ui::Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& ray_origin, glm::ve
}
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)
{
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_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 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_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_dir;
@@ -692,7 +692,7 @@ glm::vec3 ui::Canvas::point_trace(glm::vec2 loc)
return hit_pos;
return glm::vec3(0);
}
void ui::Canvas::stroke_commit()
void Canvas::stroke_commit()
{
if (!m_dirty || m_layers.empty())
return;
@@ -759,12 +759,12 @@ void ui::Canvas::stroke_commit()
m_sampler_stencil.bind(3);
if (m_state == kCanvasMode::Erase)
{
ui::ShaderManager::use(kShader::CompErase);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
//ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
ShaderManager::use(kShader::CompErase);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_int(kShaderUniform::TexStroke, 1);
//ShaderManager::u_int(kShaderUniform::TexMask, 2);
ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
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));
glActiveTexture(GL_TEXTURE0);
@@ -784,16 +784,16 @@ void ui::Canvas::stroke_commit()
{
auto& paper = TextureManager::get(const_hash("data/paper.jpg"));
ui::ShaderManager::use(kShader::CompDraw);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
//ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, m_size);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
ui::ShaderManager::u_int(kShaderUniform::Mask, m_smask_active);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false);
ui::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::use(kShader::CompDraw);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ShaderManager::u_int(kShaderUniform::TexMask, 2);
//ShaderManager::u_vec2(kShaderUniform::Resolution, m_size);
ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
ShaderManager::u_int(kShaderUniform::Mask, m_smask_active);
ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
ShaderManager::u_int(kShaderUniform::BlendMode, m_current_stroke->m_brush.m_blend_mode);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
glActiveTexture(GL_TEXTURE0);
m_tex2[i].bind();
@@ -814,7 +814,7 @@ void ui::Canvas::stroke_commit()
}
// else
// {
// ShaderManager::use(ui::kShader::StrokeLayer);
// ShaderManager::use(kShader::StrokeLayer);
// ShaderManager::u_int(kShaderUniform::TexBG, 1);
// 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);
@@ -843,11 +843,11 @@ void ui::Canvas::stroke_commit()
action->m_stroke = std::move(m_current_stroke);
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);
}
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
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;
}
void ui::Canvas::layer_add(std::string name)
void Canvas::layer_add(std::string name)
{
int idx = (int)m_layers.size();
m_layers.emplace_back();
@@ -896,7 +896,7 @@ void ui::Canvas::layer_add(std::string name)
m_order.push_back(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];
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_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]);
}
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;
@@ -962,15 +962,15 @@ void ui::Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
m_sampler.bind(0);
m_sampler_bg.bind(1);
{
ui::ShaderManager::use(kShader::CompDraw);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0); // dest
ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1); // source
//ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, m_size);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false);
ui::ShaderManager::u_float(kShaderUniform::Alpha, m_layers[source_idx].m_opacity);
ui::ShaderManager::u_int(kShaderUniform::Lock, false);
ui::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::use(kShader::CompDraw);
ShaderManager::u_int(kShaderUniform::Tex, 0); // dest
ShaderManager::u_int(kShaderUniform::TexStroke, 1); // source
//ShaderManager::u_vec2(kShaderUniform::Resolution, m_size);
ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
ShaderManager::u_float(kShaderUniform::Alpha, m_layers[source_idx].m_opacity);
ShaderManager::u_int(kShaderUniform::Lock, false);
ShaderManager::u_int(kShaderUniform::BlendMode, 0); // TODO: defaulted to normal, change to layer blend mode when implemented
ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
glActiveTexture(GL_TEXTURE0);
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);
*/
}
void ui::Canvas::resize(int width, int height)
void Canvas::resize(int width, int height)
{
m_width = width;
m_height = height;
@@ -1020,7 +1020,7 @@ void ui::Canvas::resize(int width, int height)
m_smask.create(width, height, "mask");
m_unsaved = true;
}
bool ui::Canvas::create(int width, int height)
bool Canvas::create(int width, int height)
{
m_width = width;
m_height = height;
@@ -1059,7 +1059,7 @@ bool ui::Canvas::create(int width, int height)
return true;
}
void ui::Canvas::snapshot_save()
void Canvas::snapshot_save()
{
LOG("SAVE SNAPSHOT");
m_layers_snapshot.clear();
@@ -1068,7 +1068,7 @@ void ui::Canvas::snapshot_save()
m_layers_snapshot[i] = m_layers[i].snapshot();
}
void ui::Canvas::snapshot_restore()
void Canvas::snapshot_restore()
{
LOG("RESTORE SNAPSHOT");
for (int i = 0; i < m_layers.size(); i++)
@@ -1076,7 +1076,7 @@ void ui::Canvas::snapshot_restore()
m_layers_snapshot.clear();
}
void ui::Canvas::clear_context()
void Canvas::clear_context()
{
LOG("Canvas CLEAR CONTEXT");
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();
}
void ui::Canvas::import_equirectangular_thread(std::string file_path)
void Canvas::import_equirectangular_thread(std::string file_path)
{
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 };
tex.create(img.width, img.width, iformats[img.comp - 1], formats[img.comp - 1]);
int stride = img.width * img.width * img.comp;
ui::Plane plane;
Plane plane;
plane.create<1>(2, 2);
draw_objects([&](const glm::mat4& camera, const glm::mat4& proj, int i) {
tex.update(img.m_data.get() + indices[i] * stride);
m_sampler.bind(0);
glActiveTexture(GL_TEXTURE0);
tex.bind();
ShaderManager::use(ui::kShader::Texture);
ShaderManager::use(kShader::Texture);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(-1, -1, 1)));
plane.draw_fill();
@@ -1134,14 +1134,14 @@ void ui::Canvas::import_equirectangular_thread(std::string file_path)
{
Texture2D tex;
tex.load_file(file_path);
ui::Sphere sphere;
Sphere sphere;
glDisable(GL_DEPTH_TEST);
sphere.create<64, 64>(2.f);
draw_objects([&](const glm::mat4& camera, const glm::mat4& proj, int i) {
m_sampler.bind(0);
glActiveTexture(GL_TEXTURE0);
tex.bind();
ShaderManager::use(ui::kShader::Texture);
ShaderManager::use(kShader::Texture);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera *
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();
}
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())
{
@@ -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;
@@ -1226,7 +1226,7 @@ void ui::Canvas::export_equirectangular_thread(std::string file_path)
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::Tex, 0);
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());
glActiveTexture(GL_TEXTURE0);
m_latlong.bindFramebuffer();
ui::ShaderManager::use(kShader::Equirect);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::use(kShader::Equirect);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
ShaderManager::u_int(kShaderUniform::Tex, 0);
glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id);
m_sampler_mask.bind(0);
m_plane.draw_fill();
@@ -1360,7 +1360,7 @@ void ui::Canvas::export_equirectangular_thread(std::string file_path)
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[] =
"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())
return;
@@ -1450,8 +1450,8 @@ void ui::Canvas::export_anim()
if (seq == 0)
{
m_tmp[i].clear({ 1, 1, 1, 1 });
ui::ShaderManager::use(kShader::Checkerboard);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
ShaderManager::use(kShader::Checkerboard);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
m_plane.draw_fill();
glEnable(GL_BLEND);
}
@@ -1462,7 +1462,7 @@ void ui::Canvas::export_anim()
}
glActiveTexture(GL_TEXTURE0);
ShaderManager::use(ui::kShader::TextureAlpha);
ShaderManager::use(kShader::TextureAlpha);
ShaderManager::u_float(kShaderUniform::Alpha, 1);
ShaderManager::u_int(kShaderUniform::Highlight, false);
ShaderManager::u_int(kShaderUniform::Tex, 0);
@@ -1487,9 +1487,9 @@ void ui::Canvas::export_anim()
glActiveTexture(GL_TEXTURE0);
m_latlong.bindFramebuffer();
m_latlong.clear({ 1, 1, 1, 0 });
ui::ShaderManager::use(kShader::Equirect);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::use(kShader::Equirect);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
ShaderManager::u_int(kShaderUniform::Tex, 0);
glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id);
glDisable(GL_BLEND);
m_sampler_mask.bind(0);
@@ -1521,7 +1521,7 @@ void ui::Canvas::export_anim()
glActiveTexture(GL_TEXTURE0);
}
void ui::Canvas::export_cubes()
void Canvas::export_cubes()
{
if (!App::I.check_license())
return;
@@ -1603,7 +1603,7 @@ void ui::Canvas::export_cubes()
#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())
{
@@ -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())
{
@@ -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;
@@ -1794,7 +1794,7 @@ bool ui::Canvas::project_save_thread(std::string file_path)
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([=] {
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();
}
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");
if (!fp)
@@ -1958,7 +1958,7 @@ bool ui::Canvas::project_open_thread(std::string file_path)
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
@@ -1975,7 +1975,7 @@ ui::Image ui::Canvas::thumbnail_generate(int w, int h)
fb.create(w, h);
fb.bindFramebuffer();
fb.clear({ 1, 1, 1, 1 });
ui::Plane m_face_plane;
Plane m_face_plane;
m_face_plane.create<1>(2, 2);
// 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));
ui::ShaderManager::use(kShader::Checkerboard);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
ShaderManager::use(kShader::Checkerboard);
ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
m_face_plane.draw_fill();
ui::ShaderManager::use(kShader::TextureAlpha);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(kShaderUniform::Highlight, false);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
ShaderManager::use(kShader::TextureAlpha);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_int(kShaderUniform::Highlight, false);
ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
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_face_plane.draw_fill();
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();
// read the rendered image
ui::Image image;
Image image;
image.create(w, h);
fb.readTextureData((uint8_t*)image.data());
@@ -2021,7 +2021,7 @@ ui::Image ui::Canvas::thumbnail_generate(int w, int h)
return image;
}
ui::Image ui::Canvas::thumbnail_read(std::string file_path)
Image Canvas::thumbnail_read(std::string file_path)
{
// static char name[128];
// 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;
}
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
GLint vp[4];
@@ -2079,12 +2079,12 @@ void ui::Canvas::draw_objects(std::function<void(const glm::mat4& camera, const
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]);
}
void ui::Canvas::project2Dpoints(std::vector<vertex_t>& vertices)
void Canvas::project2Dpoints(std::vector<vertex_t>& 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::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
// 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{
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;
}
void ui::Canvas::push_camera()
void Canvas::push_camera()
{
m_camera_stack.push(get_camera());
}
void ui::Canvas::pop_camera()
void Canvas::pop_camera()
{
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;
c.m_box = m_box;
@@ -2170,7 +2170,7 @@ ui::Canvas::CameraData ui::Canvas::get_camera()
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_mv = c.m_mv;
@@ -2181,11 +2181,11 @@ void ui::Canvas::set_camera(const ui::Canvas::CameraData& c)
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<p2t::Point> points(vertices.size());
@@ -2212,7 +2212,7 @@ std::vector<vertex_t> ui::Canvas::triangulate_simple(const std::vector<vertex_t>
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;
for (auto pt : points)
@@ -2220,7 +2220,7 @@ std::vector<vertex_t> ui::Canvas::triangulate(const std::vector<glm::vec2>& poin
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
{
@@ -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++)
m_rtt[i].destroy();
}
void ui::Layer::restore(const Snapshot& snap)
void Layer::restore(const Snapshot& snap)
{
//clear({ 0, 0, 0, 0 });
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;
static int counter = 0;
@@ -2416,7 +2416,7 @@ ui::Layer::Snapshot ui::Layer::snapshot()
return snap;
}
void ui::Layer::clear(const glm::vec4& c)
void Layer::clear(const glm::vec4& c)
{
// push clear color state
GLfloat cc[4];
@@ -2447,7 +2447,7 @@ void ui::Layer::clear(const glm::vec4& c)
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;
w = width;
@@ -2464,7 +2464,7 @@ bool ui::Layer::create(int width, int height, std::string name)
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);
w = width;

23
src/canvas.h
View File

@@ -8,8 +8,6 @@
#include "canvas_modes.h"
#include <stack>
NS_START
#define CANVAS_RES 512
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
{
public:
@@ -153,7 +140,7 @@ public:
RTT m_tmp[6];
RTT m_mixer;
float m_mixer_scale = 1;
ui::StrokeSample m_mixer_sample;
StrokeSample m_mixer_sample;
bool m_mixer_idle = true;
Texture2D m_brush_mix;
Texture2D m_tex[6];
@@ -206,7 +193,7 @@ public:
void layer_add(std::string name);
void layer_order(int idx, int pos);
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_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz);
void stroke_draw();
@@ -236,8 +223,8 @@ public:
void project_open(std::string file_path, std::function<void(bool)> on_complete = nullptr);
bool project_open_thread(std::string file_path);
void inject_xmp(std::string jpg_path);
ui::Image thumbnail_generate(int w, int h);
ui::Image thumbnail_read(std::string file_path);
Image thumbnail_generate(int w, int h);
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)>, Layer& layer);
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"
NodeCanvas* CanvasMode::node;
ui::Canvas* CanvasMode::canvas;
Canvas* CanvasMode::canvas;
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;
if (App::I.keys[(int)kKey::KeyAlt] && !m_resizing)
pos.x = pos.x - canvas->m_current_brush.m_tip_size * 500.f;
ui::ShaderManager::use(ui::kShader::StrokePreview);
ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0);
ui::ShaderManager::u_float(ui::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));
ShaderManager::use(kShader::StrokePreview);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_current_brush.m_tip_flow);
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_angle = canvas->m_current_brush.m_tip_angle * (float)(M_PI * 2.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);
}
}
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, tip_color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP,
ShaderManager::u_vec4(kShaderUniform::Col, tip_color);
ShaderManager::u_mat4(kShaderUniform::MVP,
glm::scale(glm::vec3(1, -1, 1)) *
ortho *
glm::translate(glm::vec3(pos + tip_offset, 0)) *
@@ -237,7 +237,7 @@ void CanvasModePen::leave()
void CanvasModePen::enter()
{
m_cur_pos = ui::Canvas::I->m_cur_pos;
m_cur_pos = Canvas::I->m_cur_pos;
if (m_valid_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)
{
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, ortho);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, canvas->m_current_brush.m_tip_color);
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, ortho);
ShaderManager::u_vec4(kShaderUniform::Col, canvas->m_current_brush.m_tip_color);
static glm::vec4 AB[2];
AB[0] = { m_drag_start, 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 dir = l.d;
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 0, 0, 1});
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ShaderManager::u_vec4(kShaderUniform::Col, {1, 0, 0, 1});
static glm::vec4 AB[2];
AB[0] = {origin - dir * 10.f, 1};
AB[1] = {origin + dir * 10.f, 1 };
@@ -421,9 +421,9 @@ void CanvasModeGrid::init()
void CanvasModeGrid::commit()
{
auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj){
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 0, 0, 1});
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ShaderManager::u_vec4(kShaderUniform::Col, {1, 0, 0, 1});
static glm::vec4 AB[2];
AB[0] = {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));
auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
//glEnable(GL_BLEND);
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 1, 1, 1});
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
m_shape.draw_fill();
};
// 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)
{
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 });
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
//m_dragging ? m_shape.draw_stroke() : m_shape.draw_fill();
m_shape.draw_stroke();
}
else
{
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 });
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
m_shape.draw_stroke();
}
}
@@ -621,9 +621,9 @@ void CanvasModeMaskLine::leave()
{
auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
//glEnable(GL_BLEND);
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 1, 1, 1});
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
m_shape.draw_fill();
};
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)
{
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 });
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
//m_dragging ? m_shape.draw_stroke() : m_shape.draw_fill();
m_shape.draw_stroke();
}
else
{
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 });
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
m_shape.draw_stroke();
}
}
@@ -743,9 +743,9 @@ void CanvasModeFill::leave()
if (m_points.size() > 2)
{
auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 1, 1, 1});
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
m_shape.draw_fill();
};
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())
{
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, .25 });
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, .25 });
m_dragging ? m_shape.draw_fill() : m_shape.draw_stroke();
}
}
@@ -906,7 +906,7 @@ void CanvasModeTransform::enter()
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;
auto points = m->m_points2d;
@@ -1013,17 +1013,17 @@ void CanvasModeTransform::enter()
glActiveTexture(GL_TEXTURE0);
glm::mat4 proj = glm::perspective(glm::radians(90.f), 1.f, .01f, 1000.f);
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 0 });
ShaderManager::use(kShader::Color);
ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 0 });
auto action = new ui::ActionStroke;
auto action = new ActionStroke;
action->was_saved = !canvas->m_unsaved;
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 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();
@@ -1102,28 +1102,28 @@ void CanvasModeTransform::leave()
glActiveTexture(GL_TEXTURE0);
glm::mat4 proj = glm::perspective(glm::radians(90.f), 1.f, .01f, 1000.f);
ui::ShaderManager::use(ui::kShader::CompDraw);
ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0);
ui::ShaderManager::u_int(ui::kShaderUniform::TexStroke, 1);
ui::ShaderManager::u_int(ui::kShaderUniform::TexMask, 2);
ui::ShaderManager::u_float(ui::kShaderUniform::Alpha, 1);
ui::ShaderManager::u_int(ui::kShaderUniform::Lock, false);
ui::ShaderManager::u_int(ui::kShaderUniform::Mask, false);
ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, true);
ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, canvas->m_size);
ui::ShaderManager::u_int(ui::kShaderUniform::BlendMode, 0);
ShaderManager::use(kShader::CompDraw);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ShaderManager::u_int(kShaderUniform::TexMask, 2);
ShaderManager::u_float(kShaderUniform::Alpha, 1);
ShaderManager::u_int(kShaderUniform::Lock, false);
ShaderManager::u_int(kShaderUniform::Mask, false);
ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, true);
ShaderManager::u_vec2(kShaderUniform::Resolution, canvas->m_size);
ShaderManager::u_int(kShaderUniform::BlendMode, 0);
canvas->m_sampler_bg.bind(1);
canvas->m_sampler_bg.bind(0);
auto action = new ui::ActionStroke;
auto action = new ActionStroke;
action->was_saved = !canvas->m_unsaved;
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 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();
@@ -1188,7 +1188,7 @@ void CanvasModeTransform::leave()
//action->m_stroke = std::move(m_current_stroke);
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();
}
@@ -1200,14 +1200,14 @@ void CanvasModeTransform::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
glEnable(GL_BLEND);
for (int i = 0; i < 6; i++)
{
ui::ShaderManager::use(ui::kShader::Color);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera * m_xform * m_xform_local);
ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 1, 1, .1 });
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera * m_xform * m_xform_local);
ShaderManager::u_vec4(kShaderUniform::Col, { 0, 1, 1, .1 });
m_shape[i].draw_fill();
ui::ShaderManager::use(ui::kShader::Texture);
ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0);
ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera * m_xform * m_xform_local);
ShaderManager::use(kShader::Texture);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera * m_xform * m_xform_local);
glActiveTexture(GL_TEXTURE0);
m_tex[i].bind();
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();
}
ui::ShaderManager::use(ui::kShader::Color);
ShaderManager::use(kShader::Color);
auto m2d = canvas->m_proj * canvas->m_mv * m_xform * m_xform_local;
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;
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));
// 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();
// 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();
}

40
src/canvas_modes.h
View File

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

4
src/image.cpp
View File

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

4
src/image.h
View File

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

2
src/log.h
View File

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

10
src/main.cpp
View File

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

11
src/node_border.cpp
View File

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

2
src/node_border.h
View File

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

137
src/node_canvas.cpp
View File

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

8
src/node_canvas.h
View File

@@ -5,13 +5,13 @@
class NodeCanvas : public Node
{
public:
std::unique_ptr<ui::Canvas> m_canvas;
std::unique_ptr<Canvas> m_canvas;
Sampler m_sampler;
Sampler m_sampler_linear;
Sampler m_sampler_stencil;
ui::Plane m_face_plane;
ui::LineSegment m_line;
ui::Plane m_grid;
Plane m_face_plane;
LineSegment m_line;
Plane m_grid;
int m_grid_divs = 30;
virtual Node* clone_instantiate() const 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);
m_picker->SetPosition(pos - m_picker->GetSize() * .5f);
using namespace ui;
ui::ShaderManager::use(kShader::ColorQuad);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ui::ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(convert_rgb2hsv(glm::vec3(m_color)), 1));
ShaderManager::use(kShader::ColorQuad);
ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(convert_rgb2hsv(glm::vec3(m_color)), 1));
m_plane.draw_fill();
}

6
src/node_colorwheel.cpp
View File

@@ -28,9 +28,9 @@ void NodeColorWheel::init_controls()
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_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;
m_quad.create<1>(quad_scale, quad_scale);
@@ -61,8 +61,6 @@ void NodeColorWheel::loaded()
void NodeColorWheel::draw()
{
using namespace ui;
glDisable(GL_BLEND);
ShaderManager::use(kShader::ColorHue);
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
{
public:
ui::Circle m_circle;
ui::Plane m_cur_hue;
ui::Circle m_cur_quad;
ui::Plane m_quad;
Circle m_circle;
Plane m_cur_hue;
Circle m_cur_quad;
Plane m_quad;
NodeBorder* m_color_cur;
glm::vec3 m_hsv;
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_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)
continue;

2
src/node_dialog_cloud.cpp
View File

@@ -142,7 +142,7 @@ void NodeDialogCloud::load_thumbs_thread()
std::string rgb;
rgb.resize(Base64::DecodedLength(info[3]));
Base64::Decode(info[3], &rgb);
ui::Image thumb;
Image thumb;
thumb.create(width, height);
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()
{
// 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");
// 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) {
if (target == current)
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");
image_tex->tex.destroy();
image_tex->tex.create(thumb);

2
src/node_dialog_picker.cpp
View File

@@ -25,7 +25,7 @@ void NodeColorPicker::init()
void NodeColorPicker::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);
// m_slider_h->m_value.x = hsv.x;
// 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");
combo = find<NodeComboBox>("resolution");
text = find<NodeText>("current-res");
resolution = ui::Canvas::I->m_width;
resolution = Canvas::I->m_width;
static char txt[128];
sprintf(txt, "Current: %s", App::I.res_to_string(resolution).c_str());
text->set_text(txt);
@@ -43,7 +43,7 @@ void NodeDialogResize::init_controls()
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");
// image_tex->tex.create(thumb);
}

15
src/node_image.cpp
View File

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

2
src/node_image.h
View File

@@ -6,7 +6,7 @@
class NodeImage : public Node
{
public:
static ui::Plane m_plane;
static Plane m_plane;
static Sampler m_sampler;
static Sampler m_sampler_mips;
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()
{
using namespace ui;
tex.bind();
auto& sampler = tex.has_mips ? NodeImage::m_sampler_mips : NodeImage::m_sampler;
sampler.bind(0);
glEnable(GL_BLEND);
ui::ShaderManager::use(kShader::Texture);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ShaderManager::use(kShader::Texture);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
NodeImage::m_plane.draw_fill();
sampler.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);
}
ui::Brush NodePanelBrushPreset::get_brush(int index) const
Brush NodePanelBrushPreset::get_brush(int index) const
{
auto b = m_brushes[index]->m_brush;
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:
int m_brushID;
ui::Brush m_brush;
Brush m_brush;
std::string high_path;
uint16_t high_id;
bool m_selected = false;
@@ -65,7 +65,7 @@ public:
virtual void init() override;
void handle_click(Node* target);
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;
};

2
src/node_panel_color.cpp
View File

@@ -55,5 +55,5 @@ void NodePanelColor::set_color(glm::vec3 rgb)
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*) {
App::I.pick_image([this](std::string path) {
ui::Image img;
Image img;
if (img.load_file(path))
{
m_hm_image = img.resize(128, 128);

4
src/node_panel_grid.h
View File

@@ -25,8 +25,8 @@ public:
NodeButton* m_hm_load;
NodeSliderH* m_hm_offset;
NodeSliderH* m_hm_height;
ui::HeightmapPlane m_hm_plane;
ui::Image m_hm_image;
HeightmapPlane m_hm_plane;
Image m_hm_image;
virtual Node* clone_instantiate() 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()
{
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_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);
@@ -50,44 +50,44 @@ void NodePanelStroke::init_controls()
m_preview = find<NodeStrokePreview>("canvas");
m_blend_mode = find<NodeComboBox>("blend-mode");
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_spacing, "tip-spacing", &ui::Brush::m_tip_spacing);
init_slider(m_tip_flow, "tip-flow", &ui::Brush::m_tip_flow);
init_slider(m_tip_opacity, "tip-opacity", &ui::Brush::m_tip_opacity);
init_slider(m_tip_angle, "tip-angle", &ui::Brush::m_tip_angle);
init_slider(m_tip_mix, "tip-mix", &ui::Brush::m_tip_mix);
init_slider(m_tip_stencil, "tip-stencil", &ui::Brush::m_tip_stencil);
init_slider(m_tip_wet, "tip-wet", &ui::Brush::m_tip_wet);
init_slider(m_tip_noise, "tip-noise", &ui::Brush::m_tip_noise);
init_slider(m_tip_hue, "tip-hue", &ui::Brush::m_tip_hue);
init_slider(m_tip_sat, "tip-sat", &ui::Brush::m_tip_sat);
init_slider(m_tip_val, "tip-val", &ui::Brush::m_tip_val);
init_slider(m_jitter_scale, "jitter-scale", &ui::Brush::m_jitter_scale);
init_slider(m_jitter_angle, "jitter-angle", &ui::Brush::m_jitter_angle);
init_slider(m_jitter_spread, "jitter-spread", &ui::Brush::m_jitter_spread);
init_slider(m_jitter_flow, "jitter-flow", &ui::Brush::m_jitter_flow);
init_slider(m_jitter_hue, "jitter-hue", &ui::Brush::m_jitter_hue);
init_slider(m_jitter_sat, "jitter-sat", &ui::Brush::m_jitter_sat);
init_slider(m_jitter_val, "jitter-val", &ui::Brush::m_jitter_val);
init_slider(m_tip_size, "tip-size", &Brush::m_tip_size);
init_slider(m_tip_spacing, "tip-spacing", &Brush::m_tip_spacing);
init_slider(m_tip_flow, "tip-flow", &Brush::m_tip_flow);
init_slider(m_tip_opacity, "tip-opacity", &Brush::m_tip_opacity);
init_slider(m_tip_angle, "tip-angle", &Brush::m_tip_angle);
init_slider(m_tip_mix, "tip-mix", &Brush::m_tip_mix);
init_slider(m_tip_stencil, "tip-stencil", &Brush::m_tip_stencil);
init_slider(m_tip_wet, "tip-wet", &Brush::m_tip_wet);
init_slider(m_tip_noise, "tip-noise", &Brush::m_tip_noise);
init_slider(m_tip_hue, "tip-hue", &Brush::m_tip_hue);
init_slider(m_tip_sat, "tip-sat", &Brush::m_tip_sat);
init_slider(m_tip_val, "tip-val", &Brush::m_tip_val);
init_slider(m_jitter_scale, "jitter-scale", &Brush::m_jitter_scale);
init_slider(m_jitter_angle, "jitter-angle", &Brush::m_jitter_angle);
init_slider(m_jitter_spread, "jitter-spread", &Brush::m_jitter_spread);
init_slider(m_jitter_flow, "jitter-flow", &Brush::m_jitter_flow);
init_slider(m_jitter_hue, "jitter-hue", &Brush::m_jitter_hue);
init_slider(m_jitter_sat, "jitter-sat", &Brush::m_jitter_sat);
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_spacing] = [](float v){ return glm::pow(v * 4.f, 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_flow_pressure, "tip-flow-pressure", &ui::Brush::m_tip_flow_pressure);
init_checkbox(m_tip_size_pressure, "tip-size-pressure", &ui::Brush::m_tip_size_pressure);
init_checkbox(m_tip_hue_pressure, "tip-hue-pressure", &ui::Brush::m_tip_hue_pressure);
init_checkbox(m_tip_sat_pressure, "tip-sat-pressure", &ui::Brush::m_tip_sat_pressure);
init_checkbox(m_tip_val_pressure, "tip-val-pressure", &ui::Brush::m_tip_val_pressure);
init_checkbox(m_tip_angle_follow, "tip-angle-follow", &Brush::m_tip_angle_follow);
init_checkbox(m_tip_flow_pressure, "tip-flow-pressure", &Brush::m_tip_flow_pressure);
init_checkbox(m_tip_size_pressure, "tip-size-pressure", &Brush::m_tip_size_pressure);
init_checkbox(m_tip_hue_pressure, "tip-hue-pressure", &Brush::m_tip_hue_pressure);
init_checkbox(m_tip_sat_pressure, "tip-sat-pressure", &Brush::m_tip_sat_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();
}
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->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;
}
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);
ui::Canvas::I->m_current_brush.*prop = curve != m_curves.end() ? curve->second(value) : value;
m_preview->m_brush = ui::Canvas::I->m_current_brush;
Canvas::I->m_current_brush.*prop = curve != m_curves.end() ? curve->second(value) : value;
m_preview->m_brush = Canvas::I->m_current_brush;
m_preview->draw_stroke();
if (on_stroke_change)
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->on_value_changed = std::bind(&NodePanelStroke::handle_checkbox,
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;
m_preview->m_brush = ui::Canvas::I->m_current_brush;
Canvas::I->m_current_brush.*prop = value;
m_preview->m_brush = Canvas::I->m_current_brush;
m_preview->draw_stroke();
if (on_stroke_change)
on_stroke_change(this);

8
src/node_panel_stroke.h
View File

@@ -45,9 +45,9 @@ public:
void init_controls();
void update_controls();
void init_slider(NodeSliderH*& slider, const char* id, float ui::Brush::* prop);
void handle_slide(float ui::Brush::* prop, Node* target, float value);
void init_slider(NodeSliderH*& slider, const char* id, float Brush::* prop);
void handle_slide(float Brush::* prop, Node* target, float value);
void init_checkbox(NodeCheckBox*& slider, const char* id, bool ui::Brush::* prop);
void handle_checkbox(bool ui::Brush::* prop, Node* target, bool value);
void init_checkbox(NodeCheckBox*& slider, const char* id, bool Brush::* prop);
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();
using namespace ui;
auto sz = GetSize();
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 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;
ui::ShaderManager::use(kShader::Color);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
ShaderManager::use(kShader::Color);
ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
m_plane.draw_fill();
}
@@ -149,11 +148,10 @@ glm::vec4 NodeSliderHue::get_hue()
void NodeSliderHue::draw()
{
using namespace ui;
ui::ShaderManager::use(kShader::ColorHue);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
//ui::ShaderManager::u_vec4(kShaderUniform::Col, m_color);
ui::ShaderManager::u_int(kShaderUniform::Direction, 1); // set vertical
ShaderManager::use(kShader::ColorHue);
ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
//ShaderManager::u_vec4(kShaderUniform::Col, m_color);
ShaderManager::u_int(kShaderUniform::Direction, 1); // set vertical
m_plane.draw_fill();
NodeBorder::m_color = glm::vec4(0);
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.set_filter(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
// 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()
@@ -56,7 +56,6 @@ void NodeStrokePreview::draw_stroke()
{
m_rtt.bindFramebuffer();
{
using namespace ui;
GLint vp[4];
GLfloat cc[4];
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);
auto b = m_brush;
m_stroke.m_camera.fov = ui::Canvas::I->m_cam_fov;
m_stroke.m_camera.rot = ui::Canvas::I->m_cam_rot;
m_stroke.m_camera.fov = Canvas::I->m_cam_fov;
m_stroke.m_camera.rot = Canvas::I->m_cam_rot;
m_stroke.reset();
m_stroke.start(b);
if (!m_stroke.m_keypoints.empty())
@@ -127,10 +126,9 @@ void NodeStrokePreview::draw_stroke()
void NodeStrokePreview::draw()
{
using namespace ui;
ui::ShaderManager::use(kShader::Texture);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::use(kShader::Texture);
ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ShaderManager::u_int(kShaderUniform::Tex, 0);
m_rtt.bindTexture();
m_sampler.bind(0);
m_plane.draw_fill();

6
src/node_stroke_preview.h
View File

@@ -9,10 +9,10 @@ class NodeStrokePreview : public NodeBorder
RTT m_rtt;
Sampler m_sampler;
Sampler m_sampler_brush;
ui::BrushMesh m_mesh;
BrushMesh m_mesh;
public:
ui::Brush m_brush;
ui::Stroke m_stroke;
Brush m_brush;
Stroke m_stroke;
std::vector<glm::vec2> m_bez_points;
virtual Node* clone_instantiate() 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()
{
using namespace ui;
glm::mat4 pos = glm::translate(glm::vec3(glm::floor(m_pos), 0));
m_mvp = m_proj * pos;
ui::ShaderManager::use(kShader::Font);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ui::ShaderManager::u_vec4(kShaderUniform::Col, m_color);
ShaderManager::use(kShader::Font);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
ShaderManager::u_vec4(kShaderUniform::Col, m_color);
glEnable(GL_BLEND);
m_text_mesh.draw();
glDisable(GL_BLEND);

9
src/node_viewport.cpp
View File

@@ -5,7 +5,6 @@
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 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();
m_sampler->bind(0);
glEnable(GL_BLEND);
ui::ShaderManager::use(kShader::Texture);
ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
ui::ShaderManager::u_mat4(kShaderUniform::MVP, proj * cam);
ShaderManager::use(kShader::Texture);
ShaderManager::u_int(kShaderUniform::Tex, 0);
ShaderManager::u_mat4(kShaderUniform::MVP, proj * cam);
m_faces->draw_fill();
m_sampler->unbind();
TextureManager::get(m_tex_id).unbind();
@@ -39,7 +38,7 @@ Node* NodeViewport::clone_instantiate() const
}
void NodeViewport::create()
{
m_faces = std::make_unique<ui::Plane>();
m_faces = std::make_unique<Plane>();
m_faces->create<1>(10, 10);
m_sampler = std::make_unique<Sampler>();
m_sampler->create();

2
src/node_viewport.h
View File

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

2
src/pch.h
View File

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

8
src/shader.cpp
View File

@@ -2,8 +2,6 @@
#include "log.h"
#include "shader.h"
using namespace ui;
std::map<kShader, Shader> ShaderManager::m_shaders;
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)
else glUniform1f(m_umap[id], f);
}
GLint ui::Shader::GetAttribLocation(const char* name)
GLint Shader::GetAttribLocation(const char* name)
{
return glGetAttribLocation(prog, name);
}
@@ -188,13 +186,13 @@ void ShaderManager::u_int(kShaderUniform id, int i)
m_current->u_int(id, i);
}
Shader* ui::ShaderManager::get(kShader id)
Shader* ShaderManager::get(kShader id)
{
auto it = m_shaders.find(id);
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);
}

4
src/shader.h
View File

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

14
src/shape.cpp
View File

@@ -2,16 +2,14 @@
#include "log.h"
#include "shape.h"
using namespace ui;
bool ui::Shape::create_buffers(GLushort * idx, GLvoid * vertices, int isize, int vsize)
bool Shape::create_buffers(GLushort * idx, GLvoid * vertices, int isize, int vsize)
{
index_type = GL_UNSIGNED_SHORT;
create_buffers_imp(idx, vertices, isize, vsize);
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;
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 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);
}
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];
@@ -605,7 +603,7 @@ void Sphere::create_impl(int rings, int sectors, float radius,
*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];
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);
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[1] = vcount;

4
src/shape.h
View File

@@ -9,8 +9,6 @@ enum class kShapeType : uint16_t
Slice9 = const_hash("slice9"),
};
namespace ui {
class Shape
{
protected:
@@ -221,5 +219,3 @@ public:
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();
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 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)
{
LOG("load texture %s", filename.c_str());
ui::Image img;
Image img;
if (!img.load(filename))
return false;
return create(img);
@@ -89,7 +89,7 @@ bool Texture2D::load(std::string filename)
bool Texture2D::load_file(std::string filename)
{
LOG("load texture %s", filename.c_str());
ui::Image img;
Image img;
if (!img.load_file(filename))
return false;
return create(img);

2
src/texture.h
View File

@@ -11,7 +11,7 @@ class Texture2D
public:
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(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);
bool load(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>
class BlockingQueue
{
@@ -216,5 +215,3 @@ struct gl_state
glBindTexture(GL_TEXTURE_CUBE_MAP, cube);
}
};
NS_END