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

use unique_ptr to hold the Layers vector

Browse Source
This commit is contained in:
omigamedev
2019-02-24 13:19:15 +01:00
parent 3d1412aee2
commit dfa44dbb55
13 changed files with 216 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
data/layout.xml
View File

@@ -640,8 +640,8 @@
<node height="20" justify="center" margin="5 0 0 0"><text text="Wireframe"/></node>
<!--<node height="20" justify="center"><text text="Thickness"/></node>-->
<node height="20" justify="center"><text text="Height"/></node>
<node height="20" justify="center"><text text="L-Yaw"/></node>
<node height="20" justify="center"><text text="L-Pitch"/></node>
<node height="20" justify="center"><text text="Light Yaw"/></node>
<node height="20" justify="center"><text text="Light Pitch"/></node>
<node height="20" justify="center"><text text="Ambient"/></node>
<node height="20" justify="center"><text text="Radius"/></node>
<node height="30" justify="center" margin="5 0 0 0"><text text="Samples"/></node>
@@ -650,9 +650,11 @@
<node dir="col" align="center" grow="1" width="1" flood-events="1" color=".3" >
<node height="30" width="100%" dir="row" pad="0 1 0 1">
<node width="20" grow="1" pad="0" dir="row">
<button id="grid-heightmap-load" text="..." width="20" height="30" margin="0 2 0 0"></button>
<button id="grid-heightmap-clear" text="Clear" width="45" height="30" margin="0 2 0 0"></button>
<button id="grid-heightmap-reload" text="Reload" width="55" height="30"></button>
<button id="grid-heightmap-load" text="Open" grow="1" width="52" height="30" margin="0 2 0 0"/>
<button id="grid-heightmap-clear" text="Clear" grow="1" width="55" height="30" margin="0 2 0 0"/>
<button-custom id="grid-heightmap-reload" pat="2">
<icon icon="arrow_rotate_clockwise" width="30" height="30"/>
</button-custom>
</node>
</node>
<node height="30" pad="1" width="100%" dir="row" margin="5 0 0 0">

4
src/app.cpp
View File

@@ -45,8 +45,8 @@ void App::open_document(std::string path)
title_update();
for (auto& i : canvas->m_canvas->m_order)
{
auto l = layers->add_layer(canvas->m_canvas->m_layers[i].m_name.c_str());
l->m_visibility->set_value(canvas->m_canvas->m_layers[i].m_visible);
auto l = layers->add_layer(canvas->m_canvas->m_layers[i]->m_name.c_str());
l->m_visibility->set_value(canvas->m_canvas->m_layers[i]->m_visible);
}
async_end();
}

2
src/app_cloud.cpp
View File

@@ -167,7 +167,7 @@ void App::cloud_browse()
doc_name = dialog->selected_name;
title_update();
for (auto& i : canvas->m_canvas->m_order)
layers->add_layer(canvas->m_canvas->m_layers[i].m_name.c_str());
layers->add_layer(canvas->m_canvas->m_layers[i]->m_name.c_str());
ActionManager::clear();
m->destroy();
async_redraw();

4
src/app_dialogs.cpp
View File

@@ -207,7 +207,7 @@ void App::dialog_open()
// async_start();
// title_update();
// for (auto& i : canvas->m_canvas->m_order)
// layers->add_layer(canvas->m_canvas->m_layers[i].m_name.c_str());
// layers->add_layer(canvas->m_canvas->m_layers[i]->m_name.c_str());
// async_end();
// });
// dialog->destroy();
@@ -505,7 +505,7 @@ void App::dialog_layer_rename()
dialog->btn_ok->on_click = [this,dialog](Node*)
{
layers->m_current_layer->set_name(dialog->get_name().c_str());
canvas->m_canvas->m_layers[canvas->m_canvas->m_current_layer_idx].m_name = dialog->get_name();
canvas->m_canvas->m_layers[canvas->m_canvas->m_current_layer_idx]->m_name = dialog->get_name();
dialog->destroy();
App::I.hideKeyboard();
};

28
src/app_layout.cpp
View File

@@ -153,14 +153,14 @@ void App::init_sidebar()
auto& src = Canvas::I->m_layers[Canvas::I->m_order[source_index]];
for (int i = 0; i < 6; i++)
{
if (!src.m_dirty_face[i])
if (!src->m_dirty_face[i])
continue;
dst.m_rtt[i].copy(src.m_rtt[i]);
dst.m_dirty_face[i] = src.m_dirty_face[i];
dst.m_dirty_box[i] = src.m_dirty_box[i];
dst.m_opacity = src.m_opacity;
dst.m_blend_mode = src.m_blend_mode;
dst.m_alpha_locked = src.m_alpha_locked;
dst->m_rtt[i].copy(src->m_rtt[i]);
dst->m_dirty_face[i] = src->m_dirty_face[i];
dst->m_dirty_box[i] = src->m_dirty_box[i];
dst->m_opacity = src->m_opacity;
dst->m_blend_mode = src->m_blend_mode;
dst->m_alpha_locked = src->m_alpha_locked;
}
Canvas::I->m_unsaved = true;
title_update();
@@ -183,31 +183,31 @@ void App::init_sidebar()
};
layers->on_layer_opacity_changed = [this](Node*, int idx, float value) {
canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]].m_opacity = value;
canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]]->m_opacity = value;
canvas->m_canvas->m_unsaved = true;
title_update();
};
layers->on_layer_visibility_changed = [this](Node*, int idx, bool visible) {
canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]].m_visible = visible;
canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]]->m_visible = visible;
canvas->m_canvas->m_unsaved = true;
title_update();
};
layers->on_layer_alpha_lock_changed = [this](Node*, int idx, bool locked) {
canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]].m_alpha_locked = locked;
canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]]->m_alpha_locked = locked;
canvas->m_canvas->m_unsaved = true;
title_update();
};
layers->on_layer_blend_mode_changed = [this](Node*, int idx, int mode) {
canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]].m_blend_mode = mode;
canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]]->m_blend_mode = mode;
canvas->m_canvas->m_unsaved = true;
title_update();
};
layers->on_layer_highlight_changed = [this](Node*, int idx, bool highlight) {
canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]].m_hightlight = highlight;
canvas->m_canvas->m_layers[canvas->m_canvas->m_order[idx]]->m_hightlight = highlight;
};
if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-stroke"))
{
@@ -786,7 +786,7 @@ void App::init_menu_layer()
canvas->m_canvas->layer_remove(current_idx_order);
layers->clear();
for (auto& i : canvas->m_canvas->m_order)
layers->add_layer(canvas->m_canvas->m_layers[i].m_name.c_str());
layers->add_layer(canvas->m_canvas->m_layers[i]->m_name.c_str());
layers->m_current_layer->m_selected = false;
layers->m_current_layer = layers->m_layers[current_idx_order - 1];
layers->m_current_layer->m_selected = true;
@@ -804,7 +804,7 @@ void App::init_menu_layer()
int down_layer_idx = order[current_idx_order - 1];
popup->find<NodeButtonCustom>("layer-merge")->
find<NodeText>("menu-label")->
set_text(("Merge with " + canvas->m_canvas->m_layers[down_layer_idx].m_name).c_str());
set_text(("Merge with " + canvas->m_canvas->m_layers[down_layer_idx]->m_name).c_str());
}
else
{

34
src/app_vr.cpp
View File

@@ -47,9 +47,9 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
auto layer_index = canvas->m_canvas->m_order[i];
for (int plane_index = 0; plane_index < 6; plane_index++)
{
if (!canvas->m_canvas->m_layers[layer_index].m_visible ||
canvas->m_canvas->m_layers[layer_index].m_opacity == .0f ||
!canvas->m_canvas->m_layers[layer_index].m_dirty_face[plane_index])
if (!canvas->m_canvas->m_layers[layer_index]->m_visible ||
canvas->m_canvas->m_layers[layer_index]->m_opacity == .0f ||
!canvas->m_canvas->m_layers[layer_index]->m_dirty_face[plane_index])
continue;
int z = (int)(canvas->m_canvas->m_order.size() - i);
@@ -67,12 +67,12 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
ShaderManager::u_int(kShaderUniform::TexStroke, 1);
ShaderManager::u_int(kShaderUniform::TexMask, 2);
ShaderManager::u_float(kShaderUniform::StrokeAlpha, canvas->m_canvas->m_current_stroke->m_brush->m_tip_opacity);
ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_layers[layer_index].m_opacity);
//ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_layers[layer_index]->m_opacity);
//ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index]->m_alpha_locked);
ShaderManager::u_int(kShaderUniform::Mask, canvas->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();
canvas->m_canvas->m_layers[layer_index]->m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1);
canvas->m_canvas->m_tmp[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE2);
@@ -82,7 +82,7 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
glActiveTexture(GL_TEXTURE1);
canvas->m_canvas->m_tmp[plane_index].unbindTexture();
glActiveTexture(GL_TEXTURE0);
canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].unbindTexture();
canvas->m_canvas->m_layers[layer_index]->m_rtt[plane_index].unbindTexture();
}
else if (canvas->m_canvas->m_show_tmp && canvas->m_canvas->m_current_layer_idx == layer_index)
{
@@ -100,8 +100,8 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
ShaderManager::u_vec2(kShaderUniform::Resolution, canvas->m_canvas->m_size);
ShaderManager::u_int(kShaderUniform::TexPattern, 3);
ShaderManager::u_float(kShaderUniform::StrokeAlpha, b->m_tip_opacity);
ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_layers[layer_index].m_opacity);
ShaderManager::u_int(kShaderUniform::Lock, canvas->m_canvas->m_layers[layer_index].m_alpha_locked);
ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_layers[layer_index]->m_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::DrawOnScreen, true);
ShaderManager::u_int(kShaderUniform::BlendMode, b->m_blend_mode);
@@ -117,7 +117,7 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
ShaderManager::u_vec2(kShaderUniform::PatternOffset, Canvas::I->m_pattern_offset);
glActiveTexture(GL_TEXTURE0);
canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
canvas->m_canvas->m_layers[layer_index]->m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1);
canvas->m_canvas->m_tmp[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE2);
@@ -131,7 +131,7 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
glActiveTexture(GL_TEXTURE1);
canvas->m_canvas->m_tmp[plane_index].unbindTexture();
glActiveTexture(GL_TEXTURE0);
canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].unbindTexture();
canvas->m_canvas->m_layers[layer_index]->m_rtt[plane_index].unbindTexture();
}
else
{
@@ -140,21 +140,21 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
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_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();
canvas->m_canvas->m_layers[layer_index]->m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1);
canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
canvas->m_canvas->m_layers[layer_index]->m_rtt[plane_index].bindTexture();
m_face_plane.draw_fill();
glActiveTexture(GL_TEXTURE1);
canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].unbindTexture();
canvas->m_canvas->m_layers[layer_index]->m_rtt[plane_index].unbindTexture();
glActiveTexture(GL_TEXTURE0);
canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].unbindTexture();
canvas->m_canvas->m_layers[layer_index]->m_rtt[plane_index].unbindTexture();
}
}
}

219
src/canvas.cpp
View File

@@ -94,12 +94,12 @@ void Canvas::pick_update(int plane)
m_sampler.bind(0);
for (auto layer_index : m_order)
{
if (!m_layers[layer_index].m_visible || m_layers[layer_index].m_opacity == 0.f)
if (!m_layers[layer_index]->m_visible || m_layers[layer_index]->m_opacity == 0.f)
continue;
ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity);
m_layers[layer_index].m_rtt[i].bindTexture();
ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index]->m_opacity);
m_layers[layer_index]->m_rtt[i].bindTexture();
m_plane.draw_fill();
m_layers[layer_index].m_rtt[i].unbindTexture();
m_layers[layer_index]->m_rtt[i].unbindTexture();
}
m_sampler.unbind();
@@ -141,13 +141,13 @@ void Canvas::pick_end()
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_layers[m_current_layer_idx]->clear(c);
m_unsaved = true;
}
void Canvas::clear_all()
{
for (auto& l : m_layers)
l.clear({0, 0, 0, 0});
l->clear({0, 0, 0, 0});
}
void Canvas::snap_history(const std::vector<int>& planes)
{
@@ -155,15 +155,15 @@ void Canvas::snap_history(const std::vector<int>& planes)
action->was_saved = !m_unsaved;
for (auto i : planes)
{
if (!m_layers[m_current_layer_idx].m_dirty_face[i])
if (!m_layers[m_current_layer_idx]->m_dirty_face[i])
continue; // no stroke on this face, skip it
m_layers[m_current_layer_idx].m_rtt[i].bindFramebuffer();
m_layers[m_current_layer_idx]->m_rtt[i].bindFramebuffer();
// save image before commit
glm::vec2 box_or = xy(m_layers[m_current_layer_idx].m_dirty_box[i]);
glm::vec2 box_sz = zw(m_layers[m_current_layer_idx].m_dirty_box[i]) - xy(m_layers[m_current_layer_idx].m_dirty_box[i]);
if (box_sz.x > 0 && box_sz.y > 0 && box_sz.x <= m_layers[m_current_layer_idx].w && box_sz.y <= m_layers[m_current_layer_idx].h)
glm::vec2 box_or = xy(m_layers[m_current_layer_idx]->m_dirty_box[i]);
glm::vec2 box_sz = zw(m_layers[m_current_layer_idx]->m_dirty_box[i]) - xy(m_layers[m_current_layer_idx]->m_dirty_box[i]);
if (box_sz.x > 0 && box_sz.y > 0 && box_sz.x <= m_layers[m_current_layer_idx]->w && box_sz.y <= m_layers[m_current_layer_idx]->h)
{
action->m_image[i] = std::make_unique<uint8_t[]>(box_sz.x * box_sz.y * 4);
glReadPixels(box_or.x, box_or.y, box_sz.x, box_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, action->m_image[i].get());
@@ -173,11 +173,11 @@ void Canvas::snap_history(const std::vector<int>& planes)
LOG("snap_history invalid box size (%d, %d)", (int)box_sz.x, (int)box_sz.y);
}
action->m_box[i] = m_layers[m_current_layer_idx].m_dirty_box[i];
action->m_old_box[i] = m_layers[m_current_layer_idx].m_dirty_box[i];
action->m_old_dirty[i] = m_layers[m_current_layer_idx].m_dirty_face[i];
action->m_box[i] = m_layers[m_current_layer_idx]->m_dirty_box[i];
action->m_old_box[i] = m_layers[m_current_layer_idx]->m_dirty_box[i];
action->m_old_dirty[i] = m_layers[m_current_layer_idx]->m_dirty_face[i];
m_layers[m_current_layer_idx].m_rtt[i].unbindFramebuffer();
m_layers[m_current_layer_idx]->m_rtt[i].unbindFramebuffer();
}
// save history
action->m_layer_idx = m_current_layer_idx;
@@ -225,9 +225,9 @@ void Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz)
auto layer_index = m_current_layer_idx;
for (int plane_index = 0; plane_index < 6; plane_index++)
{
if (!m_layers[layer_index].m_visible ||
m_layers[layer_index].m_opacity == .0f ||
!m_layers[layer_index].m_dirty_face[plane_index])
if (!m_layers[layer_index]->m_visible ||
m_layers[layer_index]->m_opacity == .0f ||
!m_layers[layer_index]->m_dirty_face[plane_index])
continue;
glm::mat4 proj = glm::perspective(glm::radians(m_cam_fov), (float)m_mixer.getWidth() / m_mixer.getHeight(), 0.1f, 1000.f);
@@ -250,7 +250,7 @@ void Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz)
ShaderManager::u_int(kShaderUniform::TexPattern, 3);
ShaderManager::u_float(kShaderUniform::StrokeAlpha, b->m_tip_opacity);
ShaderManager::u_float(kShaderUniform::Alpha, 1);
ShaderManager::u_int(kShaderUniform::Lock, false/*m_layers[layer_index].m_alpha_locked*/);
ShaderManager::u_int(kShaderUniform::Lock, false/*m_layers[layer_index]->m_alpha_locked*/);
ShaderManager::u_int(kShaderUniform::Mask, false/*m_smask_active*/);
//ShaderManager::u_int(kShaderUniform::DrawOnScreen, false);
ShaderManager::u_int(kShaderUniform::UseDual, false);
@@ -258,7 +258,7 @@ void Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz)
ShaderManager::u_int(kShaderUniform::BlendMode, b->m_blend_mode);
ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
glActiveTexture(GL_TEXTURE0);
m_layers[layer_index].m_rtt[plane_index].bindTexture();
m_layers[layer_index]->m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1);
m_tmp[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE2);
@@ -268,7 +268,7 @@ void Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz)
glActiveTexture(GL_TEXTURE1);
m_tmp[plane_index].unbindTexture();
glActiveTexture(GL_TEXTURE0);
m_layers[layer_index].m_rtt[plane_index].unbindTexture();
m_layers[layer_index]->m_rtt[plane_index].unbindTexture();
}
m_sampler.unbind();
m_mixer.unbindFramebuffer();
@@ -730,7 +730,7 @@ void Canvas::stroke_commit()
if (!m_dirty_face[i])
continue; // no stroke on this face, skip it
m_layers[m_current_layer_idx].m_rtt[i].bindFramebuffer();
m_layers[m_current_layer_idx]->m_rtt[i].bindFramebuffer();
// save image before commit
glm::vec2 box_sz = zw(m_dirty_box[i]) - xy(m_dirty_box[i]);
@@ -738,15 +738,15 @@ void Canvas::stroke_commit()
glReadPixels(m_dirty_box[i].x, m_dirty_box[i].y, box_sz.x, box_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, action->m_image[i].get());
action->m_box[i] = m_dirty_box[i];
action->m_old_box[i] = m_layers[m_current_layer_idx].m_dirty_box[i];
action->m_old_dirty[i] = m_layers[m_current_layer_idx].m_dirty_face[i];
action->m_old_box[i] = m_layers[m_current_layer_idx]->m_dirty_box[i];
action->m_old_dirty[i] = m_layers[m_current_layer_idx]->m_dirty_face[i];
auto& lbox = m_layers[m_current_layer_idx].m_dirty_box[i];
auto& lbox = m_layers[m_current_layer_idx]->m_dirty_box[i];
lbox = glm::vec4(
glm::min(xy(m_dirty_box[i]), xy(lbox)),
glm::max(zw(m_dirty_box[i]), zw(lbox))
);
m_layers[m_current_layer_idx].m_dirty_face[i] = true;
m_layers[m_current_layer_idx]->m_dirty_face[i] = true;
// copy to tmp2 for layer blending
glActiveTexture(GL_TEXTURE0);
@@ -844,7 +844,7 @@ void Canvas::stroke_commit()
// {
// 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_int(kShaderUniform::Lock, m_layers[m_current_layer_idx]->m_alpha_locked);
// ShaderManager::u_float(kShaderUniform::Alpha, b->m_tip_opacity);
//
// ShaderManager::u_int(kShaderUniform::Tex, 0);
@@ -856,7 +856,7 @@ void Canvas::stroke_commit()
// m_tmp[i].unbindTexture();
// }
m_layers[m_current_layer_idx].m_rtt[i].unbindFramebuffer();
m_layers[m_current_layer_idx]->m_rtt[i].unbindFramebuffer();
}
// restore viewport and clear color states
@@ -944,8 +944,8 @@ void Canvas::stroke_start(glm::vec3 point, float pressure)
void Canvas::layer_add(std::string name)
{
int idx = (int)m_layers.size();
m_layers.emplace_back();
m_layers.back().create(m_width, m_height, name);
m_layers.push_back(std::make_unique<Layer>());
m_layers.back()->create(m_width, m_height, name);
m_order.push_back(idx);
m_current_layer_idx = idx;
}
@@ -955,6 +955,7 @@ void Canvas::layer_remove(int idx) // m_order index
for (auto& i : m_order)
if (i > n)
i--;
m_layers[n]->destroy();
m_layers.erase(m_layers.begin() + n);
m_order.erase(m_order.begin() + idx);
m_current_layer_idx = m_order[std::min<int>((int)m_layers.size() - 1, idx)];
@@ -983,10 +984,10 @@ void Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
for (int i = 0; i < 6; i++)
{
if (!m_layers[source_idx].m_dirty_face[i])
if (!m_layers[source_idx]->m_dirty_face[i])
continue; // no stroke on this face, skip it
m_layers[dest_idx].m_rtt[i].bindFramebuffer();
m_layers[dest_idx]->m_rtt[i].bindFramebuffer();
/*
// save image before commit
@@ -995,16 +996,16 @@ void Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
glReadPixels(m_dirty_box[i].x, m_dirty_box[i].y, box_sz.x, box_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, action->m_image[i].get());
action->m_box[i] = m_dirty_box[i];
action->m_old_box[i] = m_layers[m_current_layer_idx].m_dirty_box[i];
action->m_old_dirty[i] = m_layers[m_current_layer_idx].m_dirty_face[i];
action->m_old_box[i] = m_layers[m_current_layer_idx]->m_dirty_box[i];
action->m_old_dirty[i] = m_layers[m_current_layer_idx]->m_dirty_face[i];
*/
auto& lbox = m_layers[dest_idx].m_dirty_box[i];
auto& lbox = m_layers[dest_idx]->m_dirty_box[i];
lbox = glm::vec4(
glm::min(xy(m_layers[source_idx].m_dirty_box[i]), xy(lbox)),
glm::max(zw(m_layers[source_idx].m_dirty_box[i]), zw(lbox))
glm::min(xy(m_layers[source_idx]->m_dirty_box[i]), xy(lbox)),
glm::max(zw(m_layers[source_idx]->m_dirty_box[i]), zw(lbox))
);
m_layers[dest_idx].m_dirty_face[i] = true;
m_layers[dest_idx]->m_dirty_face[i] = true;
// copy to tmp2 for layer blending
glActiveTexture(GL_TEXTURE0);
@@ -1021,10 +1022,10 @@ void Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
ShaderManager::u_vec2(kShaderUniform::Resolution, m_size);
ShaderManager::u_float(kShaderUniform::StrokeAlpha, 1);
ShaderManager::u_float(kShaderUniform::PatternAlpha, 0);
ShaderManager::u_float(kShaderUniform::Alpha, m_layers[source_idx].m_opacity);
ShaderManager::u_float(kShaderUniform::Alpha, m_layers[source_idx]->m_opacity);
ShaderManager::u_int(kShaderUniform::Lock, false);
//ShaderManager::u_int(kShaderUniform::DrawOnScreen, false);
ShaderManager::u_int(kShaderUniform::BlendMode, m_layers[source_idx].m_blend_mode);
ShaderManager::u_int(kShaderUniform::BlendMode, m_layers[source_idx]->m_blend_mode);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
ShaderManager::u_int(kShaderUniform::UseDual, false);
ShaderManager::u_int(kShaderUniform::UsePattern, false);
@@ -1032,14 +1033,14 @@ void Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
glActiveTexture(GL_TEXTURE0);
m_tex2[i].bind();
glActiveTexture(GL_TEXTURE1);
m_layers[source_idx].m_rtt[i].bindTexture();
m_layers[source_idx]->m_rtt[i].bindTexture();
m_plane.draw_fill();
m_layers[source_idx].m_rtt[i].unbindTexture();
m_layers[source_idx]->m_rtt[i].unbindTexture();
glActiveTexture(GL_TEXTURE0);
m_tex2[i].unbind();
}
m_layers[dest_idx].m_rtt[i].unbindFramebuffer();
m_layers[dest_idx]->m_rtt[i].unbindFramebuffer();
}
// restore viewport and clear color states
@@ -1075,7 +1076,7 @@ void Canvas::resize(int width, int height)
m_tex2[i].create(width, height, GL_RGBA8);
}
for (auto& l : m_layers)
l.resize(width, height);
l->resize(width, height);
m_smask.create(width, height, "mask");
m_unsaved = true;
}
@@ -1090,7 +1091,7 @@ void Canvas::destroy()
m_tex2[i].destroy();
}
for (auto& l : m_layers)
l.destroy();
l->destroy();
m_smask.destroy();
m_mixer.destroy();
}
@@ -1131,9 +1132,7 @@ bool Canvas::create(int width, int height)
m_mesh.create();
m_brush_mix.create(8, 8);
for (auto& l : m_layers)
{
l.create(width, height, "");
}
l->create(width, height, "");
m_smask.create(width, height, "mask");
//m_smask.clear({1, 1, 1, 1});
m_unsaved = true;
@@ -1146,14 +1145,14 @@ void Canvas::snapshot_save()
m_layers_snapshot.clear();
m_layers_snapshot.resize(m_layers.size());
for (int i = 0; i < m_layers.size(); i++)
m_layers_snapshot[i] = m_layers[i].snapshot();
m_layers_snapshot[i] = m_layers[i]->snapshot();
}
void Canvas::snapshot_restore()
{
LOG("RESTORE SNAPSHOT");
for (int i = 0; i < m_layers.size(); i++)
m_layers[i].restore(m_layers_snapshot[i]);
m_layers[i]->restore(m_layers_snapshot[i]);
m_layers_snapshot.clear();
}
@@ -1161,7 +1160,7 @@ void Canvas::clear_context()
{
LOG("Canvas CLEAR CONTEXT");
for (auto& layer : m_layers)
layer.destroy();
layer->destroy();
for (int i = 0; i < 6; i++)
{
m_tmp[i].destroy();
@@ -1233,8 +1232,8 @@ void Canvas::import_equirectangular_thread(std::string file_path)
}
for (int i = 0; i < 6; i++)
{
m_layers[m_current_layer_idx].m_dirty_box[i] = glm::vec4(0, 0, m_width, m_height);
m_layers[m_current_layer_idx].m_dirty_face[i] = true;
m_layers[m_current_layer_idx]->m_dirty_box[i] = glm::vec4(0, 0, m_width, m_height);
m_layers[m_current_layer_idx]->m_dirty_face[i] = true;
}
App::I.async_update();
gl.restore();
@@ -1334,25 +1333,25 @@ void Canvas::export_equirectangular_thread(std::string file_path)
m_sampler_mask.bind(1); // linear
for (auto layer_index : m_order)
{
if (!m_layers[layer_index].m_visible ||
m_layers[layer_index].m_opacity == 0.f ||
!m_layers[layer_index].m_dirty_face[i])
if (!m_layers[layer_index]->m_visible ||
m_layers[layer_index]->m_opacity == 0.f ||
!m_layers[layer_index]->m_dirty_face[i])
continue;
if (!ShaderManager::ext_framebuffer_fetch)
{
glActiveTexture(GL_TEXTURE2);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, m_width, m_height);
}
ShaderManager::u_int(kShaderUniform::BlendMode, m_layers[layer_index].m_blend_mode);
ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity);
ShaderManager::u_int(kShaderUniform::BlendMode, m_layers[layer_index]->m_blend_mode);
ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index]->m_opacity);
glActiveTexture(GL_TEXTURE0);
m_layers[layer_index].m_rtt[i].bindTexture();
m_layers[layer_index]->m_rtt[i].bindTexture();
glActiveTexture(GL_TEXTURE1);
m_layers[layer_index].m_rtt[i].bindTexture();
m_layers[layer_index]->m_rtt[i].bindTexture();
m_plane.draw_fill();
m_layers[layer_index].m_rtt[i].unbindTexture();
m_layers[layer_index]->m_rtt[i].unbindTexture();
glActiveTexture(GL_TEXTURE0);
m_layers[layer_index].m_rtt[i].unbindTexture();
m_layers[layer_index]->m_rtt[i].unbindTexture();
}
if (!ShaderManager::ext_framebuffer_fetch)
@@ -1631,9 +1630,9 @@ void Canvas::export_layers_thread(std::string file_name)
ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
m_sampler_mask.bind(0);
m_layers[layer_index].m_rtt[i].bindTexture();
m_layers[layer_index]->m_rtt[i].bindTexture();
m_plane.draw_fill();
m_layers[layer_index].m_rtt[i].unbindTexture();
m_layers[layer_index]->m_rtt[i].unbindTexture();
m_sampler_mask.unbind();
// copy result to cubemap
@@ -1732,9 +1731,9 @@ void Canvas::export_cubes()
for (int plane = 0; plane < 6; plane++)
{
auto& l = m_layers[m_order[layer]];
l.m_rtt[plane].bindFramebuffer();
l->m_rtt[plane].bindFramebuffer();
glReadPixels(0, 0, m_width, m_height, GL_RGBA, GL_UNSIGNED_BYTE, buffer.get());
l.m_rtt[plane].unbindFramebuffer();
l->m_rtt[plane].unbindFramebuffer();
if (plane < 4)
{
@@ -1910,22 +1909,22 @@ bool Canvas::project_save_thread(std::string file_path)
int n_order = m_order[i];
fwrite(&n_order, sizeof(int), 1, fp);
float layer_alpha = m_layers[i].m_opacity;
float layer_alpha = m_layers[i]->m_opacity;
fwrite(&layer_alpha, sizeof(float), 1, fp);
int name_len = (int)m_layers[i].m_name.size();
int name_len = (int)m_layers[i]->m_name.size();
fwrite(&name_len, sizeof(int), 1, fp);
fwrite(m_layers[i].m_name.data(), name_len, 1, fp);
fwrite(m_layers[i]->m_name.data(), name_len, 1, fp);
if (ppi_header.doc_version.minor > 1)
{
fwrite(&m_layers[i].m_blend_mode, sizeof(int), 1, fp);
fwrite(&m_layers[i].m_alpha_locked, sizeof(bool), 1, fp);
fwrite(&m_layers[i].m_visible, sizeof(bool), 1, fp);
fwrite(&m_layers[i]->m_blend_mode, sizeof(int), 1, fp);
fwrite(&m_layers[i]->m_alpha_locked, sizeof(bool), 1, fp);
fwrite(&m_layers[i]->m_visible, sizeof(bool), 1, fp);
}
App::I.async_start();
auto snap = m_layers[i].snapshot();
auto snap = m_layers[i]->snapshot();
App::I.async_update();
App::I.async_end();
for (int plane_index = 0; plane_index < 6; plane_index++)
@@ -2076,7 +2075,7 @@ bool Canvas::project_open_thread(std::string file_path)
App::I.async_start();
for (auto& l : m_layers)
l.destroy();
l->destroy();
m_layers.clear();
m_order.clear();
//clear_all();
@@ -2084,17 +2083,17 @@ bool Canvas::project_open_thread(std::string file_path)
App::I.async_end();
std::vector<int> tmp_order;
std::vector<Layer> tmp_layers;
std::vector<std::unique_ptr<Layer>> tmp_layers;
for (int i = 0; i < n_layers; i++)
{
int n_order;
fread(&n_order, sizeof(int), 1, fp);
tmp_layers.emplace_back();
tmp_layers.push_back(std::make_unique<Layer>());
auto& layer = tmp_layers.back();
fread(&layer.m_opacity, sizeof(float), 1, fp);
fread(&layer->m_opacity, sizeof(float), 1, fp);
int name_len;
fread(&name_len, sizeof(int), 1, fp);
@@ -2103,9 +2102,9 @@ bool Canvas::project_open_thread(std::string file_path)
if (ppi_header.doc_version.minor > 1)
{
fread(&layer.m_blend_mode, sizeof(int), 1, fp);
fread(&layer.m_alpha_locked, sizeof(bool), 1, fp);
fread(&layer.m_visible, sizeof(bool), 1, fp);
fread(&layer->m_blend_mode, sizeof(int), 1, fp);
fread(&layer->m_alpha_locked, sizeof(bool), 1, fp);
fread(&layer->m_visible, sizeof(bool), 1, fp);
}
snap.clear();
@@ -2151,9 +2150,9 @@ bool Canvas::project_open_thread(std::string file_path)
}
App::I.async_start();
tmp_layers.back().create(m_width, m_height, name.c_str());
tmp_layers.back().clear({0, 0, 0, 0});
tmp_layers.back().restore(snap);
tmp_layers.back()->create(m_width, m_height, name.c_str());
tmp_layers.back()->clear({ 0, 0, 0, 0 });
tmp_layers.back()->restore(snap);
tmp_order.push_back(n_order);
App::I.async_end();
}
@@ -2223,25 +2222,25 @@ Image Canvas::thumbnail_generate(int w, int h)
m_sampler_mask.bind(1); // linear
for (auto layer_index : m_order)
{
if (!m_layers[layer_index].m_visible ||
m_layers[layer_index].m_opacity == 0.f ||
!m_layers[layer_index].m_dirty_face[i])
if (!m_layers[layer_index]->m_visible ||
m_layers[layer_index]->m_opacity == 0.f ||
!m_layers[layer_index]->m_dirty_face[i])
continue;
if (!ShaderManager::ext_framebuffer_fetch)
{
glActiveTexture(GL_TEXTURE2);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, w, h);
}
ShaderManager::u_int(kShaderUniform::BlendMode, m_layers[layer_index].m_blend_mode);
ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity);
ShaderManager::u_int(kShaderUniform::BlendMode, m_layers[layer_index]->m_blend_mode);
ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index]->m_opacity);
glActiveTexture(GL_TEXTURE0);
m_layers[layer_index].m_rtt[i].bindTexture();
m_layers[layer_index]->m_rtt[i].bindTexture();
glActiveTexture(GL_TEXTURE1);
m_layers[layer_index].m_rtt[i].bindTexture();
m_layers[layer_index]->m_rtt[i].bindTexture();
m_face_plane.draw_fill();
m_layers[layer_index].m_rtt[i].unbindTexture();
m_layers[layer_index]->m_rtt[i].unbindTexture();
glActiveTexture(GL_TEXTURE0);
m_layers[layer_index].m_rtt[i].unbindTexture();
m_layers[layer_index]->m_rtt[i].unbindTexture();
}
if (!ShaderManager::ext_framebuffer_fetch)
@@ -2453,7 +2452,7 @@ void Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm:
void Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer)
{
draw_objects(observer, m_layers[m_current_layer_idx]);
draw_objects(observer, *m_layers[m_current_layer_idx]);
}
void Canvas::project2Dpoints(std::vector<vertex_t>& vertices)
@@ -2725,7 +2724,7 @@ void Layer::resize(int width, int height)
void ActionStroke::undo()
{
if (clear_layer)
m_canvas->m_layers[m_layer_idx].clear({ 0, 0, 0, 0 });
m_canvas->m_layers[m_layer_idx]->clear({ 0, 0, 0, 0 });
for (int i = 0; i < 6; i++)
{
// empty data
@@ -2734,26 +2733,26 @@ void ActionStroke::undo()
LOG("undo box %d dirty=%s [%d,%d,%d,%d] to dirty=%s [%d,%d,%d,%d]",
i,
m_canvas->m_layers[m_layer_idx].m_dirty_face[i] ? "true" : "false",
(int)m_canvas->m_layers[m_layer_idx].m_dirty_box[i].x,
(int)m_canvas->m_layers[m_layer_idx].m_dirty_box[i].y,
(int)m_canvas->m_layers[m_layer_idx].m_dirty_box[i].z,
(int)m_canvas->m_layers[m_layer_idx].m_dirty_box[i].w,
m_canvas->m_layers[m_layer_idx]->m_dirty_face[i] ? "true" : "false",
(int)m_canvas->m_layers[m_layer_idx]->m_dirty_box[i].x,
(int)m_canvas->m_layers[m_layer_idx]->m_dirty_box[i].y,
(int)m_canvas->m_layers[m_layer_idx]->m_dirty_box[i].z,
(int)m_canvas->m_layers[m_layer_idx]->m_dirty_box[i].w,
m_old_dirty[i] ? "true" : "false",
(int)m_old_box[i].x,
(int)m_old_box[i].y,
(int)m_old_box[i].z,
(int)m_old_box[i].w);
m_canvas->m_layers[m_layer_idx].m_dirty_box[i] = m_old_box[i];
m_canvas->m_layers[m_layer_idx].m_dirty_face[i] = m_old_dirty[i];
m_canvas->m_layers[m_layer_idx]->m_dirty_box[i] = m_old_box[i];
m_canvas->m_layers[m_layer_idx]->m_dirty_face[i] = m_old_dirty[i];
glm::vec2 box_sz = zw(m_box[i]) - xy(m_box[i]);
if (box_sz.x > 0 && box_sz.y > 0 && box_sz.x <= m_canvas->m_layers[m_layer_idx].w && box_sz.y <= m_canvas->m_layers[m_layer_idx].h)
if (box_sz.x > 0 && box_sz.y > 0 && box_sz.x <= m_canvas->m_layers[m_layer_idx]->w && box_sz.y <= m_canvas->m_layers[m_layer_idx]->h)
{
m_canvas->m_layers[m_layer_idx].m_rtt[i].bindTexture();
m_canvas->m_layers[m_layer_idx]->m_rtt[i].bindTexture();
glTexSubImage2D(GL_TEXTURE_2D, 0, (int)m_box[i].x, (int)m_box[i].y, (int)box_sz.x, (int)box_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, m_image[i].get());
m_canvas->m_layers[m_layer_idx].m_rtt[i].unbindTexture();
m_canvas->m_layers[m_layer_idx]->m_rtt[i].unbindTexture();
}
else
{
@@ -2779,15 +2778,15 @@ Action* ActionStroke::get_redo()
auto& layer = m_canvas->m_layers[m_layer_idx];
for (int i = 0; i < 6; i++)
{
if (!layer.m_dirty_face[i] && !m_image[i])
if (!layer->m_dirty_face[i] && !m_image[i])
continue; // no stroke on this face, skip it
layer.m_rtt[i].bindFramebuffer();
layer->m_rtt[i].bindFramebuffer();
// save image before commit
glm::vec2 box_or = xy(m_box[i]);
glm::vec2 box_sz = zw(m_box[i]) - xy(m_box[i]);
if (box_sz.x > 0 && box_sz.y > 0 && box_sz.x <= layer.w && box_sz.y <= layer.h)
if (box_sz.x > 0 && box_sz.y > 0 && box_sz.x <= layer->w && box_sz.y <= layer->h)
{
action->m_image[i] = std::make_unique<uint8_t[]>(box_sz.x * box_sz.y * 4);
glReadPixels(box_or.x, box_or.y, box_sz.x, box_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, action->m_image[i].get());
@@ -2798,10 +2797,10 @@ Action* ActionStroke::get_redo()
}
action->m_box[i] = m_box[i];
action->m_old_box[i] = layer.m_dirty_box[i];
action->m_old_dirty[i] = layer.m_dirty_face[i];
action->m_old_box[i] = layer->m_dirty_box[i];
action->m_old_dirty[i] = layer->m_dirty_face[i];
layer.m_rtt[i].unbindFramebuffer();
layer->m_rtt[i].unbindFramebuffer();
}
// save history
action->m_layer_idx = m_layer_idx;

2
src/canvas.h
View File

@@ -165,7 +165,7 @@ public:
std::unique_ptr<Stroke> m_current_stroke;
std::unique_ptr<Stroke> m_dual_stroke;
bool m_show_tmp = false;
std::vector<Layer> m_layers;
std::vector<std::unique_ptr<Layer>> m_layers;
std::vector<int> m_order;
std::vector<glm::vec2> m_plane_shape[6]; // screen space projection of the plane
glm::mat4 m_plane_unproject[6] = SIXPLETTE(glm::mat4(1));

46
src/canvas_modes.cpp
View File

@@ -1034,12 +1034,12 @@ void CanvasModeTransform::enter(kCanvasMode prev)
auto shape3d = triangulate(m_points_face[plane]);
m_shape[plane].update_vertices(shape3d.data(), shape3d.size());
Canvas::I->m_layers[Canvas::I->m_current_layer_idx].m_rtt[plane].bindFramebuffer();
Canvas::I->m_layers[Canvas::I->m_current_layer_idx]->m_rtt[plane].bindFramebuffer();
m_tex[plane].create(bb_sz.x, bb_sz.y);
m_tex[plane].bind();
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bb_min.x, bb_min.y, bb_sz.x, bb_sz.y);
m_tex[plane].unbind();
Canvas::I->m_layers[Canvas::I->m_current_layer_idx].m_rtt[plane].unbindFramebuffer();
Canvas::I->m_layers[Canvas::I->m_current_layer_idx]->m_rtt[plane].unbindFramebuffer();
m_commit_on_leave = true;
}
@@ -1050,7 +1050,7 @@ void CanvasModeTransform::enter(kCanvasMode prev)
GLint vp[4];
glGetIntegerv(GL_VIEWPORT, vp);
glViewport(0, 0, layer.w, layer.h);
glViewport(0, 0, layer->w, layer->h);
bool depth = glIsEnabled(GL_DEPTH_TEST);
bool blend = glIsEnabled(GL_BLEND);
@@ -1072,7 +1072,7 @@ void CanvasModeTransform::enter(kCanvasMode prev)
auto mvp = proj * plane_camera * m_xform * m_xform_local;
ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
layer.m_rtt[i].bindFramebuffer();
layer->m_rtt[i].bindFramebuffer();
glm::vec2 bb_min(Canvas::I->m_size);
glm::vec2 bb_max(0, 0);
@@ -1096,26 +1096,26 @@ void CanvasModeTransform::enter(kCanvasMode prev)
if (bb_sz.x <= 0.f || bb_sz.y <= 0.f)
{
layer.m_rtt[i].unbindFramebuffer();
layer->m_rtt[i].unbindFramebuffer();
continue;
}
action->m_image[i] = std::make_unique<uint8_t[]>(bb_sz.x * bb_sz.y * 4);
glReadPixels(bb_min.x, bb_min.y, bb_sz.x, bb_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, action->m_image[i].get());
action->m_box[i] = { bb_min, bb_max };
action->m_old_box[i] = layer.m_dirty_box[i];
action->m_old_dirty[i] = layer.m_dirty_face[i];
action->m_old_box[i] = layer->m_dirty_box[i];
action->m_old_dirty[i] = layer->m_dirty_face[i];
layer.m_dirty_face[i] = true;
layer.m_dirty_box[i] = {
glm::min(xy(layer.m_dirty_box[i]), bb_min),
glm::max(zw(layer.m_dirty_box[i]), bb_max),
layer->m_dirty_face[i] = true;
layer->m_dirty_box[i] = {
glm::min(xy(layer->m_dirty_box[i]), bb_min),
glm::max(zw(layer->m_dirty_box[i]), bb_max),
};
for (int j = 0; j < 6; j++)
m_shape[j].draw_fill();
layer.m_rtt[i].unbindFramebuffer();
layer->m_rtt[i].unbindFramebuffer();
}
depth ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);
@@ -1142,7 +1142,7 @@ void CanvasModeTransform::leave()
GLint vp[4];
glGetIntegerv(GL_VIEWPORT, vp);
glViewport(0, 0, layer.w, layer.h);
glViewport(0, 0, layer->w, layer->h);
bool depth = glIsEnabled(GL_DEPTH_TEST);
bool blend = glIsEnabled(GL_BLEND);
@@ -1179,7 +1179,7 @@ void CanvasModeTransform::leave()
auto mvp = proj * mv;
ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
layer.m_rtt[i].bindFramebuffer();
layer->m_rtt[i].bindFramebuffer();
std::vector<glm::vec2> poly2d;
static std::vector<glm::vec2> face_corners{ {1,1}, {-1,1}, {-1,-1}, {1,-1} };
@@ -1219,20 +1219,20 @@ void CanvasModeTransform::leave()
if (clipped.empty() || bb_sz.x <= 0.f || bb_sz.y <= 0.f)
{
layer.m_rtt[i].unbindFramebuffer();
layer->m_rtt[i].unbindFramebuffer();
continue;
}
action->m_image[i] = std::make_unique<uint8_t[]>(bb_sz.x * bb_sz.y * 4);
glReadPixels(bb_min.x, bb_min.y, bb_sz.x, bb_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, action->m_image[i].get());
action->m_box[i] = { bb_min, bb_max };
action->m_old_box[i] = layer.m_dirty_box[i];
action->m_old_dirty[i] = layer.m_dirty_face[i];
action->m_old_box[i] = layer->m_dirty_box[i];
action->m_old_dirty[i] = layer->m_dirty_face[i];
layer.m_dirty_face[i] = true;
layer.m_dirty_box[i] = {
glm::min(xy(layer.m_dirty_box[i]), bb_min),
glm::max(zw(layer.m_dirty_box[i]), bb_max),
layer->m_dirty_face[i] = true;
layer->m_dirty_box[i] = {
glm::min(xy(layer->m_dirty_box[i]), bb_min),
glm::max(zw(layer->m_dirty_box[i]), bb_max),
};
glActiveTexture(GL_TEXTURE0);
@@ -1247,7 +1247,7 @@ void CanvasModeTransform::leave()
m_tex[j].unbind();
}
layer.m_rtt[i].unbindFramebuffer();
layer->m_rtt[i].unbindFramebuffer();
}
depth ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);
blend ? glEnable(GL_BLEND) : glDisable(GL_BLEND);
@@ -1257,7 +1257,7 @@ void CanvasModeTransform::leave()
action->m_canvas = Canvas::I;
//action->m_stroke = std::move(m_current_stroke);
ActionManager::add(action);
layer.optimize();
layer->optimize();
//auto m = static_cast<CanvasModeMaskFree*>(Canvas::I->modes[(int)kCanvasMode::MaskFree][0]);
//m->clear();
}

40
src/node_canvas.cpp
View File

@@ -119,7 +119,7 @@ void NodeCanvas::draw()
for (size_t i = 0; i < m_canvas->m_order.size(); i++)
{
auto layer_index = m_canvas->m_order[i];
use_blend |= m_canvas->m_layers[layer_index].m_blend_mode != 0;
use_blend |= m_canvas->m_layers[layer_index]->m_blend_mode != 0;
}
if (use_blend)
@@ -156,9 +156,9 @@ void NodeCanvas::draw()
for (int plane_index = 0; plane_index < 6; plane_index++)
{
if (!(m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index) &&
(!m_canvas->m_layers[layer_index].m_visible ||
m_canvas->m_layers[layer_index].m_opacity == .0f ||
!m_canvas->m_layers[layer_index].m_dirty_face[plane_index]))
(!m_canvas->m_layers[layer_index]->m_visible ||
m_canvas->m_layers[layer_index]->m_opacity == .0f ||
!m_canvas->m_layers[layer_index]->m_dirty_face[plane_index]))
continue;
if (use_blend)
@@ -183,12 +183,12 @@ void NodeCanvas::draw()
ShaderManager::u_int(kShaderUniform::TexMask, 2);
//ShaderManager::u_vec2(kShaderUniform::Resolution, zw(m_canvas->m_box) / zoom);
ShaderManager::u_float(kShaderUniform::StrokeAlpha, b->m_tip_opacity);
ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity);
//ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index]->m_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);
m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
m_canvas->m_layers[layer_index]->m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1);
m_canvas->m_tmp[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE2);
@@ -198,7 +198,7 @@ void NodeCanvas::draw()
glActiveTexture(GL_TEXTURE1);
m_canvas->m_tmp[plane_index].unbindTexture();
glActiveTexture(GL_TEXTURE0);
m_canvas->m_layers[layer_index].m_rtt[plane_index].unbindTexture();
m_canvas->m_layers[layer_index]->m_rtt[plane_index].unbindTexture();
}
else if(m_canvas->m_current_stroke && m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index)
{
@@ -216,8 +216,8 @@ void NodeCanvas::draw()
ShaderManager::u_vec2(kShaderUniform::Resolution, Canvas::I->m_size);
ShaderManager::u_int(kShaderUniform::TexPattern, 4);
ShaderManager::u_float(kShaderUniform::StrokeAlpha, b->m_tip_opacity);
ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity);
ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index]->m_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::DrawOnScreen, true);
ShaderManager::u_int(kShaderUniform::BlendMode, b->m_blend_mode);
@@ -235,7 +235,7 @@ void NodeCanvas::draw()
ShaderManager::u_float(kShaderUniform::DualAlpha, b->m_dual_opacity);
glActiveTexture(GL_TEXTURE0);
m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
m_canvas->m_layers[layer_index]->m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1);
m_canvas->m_tmp[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE2);
@@ -255,7 +255,7 @@ void NodeCanvas::draw()
glActiveTexture(GL_TEXTURE1);
m_canvas->m_tmp[plane_index].unbindTexture();
glActiveTexture(GL_TEXTURE0);
m_canvas->m_layers[layer_index].m_rtt[plane_index].unbindTexture();
m_canvas->m_layers[layer_index]->m_rtt[plane_index].unbindTexture();
}
else
{
@@ -264,21 +264,21 @@ void NodeCanvas::draw()
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_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();
m_canvas->m_layers[layer_index]->m_rtt[plane_index].bindTexture();
glActiveTexture(GL_TEXTURE1);
m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
m_canvas->m_layers[layer_index]->m_rtt[plane_index].bindTexture();
m_face_plane.draw_fill();
glActiveTexture(GL_TEXTURE1);
m_canvas->m_layers[layer_index].m_rtt[plane_index].unbindTexture();
m_canvas->m_layers[layer_index]->m_rtt[plane_index].unbindTexture();
glActiveTexture(GL_TEXTURE0);
m_canvas->m_layers[layer_index].m_rtt[plane_index].unbindTexture();
m_canvas->m_layers[layer_index]->m_rtt[plane_index].unbindTexture();
}
if (use_blend)
@@ -298,7 +298,7 @@ void NodeCanvas::draw()
ShaderManager::u_int(kShaderUniform::TexA, 1);
if (!ShaderManager::ext_framebuffer_fetch)
ShaderManager::u_int(kShaderUniform::TexBG, 2);
ShaderManager::u_int(kShaderUniform::BlendMode, m_canvas->m_layers[layer_index].m_blend_mode);
ShaderManager::u_int(kShaderUniform::BlendMode, m_canvas->m_layers[layer_index]->m_blend_mode);
ShaderManager::u_float(kShaderUniform::Alpha, 1.f);
ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-1, 1, -1, 1));
@@ -330,7 +330,7 @@ void NodeCanvas::draw()
#ifdef _DEBUG
// draw dirty area
{
auto bb = m_canvas->m_layers[layer_index].m_dirty_box[plane_index] / (float)m_canvas->m_layers[layer_index].w;
auto bb = m_canvas->m_layers[layer_index]->m_dirty_box[plane_index] / (float)m_canvas->m_layers[layer_index]->w;
glm::vec2 bbmin = xy(bb);
glm::vec2 bbsz = zw(bb) - xy(bb);
ShaderManager::use(kShader::Color);

6
src/node_panel_layer.cpp
View File

@@ -283,7 +283,7 @@ void NodePanelLayer::clear()
void NodePanelLayer::update_attributes()
{
auto& l = Canvas::I->m_layers[Canvas::I->m_current_layer_idx];
m_opacity->set_value(l.m_opacity);
m_alpha_lock->set_value(l.m_alpha_locked);
m_blend_mode->set_index(l.m_blend_mode);
m_opacity->set_value(l->m_opacity);
m_alpha_lock->set_value(l->m_alpha_locked);
m_blend_mode->set_index(l->m_blend_mode);
}

15
src/rtt.cpp
View File

@@ -12,6 +12,21 @@ RTT::RTT()
bound = false;
}
RTT::RTT(RTT&& other)
{
fboID = other.fboID;
rboID = other.rboID;
w = other.w;
h = other.h;
bound = other.bound;
other.fboID = 0;
other.rboID = 0;
other.w = 0;
other.h = 0;
other.bound = false;
}
RTT::~RTT()
{
//destroy();

4
src/rtt.h
View File

@@ -13,8 +13,8 @@ class RTT
int h = 0;
public:
//RTT(const RTT&) = delete;
//RTT(RTT&&) = default;
RTT(const RTT&) = delete;
RTT(RTT&& other);
RTT();
~RTT();