From dfa44dbb55bddaa7425e3d7cc504cd2479b4c431 Mon Sep 17 00:00:00 2001
From: omigamedev <omarator@gmail.com>
Date: Sun, 24 Feb 2019 13:19:15 +0100
Subject: [PATCH] use unique_ptr to hold the Layers vector

---
 data/layout.xml          |  12 ++-
 src/app.cpp              |   4 +-
 src/app_cloud.cpp        |   2 +-
 src/app_dialogs.cpp      |   4 +-
 src/app_layout.cpp       |  28 ++---
 src/app_vr.cpp           |  34 +++---
 src/canvas.cpp           | 219 +++++++++++++++++++--------------------
 src/canvas.h             |   2 +-
 src/canvas_modes.cpp     |  46 ++++----
 src/node_canvas.cpp      |  40 +++----
 src/node_panel_layer.cpp |   6 +-
 src/rtt.cpp              |  15 +++
 src/rtt.h                |   4 +-
 13 files changed, 216 insertions(+), 200 deletions(-)

diff --git a/data/layout.xml b/data/layout.xml
index 627dd25..605f3f2 100644
--- a/data/layout.xml
+++ b/data/layout.xml
@@ -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">
diff --git a/src/app.cpp b/src/app.cpp
index fc1764c..3d29290 100644
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -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();
         }
diff --git a/src/app_cloud.cpp b/src/app_cloud.cpp
index 574dbd6..22b58d7 100644
--- a/src/app_cloud.cpp
+++ b/src/app_cloud.cpp
@@ -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();
diff --git a/src/app_dialogs.cpp b/src/app_dialogs.cpp
index 9795a84..f6bbd1c 100644
--- a/src/app_dialogs.cpp
+++ b/src/app_dialogs.cpp
@@ -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();
     };
diff --git a/src/app_layout.cpp b/src/app_layout.cpp
index 8f82f45..91cd506 100644
--- a/src/app_layout.cpp
+++ b/src/app_layout.cpp
@@ -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
                 {
diff --git a/src/app_vr.cpp b/src/app_vr.cpp
index 38831f3..55ada29 100644
--- a/src/app_vr.cpp
+++ b/src/app_vr.cpp
@@ -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();
             }
         }
     }
diff --git a/src/canvas.cpp b/src/canvas.cpp
index 803a458..da270c3 100644
--- a/src/canvas.cpp
+++ b/src/canvas.cpp
@@ -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;
diff --git a/src/canvas.h b/src/canvas.h
index 3e2a2be..1b02569 100644
--- a/src/canvas.h
+++ b/src/canvas.h
@@ -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));
diff --git a/src/canvas_modes.cpp b/src/canvas_modes.cpp
index b0245a7..4802fc5 100644
--- a/src/canvas_modes.cpp
+++ b/src/canvas_modes.cpp
@@ -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();
 }
diff --git a/src/node_canvas.cpp b/src/node_canvas.cpp
index d6e7f0a..1ab8fdc 100644
--- a/src/node_canvas.cpp
+++ b/src/node_canvas.cpp
@@ -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);
diff --git a/src/node_panel_layer.cpp b/src/node_panel_layer.cpp
index 16a696e..12ba2f4 100644
--- a/src/node_panel_layer.cpp
+++ b/src/node_panel_layer.cpp
@@ -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);
 }
diff --git a/src/rtt.cpp b/src/rtt.cpp
index 57457ca..0e40bc5 100644
--- a/src/rtt.cpp
+++ b/src/rtt.cpp
@@ -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();
diff --git a/src/rtt.h b/src/rtt.h
index 9549d33..6c84b18 100644
--- a/src/rtt.h
+++ b/src/rtt.h
@@ -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();