Refactor Slice / SliceRenderer to be less general; get away from "prop" overhead.

vis/include/geometry.hpp

@@ -7,6 +7,33 @@
 #include <iostream>
 #include "combo_iterator.hpp"
 
+template<int N>
+using vec = Eigen::Matrix<float, N, 1>;
+template<int N>
+using mat = Eigen::Matrix<float, N, N>;
+
+using vec1 = vec<1>;
+using vec2 = vec<2>;
+using vec3 = vec<3>;
+using vec4 = vec<4>;
+using vec5 = vec<5>;
+
+using mat1 = mat<1>;
+using mat2 = mat<2>;
+using mat3 = mat<3>;
+using mat4 = mat<4>;
+using mat5 = mat<5>;
+
+mat4 ortho(float left, float right, float bottom, float top, float front, float back) {
+    mat<4> res = mat4();
+    res <<
+        2 / (right - left), 0, 0, -(right + left) / (right - left),
+            0, 2 / (top - bottom), 0, -(top + bottom) / (top - bottom),
+            0, 0, 2 / (front - back), -(front + back) / (front - back),
+            0, 0, 0, 1;
+    return res;
+}
+
 /**
  * An primitive stage N indices.
  * @tparam N

vis/include/mirror.hpp

@@ -8,22 +8,7 @@
 
 #include <nanogui/glutil.h>
 
-template<int N>
-using vec = Eigen::Matrix<float, N, 1>;
-template<int N>
-using mat = Eigen::Matrix<float, N, N>;
-
-using vec1 = vec<1>;
-using vec2 = vec<2>;
-using vec3 = vec<3>;
-using vec4 = vec<4>;
-using vec5 = vec<5>;
-
-using mat1 = mat<1>;
-using mat2 = mat<2>;
-using mat3 = mat<3>;
-using mat4 = mat<4>;
-using mat5 = mat<5>;
+#include <geometry.hpp>
 
 template<class V>
 float dot(int n, const V &a, const V &b) {
@@ -143,13 +128,3 @@ mat<N> rot(int u, int v, float theta) {
     res(v, v) = std::cos(theta);
     return res;
 }
-
-mat4 ortho(float left, float right, float bottom, float top, float front, float back) {
-    mat<4> res = mat4();
-    res <<
-        2 / (right - left), 0, 0, -(right + left) / (right - left),
-        0, 2 / (top - bottom), 0, -(top + bottom) / (top - bottom),
-        0, 0, 2 / (front - back), -(front + back) / (front - back),
-        0, 0, 0, 1;
-    return res;
-}

vis/include/rendering.hpp

@@ -3,49 +3,98 @@
 #include <cgl/vertexarray.hpp>
 #include <cgl/buffer.hpp>
 #include <cgl/pipeline.hpp>
+
 #include <geometry.hpp>
+#include "mirror.hpp"
 
-#include <tuple>
+struct Matrices {
+    mat4 proj = mat4::Identity();
+    mat4 view = mat4::Identity();
 
-template<unsigned N, class... T>
-struct Prop {
-    cgl::VertexArray vao;
-    std::tuple<cgl::Buffer<T>...> vbos;
+    Matrices() = default;
+
+    Matrices(mat4 proj, mat4 view) : proj(std::move(proj)), view(std::move(view)) {}
+
+    static Matrices build(const nanogui::Screen &screen) {
+        auto aspect = (float) screen.width() / (float) screen.height();
+        auto pheight = 1.4f;
+        auto pwidth = aspect * pheight;
+        mat4 proj = ortho(-pwidth, pwidth, -pheight, pheight, -10.0f, 10.0f);
+
+        auto view = mat4::Identity();
+        return Matrices(proj, view);
+    }
+};
+
+template<class T>
+class Renderer {
+public:
+    virtual void draw(const T &prop) const = 0;
+};
+
+template<unsigned N>
+class Slice {
+private:
+    const tc::Group group;
+
+public:
     cgl::Buffer<Primitive<N>> ibo;
+    cgl::Buffer<vec4> vbo;
+    cgl::VertexArray vao;
+
+    template<class T>
+    Slice(const tc::Group &g, T all_sg_gens, const std::vector<std::vector<int>> &exclude) : group(g) {
+        ibo.put(merge<N>(hull<N>(g, all_sg_gens, exclude)));
+        vao.ipointer(0, ibo, 4, GL_UNSIGNED_INT);
+    }
+
+    void setPoints(const vec5 &root, mat5 transform = mat5::Identity()) {
+        auto cosets = group.solve();
+        auto mirrors = mirror<5>(group);
+
+        auto corners = plane_intersections(mirrors);
+        auto start = barycentric(corners, root);
+
+        auto higher = cosets.path.walk<vec5, vec5>(start, mirrors, reflect<vec5>);
+
+        std::transform(
+                higher.begin(), higher.end(), higher.begin(),
+                [&](const vec5& v) { return transform * v; }
+        );
+
+        std::vector<vec4> lower(higher.size());
+        std::transform(higher.begin(), higher.end(), lower.begin(), stereo<4>);
+
+        vbo.put(lower);
+    }
 };
 
-template<unsigned N, class T>
-struct Renderer {
-    cgl::pipeline pipe;
-
-    virtual void draw(const Prop<N, T> &prop) const = 0;
-};
-
-template<unsigned N, class T>
-struct SliceRenderer : public Renderer<N, T> {
+template<unsigned N>
+class SliceRenderer : public Renderer<Slice<N>> {
+private:
     cgl::pgm::vert defer = cgl::pgm::vert::file(
-        "shaders/slice/deferred.vs.glsl");
+            "shaders/slice/deferred.vs.glsl");
     cgl::pgm::geom slice = cgl::pgm::geom::file(
-        "shaders/slice/slice.gm.glsl");
+            "shaders/slice/slice.gm.glsl");
     cgl::pgm::frag solid = cgl::pgm::frag::file(
-        "shaders/solid.fs.glsl");
+            "shaders/solid.fs.glsl");
 
     cgl::pipeline pipe;
 
+    cgl::Buffer<Matrices> ubo;
+
+public:
     SliceRenderer() {
         pipe.stage(defer);
         pipe.stage(slice);
         pipe.stage(solid);
     }
 
-    void draw(const Prop<N, T> &prop) const override {
-        pipe.bound([&]() {
-            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, std::get<0>(prop.vbos));
-////        glProgramUniform3fv(solid, 2, 1, &prop.color.front());
-            glProgramUniform3f(solid, 2, 1.f, 1.f, 1.f);
-            prop.vao.bound([&]() {
-                glDrawArrays(GL_POINTS, 0, prop.ibo.count() * N);
-            });
-        });
+    void draw(const Slice<N> &prop) const {
+        glBindProgramPipeline(pipe);
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, prop.vbo);
+        glProgramUniform3f(solid, 2, 1.f, 1.f, 1.f);
+        glBindVertexArray(prop.vao);
+        glDrawArrays(GL_POINTS, 0, prop.ibo.count() * N);
     }
 };