remove glm swizzling for better debugability

engine/canvas.cpp

@@ -142,8 +142,8 @@ void ui::Canvas::snap_history(const std::vector<int>& planes)
         m_layers[m_current_layer_idx].m_rtt[i].bindFramebuffer();
 
         // save image before commit
-        glm::vec2 box_or = m_layers[m_current_layer_idx].m_dirty_box[i].xy();
+        glm::vec2 box_or = xy(m_layers[m_current_layer_idx].m_dirty_box[i]);
-        glm::vec2 box_sz = m_layers[m_current_layer_idx].m_dirty_box[i].zw() - m_layers[m_current_layer_idx].m_dirty_box[i].xy();
+        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]);
         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());
 
@@ -216,7 +216,7 @@ void ui::Canvas::stroke_draw()
     {
         // check if plane is even visible
         glm::vec4 forward = m_mv * glm::vec4(0, 0, 1, 1);
-        float dot = glm::dot(forward.xyz(), m_plane_normal[i]);
+        float dot = glm::dot(xyz(forward), m_plane_normal[i]);
         // TODO: use better threshold than 0.3
         // some trigonometric shit, tangent and stuff
 //        if (dot < -0.3f)
@@ -263,7 +263,7 @@ void ui::Canvas::stroke_draw()
                 for (int j = 0; j < 4; j++)
                 {
                     glm::vec3 ray_origin, ray_dir;
-                    point_unproject(s.pos + off[j] * glm::orientate2(-s.angle), { 0, 0, m_box.zw }, m_mv, m_proj, ray_origin, ray_dir);
+                    point_unproject(s.pos + off[j] * glm::orientate2(-s.angle), { 0, 0, zw(m_box) }, m_mv, m_proj, ray_origin, ray_dir);
                     glm::vec3 hit;
                     if (ray_intersect(ray_origin, ray_dir, m_plane_origin[i], m_plane_normal[i], m_plane_tangent[i], hit))
                     {
@@ -294,8 +294,8 @@ void ui::Canvas::stroke_draw()
                 glm::vec2 bb_max(0, 0);
                 for (int j = 0; j < 4; j++)
                 {
-                    bb_min = glm::max({ 0, 0 }, glm::min(bb_min, P[j].xy()));
+                    bb_min = glm::max({ 0, 0 }, glm::min(bb_min, xy(P[j])));
-                    bb_max = glm::min({ m_width, m_height }, glm::max(bb_max, P[j].xy()));
+                    bb_max = glm::min({ m_width, m_height }, glm::max(bb_max, xy(P[j])));
                 }
                 auto bb_sz = bb_max - bb_min;
                 
@@ -309,8 +309,10 @@ void ui::Canvas::stroke_draw()
                                     tex_sz.x, tex_sz.y);
                 #endif
                 
-                m_dirty_box[i].xy = glm::min(m_dirty_box[i].xy(), (glm::vec2)tex_pos);
+                m_dirty_box[i] = glm::vec4(
-                m_dirty_box[i].zw = glm::max(m_dirty_box[i].zw(), (glm::vec2)(tex_pos + tex_sz));
+                    glm::min(xy(m_dirty_box[i]), (glm::vec2)tex_pos),
+                    glm::max(zw(m_dirty_box[i]), (glm::vec2)(tex_pos + tex_sz))
+                    );
                 
                 ShaderManager::u_mat4(kShaderUniform::MVP, ortho_proj);
                 ShaderManager::u_float(kShaderUniform::Alpha, s.flow);
@@ -353,7 +355,7 @@ void ui::Canvas::stroke_draw()
 bool ui::Canvas::point_trace(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ray_dir,
                              glm::vec3& hit_pos, glm::vec2& fb_pos, glm::vec3& hit_normal, int& out_plane_id)
 {
-    point_unproject(loc, { 0, 0, m_box.zw }, m_mv, m_proj, ray_origin, ray_dir);
+    point_unproject(loc, { 0, 0, zw(m_box) }, m_mv, m_proj, ray_origin, ray_dir);
     glm::vec3 hit;
     for (int i = 0; i < 6; i++)
     {
@@ -379,7 +381,7 @@ bool ui::Canvas::point_trace(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ra
 bool ui::Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ray_dir,
                              glm::vec3& hit_pos, glm::vec3& hit_normal, glm::vec2& hit_fb_pos, int plane_id)
 {
-    point_unproject(loc, { 0, 0, m_box.zw }, m_mv, m_proj, ray_origin, ray_dir);
+    point_unproject(loc, { 0, 0, zw(m_box) }, m_mv, m_proj, ray_origin, ray_dir);
     glm::vec3 hit;
     glm::vec2 fb_pos;
     if (ray_intersect(ray_origin, ray_dir, m_plane_origin[plane_id],
@@ -413,12 +415,12 @@ bool ui::Canvas::ray_intersect(glm::vec3 ray_origin, glm::vec3 ray_dir, glm::vec
 void ui::Canvas::point_unproject(glm::vec2 loc, glm::vec4 vp, glm::mat4 camera, glm::mat4 proj,
                                  glm::vec3& out_origin, glm::vec3& out_dir)
 {
-    auto clip_space = glm::vec2(loc.x, vp.w - loc.y - 1.f) / vp.zw() * 2.f - 1.f;
+    auto clip_space = glm::vec2(loc.x, vp.w - loc.y - 1.f) / zw(vp) * 2.f - 1.f;
     auto inv = glm::inverse(proj * camera);
     auto wp0 = inv * glm::vec4(clip_space, 0, 1);
     auto wp1 = inv * glm::vec4(clip_space, .5, 1);
-    out_origin = (wp0 / wp0.w).xyz();
+    out_origin = xyz(wp0 / wp0.w);
-    out_dir = glm::normalize((wp1 / wp1.w).xyz() - out_origin);
+    out_dir = glm::normalize(xyz(wp1 / wp1.w) - out_origin);
 };
 void ui::Canvas::stroke_commit()
 {
@@ -449,7 +451,7 @@ void ui::Canvas::stroke_commit()
         m_layers[m_current_layer_idx].m_rtt[i].bindFramebuffer();
         
         // save image before commit
-        glm::vec2 box_sz = m_dirty_box[i].zw() - m_dirty_box[i].xy();
+        glm::vec2 box_sz = zw(m_dirty_box[i]) - xy(m_dirty_box[i]);
         action->m_image[i] = std::make_unique<uint8_t[]>(box_sz.x * box_sz.y * 4);
         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());
         
@@ -458,8 +460,10 @@ void ui::Canvas::stroke_commit()
         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];
-        lbox.xy = glm::min(m_dirty_box[i].xy(), lbox.xy());
+        lbox = glm::vec4(
-        lbox.zw = glm::max(m_dirty_box[i].zw(), lbox.zw());
+            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;
 
         // copy to tmp2 for layer blending
@@ -659,8 +663,10 @@ void ui::Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
 */
 
         auto& lbox = m_layers[dest_idx].m_dirty_box[i];
-        lbox.xy = glm::min(m_layers[source_idx].m_dirty_box[i].xy(), lbox.xy());
+        lbox = glm::vec4(
-        lbox.zw = glm::max(m_layers[source_idx].m_dirty_box[i].zw(), lbox.zw());
+            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;
 
         // copy to tmp2 for layer blending
@@ -1205,7 +1211,7 @@ void ui::Canvas::project_save_thread(std::string file_path)
             if (has_data)
             {
                 glm::ivec4 b = snap.m_dirty_box[plane_index];
-                glm::vec2 sz = b.zw() - b.xy();
+                glm::vec2 sz = zw(b) - xy(b);
                 int box[4] = { b.x, b.y, b.z, b.w };
                 fwrite(&box, sizeof(box), 1, fp);
                 
@@ -1331,7 +1337,7 @@ void ui::Canvas::project_open_thread(std::string file_path)
                 int b[4];
                 fread(&b, sizeof(b), 1, fp);
                 snap.m_dirty_box[plane_index] = glm::vec4(b[0], b[1], b[2], b[3]);
-                glm::vec2 sz = snap.m_dirty_box[plane_index].zw() - snap.m_dirty_box[plane_index].xy();
+                glm::vec2 sz = zw(snap.m_dirty_box[plane_index]) - xy(snap.m_dirty_box[plane_index]);
                 
                 int data_size;
                 fread(&data_size, sizeof(int), 1, fp);
@@ -1659,7 +1665,7 @@ void ui::Layer::restore(const Snapshot& snap)
 
         m_rtt[i].recreate(); // TODO: this should not be recreated here! Sorry I messed up with this, just quick fix DON'T SHIP!!
         m_rtt[i].bindTexture();
-        glm::vec2 box_sz = m_dirty_box[i].zw() - m_dirty_box[i].xy();
+        glm::vec2 box_sz = zw(m_dirty_box[i]) - xy(m_dirty_box[i]);
         glTexSubImage2D(GL_TEXTURE_2D, 0, m_dirty_box[i].x, m_dirty_box[i].y, box_sz.x, box_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, snap.image[i].get());
         m_rtt[i].unbindTexture();
         LOG("restore face %d - %d bytes (%dx%d)", i, (int)box_sz.x * (int)box_sz.y * 4, (int)box_sz.x, (int)box_sz.y);
@@ -1685,7 +1691,7 @@ ui::Layer::Snapshot ui::Layer::snapshot(std::string data_path)
 
         glReadBuffer(GL_BACK);
         m_rtt[i].bindFramebuffer();
-        glm::vec2 box_sz = m_dirty_box[i].zw() - m_dirty_box[i].xy();
+        glm::vec2 box_sz = zw(m_dirty_box[i]) - xy(m_dirty_box[i]);
         glReadPixels(m_dirty_box[i].x, m_dirty_box[i].y, box_sz.x, box_sz.y, GL_RGBA, GL_UNSIGNED_BYTE, snap.image[i].get());
         m_rtt[i].unbindFramebuffer();
         glReadBuffer(GL_NONE);

engine/canvas.h

@@ -186,7 +186,7 @@ public:
             m_canvas->m_layers[m_layer_idx].m_dirty_face[i] = m_old_dirty[i];
 
             m_canvas->m_layers[m_layer_idx].m_rtt[i].bindTexture();
-            glm::vec2 box_sz = m_box[i].zw() - m_box[i].xy();
+            glm::vec2 box_sz = zw(m_box[i]) - xy(m_box[i]);
             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();
         }
@@ -196,7 +196,7 @@ public:
         size_t mem = 0;
         for (int i = 0; i < 6; i++)
         {
-            glm::ivec2 sz = m_box[i].zw() - m_box[i].xy();
+            glm::ivec2 sz = zw(m_box[i]) - xy(m_box[i]);
             mem += sz.x * sz.y * 4 + sizeof(*this);
         }
         return mem;

engine/canvas_modes.cpp

@@ -246,7 +246,7 @@ void CanvasModeCamera::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
     case kEventType::MouseDownL:
         m_dragging = true;
         m_drag_start = me->m_pos;
-        m_pos_start = canvas->m_cam_pos.xy;
+        m_pos_start = xy(canvas->m_cam_pos);
         node->mouse_capture();
         break;
     case kEventType::MouseUpL:
@@ -256,7 +256,7 @@ void CanvasModeCamera::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
         break;
     case kEventType::MouseMove:
         if (m_dragging)
-            canvas->m_cam_pos.xy = m_pos_start + (me->m_pos - m_drag_start) * glm::vec2(1, -1) * 0.001f;
+            canvas->m_cam_pos = glm::vec3(m_pos_start + (me->m_pos - m_drag_start) * glm::vec2(1, -1) * 0.001f, canvas->m_cam_pos.z);
         break;
     case kEventType::MouseCancel:
         m_dragging = false;

engine/node_image.cpp

@@ -35,8 +35,8 @@ void NodeImage::create()
     {
         //LOG("load image node %s", m_path.c_str());
         auto tex_sz = TextureManager::get(m_tex_id).size();
-        m_off = m_region.xy / tex_sz;
+        m_off = xy(m_region) / tex_sz;
-        m_sz = (m_region.zw - m_region.xy) / tex_sz;
+        m_sz = (zw(m_region) - xy(m_region)) / tex_sz;
     }
 }
 

engine/node_scroll.cpp

@@ -13,7 +13,7 @@ void NodeScroll::fix_scroll()
     auto pad = GetPadding();
     glm::vec2 padoff = { pad.y + pad.w, pad.x + pad.z };
     auto rect = get_children_rect();
-    m_offset = glm::clamp(m_offset, -rect.zw() + m_clip_uncut.zw() - padoff, { 0, 0 });
+    m_offset = glm::clamp(m_offset, - zw(rect) + zw(m_clip_uncut) - padoff, { 0, 0 });
     m_pos_offset_childred = m_offset;
 }
 

engine/pch.h

@@ -93,7 +93,7 @@
 #include <condition_variable>
 
 #define GLM_FORCE_RADIANS
-#define GLM_FORCE_SWIZZLE
+//#define GLM_FORCE_SWIZZLE
 //#define GLM_FORCE_MESSAGES
 #define GLM_ENABLE_EXPERIMENTAL
 #include <glm/glm.hpp>

engine/shape.cpp

@@ -214,10 +214,10 @@ void ui::Plane::update_vertices(const glm::vec4* data)
     static vertex_t vertices[4];
     
     glm::vec2 mid;
-    segments_intersect(data[0].xy, data[2].xy, data[1].xy, data[3].xy, mid);
+    segments_intersect(xy(data[0]), xy(data[2]), xy(data[1]), xy(data[3]), mid);
     static float d[4];
     for (int i = 0; i < 4; i++)
-        d[i] = glm::distance(data[i].xy(), mid);
+        d[i] = glm::distance(xy(data[i]), mid);
 
     vertices[0] = { data[0],{ 0, 0 } }; // A
     vertices[1] = { data[1],{ 0, 1 } }; // B
@@ -385,8 +385,8 @@ void Rounded::create_impl(float w, float h, float r, int div, GLushort* idx, GLu
         for (int i = 1; i < div; i++)
         {
             float t = (float)(i) / div;
-            auto p = glm::normalize(glm::mix(v[a].pos.xyz()-v[c].pos.xyz(), v[b].pos.xyz()-v[c].pos.xyz(), t));
+            auto p = glm::normalize(glm::mix(xyz(v[a].pos)-xyz(v[c].pos), xyz(v[b].pos)-xyz(v[c].pos), t));
-            v[n].pos = glm::vec4(p * r + v[c].pos.xyz(), 1);
+            v[n].pos = glm::vec4(p * r + xyz(v[c].pos), 1.0f);
             v[n].uvs = glm::normalize(glm::mix(v[a].uvs-v[c].uvs, v[b].uvs-v[c].uvs, t)) * glm::vec2(r/w, r/h) + v[c].uvs;
             idx_tmp[i] = n;
             n++;

engine/util.cpp

@@ -11,12 +11,12 @@ bool point_in_rect(const glm::vec2& p, const glm::vec4& r)
 glm::vec4 rect_intersection(glm::vec4 a, glm::vec4 b)
 {
     // convert from [x,y,w,h] to [x1,y1,x2,y1]
-    a = glm::vec4(a.xy(), a.xy() + a.zw());
+    a = glm::vec4(xy(a), xy(a) + zw(a));
-    b = glm::vec4(b.xy(), b.xy() + b.zw());
+    b = glm::vec4(xy(b), xy(b) + zw(b));
     // compute intersection
-    auto o = glm::vec4(glm::max(a.xy(), b.xy()), glm::min(a.zw(), b.zw()));
+    auto o = glm::vec4(glm::max(xy(a), xy(b)), glm::min(zw(a), zw(b)));
     // back to rect form
-    o = glm::vec4(o.xy(), glm::max({ 0, 0 }, o.zw() - o.xy()));
+    o = glm::vec4(xy(o), glm::max({ 0, 0 }, zw(o) - xy(o)));
     return o;
 }
 
@@ -24,12 +24,12 @@ glm::vec4 rect_intersection(glm::vec4 a, glm::vec4 b)
 glm::vec4 rect_union(glm::vec4 a, glm::vec4 b)
 {
     // convert from rect [x,y,w,h] to bb [x1,y1,x2,y1]
-    a = glm::vec4(a.xy(), a.xy() + a.zw());
+    a = glm::vec4(xy(a), xy(a) + zw(a));
-    b = glm::vec4(b.xy(), b.xy() + b.zw());
+    b = glm::vec4(xy(b), xy(b) + zw(b));
     // compute union
-    glm::vec4 o = { glm::min(a.xy(), b.xy()), glm::max(a.zw(), b.zw()) };
+    glm::vec4 o = { glm::min(xy(a), xy(b)), glm::max(zw(a), zw(b)) };
     // back to rect form
-    o = glm::vec4(o.xy(), glm::max({ 0, 0 }, o.zw() - o.xy()));
+    o = glm::vec4(xy(o), glm::max({ 0, 0 }, zw(o) - xy(o)));
     return o;
 }
 
@@ -47,8 +47,8 @@ bool segments_intersect(const glm::vec2& p0a, const glm::vec2& p0b,
     if (den == 0.f)
     {
         glm::vec4 is = rect_intersection({p, r}, {q, s});
-        out_pt = is.xy + is.zw * 0.5f;
+        out_pt = xy(is) + zw(is) * 0.5f;
-        return glm::all(glm::greaterThan(is.zw(), glm::vec2(0, 0)));
+        return glm::all(glm::greaterThan(zw(is), glm::vec2(0, 0)));
     }
     float t = cross2d(q - p, s) / den;
     float u = cross2d(q - p, r) / den;
@@ -71,9 +71,9 @@ glm::vec4 rand_color()
 glm::vec3 convert_hsv2rgb(const glm::vec3 c)
 {
     glm::vec4 K = glm::vec4(1.0f, 2.0f / 3.0f, 1.0f / 3.0f, 3.0f);
-    glm::vec3 p = glm::abs(glm::fract(glm::vec3(c.xxx + K.xyz)) * 6.0f - K.www);
+    glm::vec3 p = glm::abs(glm::fract(glm::vec3(c.x) + xyz(K)) * 6.0f - glm::vec3(K.w));
-    auto tmp = glm::clamp(glm::vec3(p - K.xxx), 0.0f, 1.0f);
+    auto tmp = glm::clamp(p - glm::vec3(K.x), 0.0f, 1.0f);
-    return c.z * glm::mix(glm::vec3(K.xxx), tmp, c.y);
+    return c.z * glm::mix(glm::vec3(K.x), tmp, c.y);
 }
 
 glm::vec3 convert_rgb2hsv(const glm::vec3 c)
@@ -81,8 +81,8 @@ glm::vec3 convert_rgb2hsv(const glm::vec3 c)
     glm::vec4 K = glm::vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
     //glm::vec4 p = mix(glm::vec4(c.bg, K.wz), glm::vec4(c.gb, K.xy), glm::step(c.b, c.g));
     //glm::vec4 q = mix(glm::vec4(p.xyw, c.r), glm::vec4(c.r, p.yzx), glm::step(p.x, c.r));
-    glm::vec4 p = c.g < c.b ? glm::vec4(c.bg, K.wz) : glm::vec4(c.gb, K.xy);
+    glm::vec4 p = c.g < c.b ? glm::vec4(c.b, c.g, K.w, K.z) : glm::vec4(c.g, c.b, K.x, K.y);
-    glm::vec4 q = c.r < p.x ? glm::vec4(p.xyw, c.r) : glm::vec4(c.r, p.yzx);
+    glm::vec4 q = c.r < p.x ? glm::vec4(p.x, p.y, p.w, c.r) : glm::vec4(c.r, p.y, p.z, p.x);
     float d = q.x - glm::min(q.w, q.y);
     float e = 1.0e-10f;
     return glm::vec3(fabs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);

engine/util.h

@@ -19,6 +19,14 @@ glm::vec3 convert_rgb2hsv(const glm::vec3 c);
 size_t curl_data_handler(void *contents, size_t size, size_t nmemb, void *userp);
 size_t curl_data_write(void *ptr, size_t size, size_t nmemb, FILE *stream);
 void check_OpenGLError(const char* stmt, const char* fname, int line);
+inline glm::vec2 xy(const glm::vec4& v) { return glm::vec2(v.x, v.y); }
+inline glm::vec3 xyz(const glm::vec4& v) { return glm::vec3(v.x, v.y, v.z); }
+inline glm::vec2 zw(const glm::vec4& v) { return glm::vec2(v.z, v.w); }
+inline glm::ivec2 xy(const glm::ivec4& v) { return glm::ivec2(v.x, v.y); }
+inline glm::ivec3 xyz(const glm::ivec4& v) { return glm::ivec3(v.x, v.y, v.z); }
+inline glm::ivec2 zw(const glm::ivec4& v) { return glm::ivec2(v.z, v.w); }
+
+inline glm::vec2 xy(const glm::vec3& v) { return glm::vec2(v.x, v.y); }
 
 template<typename T, int N> struct cbuffer
 {