Migrate to NanoGUI / Eigen for GUI and linear algebra.

Also introduce a GUI play/pause button.

vis/include/cgl/buffer.hpp

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <memory>
+
+#include <nanogui/opengl.h>
+
+namespace cgl {
+    template<class T>
+    class Buffer {
+        GLuint id{};
+
+    public:
+        Buffer() {
+            glCreateBuffers(1, &id);
+        }
+
+        Buffer(const T &data, GLenum usage = GL_STATIC_DRAW)
+            : Buffer() {
+            put(data, usage);
+        }
+
+        Buffer(const std::vector<T> &data, GLenum usage = GL_STATIC_DRAW)
+            : Buffer() {
+            put(data, usage);
+        }
+
+        Buffer(const Buffer &) = delete;
+
+        Buffer(Buffer &&o) noexcept {
+            id = std::exchange(o.id, 0);
+        };
+
+        ~Buffer() {
+            glDeleteBuffers(1, &id);
+            id = 0;
+        }
+
+        operator GLuint() const {
+            return id;
+        }
+
+        [[nodiscard]] size_t size() const {
+            GLint res;
+            glGetNamedBufferParameteriv(id, GL_BUFFER_SIZE, &res);
+            return (size_t) res;
+        }
+
+        [[nodiscard]] size_t count() const {
+            return size() / sizeof(T);
+        }
+
+        void put(const T &data, GLenum usage = GL_STATIC_DRAW) {
+            glNamedBufferData(id, sizeof(T), &data, usage);
+        }
+
+        void put(const std::vector<T> &data, GLenum usage = GL_STATIC_DRAW) {
+            glNamedBufferData(id, sizeof(T) * data.size(), &data[0], usage);
+        }
+
+        void bound(GLenum target, const std::function<void()> &action) const {
+            glBindBuffer(target, id);
+            action();
+            glBindBuffer(target, 0);
+        }
+
+        std::vector<T> getSubData(size_t offset, size_t count) const {
+            GLintptr glOffset = offset * sizeof(T);
+            GLsizeiptr glSize = count * sizeof(T);
+
+            std::vector<T> data(count);
+
+            glad_glGetNamedBufferSubData(id, glOffset, glSize, data.data());
+
+            return data;
+        }
+    };
+
+}

vis/include/cgl/error.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <stdexcept>
+
+#include <nanogui/opengl.h>
+
+namespace cgl {
+    class GlError : public std::domain_error {
+    public:
+        explicit GlError(const std::string &arg) : domain_error(arg) {}
+
+        explicit GlError(const char *string) : domain_error(string) {}
+    };
+
+    class ShaderError : public GlError {
+    public:
+        explicit ShaderError(const std::string &arg) : GlError(arg) {}
+
+        explicit ShaderError(const char *string) : GlError(string) {}
+    };
+
+    class ProgramError : public GlError {
+    public:
+        explicit ProgramError(const std::string &arg) : GlError(arg) {}
+
+        explicit ProgramError(const char *string) : GlError(string) {}
+    };
+}

vis/include/cgl/pipeline.hpp

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <utility>
+
+#include <nanogui/opengl.h>
+
+#include <cgl/error.hpp>
+#include <cgl/shaderprogram.hpp>
+
+#include <util.hpp>
+
+namespace cgl {
+    class pipeline {
+    protected:
+        GLuint id{};
+
+    public:
+        pipeline() {
+            glCreateProgramPipelines(1, &id);
+        }
+
+        pipeline(pipeline &) = delete;
+
+        pipeline(pipeline &&o) noexcept {
+            id = std::exchange(o.id, 0);
+        }
+
+        ~pipeline() {
+            glDeleteProgramPipelines(1, &id);
+            id = 0;
+        }
+
+        operator GLuint() const {
+            return id;
+        }
+
+        [[nodiscard]] int get(GLenum pname) const {
+            GLint res;
+            glGetProgramPipelineiv(id, pname, &res);
+            return (int) res;
+        }
+
+        [[nodiscard]] std::string get_info_log() const {
+            auto len = (size_t) get(GL_INFO_LOG_LENGTH);
+            char buffer[len];
+            glGetProgramPipelineInfoLog(id, len, nullptr, buffer);
+            return std::string(buffer);
+        }
+
+        pipeline &unstage(GLenum stage_bits) {
+            glUseProgramStages(id, stage_bits, 0);
+            return *this;
+        }
+
+        pipeline &stage(const ShaderProgram<GL_VERTEX_SHADER> &pgm) {
+            glUseProgramStages(id, GL_VERTEX_SHADER_BIT, pgm);
+            return *this;
+        }
+
+        pipeline &stage(const ShaderProgram<GL_TESS_CONTROL_SHADER> &pgm) {
+            glUseProgramStages(id, GL_TESS_CONTROL_SHADER_BIT, pgm);
+            return *this;
+        }
+
+        pipeline &stage(const ShaderProgram<GL_TESS_EVALUATION_SHADER> &pgm) {
+            glUseProgramStages(id, GL_TESS_EVALUATION_SHADER_BIT, pgm);
+            return *this;
+        }
+
+        pipeline &stage(const ShaderProgram<GL_GEOMETRY_SHADER> &pgm) {
+            glUseProgramStages(id, GL_GEOMETRY_SHADER_BIT, pgm);
+            return *this;
+        }
+
+        pipeline &stage(const ShaderProgram<GL_FRAGMENT_SHADER> &pgm) {
+            glUseProgramStages(id, GL_FRAGMENT_SHADER_BIT, pgm);
+            return *this;
+        }
+
+        pipeline &stage(const ShaderProgram<GL_COMPUTE_SHADER> &pgm) {
+            glUseProgramStages(id, GL_COMPUTE_SHADER_BIT, pgm);
+            return *this;
+        }
+
+        void bound(const std::function<void()> &action) const {
+            glBindProgramPipeline(id);
+            action();
+            glBindProgramPipeline(0);
+        }
+    };
+}

vis/include/cgl/program.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <string>
+#include <utility>
+
+#include <nanogui/opengl.h>
+
+#include <cgl/error.hpp>
+#include <cgl/shader.hpp>
+
+#include <util.hpp>
+
+namespace cgl {
+    class Program {
+    protected:
+        GLuint id{};
+
+    public:
+        Program() {
+            id = glCreateProgram();
+        }
+
+        Program(Program &) = delete;
+
+        Program(Program &&o) noexcept {
+            id = std::exchange(o.id, 0);
+        };
+
+        ~Program() {
+            glDeleteProgram(id);
+        }
+
+        operator GLuint() const {
+            return id;
+        }
+
+        [[nodiscard]] int get(GLenum pname) const {
+            GLint res;
+            glGetProgramiv(id, pname, &res);
+            return (int) res;
+        }
+
+        [[nodiscard]] std::string get_info_log() const {
+            auto len = (size_t) get(GL_INFO_LOG_LENGTH);
+            char buffer[len];
+            glGetProgramInfoLog(id, len, nullptr, buffer);
+            return std::string(buffer);
+        }
+
+        template<GLenum mode>
+        void attach(const Shader<mode> &sh) {
+            glAttachShader(id, sh);
+        }
+
+        template<GLenum mode>
+        void detach(const Shader<mode> &sh) {
+            glDetachShader(id, sh);
+        }
+
+        bool link() {
+            glLinkProgram(id);
+            return (bool) get(GL_LINK_STATUS);
+        }
+    };
+}

vis/include/cgl/shader.hpp

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <string>
+#include <utility>
+
+#include <nanogui/opengl.h>
+
+#include <cgl/error.hpp>
+
+#include <util.hpp>
+
+namespace cgl {
+    template<GLenum mode>
+    class Shader {
+    protected:
+        GLuint id{};
+
+    public:
+        Shader() {
+            id = glCreateShader(mode);
+        }
+
+        Shader(const std::string &src) : Shader() {
+            set_source(src);
+
+            if (!compile())
+                throw ShaderError(get_info_log());
+        }
+
+        static Shader<mode> file(const std::string &name) {
+            return Shader<mode>(utilReadFile(name));
+        }
+
+        Shader(Shader &) = delete;
+
+        Shader(Shader &&o) noexcept {
+            id = std::exchange(o.id, 0);
+        };
+
+        ~Shader() {
+            glDeleteShader(id);
+        }
+
+        operator GLuint() const {
+            return id;
+        }
+
+        [[nodiscard]] int get(GLenum pname) const {
+            GLint res;
+            glGetShaderiv(id, pname, &res);
+            return (int) res;
+        }
+
+        [[nodiscard]] std::string get_info_log() const {
+            auto len = (size_t) get(GL_INFO_LOG_LENGTH);
+            char buffer[len];
+            glGetShaderInfoLog(id, len, nullptr, buffer);
+            return std::string(buffer);
+        }
+
+        void set_source(const std::string &src) {
+            const char *c_src = src.c_str();
+            glShaderSource(id, 1, &c_src, nullptr);
+        }
+
+        bool compile() {
+            glCompileShader(id);
+            return (bool) get(GL_COMPILE_STATUS);
+        }
+    };
+
+    namespace sh {
+        using vert = Shader<GL_VERTEX_SHADER>;
+        using tcs = Shader<GL_TESS_CONTROL_SHADER>;
+        using tes = Shader<GL_TESS_EVALUATION_SHADER>;
+        using geom = Shader<GL_GEOMETRY_SHADER>;
+        using frag = Shader<GL_FRAGMENT_SHADER>;
+        using comp = Shader<GL_COMPUTE_SHADER>;
+    }
+}

vis/include/cgl/shaderprogram.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <string>
+#include <utility>
+
+#include <nanogui/opengl.h>
+
+#include <cgl/error.hpp>
+#include <cgl/shader.hpp>
+#include <cgl/program.hpp>
+
+#include <util.hpp>
+
+namespace cgl{
+    template<GLenum mode>
+    class ShaderProgram : public Program {
+    public:
+        ShaderProgram() : Program() {
+            glProgramParameteri(id, GL_PROGRAM_SEPARABLE, GL_TRUE);
+        }
+
+        ShaderProgram(const std::string &src) : ShaderProgram() {
+            Shader<mode> sh(src);
+
+            attach(sh);
+
+            if (!link())
+                throw ShaderError(get_info_log());
+
+            detach(sh);
+        }
+
+        static ShaderProgram<mode> file(const std::string &name) {
+            return ShaderProgram<mode>(utilReadFile(name));
+        }
+    };
+
+    namespace pgm {
+        using vert = ShaderProgram<GL_VERTEX_SHADER>;
+        using tcs = ShaderProgram<GL_TESS_CONTROL_SHADER>;
+        using tes = ShaderProgram<GL_TESS_EVALUATION_SHADER>;
+        using geom = ShaderProgram<GL_GEOMETRY_SHADER>;
+        using frag = ShaderProgram<GL_FRAGMENT_SHADER>;
+        using comp = ShaderProgram<GL_COMPUTE_SHADER>;
+    }
+}

vis/include/cgl/vertexarray.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <utility>
+
+#include <nanogui/opengl.h>
+
+#include <cgl/error.hpp>
+#include <cgl/buffer.hpp>
+
+namespace cgl {
+    class VertexArray {
+        GLuint id{};
+
+    public:
+        VertexArray() {
+            glCreateVertexArrays(1, &id);
+        }
+
+        VertexArray(VertexArray &) = delete;
+
+        VertexArray(VertexArray &&o) noexcept {
+            id = std::exchange(o.id, 0);
+        }
+
+        ~VertexArray() {
+            glDeleteVertexArrays(1, &id);
+            id = 0;
+        }
+
+        operator GLuint() const {
+            return id;
+        }
+
+        void bound(const std::function<void()> &action) const {
+            glBindVertexArray(id);
+            action();
+            glBindVertexArray(0);
+        }
+
+        template<class T>
+        void pointer(
+            GLuint index,
+            const Buffer<T> &buf,
+            unsigned size,
+            GLenum type,
+            bool normalized = false,
+            unsigned stride = 0
+        ) const {
+            bound([&]() {
+                glEnableVertexAttribArray(index);
+                buf.bound(GL_ARRAY_BUFFER, [&]() {
+                    glVertexAttribPointer(index, size, type, normalized, stride, nullptr);
+                });
+            });
+        }
+
+        template<class T>
+        void ipointer(
+            GLuint index,
+            const Buffer<T> &buf,
+            unsigned size,
+            GLenum type,
+            unsigned stride = 0
+        ) const {
+            bound([&]() {
+                glEnableVertexAttribArray(index);
+                buf.bound(GL_ARRAY_BUFFER, [&]() {
+                    glVertexAttribIPointer(index, size, type, stride, nullptr);
+                });
+            });
+        }
+    };
+}

vis/include/mirror.hpp

@@ -6,8 +6,12 @@
 #include <vector>
 #include <algorithm>
 
-template<unsigned N>
-using vec = std::array<float, N>;
+#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>;
@@ -15,75 +19,12 @@ using vec3 = vec<3>;
 using vec4 = vec<4>;
 using vec5 = vec<5>;
 
-template<unsigned N>
-using mat = std::array<std::array<float, N>, N>;
-
 using mat1 = mat<1>;
 using mat2 = mat<2>;
 using mat3 = mat<3>;
 using mat4 = mat<4>;
 using mat5 = mat<5>;
 
-template<class V>
-V operator*(V a, const float &b) {
-    for (auto &e : a) e *= b;
-    return a;
-}
-
-template<class V>
-V operator*(const float &b, V a) {
-    for (auto &e : a) e *= b;
-    return a;
-}
-
-template<class V>
-V operator/(V a, const float &b) {
-    for (auto &e : a) e /= b;
-    return a;
-}
-
-template<class V>
-V operator+(const V &a, V b) {
-    for (int i = 0; i < a.size(); ++i) {
-        a[i] += b[i];
-    }
-    return a;
-}
-
-template<class V>
-V operator-(V a, const V &b) {
-    for (int i = 0; i < a.size(); ++i) {
-        a[i] -= b[i];
-    }
-    return a;
-}
-
-template<class V>
-void operator-=(V &a, const V &b) {
-    for (int i = 0; i < a.size(); ++i) {
-        a[i] -= b[i];
-    }
-}
-
-template<class V>
-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 (const auto &e : a) sum += e * e;
-    return sqrtf(sum);
-}
-
-template<class V>
-V normalized(const V &a) {
-    return a / length(a);
-}
-
 template<class V>
 float dot(int n, const V &a, const V &b) {
     float sum = 0;
@@ -93,39 +34,6 @@ float dot(int n, const V &a, const V &b) {
     return sum;
 }
 
-template<class V>
-float dot(const V &a, const V &b) {
-    float sum = 0;
-    for (int i = 0; i < a.size(); ++i) {
-        sum += a[i] * b[i];
-    }
-    return sum;
-}
-
-vec5 mul(vec5 v, mat5 m) {
-    vec5 r{};
-
-    for (int i = 0; i < 5; ++i)
-        for (int j = 0; j < 5; ++j)
-            r[i] += m[i][j] * v[j];
-
-    return r;
-}
-
-mat5 mul(mat5 a, mat5 b) {
-    mat5 r{};
-
-    for (int i = 0; i < 5; ++i) {
-        for (int j = 0; j < 5; ++j) {
-            for (int k = 0; k < 5; ++k) {
-                r[i][j] += a[i][k] * b[k][j];
-            }
-        }
-    }
-
-    return r;
-}
-
 template<unsigned N>
 std::vector<vec<N>> mirror(const tc::Group &group) {
     std::vector<std::vector<float>> mirrors;
@@ -152,7 +60,7 @@ std::vector<vec<N>> mirror(const tc::Group &group) {
 
     std::vector<vec<N>> res;
     for (const auto &v : mirrors) {
-        vec<N> rv{};
+        vec<N> rv = vec<N>::Zero();
 
         // ortho proj
         for (int i = 0; i < std::min(v.size(), (size_t) N); ++i) {
@@ -184,7 +92,7 @@ vec<N> ortho(const vec<N + 1> &v) {
 
 template<class V>
 V project(const V &vec, const V &target) {
-    return dot(vec, target) / dot(target, target) * target;
+    return vec.dot(target) / target.dot(target) * target;
 }
 
 template<class V>
@@ -200,14 +108,14 @@ V gram_schmidt_last(std::vector<V> vecs) {
         }
     }
 
-    return normalized(vecs[vecs.size() - 1]);
+    return vecs[vecs.size() - 1].normalized();
 }
 
 template<class V, class C>
 V barycentric(const std::vector<V> &basis, const C &coords) {
-    V res{};
+    V res = V::Zero();
 
-    int N = std::min(basis.size(), coords.size());
+    int N = std::min((int) basis.size(), (int) coords.rows());
     for (int i = 0; i < N; ++i) {
         res += basis[i] * coords[i];
     }
@@ -226,29 +134,22 @@ std::vector<V> plane_intersections(std::vector<V> normals) {
     return results;
 }
 
-template<unsigned N>
-mat<N> identity() {
-    mat<N> res{};
-    for (int i = 0; i < N; ++i)
-        res[i][i] = 1;
-    return res;
-}
-
 template<unsigned N>
 mat<N> rot(int u, int v, float theta) {
-    auto res = identity<N>();
-    res[u][u] = std::cos(theta);
-    res[u][v] = std::sin(theta);
-    res[v][u] = -std::sin(theta);
-    res[v][v] = std::cos(theta);
+    mat<N> res = mat<N>::Identity();
+    res(u, u) = std::cos(theta);
+    res(u, v) = std::sin(theta);
+    res(v, u) = -std::sin(theta);
+    res(v, v) = std::cos(theta);
     return res;
 }
 
 mat4 ortho(float left, float right, float bottom, float top, float front, float back) {
-    return {
+    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,
-    };
+        0, 0, 0, 1;
+    return res;
 }

vis/include/util.hpp

@@ -1,13 +1,13 @@
 #pragma once
 
+#include <nanogui/opengl.h>
+
 #include <cerrno>
 #include <fstream>
 #include <sstream>
 #include <string>
 #include <vector>
 
-#include <glad/glad.h>
-
 std::string utilInfo() {
     std::stringstream ss;
     ss
@@ -19,6 +19,10 @@ std::string utilInfo() {
     return ss.str();
 }
 
+std::string utilGetString(GLenum name) {
+    return reinterpret_cast<char const*>(glGetString(name));
+}
+
 std::string utilReadFile(const std::string &filename) {
     std::ifstream in(filename, std::ios::in | std::ios::binary);
     if (in) {