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

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;