136 lines
4.1 KiB
C++
136 lines
4.1 KiB
C++
#pragma once
|
|
|
|
#include <vector>
|
|
#include <chrono>
|
|
#include <iostream>
|
|
|
|
#include "coxeter.hpp"
|
|
#include "mirrors.hpp"
|
|
#include "numeric.hpp"
|
|
|
|
glm::vec4 identity(const std::vector<glm::vec4> &normals, const std::vector<float> &coords) {
|
|
const std::vector<glm::vec4> corners = plane_intersections(normals);
|
|
const glm::vec4 identity = barycentric(corners, coords);
|
|
return glm::normalize(identity);
|
|
}
|
|
|
|
|
|
glm::vec4 identity(const Mults &mults, const std::vector<float> &coords) {
|
|
const std::vector<glm::vec4> normals = mirror(mults);
|
|
return identity(normals, coords);
|
|
}
|
|
|
|
|
|
glm::vec4 center(const Mults &mults) {
|
|
const std::vector<glm::vec4> normals = mirror(mults);
|
|
const std::vector<glm::vec4> corners = plane_intersections(normals);
|
|
std::vector<float> coords{};
|
|
for (int i = 0; i < corners.size(); ++i) {
|
|
const auto u = (i + 2) % corners.size();
|
|
const auto v = (i + 1) % corners.size();
|
|
const auto &d = corners[u] - corners[v];
|
|
coords.push_back(glm::length(d));
|
|
}
|
|
const glm::vec4 identity = barycentric(corners, coords);
|
|
return glm::normalize(identity);
|
|
}
|
|
|
|
|
|
struct Buffer {
|
|
GLuint name = 0;
|
|
unsigned size = 0;
|
|
};
|
|
|
|
struct Mesh {
|
|
const Mults mults;
|
|
const Table *t_vert;
|
|
|
|
const std::vector<glm::vec4> normals;
|
|
glm::vec4 *vert_data;
|
|
|
|
Buffer vert;
|
|
Buffer edge;
|
|
Buffer face;
|
|
|
|
explicit Mesh(const Mults &mults) : mults(mults), normals(mirror(mults)) {
|
|
auto a = std::chrono::high_resolution_clock::now();
|
|
t_vert = mults.isolve({});
|
|
auto b = std::chrono::high_resolution_clock::now();
|
|
auto delta = (std::chrono::duration<double>) (b - a);
|
|
std::cout << "time to solve verts: " << delta.count() << std::endl;
|
|
|
|
vert.size = t_vert->size();
|
|
vert_data = new glm::vec4[vert.size];
|
|
|
|
glGenBuffers(1, &vert.name);
|
|
glGenBuffers(1, &edge.name);
|
|
glGenBuffers(1, &face.name);
|
|
|
|
gen_indices();
|
|
}
|
|
|
|
void gen_vertices(const glm::vec4 root) {
|
|
auto a = std::chrono::high_resolution_clock::now();
|
|
vert_data[0] = root;
|
|
for (unsigned from = 0; from < vert.size; ++from) {
|
|
for (unsigned gen = 0; gen < mults.dim; ++gen) {
|
|
int to = t_vert->iget((int) from, (int) gen);
|
|
vert_data[to] = reflect(vert_data[from], normals[gen]);
|
|
}
|
|
}
|
|
auto b = std::chrono::high_resolution_clock::now();
|
|
auto delta = (std::chrono::duration<double>) (b - a);
|
|
std::cout << "time to build verts: " << delta.count() << std::endl;
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, vert.name);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec4) * vert.size, vert_data, GL_STATIC_DRAW);
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
}
|
|
|
|
void gen_indices() {
|
|
std::vector<int> edge_data;
|
|
|
|
auto e_table = mults.sub({0, 1}).isolve({});
|
|
|
|
// std::cout << "building gens" << std::endl;
|
|
// const std::vector<int> gens{0, 1};
|
|
// std::cout << "built gens" << std::endl;
|
|
// const std::vector<int> &igens = gens;
|
|
// Mults<2> res{};
|
|
// for (int a = 0; a < 2; ++a) {
|
|
// for (int b = a + 1; b < 2; ++b) {
|
|
// res.set(a, b, t_vert->mults.get(igens[a], igens[b]));
|
|
// }
|
|
// }
|
|
// const auto &mults = res;
|
|
// std::cout << "built mults" << std::endl;
|
|
|
|
|
|
// auto *e_table = mults.isolve({});
|
|
// std::cout << "built table" << std::endl;
|
|
// std::cout << "edge verts:" << e_table->size() << std::endl;
|
|
//
|
|
//// for (int i = 0; i < e_table->size(); ++i) {
|
|
//// edge_data.push_back(i);
|
|
//// }
|
|
//
|
|
// delete e_table;
|
|
|
|
edge.size = edge_data.size();
|
|
glBindBuffer(GL_ARRAY_BUFFER, edge.name);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(int) * edge.size, &edge_data[0], GL_STATIC_DRAW);
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
}
|
|
|
|
~Mesh() {
|
|
delete t_vert;
|
|
delete[] vert_data;
|
|
|
|
// glDeleteBuffers(1, &vert.name);
|
|
// glDeleteBuffers(1, &edge.name);
|
|
// glDeleteBuffers(1, &face.name);
|
|
}
|
|
};
|
|
|
|
std::ostream &operator<<(std::ostream &out, Buffer b);
|