refactor mesh composition

framework/include/gl_util.h

@@ -1,7 +1,3 @@
-#include <utility>
-
-#include <utility>
-
 #ifndef GL_TEMPLATE_UTIL_H
 #define GL_TEMPLATE_UTIL_H
 

simplex/include/mesh.h

@@ -0,0 +1,152 @@
+#ifndef SIMPLEX_MESH_H
+#define SIMPLEX_MESH_H
+
+#include <algorithm>
+#include <vector>
+
+#include <glm/mat4x4.hpp>
+#include <glm/vec4.hpp>
+
+template<unsigned int prim>
+struct Mesh {
+    std::vector<glm::vec4> verts;
+    std::vector<unsigned> inds;
+
+    Mesh(std::vector<glm::vec4> verts, std::vector<unsigned> inds)
+        : verts(std::move(verts)), inds(std::move(inds)) {}
+
+    unsigned size() {
+        return (unsigned) inds.size() / prim;
+    }
+};
+
+template<unsigned int prim>
+Mesh<prim> concat(Mesh<prim> m, Mesh<prim> n) {
+    Mesh<prim> res({}, {});
+
+    for (auto v: m.verts) res.verts.push_back(v);
+    for (auto v: n.verts) res.verts.push_back(v);
+
+    auto off = (unsigned) m.verts.size();
+
+    for (auto i: m.inds) res.inds.push_back(i);
+    for (auto i: n.inds) res.inds.push_back(off + i);
+
+    return res;
+}
+
+template<unsigned int prim>
+Mesh<prim> transform(Mesh<prim> m, glm::mat4 mat) {
+    Mesh<prim> res(m.verts, m.inds);
+    for (auto &vert : res.verts)
+        vert = mat * vert;
+    return res;
+}
+
+template<unsigned int prim>
+Mesh<prim> offset(Mesh<prim> m, glm::vec4 off) {
+    Mesh<prim> res(m.verts, m.inds);
+    for (auto &vert : res.verts)
+        vert += off;
+    return res;
+}
+
+template<unsigned int prim>
+Mesh<prim> scale(Mesh<prim> m, glm::vec4 scl) {
+    Mesh<prim> res(m.verts, m.inds);
+    for (auto &vert : res.verts)
+        vert *= scl;
+    return res;
+}
+
+template<unsigned int prim>
+Mesh<prim> scale(Mesh<prim> m, float scl) {
+    return scale(m, glm::vec4(scl));
+}
+
+template<unsigned int prim>
+Mesh<prim + 1> pyramid(Mesh<prim> m, glm::vec4 apex) {
+    Mesh<prim + 1> res(m.verts, {});
+    res.verts.push_back(apex);
+    auto apex_ind = (unsigned) res.verts.size() - 1;
+
+    for (int i = 0; i < m.size(); ++i) {
+        for (int j = 0; j < prim; ++j) {
+            res.inds.push_back(m.inds[i * prim + j]);
+        }
+        res.inds.push_back(apex_ind);
+    }
+
+    return res;
+}
+
+template<unsigned int prim>
+Mesh<prim + 1> fill(Mesh<prim> m) {
+    Mesh<prim + 1> res(m.verts, {});
+
+    for (int i = 0; i < m.size(); ++i) {
+        for (int j = 0; j < prim; ++j) {
+            res.inds.push_back(m.inds[i * prim + j]);
+        }
+        res.inds.push_back(0);
+    }
+
+    return res;
+}
+
+template<unsigned int prim>
+Mesh<prim + 1> join(Mesh<prim> m, Mesh<prim> n) {
+    Mesh<prim + 1> res({}, {});
+
+    for (auto v : m.verts) res.verts.push_back(v);
+    for (auto v : n.verts) res.verts.push_back(v);
+
+    auto off = (unsigned) m.verts.size();
+    auto size = (int) std::min(m.inds.size(), n.inds.size());
+
+    for (int i = 0; i < size; i += prim) {
+        for (int j = 0; j < prim; ++j) {
+            for (int x = j; x < prim; ++x)
+                res.inds.push_back(m.inds[i + x]);
+            for (int x = 0; x <= j; ++x)
+                res.inds.push_back(off + n.inds[i + x]);
+        }
+    }
+
+    return res;
+}
+
+template<unsigned int prim>
+Mesh<prim + 1> joinCap(Mesh<prim> m, Mesh<prim> n) {
+    return concat(join(m, n), concat(fill(m), fill(n)));
+}
+
+Mesh<4> thicken(const Mesh<3> &m, float thickness) {
+    return joinCap(offset(m, glm::vec4(0, 0, 0, -thickness / 2)), offset(m, glm::vec4(0, 0, 0, thickness / 2)));
+}
+
+template<unsigned int prim>
+Mesh<prim> operator+(Mesh<prim> m, Mesh<prim> n) { return concat(m, n); }
+
+template<unsigned int prim>
+Mesh<prim> operator+(Mesh<prim> m, glm::vec4 off) { return offset(m, off); }
+
+template<unsigned int prim>
+Mesh<prim> operator-(Mesh<prim> m, glm::vec4 off) { return offset(m, -off); }
+
+template<unsigned int prim>
+Mesh<prim> operator*(Mesh<prim> m, glm::vec4 scl) { return scale(m, scl); }
+
+template<unsigned int prim>
+Mesh<prim> operator/(Mesh<prim> m, glm::vec4 scl) { return scale(m, 1.f / scl); }
+
+template<unsigned int prim>
+Mesh<prim> operator*(Mesh<prim> m, float scl) { return scale(m, scl); }
+
+template<unsigned int prim>
+Mesh<prim> operator/(Mesh<prim> m, float scl) { return scale(m, 1.f / scl); }
+
+template<unsigned int prim>
+Mesh<prim> operator*(glm::mat4 mat, Mesh<prim> m) { return transform(m, mat); }
+
+#endif //SIMPLEX_MESH_H

simplex/include/rotor.h

@@ -4,6 +4,7 @@
 #include <glm/vec4.hpp>
 #include <glm/mat4x4.hpp>
 #include <glm/gtc/type_ptr.hpp>
+
 #include <vsr/vsr.h>
 
 glm::mat4 rotor(glm::vec4 u, glm::vec4 v, float angle) {
@@ -12,7 +13,7 @@ glm::mat4 rotor(glm::vec4 u, glm::vec4 v, float angle) {
     auto eu = *((Vec *) (void *) &u);
     auto ev = *((Vec *) (void *) &v);
 
-    auto biv = (eu ^ ev).unit() * angle;
+    auto biv = (eu ^ ev).unit() * angle / 2;
 
     Vec col[4] = {
         Vec(1, 0, 0, 0).rotate(biv),
@@ -24,4 +25,16 @@ glm::mat4 rotor(glm::vec4 u, glm::vec4 v, float angle) {
     return glm::make_mat4((float *) col);
 }
 
+glm::mat4 rot_xy(float angle) { return rotor(glm::vec4(1, 0, 0, 0), glm::vec4(0, 1, 0, 0), angle); }
+
+glm::mat4 rot_xz(float angle) { return rotor(glm::vec4(1, 0, 0, 0), glm::vec4(0, 0, 1, 0), angle); }
+
+glm::mat4 rot_xw(float angle) { return rotor(glm::vec4(1, 0, 0, 0), glm::vec4(0, 0, 0, 1), angle); }
+
+glm::mat4 rot_yz(float angle) { return rotor(glm::vec4(0, 1, 0, 0), glm::vec4(0, 0, 1, 0), angle); }
+
+glm::mat4 rot_yw(float angle) { return rotor(glm::vec4(0, 1, 0, 0), glm::vec4(0, 0, 0, 1), angle); }
+
+glm::mat4 rot_zw(float angle) { return rotor(glm::vec4(0, 0, 1, 0), glm::vec4(0, 0, 0, 1), angle); }
+
 #endif //GL_TEMPLATE_ROTOR_H

simplex/include/solids.h

@@ -0,0 +1,50 @@
+#ifndef SIMPLEX_SOLIDS_H
+#define SIMPLEX_SOLIDS_H
+
+#include "mesh.h"
+#include "rotor.h"
+
+static auto T = (float) PI / 2;
+
+Mesh<2> poly(int sides) {
+    Mesh<2> res({}, {});
+
+    auto t = (float) (PI * 2 / sides);
+    float t0 = t / 2;
+    auto r = 1 / cos(t0);
+
+    for (int i = 0; i < sides; i++) {
+        glm::vec2 p = r * glm::vec2(cos(t0 + t * i), sin(t0 + t * i));
+        res.verts.emplace_back(p, 0, 0);
+    }
+
+    for (unsigned i = 0; i < sides - 1; i++) {
+        res.inds.push_back(i);
+        res.inds.push_back(i + 1);
+    }
+
+    return res;
+}
+
+Mesh<3> cube() {
+    glm::vec4 off = glm::vec4(0, 0, 1, 0);
+    Mesh<3> face = fill(poly(4));
+    Mesh<3> pair = (face + off) + (face - off);
+
+    return pair +
+        rot_xz(T) * pair +
+        rot_yz(T) * pair;
+}
+
+Mesh<4> tesseract() {
+    glm::vec4 off = glm::vec4(0, 0, 0, 1);
+    Mesh<4> cell = fill(cube());
+    Mesh<4> pair = (cell + off) + (cell - off);
+
+    return pair +
+        rot_xw(T) * pair +
+        rot_yw(T) * pair +
+        rot_zw(T) * pair;
+}
+
+#endif //SIMPLEX_SOLIDS_H

simplex/shaders/sect.geom

@@ -1,7 +1,7 @@
 #version 440 core
 
 layout(points) in;
-layout(triangle_strip, max_vertices=48) out;
+layout(triangle_strip, max_vertices=4) out;
 
 layout(std430, binding=1) buffer Positions {
     vec4 verts[];

simplex/shaders/wire.geom

@@ -1,7 +1,7 @@
 #version 440 core
 
 layout(points) in;
-layout(line_strip, max_vertices=48) out;
+layout(line_strip, max_vertices=20) out;
 
 layout(std430, binding=1) buffer Positions {
     vec4 verts[];

simplex/src/main.cpp

@@ -1,20 +1,14 @@
+#include <unordered_map>
+#include <vector>
+
 #include <framework.h>
-#include <util.h>
+#include <gl_util.h>
+#include <vsr/vsr.h>
 
 #include "glmutil.h"
+#include "mesh.h"
 #include "rotor.h"
-
+#include "solids.h"
-#include <glm/vec3.hpp>
-#include <glm/vec4.hpp>
-#include <glm/mat4x4.hpp>
-#include <glm/trigonometric.hpp>
-
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/type_ptr.hpp>
-
-#include <cstdlib>
-#include <cstdio>
-#include <vector>
 
 extern "C" {
 __attribute__((dllexport)) DWORD NvOptimusEnablement = 0x00000001;
@@ -28,64 +22,9 @@ struct Matrices {
     glm::mat4 proj;
 };
 
-void push_tetrahedron(std::vector<unsigned> *inds, const std::vector<unsigned> &tetra) {
-    for (int i = 0; i < 4; ++i) {
-        inds->push_back(tetra[i]);
-    }
-}
-
-void push_cube(std::vector<unsigned> *inds, const std::vector<unsigned> &cube) {
-    push_tetrahedron(inds, {cube[0], cube[1], cube[2], cube[4]});
-    push_tetrahedron(inds, {cube[1], cube[4], cube[5], cube[7]});
-    push_tetrahedron(inds, {cube[1], cube[2], cube[3], cube[7]});
-    push_tetrahedron(inds, {cube[2], cube[4], cube[6], cube[7]});
-    push_tetrahedron(inds, {cube[1], cube[2], cube[4], cube[7]});
-}
-
-void push_tesseract(std::vector<unsigned> *inds, const std::vector<unsigned> &tess) {
-    push_cube(inds, {tess[0], tess[1], tess[2], tess[3], tess[4], tess[5], tess[6], tess[7]});
-    push_cube(inds, {tess[8], tess[9], tess[10], tess[11], tess[12], tess[13], tess[14], tess[15]});
-    push_cube(inds, {tess[0], tess[1], tess[2], tess[3], tess[8], tess[9], tess[10], tess[11]});
-    push_cube(inds, {tess[4], tess[5], tess[6], tess[7], tess[12], tess[13], tess[14], tess[15]});
-    push_cube(inds, {tess[0], tess[1], tess[4], tess[5], tess[8], tess[9], tess[12], tess[13]});
-    push_cube(inds, {tess[2], tess[3], tess[6], tess[7], tess[10], tess[11], tess[14], tess[15]});
-    push_cube(inds, {tess[0], tess[2], tess[4], tess[6], tess[8], tess[10], tess[12], tess[14]});
-    push_cube(inds, {tess[1], tess[3], tess[5], tess[7], tess[9], tess[11], tess[13], tess[15]});
-}
-
-void build_tesseract(std::vector<unsigned> *inds, std::vector<glm::vec4> *verts, const glm::vec4 center,
-    const glm::vec4 size) {
-    const glm::vec4 rad = size / 2.f;
-
-    std::vector<glm::vec4> new_verts = {
-        {center.x + size.x, center.y + size.y, center.z + size.z, center.w + size.w},
-        {center.x + size.x, center.y + size.y, center.z + size.z, center.w - size.w},
-        {center.x + size.x, center.y + size.y, center.z - size.z, center.w + size.w},
-        {center.x + size.x, center.y + size.y, center.z - size.z, center.w - size.w},
-        {center.x + size.x, center.y - size.y, center.z + size.z, center.w + size.w},
-        {center.x + size.x, center.y - size.y, center.z + size.z, center.w - size.w},
-        {center.x + size.x, center.y - size.y, center.z - size.z, center.w + size.w},
-        {center.x + size.x, center.y - size.y, center.z - size.z, center.w - size.w},
-        {center.x - size.x, center.y + size.y, center.z + size.z, center.w + size.w},
-        {center.x - size.x, center.y + size.y, center.z + size.z, center.w - size.w},
-        {center.x - size.x, center.y + size.y, center.z - size.z, center.w + size.w},
-        {center.x - size.x, center.y + size.y, center.z - size.z, center.w - size.w},
-        {center.x - size.x, center.y - size.y, center.z + size.z, center.w + size.w},
-        {center.x - size.x, center.y - size.y, center.z + size.z, center.w - size.w},
-        {center.x - size.x, center.y - size.y, center.z - size.z, center.w + size.w},
-        {center.x - size.x, center.y - size.y, center.z - size.z, center.w - size.w},
-    };
-
-    std::vector<unsigned> new_inds;
-    for (int i = 0; i < 16; i++) new_inds.push_back((unsigned) verts->size() + i);
-    for (auto vert: new_verts) verts->push_back(vert);
-
-    push_tesseract(inds, new_inds);
-}
-
 class GLApp : public App {
-    std::vector<glm::vec4> cell_verts{};
+    Mesh<4> mesh = Mesh<4>({}, {});
-    std::vector<unsigned> cell_elems{};
+
     Matrices matrices{};
 
     GLuint cell_array{};
@@ -100,68 +39,9 @@ class GLApp : public App {
     bool DRAW_WIRE = true;
 
     void init() override {
-        const bool CUBE = false;
+        mesh = tesseract();
-        const bool TESS = true;
-
-        //region tesseract frame
-        if (TESS) {
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, -0.875, -0.875, +0.00}, {0.125, 0.125, 0.125, 1.000});
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, -0.875, +0.875, +0.00}, {0.125, 0.125, 0.125, 1.000});
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, +0.875, -0.875, +0.00}, {0.125, 0.125, 0.125, 1.000});
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, +0.875, +0.875, +0.00}, {0.125, 0.125, 0.125, 1.000});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, -0.875, -0.875, +0.00}, {0.125, 0.125, 0.125, 1.000});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, -0.875, +0.875, +0.00}, {0.125, 0.125, 0.125, 1.000});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, +0.875, -0.875, +0.00}, {0.125, 0.125, 0.125, 1.000});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, +0.875, +0.875, +0.00}, {0.125, 0.125, 0.125, 1.000});
-
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, -0.875, +0.00, -0.875}, {0.125, 0.125, 0.750, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, -0.875, +0.00, +0.875}, {0.125, 0.125, 0.750, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, +0.875, +0.00, -0.875}, {0.125, 0.125, 0.750, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, +0.875, +0.00, +0.875}, {0.125, 0.125, 0.750, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, -0.875, +0.00, -0.875}, {0.125, 0.125, 0.750, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, -0.875, +0.00, +0.875}, {0.125, 0.125, 0.750, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, +0.875, +0.00, -0.875}, {0.125, 0.125, 0.750, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, +0.875, +0.00, +0.875}, {0.125, 0.125, 0.750, 0.125});
-
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, +0.00, -0.875, -0.875}, {0.125, 0.750, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, +0.00, -0.875, +0.875}, {0.125, 0.750, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, +0.00, +0.875, -0.875}, {0.125, 0.750, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, +0.00, +0.875, +0.875}, {0.125, 0.750, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, +0.00, -0.875, -0.875}, {0.125, 0.750, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, +0.00, -0.875, +0.875}, {0.125, 0.750, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, +0.00, +0.875, -0.875}, {0.125, 0.750, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, +0.00, +0.875, +0.875}, {0.125, 0.750, 0.125, 0.125});
-
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, -0.875, -0.875, -0.875}, {0.750, 0.125, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, -0.875, -0.875, +0.875}, {0.750, 0.125, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, -0.875, +0.875, -0.875}, {0.750, 0.125, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, -0.875, +0.875, +0.875}, {0.750, 0.125, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, +0.875, -0.875, -0.875}, {0.750, 0.125, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, +0.875, -0.875, +0.875}, {0.750, 0.125, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, +0.875, +0.875, -0.875}, {0.750, 0.125, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, +0.875, +0.875, +0.875}, {0.750, 0.125, 0.125, 0.125});
-        }
-        //endregion
-
-        //region cube frame
-        if (CUBE) {
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, -0.875, +0.00, +0.00}, {0.125, 0.125, 1.000, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, +0.875, +0.00, +0.00}, {0.125, 0.125, 1.000, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, -0.875, +0.00, +0.00}, {0.125, 0.125, 1.000, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, +0.875, +0.00, +0.00}, {0.125, 0.125, 1.000, 0.125});
-
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, +0.00, -0.875, +0.00}, {0.125, 0.750, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {-0.875, +0.00, +0.875, +0.00}, {0.125, 0.750, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, +0.00, -0.875, +0.00}, {0.125, 0.750, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.875, +0.00, +0.875, +0.00}, {0.125, 0.750, 0.125, 0.125});
-
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, -0.875, -0.875, +0.00}, {0.750, 0.125, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, -0.875, +0.875, +0.00}, {0.750, 0.125, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, +0.875, -0.875, +0.00}, {0.750, 0.125, 0.125, 0.125});
-            build_tesseract(&cell_elems, &cell_verts, {+0.00, +0.875, +0.875, +0.00}, {0.750, 0.125, 0.125, 0.125});
-        }
-        //endregion
 
+        //region Uniforms
         matrices = {
             glm::identity<glm::mat4>(),
             glm::vec4(0),
@@ -169,6 +49,7 @@ class GLApp : public App {
             glm::identity<glm::mat4>(),
             glm::identity<glm::mat4>(),
         };
+        //endregion
 
         //region Shaders
         GLuint main_vs = util::buildShader(GL_VERTEX_SHADER, {"shaders/main.vert"});
@@ -191,12 +72,12 @@ class GLApp : public App {
         glGenBuffers(1, &cell_vert_buf);
         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, verts_binding_point, cell_vert_buf);
         glBindBuffer(GL_SHADER_STORAGE_BUFFER, cell_vert_buf);
-        util::bufferData(GL_SHADER_STORAGE_BUFFER, cell_verts, GL_STATIC_DRAW);
+        util::bufferData(GL_SHADER_STORAGE_BUFFER, mesh.verts, GL_STATIC_DRAW);
         glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 
         glGenBuffers(1, &cell_elem_arr_buf);
         glBindBuffer(GL_ARRAY_BUFFER, cell_elem_arr_buf);
-        util::bufferData(GL_ARRAY_BUFFER, cell_elems, GL_STATIC_DRAW);
+        util::bufferData(GL_ARRAY_BUFFER, mesh.inds, GL_STATIC_DRAW);
         glBindBuffer(GL_ARRAY_BUFFER, 0);
 
         glGenBuffers(1, &matrix_buffer);
@@ -226,16 +107,14 @@ class GLApp : public App {
         float ratio = (float) width / height;
 
         matrices.model = glm::identity<glm::mat4>() *
-//            rotor(glm::vec4(1, 0, 0, 0), glm::vec4(0, 1, 0, 0), getTime() / 5) *
+            rotor(glm::vec4(1, 0, 0, 0), glm::vec4(0, 0, 0, 1), getTime() / 3) *
+            rotor(glm::vec4(0, 1, 0, 0), glm::vec4(0, 0, 1, 0), getTime() / 3) *
 
-//            rotor(glm::vec4(1, 1, 1, 0), glm::vec4(0, 0, 0, 1), 1) *
+//            rotor(glm::vec4(1, 1, 1, 0), glm::vec4(0, 0, 0, 1), getTime() / 3) *
-//            rotor(glm::vec4(1, 0, 0, 0), glm::vec4(0, 0, 0, 1), 1) *
+//            rotor(glm::vec4(1, 0, 0, 0), glm::vec4(0, 0, 1, 0), getTime() / 3) *
-
-            rotor(glm::vec4(1, 1, 1, 0), glm::vec4(0, 0, 0, 1), getTime() / 4) *
-            rotor(glm::vec4(1, 0, 0, 0), glm::vec4(0, 0, 0, 1), getTime() / 5) *
             1.f;
 
-//        matrices.offset.w = sin(getTime() / 3) * 1.8f;
+//        matrices.offset = glm::vec4(0,0,0,sin(getTime() / 2));
 
         matrices.view = glm::lookAt(glm::vec3(0, 0, -4), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
         matrices.proj = glm::perspective(1.f, ratio, 0.1f, 20.0f);
@@ -260,11 +139,12 @@ class GLApp : public App {
         glBindVertexArray(cell_array);
 
         glUseProgram(sect_prog);
-        glDrawArrays(GL_POINTS, 0, (GLsizei) cell_elems.size() / 4);
+        glDrawArrays(GL_POINTS, 0, mesh.size());
 
         if (DRAW_WIRE) {
+            glClear(GL_DEPTH_BUFFER_BIT);
             glUseProgram(wire_prog);
-            glDrawArrays(GL_POINTS, 0, (GLsizei) cell_elems.size() / 4);
+            glDrawArrays(GL_POINTS, 0, mesh.size());
         }
 
         glBindVertexArray(0);