mirror of
https://github.com/allemangD/toddcox-visualize.git
synced 2025-11-10 12:02:47 -05:00
generics don't crash, but don't work either
This commit is contained in:
@@ -26,63 +26,44 @@ size_t num_gens_from_key(size_t key) {
|
||||
return count;
|
||||
}
|
||||
|
||||
struct Mesh {
|
||||
// int dim;
|
||||
std::vector<int> vals;
|
||||
template<unsigned N>
|
||||
struct Primitive {
|
||||
std::array<unsigned, N> inds;
|
||||
|
||||
Mesh() : vals() {}
|
||||
Primitive() = default;
|
||||
|
||||
explicit Mesh(std::vector<int> &vals) : vals(vals) {}
|
||||
Primitive(const Primitive<N> &) = default;
|
||||
|
||||
explicit Mesh(const std::vector<Mesh> &parts) {
|
||||
size_t count = 0;
|
||||
for (const auto &part : parts) {
|
||||
count += part.size();
|
||||
}
|
||||
vals.reserve(count);
|
||||
|
||||
for (const auto &part : parts) {
|
||||
vals.insert(vals.end(), part.vals.begin(), part.vals.end());
|
||||
}
|
||||
Primitive(const Primitive<N - 1> &sub, unsigned root) {
|
||||
std::copy(sub.inds.begin(), sub.inds.end(), inds.begin());
|
||||
inds[N - 1] = root;
|
||||
}
|
||||
|
||||
[[nodiscard]] size_t size() const {
|
||||
return vals.size();
|
||||
~Primitive() = default;
|
||||
|
||||
inline void flip() {
|
||||
if (N > 1) std::swap(inds[0], inds[1]);
|
||||
}
|
||||
|
||||
void flip() {
|
||||
// if (dim == 0)
|
||||
// return;
|
||||
// for (int i = 0; i < vals.size(); i += dim + 1) {
|
||||
// std::swap(vals[i], vals[i + 1]);
|
||||
// }
|
||||
void apply(const tc::Cosets &table, int gen) {
|
||||
for (auto &ind : inds) {
|
||||
ind = table.get(ind, gen);
|
||||
}
|
||||
flip();
|
||||
}
|
||||
};
|
||||
|
||||
struct GeomGen {
|
||||
std::vector<std::vector<std::optional<tc::Cosets>>> coset_memo;
|
||||
std::vector<std::optional<Mesh>> triangulate_memo;
|
||||
tc::Group &context;
|
||||
|
||||
explicit GeomGen(tc::Group &g) : context(g) {
|
||||
size_t num_sg = std::pow(2, g.ngens);
|
||||
coset_memo.resize(num_sg);
|
||||
triangulate_memo.resize(num_sg);
|
||||
for (size_t i = 0; i < num_sg; i++) {
|
||||
auto num_sg_sg = std::pow(2, num_gens_from_key(i));
|
||||
coset_memo[i].resize(num_sg_sg, std::nullopt);
|
||||
}
|
||||
std::vector<int> gens(const tc::Group &context) {
|
||||
std::vector<int> g_gens(context.ngens);
|
||||
std::iota(g_gens.begin(), g_gens.end(), 0);
|
||||
return g_gens;
|
||||
}
|
||||
|
||||
std::vector<int> group_gens() {
|
||||
std::vector<int> gens(context.ngens);
|
||||
for (int i = 0; i < context.ngens; i++) {
|
||||
gens[i] = i;
|
||||
}
|
||||
return gens;
|
||||
}
|
||||
std::vector<int> recontext_gens(
|
||||
const tc::Group &context,
|
||||
std::vector<int> g_gens,
|
||||
std::vector<int> sg_gens) {
|
||||
|
||||
std::vector<int> prepare_gens(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
|
||||
std::sort(g_gens.begin(), g_gens.end());
|
||||
|
||||
int inv_gen_map[context.ngens];
|
||||
@@ -98,118 +79,375 @@ struct GeomGen {
|
||||
std::sort(s_sg_gens.begin(), s_sg_gens.end());
|
||||
|
||||
return s_sg_gens;
|
||||
|
||||
// std::sort(g_gens.begin(), g_gens.end());
|
||||
//
|
||||
// std::vector<int> inv_g_map(g_gens.size());
|
||||
// for (int i = 0; i < g_gens.size(); ++i) {
|
||||
// inv_g_map[g_gens[i]] = i;
|
||||
// }
|
||||
//
|
||||
// std::transform(sg_gens.begin(), sg_gens.end(), sg_gens.begin(),
|
||||
// [inv_g_map](const auto &gen) {
|
||||
// return inv_g_map[gen];
|
||||
// }
|
||||
// );
|
||||
//
|
||||
// std::sort(sg_gens.begin(), sg_gens.end());
|
||||
// return sg_gens;
|
||||
}
|
||||
|
||||
int get_parity(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
|
||||
if (g_gens.size() != sg_gens.size() + 1)
|
||||
return 0;
|
||||
auto s_sg_gens = prepare_gens(g_gens, sg_gens);
|
||||
const int loop_max = g_gens.size() - 1;
|
||||
for (int i = 0; i < loop_max; i++) {
|
||||
if (s_sg_gens[i] != i)
|
||||
return i % 2;
|
||||
int get_parity(
|
||||
const tc::Group &context,
|
||||
const std::vector<int> &g_gens,
|
||||
const std::vector<int> &sg_gens
|
||||
) {
|
||||
if (g_gens.size() != sg_gens.size() + 1) return 0;
|
||||
|
||||
const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
|
||||
|
||||
int i = 0;
|
||||
for (; i < sg_gens.size(); ++i) {
|
||||
if (proper_sg_gens[i] != i) {
|
||||
break;
|
||||
}
|
||||
return loop_max % 2;
|
||||
}
|
||||
|
||||
tc::Cosets _solve(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
|
||||
auto s_sg_gens = prepare_gens(g_gens, sg_gens);
|
||||
|
||||
size_t group_key = get_key_from_gens(g_gens);
|
||||
size_t subgroup_key = get_key_from_gens(s_sg_gens);
|
||||
|
||||
if (!coset_memo[group_key][subgroup_key]) {
|
||||
tc::SubGroup g = context.subgroup(g_gens);
|
||||
coset_memo[group_key][subgroup_key] = g.solve(s_sg_gens);
|
||||
}
|
||||
return *coset_memo[group_key][subgroup_key];
|
||||
return i & 1;
|
||||
}
|
||||
|
||||
tc::Cosets solve(std::vector<int> g_gens, std::vector<int> sg_gens) {
|
||||
return _solve(g_gens, sg_gens);
|
||||
tc::Cosets solve(
|
||||
const tc::Group &context,
|
||||
const std::vector<int> &g_gens,
|
||||
const std::vector<int> &sg_gens
|
||||
) {
|
||||
const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
|
||||
return context.subgroup(g_gens).solve(proper_sg_gens);
|
||||
}
|
||||
|
||||
tc::Cosets solve_sg(std::vector<int> &sg_gens) {
|
||||
auto g_gens = group_gens();
|
||||
return _solve(g_gens, sg_gens);
|
||||
tc::Cosets solve_sg(
|
||||
const tc::Group &context,
|
||||
const std::vector<int> &sg_gens
|
||||
) {
|
||||
return solve(context, gens(context), sg_gens);
|
||||
}
|
||||
|
||||
tc::Cosets solve_g(std::vector<int> &g_gens) {
|
||||
tc::Cosets solve_g(
|
||||
const tc::Group &context,
|
||||
const std::vector<int> &g_gens
|
||||
) {
|
||||
std::vector<int> sg_gens;
|
||||
return _solve(g_gens, sg_gens);
|
||||
return solve(context, g_gens, sg_gens);
|
||||
}
|
||||
|
||||
tc::Cosets solve() {
|
||||
tc::Cosets solve(
|
||||
const tc::Group &context
|
||||
) {
|
||||
std::vector<int> sg_gens;
|
||||
return solve_sg(sg_gens);
|
||||
return solve_sg(context, sg_gens);
|
||||
}
|
||||
|
||||
Mesh recontext(std::vector<int> &g_gens, std::vector<int> &sg_gens, const Mesh &items) {
|
||||
auto s_sg_gens = prepare_gens(g_gens, sg_gens);
|
||||
auto table = solve_g(g_gens);
|
||||
auto path = solve_g(sg_gens).path;
|
||||
template<unsigned N>
|
||||
struct Mesh {
|
||||
std::vector<Primitive<N>> prims;
|
||||
|
||||
auto coset_map = [table](int coset, int gen) { return table.get(coset, gen); };
|
||||
Mesh() : prims() {}
|
||||
|
||||
auto map = path.walk<int, int>(0, s_sg_gens, coset_map);
|
||||
Mesh(const Mesh<N> &) = default;
|
||||
|
||||
Mesh ret;
|
||||
ret.vals.reserve(items.size());
|
||||
for (const auto val : items.vals) {
|
||||
ret.vals.push_back(map[val]);
|
||||
}
|
||||
if (get_parity(g_gens, sg_gens) == 1)
|
||||
ret.flip();
|
||||
return ret;
|
||||
explicit Mesh(std::vector<Primitive<N>> &prims) : prims(prims) {}
|
||||
|
||||
[[nodiscard]] size_t size() const {
|
||||
return prims.size();
|
||||
}
|
||||
|
||||
Mesh tile(std::vector<int> &g_gens, std::vector<int> &sg_gens, const Mesh &items) {
|
||||
Mesh base = recontext(g_gens, sg_gens, items);
|
||||
auto s_sg_gens = prepare_gens(g_gens, sg_gens);
|
||||
auto table = solve_g(g_gens);
|
||||
auto path = _solve(g_gens, sg_gens).path;
|
||||
|
||||
auto simplex_map = [table](Mesh from, int gen) -> Mesh {
|
||||
for (auto &coset : from.vals) {
|
||||
coset = table.get(coset, gen);
|
||||
void apply(const tc::Cosets &table, int gen) {
|
||||
for (auto &prim : prims) {
|
||||
prim.apply(table, gen);
|
||||
}
|
||||
from.flip();
|
||||
}
|
||||
|
||||
void flip() {
|
||||
for (auto &prim : prims) {
|
||||
prim.flip();
|
||||
}
|
||||
}
|
||||
|
||||
Mesh<N> recontext(
|
||||
const tc::Group &context,
|
||||
const std::vector<int> &g_gens,
|
||||
const std::vector<int> &sg_gens
|
||||
) {
|
||||
const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
|
||||
// todo memo recontext
|
||||
const auto table = solve_g(context, g_gens);
|
||||
const auto path = solve_g(context, sg_gens).path;
|
||||
|
||||
auto map = path.template walk<int, int>(0, proper_sg_gens, [table](int coset, int gen) {
|
||||
return table.get(coset, gen);
|
||||
});
|
||||
|
||||
Mesh<N> res = *this;
|
||||
for (Primitive<N> &prim : res.prims) {
|
||||
for (auto &ind : prim.inds) {
|
||||
ind = map[ind];
|
||||
}
|
||||
}
|
||||
|
||||
if (get_parity(context, g_gens, sg_gens) == 1)
|
||||
res.flip();
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
Mesh<N> tile(
|
||||
const tc::Group &context,
|
||||
const std::vector<int> &g_gens,
|
||||
const std::vector<int> &sg_gens
|
||||
) {
|
||||
Mesh<N> base = recontext(context, g_gens, sg_gens);
|
||||
const auto proper_sg_gens = recontext_gens(context, g_gens, sg_gens);
|
||||
|
||||
// todo memo tile
|
||||
const auto table = solve_g(context, g_gens);
|
||||
const auto path = solve(context, g_gens, sg_gens).path;
|
||||
|
||||
const auto all = path.template walk<Mesh<N>, int>(base, g_gens, [table](Mesh<N> from, int gen) {
|
||||
from.apply(table, gen);
|
||||
return from;
|
||||
});
|
||||
|
||||
return merge(all);
|
||||
}
|
||||
|
||||
Mesh<N + 1> fan(int root) {
|
||||
std::vector<Primitive<N + 1>> res(prims.size());
|
||||
std::transform(prims.begin(), prims.end(), res.begin(),
|
||||
[root](const Primitive<N> &prim) {
|
||||
return Primitive<N + 1>(prim, root);
|
||||
}
|
||||
);
|
||||
return Mesh<N + 1>(res);
|
||||
}
|
||||
};
|
||||
|
||||
auto r = path.walk<Mesh, int>(base, group_gens(), simplex_map);
|
||||
|
||||
return Mesh(r);
|
||||
template<unsigned N>
|
||||
Mesh<N> merge(const std::vector<Mesh<N>> &meshes) {
|
||||
size_t size = 0;
|
||||
for (const auto &mesh : meshes) {
|
||||
size += mesh.size();
|
||||
}
|
||||
|
||||
Mesh triangulate(std::vector<int> &g_gens);
|
||||
|
||||
Mesh _triangulate(std::vector<int> &g_gens) {
|
||||
Mesh S;
|
||||
if (g_gens.empty()) {
|
||||
S.vals.push_back(0);
|
||||
return S;
|
||||
}
|
||||
for (std::vector<int> sg_gens : Combos(g_gens, g_gens.size() - 1)) {
|
||||
auto sub_simps = triangulate(sg_gens);
|
||||
int start = sub_simps.size();
|
||||
sub_simps = tile(g_gens, sg_gens, sub_simps);
|
||||
for (int l = start; l < sub_simps.size(); l += g_gens.size()) {
|
||||
for (int m = l; m < l + g_gens.size(); m++) {
|
||||
S.vals.push_back(sub_simps.vals[m]);
|
||||
}
|
||||
S.vals.push_back(0);
|
||||
}
|
||||
}
|
||||
return S;
|
||||
std::vector<Primitive<N>> prims;
|
||||
prims.reserve(size);
|
||||
for (const auto &mesh : meshes) {
|
||||
prims.insert(prims.end(), mesh.prims.begin(), mesh.prims.end());
|
||||
}
|
||||
|
||||
};
|
||||
return Mesh(prims);
|
||||
}
|
||||
|
||||
Mesh GeomGen::triangulate(std::vector<int> &g_gens) {
|
||||
int key = get_key_from_gens(g_gens);
|
||||
if (!triangulate_memo[key]) {
|
||||
triangulate_memo[key] = _triangulate(g_gens);
|
||||
template<unsigned N>
|
||||
Mesh<N> triangulate(
|
||||
const tc::Group &context,
|
||||
const std::vector<int> &g_gens
|
||||
) {
|
||||
if (g_gens.size() + 1 != N)
|
||||
throw std::logic_error("g_gens size must be one less than N");
|
||||
|
||||
const auto &combos = Combos(g_gens, g_gens.size() - 1);
|
||||
|
||||
std::vector<Mesh<N>> meshes;
|
||||
for (const auto &sg_gens : combos) {
|
||||
Mesh<N - 1> base = triangulate<N - 1>(context, sg_gens);
|
||||
Mesh<N - 1> raised = base.tile(context, g_gens, sg_gens);
|
||||
raised.prims.erase(raised.prims.begin(), raised.prims.begin() + base.size());
|
||||
Mesh<N> fan = raised.fan(0);
|
||||
meshes.push_back(fan);
|
||||
}
|
||||
return *triangulate_memo[key];
|
||||
|
||||
return merge(meshes);
|
||||
}
|
||||
|
||||
template<>
|
||||
Mesh<1> triangulate<1>(
|
||||
const tc::Group &context,
|
||||
const std::vector<int> &g_gens
|
||||
) {
|
||||
if (not g_gens.empty())
|
||||
throw std::logic_error("g_gens must be empty for a trivial Mesh");
|
||||
|
||||
Mesh<1> res;
|
||||
res.prims.emplace_back();
|
||||
return res;
|
||||
}
|
||||
|
||||
//template<unsigned N>
|
||||
//struct GeomGen {
|
||||
// std::vector<std::vector<std::optional<tc::Cosets>>> coset_memo;
|
||||
// std::vector<std::optional<Mesh<N>>> triangulate_memo;
|
||||
// tc::Group &context;
|
||||
//
|
||||
// explicit GeomGen(tc::Group &g) : context(g) {
|
||||
// size_t num_sg = std::pow(2, g.ngens);
|
||||
// coset_memo.resize(num_sg);
|
||||
// triangulate_memo.resize(num_sg);
|
||||
// for (size_t i = 0; i < num_sg; i++) {
|
||||
// auto num_sg_sg = std::pow(2, num_gens_from_key(i));
|
||||
// coset_memo[i].resize(num_sg_sg, std::nullopt);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// std::vector<int> group_gens() {
|
||||
// std::vector<int> gens(context.ngens);
|
||||
// for (int i = 0; i < context.ngens; i++) {
|
||||
// gens[i] = i;
|
||||
// }
|
||||
// return gens;
|
||||
// }
|
||||
//
|
||||
// std::vector<int> prepare_gens(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
|
||||
// std::sort(g_gens.begin(), g_gens.end());
|
||||
//
|
||||
// int inv_gen_map[context.ngens];
|
||||
// for (size_t i = 0; i < g_gens.size(); i++) {
|
||||
// inv_gen_map[g_gens[i]] = i;
|
||||
// }
|
||||
//
|
||||
// std::vector<int> s_sg_gens;
|
||||
// s_sg_gens.reserve(sg_gens.size());
|
||||
// for (const auto gen : sg_gens) {
|
||||
// s_sg_gens.push_back(inv_gen_map[gen]);
|
||||
// }
|
||||
// std::sort(s_sg_gens.begin(), s_sg_gens.end());
|
||||
//
|
||||
// return s_sg_gens;
|
||||
// }
|
||||
//
|
||||
// int get_parity(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
|
||||
// if (g_gens.size() != sg_gens.size() + 1)
|
||||
// return 0;
|
||||
// auto s_sg_gens = prepare_gens(g_gens, sg_gens);
|
||||
// const int loop_max = g_gens.size() - 1;
|
||||
// for (int i = 0; i < loop_max; i++) {
|
||||
// if (s_sg_gens[i] != i)
|
||||
// return i % 2;
|
||||
// }
|
||||
// return loop_max % 2;
|
||||
// }
|
||||
//
|
||||
// tc::Cosets _solve(std::vector<int> &g_gens, std::vector<int> &sg_gens) {
|
||||
// auto s_sg_gens = prepare_gens(g_gens, sg_gens);
|
||||
//
|
||||
// size_t group_key = get_key_from_gens(g_gens);
|
||||
// size_t subgroup_key = get_key_from_gens(s_sg_gens);
|
||||
//
|
||||
// if (!coset_memo[group_key][subgroup_key]) {
|
||||
// tc::SubGroup g = context.subgroup(g_gens);
|
||||
// coset_memo[group_key][subgroup_key] = g.solve(s_sg_gens);
|
||||
// }
|
||||
// return *coset_memo[group_key][subgroup_key];
|
||||
// }
|
||||
//
|
||||
// tc::Cosets solve(std::vector<int> g_gens, std::vector<int> sg_gens) {
|
||||
// return _solve(g_gens, sg_gens);
|
||||
// }
|
||||
//
|
||||
// tc::Cosets solve_sg(std::vector<int> &sg_gens) {
|
||||
// auto g_gens = group_gens();
|
||||
// return _solve(g_gens, sg_gens);
|
||||
// }
|
||||
//
|
||||
// tc::Cosets solve_g(std::vector<int> &g_gens) {
|
||||
// std::vector<int> sg_gens;
|
||||
// return _solve(g_gens, sg_gens);
|
||||
// }
|
||||
//
|
||||
// tc::Cosets solve() {
|
||||
// std::vector<int> sg_gens;
|
||||
// return solve_sg(sg_gens);
|
||||
// }
|
||||
//
|
||||
// Mesh<N> recontext(std::vector<int> &g_gens, std::vector<int> &sg_gens, const Mesh<N> &items) {
|
||||
// auto s_sg_gens = prepare_gens(g_gens, sg_gens);
|
||||
// auto table = solve_g(g_gens);
|
||||
// auto path = solve_g(sg_gens).path;
|
||||
//
|
||||
// auto coset_map = [table](int coset, int gen) { return table.get(coset, gen); };
|
||||
//
|
||||
// auto map = path.template walk<int, int>(0, s_sg_gens, coset_map);
|
||||
//
|
||||
// Mesh<N> ret;
|
||||
// ret.vals.reserve(items.size());
|
||||
// for (const auto val : items.vals) {
|
||||
// ret.vals.push_back(map[val]);
|
||||
// }
|
||||
// if (get_parity(g_gens, sg_gens) == 1)
|
||||
// ret.flip();
|
||||
// return ret;
|
||||
// }
|
||||
//
|
||||
// Mesh<N> tile(std::vector<int> &g_gens, std::vector<int> &sg_gens, const Mesh<N> &items) {
|
||||
// Mesh<N> base = recontext(g_gens, sg_gens, items);
|
||||
// auto s_sg_gens = prepare_gens(g_gens, sg_gens);
|
||||
// auto table = solve_g(g_gens);
|
||||
// auto path = _solve(g_gens, sg_gens).path;
|
||||
//
|
||||
// auto simplex_map = [table](Mesh<N> from, int gen) -> Mesh<N> {
|
||||
// for (auto &prim : from.prims) {
|
||||
// prim.apply(table, gen);
|
||||
// }
|
||||
// from.flip();
|
||||
// return from;
|
||||
// };
|
||||
//
|
||||
// auto r = path.template walk<Mesh<N>, int>(base, group_gens(), simplex_map);
|
||||
//
|
||||
// return merge(r);
|
||||
// }
|
||||
//
|
||||
// Mesh<N> triangulate(std::vector<int> &g_gens);
|
||||
//
|
||||
// Mesh<1> _triangulate(std::vector<int> &g_gens) {
|
||||
// Mesh<1> m;
|
||||
// m.prims.emplace_back();
|
||||
// return m;
|
||||
// }
|
||||
//
|
||||
// Mesh<N> _triangulate(std::vector<int> &g_gens) {
|
||||
//
|
||||
// Mesh<N> S;
|
||||
// if (g_gens.empty()) {
|
||||
// S.prims.push_back(Primitive<N>());
|
||||
// return S;
|
||||
// }
|
||||
//
|
||||
// GeomGen<N - 1> gg(context);
|
||||
// for (std::vector<int> sg_gens : Combos(g_gens, g_gens.size() - 1)) {
|
||||
// Mesh<N - 1> sub_simps = gg.triangulate(sg_gens);
|
||||
// int start = sub_simps.size();
|
||||
// Mesh<N - 1> raised = tile(g_gens, sg_gens, sub_simps);
|
||||
//
|
||||
// for (const Primitive<N - 1> &prim : raised.prims) {
|
||||
// S.prims.push_back(Primitive<N>(prim, 0));
|
||||
// }
|
||||
//
|
||||
//// for (int l = start; l < raised.size(); l += g_gens.size()) {
|
||||
//// for (int m = l; m < l + g_gens.size(); m++) {
|
||||
//// S.vals.push_back(raised.vals[m]);
|
||||
//// }
|
||||
//// S.vals.push_back(0);
|
||||
//// }
|
||||
// }
|
||||
// return S;
|
||||
// }
|
||||
//};
|
||||
//
|
||||
//template<unsigned N>
|
||||
//Mesh<N> GeomGen<N>::triangulate(std::vector<int> &g_gens) {
|
||||
// int key = get_key_from_gens(g_gens);
|
||||
// if (!triangulate_memo[key]) {
|
||||
// triangulate_memo[key] = _triangulate(g_gens);
|
||||
// }
|
||||
// return *triangulate_memo[key];
|
||||
//}
|
||||
@@ -97,8 +97,10 @@ int main(int argc, char *argv[]) {
|
||||
|
||||
//region points
|
||||
auto group = tc::group::H(4);
|
||||
GeomGen gg(group);
|
||||
auto res = gg.solve();
|
||||
// GeomGen<4> gg4(group);
|
||||
// GeomGen<3> gg3(group);
|
||||
// auto res = gg4.solve();
|
||||
auto res = group.solve();
|
||||
auto mirrors = mirror(group);
|
||||
|
||||
auto corners = plane_intersections(mirrors);
|
||||
@@ -107,7 +109,7 @@ int main(int argc, char *argv[]) {
|
||||
// auto start = barycentric(corners, {0.05f, 0.1f, 0.2f, 1.00f});
|
||||
auto points = res.path.walk<glm::vec4, glm::vec4>(start, mirrors, reflect);
|
||||
|
||||
auto g_gens = gg.group_gens();
|
||||
auto g_gens = gens(group);
|
||||
|
||||
std::vector<GLuint> vaos;
|
||||
std::vector<GLuint> ibos;
|
||||
@@ -120,17 +122,18 @@ int main(int argc, char *argv[]) {
|
||||
// };
|
||||
auto chosen = combos;
|
||||
|
||||
for (auto sg_gens : chosen) {
|
||||
auto s = gg.tile(g_gens, sg_gens, gg.triangulate(sg_gens));
|
||||
const std::vector<int> data = s.vals;
|
||||
for (const auto& sg_gens : chosen) {
|
||||
const Mesh<4> &base = triangulate<4>(group, sg_gens);
|
||||
const auto &s = base;
|
||||
// s = tile(context, g_gens, sg_gens, base);
|
||||
|
||||
GLuint vao = utilCreateVertexArray();
|
||||
GLuint ibo = utilCreateBuffer();
|
||||
unsigned count = data.size();
|
||||
unsigned count = s.size();
|
||||
|
||||
glBindVertexArray(vao);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, ibo);
|
||||
glBufferData(GL_ARRAY_BUFFER, sizeof(int) * count, &data[0], GL_STATIC_DRAW);
|
||||
glBufferData(GL_ARRAY_BUFFER, sizeof(Primitive<4>) * count, &s.prims[0], GL_STATIC_DRAW);
|
||||
glEnableVertexAttribArray(0);
|
||||
glVertexAttribIPointer(0, 4, GL_INT, 0, nullptr);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
|
||||
Reference in New Issue
Block a user