mirror of
https://github.com/allemangD/toddcox-visualize.git
synced 2025-11-10 12:02:47 -05:00
290 lines
8.9 KiB
C++
290 lines
8.9 KiB
C++
#include <glad/glad.h>
|
|
#include <GLFW/glfw3.h>
|
|
#include <iostream>
|
|
|
|
#include <tc/groups.h>
|
|
#include <tc/solver.h>
|
|
|
|
#include "geom.h"
|
|
|
|
#include <glm/gtc/type_ptr.hpp>
|
|
#include <glm/gtx/string_cast.hpp>
|
|
|
|
#ifdef _WIN32
|
|
extern "C" {
|
|
__attribute__((unused)) __declspec(dllexport) int NvOptimusEnablement = 0x00000001;
|
|
}
|
|
#endif
|
|
|
|
void utilShaderSource(GLuint shader, const std::vector<std::string> &sources) {
|
|
char const *ptrs[sources.size()];
|
|
for (size_t i = 0; i < sources.size(); ++i) {
|
|
ptrs[i] = sources[i].c_str();
|
|
}
|
|
glShaderSource(shader, sources.size(), ptrs, nullptr);
|
|
}
|
|
|
|
std::string utilShaderInfoLog(GLuint shader) {
|
|
int len;
|
|
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
|
|
char buffer[len];
|
|
glGetShaderInfoLog(shader, len, nullptr, buffer);
|
|
return std::string(buffer);
|
|
}
|
|
|
|
std::string utilProgramInfoLog(GLuint program) {
|
|
int len;
|
|
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &len);
|
|
char buffer[len];
|
|
glGetProgramInfoLog(program, len, nullptr, buffer);
|
|
return std::string(buffer);
|
|
}
|
|
|
|
std::vector<int> build(const tc::Group &g, std::vector<int> gens) {
|
|
std::cout << g.name << std::endl;
|
|
|
|
if (g.trivial()) return {0};
|
|
|
|
std::vector<int> res;
|
|
|
|
auto root = tc::solve(g);
|
|
|
|
for (size_t i = 0; i < gens.size(); ++i) {
|
|
std::vector<int> sub(gens);
|
|
sub.erase(sub.begin() + i);
|
|
|
|
auto base = build(g.shrink(sub), sub);
|
|
for (auto e : base) {
|
|
res.push_back(e);
|
|
}
|
|
res.push_back(0);
|
|
}
|
|
|
|
auto map = tc::solve(g, gens);
|
|
size_t N = res.size();
|
|
res.resize(N * map.size());
|
|
,.
|
|
for (size_t i = 1; i < res.size(); ++i) {
|
|
auto action = map.path[i];
|
|
for (size_t j = 0; j < N; ++j) {
|
|
res[i * N + j] = root.get(res[action.coset * N + j], action.gen);
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
if (!glfwInit()) {
|
|
std::cerr << "Failed to initialize GLFW" << std::endl;
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
auto window = glfwCreateWindow(
|
|
1920, 1080,
|
|
"Coset Visualization",
|
|
nullptr, nullptr);
|
|
|
|
if (!window) {
|
|
std::cerr << "Failed to create window" << std::endl;
|
|
glfwTerminate();
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
glfwMakeContextCurrent(window);
|
|
gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
|
|
glfwSwapInterval(0);
|
|
|
|
std::cout
|
|
<< "Graphics Information:" << std::endl
|
|
<< " Vendor: " << glGetString(GL_VENDOR) << std::endl
|
|
<< " Renderer: " << glGetString(GL_RENDERER) << std::endl
|
|
<< " OpenGL version: " << glGetString(GL_VERSION) << std::endl
|
|
<< " Shading version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
|
|
|
|
auto group = tc::group::B(3);
|
|
auto res = tc::solve(group);
|
|
auto mirrors = mirror(group);
|
|
auto corners = plane_intersections(mirrors);
|
|
|
|
auto points = std::vector<glm::vec4>(res.size());
|
|
points[0] = barycentric(corners, {1.00f, 0.50f, 0.50f, 0.50f});
|
|
for (int i = 1; i < res.size(); ++i) {
|
|
auto action = res.path[i];
|
|
points[i] = reflect(points[action.coset], mirrors[action.gen]);
|
|
}
|
|
|
|
auto res0 = tc::solve(group, {0});
|
|
auto res0_inds = std::vector<int>(res0.size() * 2);
|
|
res0_inds[0] = res.get(0, 0);
|
|
res0_inds[1] = 0;
|
|
for (int i = 1; i < res0.size(); ++i) {
|
|
auto action = res0.path[i];
|
|
res0_inds[i * 2 + 0] = res.get(res0_inds[action.coset * 2 + 0], action.gen);
|
|
res0_inds[i * 2 + 1] = res.get(res0_inds[action.coset * 2 + 1], action.gen);
|
|
}
|
|
|
|
auto res1 = tc::solve(group, {1});
|
|
auto res1_inds = std::vector<int>(res1.size() * 2);
|
|
res1_inds[0] = res.get(0, 1);
|
|
res1_inds[1] = 0;
|
|
for (int i = 1; i < res1.size(); ++i) {
|
|
auto action = res1.path[i];
|
|
res1_inds[i * 2 + 0] = res.get(res1_inds[action.coset * 2 + 0], action.gen);
|
|
res1_inds[i * 2 + 1] = res.get(res1_inds[action.coset * 2 + 1], action.gen);
|
|
}
|
|
|
|
auto res2 = tc::solve(group, {2});
|
|
auto res2_inds = std::vector<int>(res2.size() * 2);
|
|
res2_inds[0] = res.get(0, 2);
|
|
res2_inds[1] = 0;
|
|
for (int i = 1; i < res2.size(); ++i) {
|
|
auto action = res2.path[i];
|
|
res2_inds[i * 2 + 0] = res.get(res2_inds[action.coset * 2 + 0], action.gen);
|
|
res2_inds[i * 2 + 1] = res.get(res2_inds[action.coset * 2 + 1], action.gen);
|
|
}
|
|
|
|
// auto res01 = tc::solve(group, {0, 1});
|
|
// auto res01_inds = std::vector<int>(res01.size() * 3);
|
|
// res01_inds[0] = res.get(0, 0);
|
|
// res01_inds[1] = res.get(0, 1);
|
|
// res01_inds[2] = 0;
|
|
// for (int i = 0; i < res01.size(); ++i) {
|
|
// auto action = res01.path[i];
|
|
// for (int j = 0; j < 3; ++j) {
|
|
// res01_inds[i * 3 + j] = res.get(res01_inds[action.coset * 3 + j], action.gen);
|
|
// }
|
|
// }
|
|
|
|
auto test_inds = build(group, {0, 1, 2});
|
|
std::cout << "done" << std::endl;
|
|
|
|
auto test_mode = GL_TRIANGLES;
|
|
|
|
GLuint vs = glCreateShader(GL_VERTEX_SHADER);
|
|
utilShaderSource(vs, {
|
|
"#version 430\n",
|
|
|
|
"layout(location=0) uniform mat4 proj;"
|
|
"layout(location=1) uniform mat4 view;"
|
|
""
|
|
"layout(location=0) in vec4 pos;"
|
|
""
|
|
"void main() {"
|
|
" int i = gl_VertexID;"
|
|
" gl_Position = proj * view * vec4(pos.xyz, 1);"
|
|
" gl_PointSize = 5;"
|
|
"}"
|
|
});
|
|
glCompileShader(vs);
|
|
|
|
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
|
|
utilShaderSource(fs, {
|
|
"#version 430\n",
|
|
|
|
"layout(location=2) uniform float gray;"
|
|
""
|
|
"out vec4 color;"
|
|
""
|
|
"void main() {"
|
|
" color = vec4(gray);"
|
|
"}"
|
|
});
|
|
|
|
GLuint pgm = glCreateProgram();
|
|
glAttachShader(pgm, vs);
|
|
glAttachShader(pgm, fs);
|
|
glLinkProgram(pgm);
|
|
|
|
GLint status;
|
|
|
|
glGetShaderiv(vs, GL_COMPILE_STATUS, &status);
|
|
if (!status) {
|
|
std::cerr << utilShaderInfoLog(vs) << "\n=========\n" << std::endl;
|
|
}
|
|
|
|
glGetShaderiv(fs, GL_COMPILE_STATUS, &status);
|
|
if (!status) {
|
|
std::cerr << utilShaderInfoLog(fs) << "\n=========\n" << std::endl;
|
|
}
|
|
|
|
glGetProgramiv(pgm, GL_LINK_STATUS, &status);
|
|
if (!status) {
|
|
std::cerr << utilProgramInfoLog(pgm) << "\n=========\n" << std::endl;
|
|
glfwTerminate();
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
GLuint vbo;
|
|
glGenBuffers(1, &vbo);
|
|
glBindBuffer(GL_ARRAY_BUFFER, vbo);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec4) * points.size(), &points[0], GL_STATIC_DRAW);
|
|
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 4, GL_FLOAT, false, 0, nullptr);
|
|
|
|
GLuint res0_ibo;
|
|
glGenBuffers(1, &res0_ibo);
|
|
glBindBuffer(GL_ARRAY_BUFFER, res0_ibo);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(int) * res0_inds.size(), &res0_inds[0], GL_STATIC_DRAW);
|
|
|
|
GLuint res1_ibo;
|
|
glGenBuffers(1, &res1_ibo);
|
|
glBindBuffer(GL_ARRAY_BUFFER, res1_ibo);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(int) * res1_inds.size(), &res1_inds[0], GL_STATIC_DRAW);
|
|
|
|
GLuint res2_ibo;
|
|
glGenBuffers(1, &res2_ibo);
|
|
glBindBuffer(GL_ARRAY_BUFFER, res2_ibo);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(int) * res2_inds.size(), &res2_inds[0], GL_STATIC_DRAW);
|
|
|
|
GLuint test_ibo;
|
|
glGenBuffers(1, &test_ibo);
|
|
glBindBuffer(GL_ARRAY_BUFFER, test_ibo);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(int) * test_inds.size(), &test_inds[0], GL_STATIC_DRAW);
|
|
|
|
while (!glfwWindowShouldClose(window)) {
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
glUseProgram(pgm);
|
|
glEnable(GL_PROGRAM_POINT_SIZE);
|
|
glEnable(GL_POINT_SMOOTH);
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
int width, height;
|
|
glfwGetFramebufferSize(window, &width, &height);
|
|
glViewport(0, 0, width, height);
|
|
auto aspect = (float) width / (float) height;
|
|
auto pheight = 1.4f;
|
|
auto pwidth = aspect * pheight;
|
|
glm::mat4 proj = glm::ortho(-pwidth, pwidth, -pheight, pheight);
|
|
glUniformMatrix4fv(0, 1, false, glm::value_ptr(proj));
|
|
|
|
auto t = (float) glfwGetTime() / 3;
|
|
glm::mat4 view = glm::rotate(glm::identity<glm::mat4>(), t, glm::vec3(0, 1, 0));
|
|
glUniformMatrix4fv(1, 1, false, glm::value_ptr(view));
|
|
|
|
glUniform1f(2, 1.0f);
|
|
glDrawArrays(GL_POINTS, 0, points.size());
|
|
|
|
// glUniform1f(2, 0.9f);
|
|
// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, res0_ibo);
|
|
// glDrawElements(GL_LINES, res0_inds.size(), GL_UNSIGNED_INT, nullptr);
|
|
// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, res1_ibo);
|
|
// glDrawElements(GL_LINES, res1_inds.size(), GL_UNSIGNED_INT, nullptr);
|
|
// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, res2_ibo);
|
|
// glDrawElements(GL_LINES, res2_inds.size(), GL_UNSIGNED_INT, nullptr);
|
|
|
|
glUniform1f(2, 0.5f);
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, test_ibo);
|
|
glDrawElements(test_mode, test_inds.size(), GL_UNSIGNED_INT, nullptr);
|
|
|
|
glfwSwapBuffers(window);
|
|
|
|
glfwPollEvents();
|
|
}
|
|
|
|
glfwTerminate();
|
|
return EXIT_SUCCESS;
|
|
}
|