solid wireframes working

vis/include/mirror.hpp

@@ -16,25 +16,25 @@ using vec4 = vec<4>;
 using vec5 = vec<5>;
 
 template<class V>
-V operator*(V a, float b) {
+V operator*(V a, const float &b) {
     for (auto &e : a) e *= b;
     return a;
 }
 
 template<class V>
-V operator*(float b, V a) {
+V operator*(const float &b, V a) {
     for (auto &e : a) e *= b;
     return a;
 }
 
 template<class V>
-V operator/(V a, float b) {
+V operator/(V a, const float &b) {
     for (auto &e : a) e /= b;
     return a;
 }
 
 template<class V>
-V operator+(V a, V b) {
+V operator+(const V &a, V b) {
     for (int i = 0; i < a.size(); ++i) {
         a[i] += b[i];
     }
@@ -42,7 +42,7 @@ V operator+(V a, V b) {
 }
 
 template<class V>
-V operator-(V a, V b) {
+V operator-(V a, const V &b) {
     for (int i = 0; i < a.size(); ++i) {
         a[i] -= b[i];
     }
@@ -50,21 +50,28 @@ V operator-(V a, V b) {
 }
 
 template<class V>
-void operator-=(V &a, V b) {
+void operator-=(V &a, const V &b) {
     for (int i = 0; i < a.size(); ++i) {
         a[i] -= b[i];
     }
 }
 
 template<class V>
-float length(V a) {
+void operator+=(V &a, const V &b) {
+    for (int i = 0; i < a.size(); ++i) {
+        a[i] += b[i];
+    }
+}
+
+template<class V>
+float length(const V &a) {
     float sum = 0;
-    for (auto e : a) sum += e * e;
+    for (const auto &e : a) sum += e * e;
     return sqrtf(sum);
 }
 
 template<class V>
-V normalized(V a) {
+V normalized(const V &a) {
     return a / length(a);
 }
 
@@ -125,10 +132,10 @@ std::vector<vec<N>> mirror(const tc::Group &group) {
 }
 
 template<unsigned N>
-vec<N> stereo(vec<N + 1> v) {
+vec<N> stereo(const vec<N + 1> &v) {
     vec<N> r;
     for (int i = 0; i < N; ++i) {
-        r[i] = v[i] / (1-v[N]);
+        r[i] = v[i] / (1 - v[N]);
     }
     return r;
 }
@@ -145,33 +152,31 @@ V reflect(const V &a, const V &axis) {
 
 template<class V>
 V gram_schmidt_last(std::vector<V> vecs) {
-    int N = vecs.size();
-    for (int i = 0; i < N; ++i) {
+    for (int i = 0; i < vecs.size(); ++i) {
         for (int j = 0; j < i; ++j) {
             vecs[i] -= project(vecs[i], vecs[j]);
         }
     }
 
-    return normalized(vecs[N - 1]);
+    return normalized(vecs[vecs.size() - 1]);
 }
 
 template<class V>
-V barycentric(std::vector<V> basis, std::vector<float> coords) {
+V barycentric(const std::vector<V> &basis, const std::vector<float> &coords) {
     V res{};
 
     int N = std::min(basis.size(), coords.size());
     for (int i = 0; i < N; ++i) {
-        res = res + (basis[i] * coords[i]);
+        res += basis[i] * coords[i];
     }
     return normalized(res);
 }
 
 template<class V>
 std::vector<V> plane_intersections(std::vector<V> normals) {
-    int N = normals.size();
-    std::vector<V> results(N);
+    std::vector<V> results(normals.size());
 
-    for (int i = 0; i < N; ++i) {
+    for (int i = 0; i < normals.size(); ++i) {
         std::rotate(normals.begin(), normals.begin() + 1, normals.end());
         results[i] = gram_schmidt_last(normals);
     }

vis/src/main.cpp

@@ -91,10 +91,8 @@ std::vector<std::vector<Primitive<N>>> poly_parts(const tc::Group &group) {
     for (const auto &sg_gens : Combos(g_gens, N - 1)) {
         const auto &base = triangulate<N>(group, sg_gens);
         const auto &all = tile(base, group, g_gens, sg_gens);
-//        const auto &all = recontext(base, group, g_gens, sg_gens);
         parts.push_back(all);
     }
-    parts.erase(parts.end() - 1, parts.end());
     return parts;
 }
 
@@ -126,7 +124,7 @@ std::vector<vec4> points(const tc::Group &group) {
 
     auto corners = plane_intersections(mirrors);
 
-    auto start = barycentric(corners, {1.00f, 0.2f, 0.1f, 0.05f, 0.025f});
+    auto start = barycentric(corners, {1.0f, 0.2f, 0.1f, 0.05f, 0.025f});
 //    auto start = barycentric(corners, {1.0f, 1.0f, 1.0f, 1.0f});
 //    auto start = barycentric(corners, {0.05f, 0.1f, 0.2f, 1.00f});
 
@@ -160,10 +158,12 @@ void run(GLFWwindow *window) {
     auto group = tc::schlafli({5, 3, 3, 2});
 
     auto wire_data = merge(poly_parts<2>(group));
-    const auto slice_dark = glm::vec3(.5, .3, .7);
     const auto slice_light = glm::vec3(.9, .9, .95);
+//    const auto slice_dark = slice_light;
+    const auto slice_dark = glm::vec3(.5, .3, .7);
 
-    const auto slice_parts = poly_parts<4>(group);
+    auto slice_parts = poly_parts<4>(group);
+    slice_parts.erase(slice_parts.end() - 1, slice_parts.end());
     auto slice_data = merge(slice_parts);
 
     auto slice_colors = std::vector<glm::vec3>(slice_data.size());
@@ -206,7 +206,7 @@ void run(GLFWwindow *window) {
 
         glProgramUniform3f(sh.solid, 2, 0.3, 0.3, 0.3);
         proj_pipe.bound([&]() {
-//            wires.draw_direct();
+            wires.draw_direct();
         });
 
         slice_pipe.bound([&]() {