// Hyperbolic Rogue -- Arbitrary Tilings // Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details /** \file arbitrile.cpp * \brief Arbitrary tilings * * Arbitrary tilings, defined in .tes files. */ #include "hyper.h" namespace hr { EX namespace arb { EX int affine_limit = 200; EX bool legacy; /* angleofs command */ #if HDR /** a type used to specify the connections between shapes */ struct connection_t { /** the index of the connected shape in the 'shapes' table */ int sid; /** the index of the edge in the 'shapes' table */ int eid; /** 1 if this connection mirrored, 0 otherwise. do_unmirror() removes all mirrors by doubling shapes */ int mirror; }; inline void print(hstream& hs, const connection_t& conn) { print(hs, tie(conn.sid, conn.eid, conn.mirror)); } /** \brief each shape of the arb tessellation * note: the usual HyperRogue convention is: vertex 0, edge 0, vertex 1, edge 1, ... * note: the tesfile convention is: edge 0, vertex 0, edge 1, vertex 1, ... */ struct shape { /** index in the arbi_tiling::shapes */ int id; /** flags such as sfLINE and sfPH */ int flags; /** list of vertices in the usual convention */ vector vertices; /** list of vertices in the tesfile convention */ vector angles; /** list of edge lengths */ vector edges; /** list of edge connections */ vector connections; int size() const { return isize(vertices); } void build_from_angles_edges(); vector > sublines; vector> stretch_shear; int repeat_value; /** if a tile/edge combination may be connected to edges j1 and j2 of this, j1-j2 must be divisible by cycle_length */ int cycle_length; /** list of valences of vertices in the tesfile convention */ vector vertex_valence; }; struct slider { string name; ld zero; ld current; ld min; ld max; }; struct arbi_tiling { int order; bool have_line, have_ph, have_tree; int yendor_backsteps; vector shapes; string name; string comment; vector sliders; ld cscale; int range; ld floor_scale; ld boundary_ratio; string filename; int min_valence, max_valence; geometryinfo1& get_geometry(); eGeometryClass get_class() { return get_geometry().kind; } ld scale(); }; #endif EX arbi_tiling current; EX bool using_slided; EX arbi_tiling slided; EX bool in_slided() { return in() && using_slided; } EX arbi_tiling& current_or_slided() { return using_slided ? slided : current; } /** id of vertex in the arbitrary tiling */ EX short& id_of(heptagon *h) { return h->zebraval; } #if HDR struct hr_polygon_error : hr_exception { vector v; eGeometryClass c; int id; transmatrix end; map params; hr_polygon_error(const vector& _v, int _id, transmatrix _e) : v(_v), c(cgclass), id(_id), end(_e) {} ~hr_polygon_error() noexcept(true) {} string generate_error(); }; #endif string hr_polygon_error::generate_error() { cld dist = (hdist0(tC0(end)) / params["distunit"]); bool angle = abs(dist) < 1e-9; if(angle) dist = (atan2(end * xpush0(1)) / params["angleunit"]); return XLAT("Polygon number %1 did not close correctly (%2 %3). Here is the picture to help you understand the issue.\n\n", its(id), angle ? "angle" : "distance", lalign(0, dist) ); } struct connection_debug_request : hr_exception { int id; eGeometryClass c; connection_debug_request(int i): id(i), c(cgclass) {} }; void ensure_geometry(eGeometryClass c) { stop_game(); if(c != cgclass) { if(c == gcEuclid) set_geometry(gEuclid); if(c == gcHyperbolic) set_geometry(gNormal); if(c == gcSphere) set_geometry(gSphere); } if(specialland != laCanvas) { canvas_default_wall = waInvisibleFloor; patterns::whichCanvas = 'g'; patterns::canvasback = 0xFFFFFF; enable_canvas(); } start_game(); } void start_poly_debugger(hr_polygon_error& err) { #if CAP_EDIT ensure_geometry(err.c); drawthemap(); mapeditor::drawing_tool = true; pushScreen(mapeditor::showDrawEditor); mapeditor::initdraw(cwt.at); int n = isize(err.v); mapeditor::dtcolor = 0xFF0000FF; mapeditor::dtwidth = 0.02; for(int i=0; i matrices; if(!legacy) for(auto& a: angles) a += M_PI; for(int i=0; i= s); co.mirror = false; if(mirr) { co.sid += s; co.eid = isize(sh[co.sid].angles) - 1 - co.eid; } } } } EX void compute_vertex_valence() { auto& ac = arb::current; int tcl = -1; for(auto& sh: ac.shapes) sh.cycle_length = isize(sh.vertices); while(true) { for(auto& sh: ac.shapes) { int i = sh.id; int n = isize(sh.vertices); for(int k=sh.cycle_length; k 360 * degree) a -= 360 * degree; total += a; qty++; at.eid++; if(at.eid == isize(ac.shapes[at.sid].angles)) at.eid = 0; at = ac.shapes[at.sid].connections[at.eid]; } while(total < 360*degree - 1e-6); if(total > 360*degree + 1e-6) throw hr_parse_exception("improper total in compute_stats"); if(at.sid != i) throw hr_parse_exception("ended at wrong type determining vertex_valence"); if((at.eid - k) % ac.shapes[i].cycle_length) throw hr_parse_exception("ended at wrong edge determining vertex_valence"); sh.vertex_valence[k] = qty; } if(debugflags & DF_GEOM) println(hlog, "computed vertex_valence of ", i, " as ", ac.shapes[i].vertex_valence); } ac.min_valence = UNKNOWN; ac.max_valence = 0; for(auto& sh: ac.shapes) for(auto& val: sh.vertex_valence) { if(val < ac.min_valence) ac.min_valence = val; if(val > ac.max_valence) ac.max_valence = val; } } EX void load(const string& fname, bool after_sliding IS(false)) { fhstream f(fname, "rt"); if(!f.f) throw hr_parse_exception("file " + fname + " does not exist"); string s; while(true) { int c = fgetc(f.f); if(c < 0) break; s += c; } auto& c = after_sliding ? slided : current; c.order++; c.shapes.clear(); c.sliders.clear(); c.name = unnamed; c.comment = ""; c.filename = fname; c.cscale = 1; c.range = 0; c.boundary_ratio = 1; c.floor_scale = .5; c.have_ph = c.have_line = false; c.have_tree = false; c.yendor_backsteps = 0; exp_parser ep; ep.s = s; ld angleunit = 1, distunit = 1, angleofs = 0; auto addflag = [&] (int f) { int ai; if(ep.next() == ')') ai = isize(c.shapes)-1; else ai = ep.iparse(); verify_index(ai, c.shapes, ep); c.shapes[ai].flags |= f; ep.force_eat(")"); }; while(true) { ep.extra_params["distunit"] = distunit; ep.extra_params["angleunit"] = angleunit; ep.extra_params["angleofs"] = angleofs; ep.skip_white(); if(ep.next() == 0) break; if(ep.eat("#")) { bool doubled = ep.eat("#"); while(ep.eat(" ")) ; string s = ""; while(ep.next() >= 32) s += ep.next(), ep.at++; if(doubled) { if(c.name == unnamed) c.name = s; else { c.comment += s; c.comment += "\n"; } } } else if(ep.eat("e2.")) { ginf[gArbitrary].g = giEuclid2; ginf[gArbitrary].sides = 7; set_flag(ginf[gArbitrary].flags, qBOUNDED, false); set_flag(ginf[gArbitrary].flags, qAFFINE, false); geom3::apply_always3(); } else if(ep.eat("a2.")) { ginf[gArbitrary].g = giEuclid2; ginf[gArbitrary].sides = 7; set_flag(ginf[gArbitrary].flags, qBOUNDED, false); set_flag(ginf[gArbitrary].flags, qAFFINE, true); affine_limit = 200; geom3::apply_always3(); } else if(ep.eat("h2.")) { ginf[gArbitrary].g = giHyperb2; ginf[gArbitrary].sides = 7; set_flag(ginf[gArbitrary].flags, qBOUNDED, false); set_flag(ginf[gArbitrary].flags, qAFFINE, false); geom3::apply_always3(); } else if(ep.eat("s2.")) { ginf[gArbitrary].g = giSphere2; ginf[gArbitrary].sides = 5; set_flag(ginf[gArbitrary].flags, qBOUNDED, true); set_flag(ginf[gArbitrary].flags, qAFFINE, false); geom3::apply_always3(); } else if(ep.eat("legacysign.")) { if(legacy) angleunit *= -1; } else if(ep.eat("angleunit(")) angleunit = real(ep.parsepar()); else if(ep.eat("angleofs(")) { angleofs = real(ep.parsepar()); if(!legacy) angleofs = 0; } else if(ep.eat("distunit(")) distunit = real(ep.parsepar()); else if(ep.eat("line(")) { addflag(arcm::sfLINE); c.have_line = true; } else if(ep.eat("grave(")) { addflag(arcm::sfPH); c.have_ph = true; } else if(ep.eat("slider(")) { slider sl; sl.name = ep.next_token(); ep.force_eat(","); sl.current = sl.zero = ep.rparse(); ep.force_eat(","); sl.min = ep.rparse(); ep.force_eat(","); sl.max = ep.rparse(); ep.force_eat(")"); c.sliders.push_back(sl); if(after_sliding) ep.extra_params[sl.name] = current.sliders[isize(c.sliders)-1].current; else ep.extra_params[sl.name] = sl.zero; } else if(ep.eat("let(")) { string tok = ep.next_token(); ep.force_eat("="); ep.extra_params[tok] =ep.parsepar(); if(debugflags & DF_GEOM) println(hlog, "let ", tok, " = ", ep.extra_params[tok]); } else if(ep.eat("unittile(")) load_tile(ep, c, true); else if(ep.eat("tile(")) load_tile(ep, c, false); else if(ep.eat("affine_limit(")) { affine_limit = ep.iparse(); ep.force_eat(")"); } else if(ep.eat("cscale(")) { c.cscale = ep.rparse(); ep.force_eat(")"); } else if(ep.eat("treestate(")) { rulegen::parse_treestate(c, ep); } else if(ep.eat("yendor_backsteps(")) { c.yendor_backsteps = ep.iparse(); ep.force_eat(")"); } else if(ep.eat("range(")) { c.range = ep.iparse(); ep.force_eat(")"); } else if(ep.eat("floor_scale(")) { c.floor_scale = ep.rparse(); ep.force_eat(")"); } else if(ep.eat("boundary_ratio(")) { c.boundary_ratio = ep.rparse(); ep.force_eat(")"); } else if(ep.eat("conway(\"")) { string s = ""; while(true) { int m = 0; if(ep.eat("(")) m = 0; else if(ep.eat("[")) m = 1; else if(ep.eat("\"")) break; else throw hr_parse_exception("cannot parse Conway notation, " + ep.where()); int ai = 0; int as = ep.iparse(); while(ep.eat("'")) ai++; if(ep.eat("@")) ai = ep.iparse(); int bi = 0, bs = 0; if(ep.eat(")") || ep.eat("]")) bs = as, bi = ai; else { bs = ep.iparse(); while(ep.eat("'")) bi++; if(ep.eat("@")) bi = ep.iparse(); } if(ep.eat(")") || ep.eat("]")) {} verify_index(ai, c.shapes, ep); verify_index(as, c.shapes[ai], ep); verify_index(bi, c.shapes, ep); verify_index(bs, c.shapes[bi], ep); c.shapes[ai].connections[as] = connection_t{bi, bs, m}; c.shapes[bi].connections[bs] = connection_t{ai, as, m}; } ep.force_eat(")"); } else if(ep.eat("c(")) { int ai = ep.iparse(); verify_index(ai, c.shapes, ep); ep.force_eat(","); int as = ep.iparse(); verify_index(as, c.shapes[ai], ep); ep.force_eat(","); int bi = ep.iparse(); verify_index(bi, c.shapes, ep); ep.force_eat(","); int bs = ep.iparse(); verify_index(bs, c.shapes[bi], ep); ep.force_eat(","); int m = ep.iparse(); ep.force_eat(")"); c.shapes[ai].connections[as] = connection_t{bi, bs, m}; c.shapes[bi].connections[bs] = connection_t{ai, as, m}; } else if(ep.eat("subline(")) { int ai = ep.iparse(); verify_index(ai, c.shapes, ep); ep.force_eat(","); int as = ep.iparse(); verify_index(as, c.shapes[ai], ep); ep.force_eat(","); int bs = ep.iparse(); verify_index(bs, c.shapes[ai], ep); ep.force_eat(")"); c.shapes[ai].sublines.emplace_back(as, bs); } else if(ep.eat("sublines(")) { ld d = ep.rparse() * distunit; ld eps = 1e-4; if(ep.eat(",")) eps = ep.rparse() * distunit; ep.force_eat(")"); for(auto& sh: c.shapes) { for(int i=0; i 1e-6) throw hr_parse_exception(lalign(0, "connecting ", make_pair(i,j), " to ", con, " of different lengths only possible in a2")); } } } if(do_unmirror) { unmirror(); } if(!c.have_tree) compute_vertex_valence(); if(c.have_tree) rulegen::verify_parsed_treestates(); if(!after_sliding) slided = current; } arbi_tiling debugged; vector > debug_polys; string primes(int i) { string res; while(i--) res += "'"; return res; } void connection_debugger() { cmode = sm::SIDE | sm::DIALOG_STRICT_X; gamescreen(0); auto& last = debug_polys.back(); initquickqueue(); for(auto& p: debug_polys) { int id = p.second; shiftmatrix V = gmatrix[cwt.at] * p.first; auto& sh = debugged.shapes[id].vertices; for(auto& v: sh) curvepoint(v); curvepoint(sh[0]); color_t col = colortables['A'][id]; col = darkena(col, 0, 0xFF); if(&p == &last) { vid.linewidth *= 2; queuecurve(V, 0xFFFF00FF, col, PPR::LINE); vid.linewidth /= 2; for(int i=0; i " + its(con.eid) + primes(con.sid) + (con.mirror ? " (m) " : ""); dialog::addSelItem(cap, "go", '0' + k); dialog::add_action([k, last, con] { if(euclid) cgflags |= qAFFINE; debug_polys.emplace_back(last.first * get_adj(debugged, last.second, k, -1, -1), con.sid); if(euclid) cgflags &= ~qAFFINE; }); } dialog::addItem("undo", 'u'); dialog::add_action([] { if(isize(debug_polys) > 1) debug_polys.pop_back(); }); dialog::addBack(); dialog::display(); keyhandler = [] (int sym, int uni) { handlePanning(sym, uni); dialog::handleNavigation(sym, uni); if(doexiton(sym, uni)) popScreen(); }; } geometryinfo1& arbi_tiling::get_geometry() { return ginf[gEuclid].g; } map > > altmap; EX map> arbi_matrix; EX hrmap *current_altmap; heptagon *build_child(heptspin p, pair adj); EX transmatrix get_adj(arbi_tiling& c, int t, int dl, int t1, int xdl) { auto& sh = c.shapes[t]; int dr = gmod(dl+1, sh.size()); auto& co = sh.connections[dl]; if(xdl == -1) xdl = co.eid; if(t1 == -1) t1 = co.sid; auto& xsh = c.shapes[t1]; int xdr = gmod(xdl+1, xsh.size()); hyperpoint vl = sh.vertices[dl]; hyperpoint vr = sh.vertices[dr]; hyperpoint vm = mid(vl, vr); transmatrix rm = gpushxto0(vm); hyperpoint xvl = xsh.vertices[xdl]; hyperpoint xvr = xsh.vertices[xdr]; hyperpoint xvm = mid(xvl, xvr); transmatrix xrm = gpushxto0(xvm); transmatrix Res = rgpushxto0(vm) * rspintox(rm*vr); if(cgflags & qAFFINE) { ld sca = hdist(vl, vr) / hdist(xvl, xvr); transmatrix Tsca = Id; Tsca[0][0] = Tsca[1][1] = sca; auto& ss = sh.stretch_shear[dl]; Tsca[0][1] = ss.first * ss.second * sca; Tsca[1][1] *= ss.first; Res = Res * Tsca; } if(co.mirror) Res = Res * MirrorX; Res = Res * spintox(xrm*xvl) * xrm; if(co.mirror) swap(vl, vr); if(hdist(vl, Res*xvr) + hdist(vr, Res*xvl) > .1) { println(hlog, "s1 = ", kz(spintox(rm*vr)), " s2 = ", kz(rspintox(xrm*xvr))); println(hlog, tie(t, dl), " = ", kz(Res)); println(hlog, hdist(vl, Res * xvr), " # ", hdist(vr, Res * xvl)); exit(3); } return Res; } struct hrmap_arbi : hrmap { heptagon *origin; heptagon *getOrigin() override { return origin; } hrmap_arbi() { dynamicval curmap(currentmap, this); origin = init_heptagon(current.shapes[0].size()); origin->s = hsOrigin; origin->c7 = newCell(origin->type, origin); heptagon *alt = NULL; if(hyperbolic) { dynamicval g(geometry, gNormal); alt = init_heptagon(S7); alt->s = hsOrigin; alt->alt = alt; current_altmap = newAltMap(alt); } transmatrix T = xpush(.01241) * spin(1.4117) * xpush(0.1241) * Id; arbi_matrix[origin] = make_pair(alt, T); altmap[alt].emplace_back(origin, T); if(!current.range) current.range = auto_compute_range(origin->c7); } ~hrmap_arbi() { clearfrom(origin); altmap.clear(); arbi_matrix.clear(); if(current_altmap) { dynamicval g(geometry, gNormal); delete current_altmap; current_altmap = NULL; } } void verify() override { } transmatrix adj(heptagon *h, int dl) override { return get_adj(current_or_slided(), id_of(h), dl, -1, h->c.move(dl) ? h->c.spin(dl) : -1); } heptagon *create_step(heptagon *h, int d) override { dynamicval sl(using_slided, false); int t = id_of(h); auto& sh = current.shapes[t]; auto& co = sh.connections[d]; auto& xsh = current.shapes[co.sid]; if(cgflags & qAFFINE) { set visited; vector > v; visited.insert(h); v.emplace_back(h, Id); transmatrix goal = adj(h, d); for(int i=0; ic.connect(d, h2, co.eid, co.mirror); return h2; } for(int i=0; itype; i++) { heptagon *h3 = h2->move(i); if(!h3) continue; if(visited.count(h3)) continue; visited.insert(h3); v.emplace_back(h3, T * adj(h2, i)); } } auto h1 = init_heptagon(current.shapes[co.sid].size()); h1->distance = h->distance + 1; h1->zebraval = co.sid; h1->c7 = newCell(h1->type, h1); h1->emeraldval = h->emeraldval ^ co.mirror; h->c.connect(d, h1, co.eid, co.mirror); return h1; } const auto& p = arbi_matrix[h]; heptagon *alt = p.first; transmatrix T = p.second * adj(h, d); if(hyperbolic) { dynamicval g(geometry, gNormal); dynamicval cm(currentmap, current_altmap); // transmatrix U = T; current_altmap->virtualRebase(alt, T); // U = U * inverse(T); } fixmatrix(T); if(euclid) { /* hash the rough coordinates as heptagon* alt */ size_t s = size_t(T[0][LDIM]+.261) * 124101 + size_t(T[1][LDIM]+.261) * 82143; alt = (heptagon*) s; } for(auto& p2: altmap[alt]) if(id_of(p2.first) == co.sid && hdist(tC0(p2.second), tC0(T)) < 1e-2) { for(int oth=0; oth < p2.first->type; oth++) { ld err = hdist(p2.second * xsh.vertices[oth], T * xsh.vertices[co.eid]); if(err < 1e-2) { static ld max_err = 0; if(err > max_err) { println(hlog, "err = ", err); max_err = err; } h->c.connect(d, p2.first, oth%p2.first->type, co.mirror); return p2.first; } } } auto h1 = init_heptagon(current.shapes[co.sid].size()); h1->distance = h->distance + 1; h1->zebraval = co.sid; h1->c7 = newCell(h1->type, h1); h1->emeraldval = h->emeraldval ^ co.mirror; h->c.connect(d, h1, co.eid, co.mirror); arbi_matrix[h1] = make_pair(alt, T); altmap[alt].emplace_back(h1, T); return h1; } transmatrix relative_matrixh(heptagon *h2, heptagon *h1, const hyperpoint& hint) override { return relative_matrix_recursive(h2, h1); } transmatrix adj(cell *c, int dir) override { return adj(c->master, dir); } ld spin_angle(cell *c, int d) override { return SPIN_NOT_AVAILABLE; } int shvid(cell *c) override { return id_of(c->master); } hyperpoint get_corner(cell *c, int cid, ld cf) override { auto& sh = arb::current_or_slided().shapes[arb::id_of(c->master)]; return normalize(C0 + (sh.vertices[gmod(cid, c->type)] - C0) * 3 / cf); } }; EX hrmap *new_map() { return new hrmap_arbi; } EX void run(string fname) { stop_game(); eGeometry g = geometry; arbi_tiling t = current; auto v = variation; set_geometry(gArbitrary); try { load(fname); ginf[gArbitrary].tiling_name = current.name; } catch(hr_polygon_error& poly) { set_geometry(g); set_variation(v); current = t; start_poly_debugger(poly); string help = poly.generate_error(); showstartmenu = false; for(auto& p: poly.params) help += lalign(-1, p.first, " = ", p.second, "\n"); gotoHelp(help); } catch(hr_parse_exception& ex) { println(hlog, "failed: ", ex.s); set_geometry(g); current = t; start_game(); addMessage("failed: " + ex.s); } catch(connection_debug_request& cr) { set_geometry(g); debugged = current; current = t; ensure_geometry(cr.c); debug_polys.clear(); debug_polys.emplace_back(Id, cr.id); pushScreen(connection_debugger); } start_game(); } string slider_error; EX void sliders_changed() { try { load(current.filename, true); using_slided = true; slider_error = "OK"; #if CAP_TEXTURE texture::config.remap(); #endif } catch(hr_parse_exception& ex) { using_slided = false; slider_error = ex.s; } catch(hr_polygon_error& poly) { using_slided = false; slider_error = poly.generate_error(); } } EX void set_sliders() { cmode = sm::SIDE | sm::MAYDARK; gamescreen(1); dialog::init(XLAT("tessellation sliders")); char ch = 'A'; for(auto& sl: current.sliders) { dialog::addSelItem(sl.name, fts(sl.current), ch++); dialog::add_action([&] { dialog::editNumber(sl.current, sl.min, sl.max, 1, sl.zero, sl.name, sl.name); dialog::reaction = sliders_changed; }); } dialog::addInfo(slider_error); dialog::addBack(); dialog::display(); } /** convert a tessellation (e.g. Archimedean, regular, etc.) to the arb::current internal representation */ EX namespace convert { EX eGeometry base_geometry; EX eVariation base_variation; struct id_record { int target; /* master of this id type */ int shift; /* sample direction 0 == our direction shift */ int modval; /* this master type is the same as itself rotated by modval */ cell *sample; /* sample of the master type */ }; inline void print(hstream& hs, const id_record& i) { print(hs, "[", i.target, " shift=", i.shift, " mod=", i.modval, "]"); } map identification; id_record& get_identification(int s, cell *c) { if(!identification.count(s)) { auto &id = identification[s]; id.target = s; id.shift = 0; id.modval = c->type; id.sample = c; } return identification[s]; } id_record& get_identification(cell *c) { auto id = currentmap->full_shvid(c); return get_identification(id, c); } int changes; void be_identified(cellwalker cw1, cellwalker cw2) { auto& id1 = get_identification(cw1.at); auto& id2 = get_identification(cw2.at); indenter ind(2); int t = cw2.at->type; if(cw1.at->type != t) { println(hlog, cw1.at->type, " vs ", t); throw hr_exception("numbers disagree"); } int d2 = gmod(-cw2.to_spin(id2.shift), id2.modval); int d1 = gmod(-cw1.to_spin(id1.shift), id1.modval); indenter ind1(2); if(id2.target != id1.target) { auto oid2 = id2; id1.modval = gcd(id1.modval, id2.modval); if(id1.modval < 6 && t == 6) throw hr_exception("reducing hex"); for(auto& p: identification) { auto& idr = p.second; if(idr.target == oid2.target) { idr.target = id1.target; idr.modval = id1.modval; idr.shift = gmod(idr.shift + (d2-d1), idr.modval); idr.sample = id1.sample; } } changes++; println(hlog, identification); return; } if(d2 != d1) { auto oid2 = id2; id2.modval = gcd(id2.modval, abs(d2-d1)); if(id1.modval == 1 && t == 6) throw hr_exception("reducing hex"); for(auto& p: identification) if(p.second.target == oid2.target) p.second.modval = id2.modval; changes++; println(hlog, identification); return; } } EX void convert() { start_game(); manual_celllister cl; cl.add(currentmap->gamestart()); int chg = -1; while(changes > chg) { changes = chg; set masters_analyzed; for(int i=0; itype; i++) { if(1) { indenter ind(2); be_identified(cw0 + i + wstep, cws + i + wstep); be_identified(cw0 + i + wstep, cw0 + i + id.modval + wstep); } if(1) { indenter ind(2); auto cwx = cw0 + i + wstep; auto idx = get_identification(cwx.at); cellwalker xsample(idx.sample, cwx.spin); xsample -= idx.shift; be_identified(cwx + wstep, xsample + wstep); cl.add((cw0 + i).cpeek()); } } } } vector old_shvids; map old_to_new; for(auto id: identification) if(id.first == id.second.target) { old_to_new[id.first] = isize(old_shvids); old_shvids.push_back(id.first); } auto& ac = arb::current; ac.order++; ac.comment = ac.filename = "converted from: " + full_geometry_name(); ac.cscale = cgi.scalefactor; ac.boundary_ratio = 1; ac.floor_scale = cgi.hexvdist / cgi.scalefactor; ac.range = cgi.base_distlimit; int N = isize(old_shvids); ac.shapes.resize(N); ginf[gArbitrary].g = cginf.g; ginf[gArbitrary].flags = cgflags & qBOUNDED; for(int i=0; itype; sh.vertices.clear(); sh.connections.clear(); sh.repeat_value = id.modval; for(int j=0; jget_corner(s, j); sh.vertices.push_back(co); cellwalker cw(s, j); cw += wstep; auto idx = get_identification(cw.at); cellwalker xsample(idx.sample, cw.spin); xsample -= idx.shift; sh.connections.emplace_back(arb::connection_t{old_to_new.at(idx.target), xsample.spin, false}); } sh.stretch_shear.resize(t, make_pair(1, 0)); sh.edges.clear(); for(int j=0; j M_PI) alpha -= 360*degree; while(alpha < -M_PI) alpha += 360*degree; sh.angles.push_back(alpha); } if(debugflags & DF_GEOM) { println(hlog, "shape ", i, ":"); indenter indp(2); println(hlog, "vertices=", sh.vertices); println(hlog, "connections=", sh.connections); println(hlog, "edges=", sh.edges); println(hlog, "angles=", sh.angles); } } arb::compute_vertex_valence(); } EX bool in() { return arb::in() && base_geometry != gArbitrary; } /** activate the converted tessellation */ EX void activate() { if(geometry != gArbitrary) { base_geometry = geometry; base_variation = variation; stop_game(); geometry = gArbitrary; variation = eVariation::pure; } } EX } #if CAP_COMMANDLINE int readArgs() { using namespace arg; if(0) ; else if(argis("-tes") || argis("-arbi")) { PHASEFROM(2); shift(); run(args()); } else if(argis("-arb-legacy")) { legacy = true; } else if(argis("-arb-convert")) { try { convert::convert(); set_geometry(gArbitrary); } catch(hr_exception& e) { println(hlog, "failed to convert: ", e.what()); } } else if(argis("-arb-slider")) { PHASEFROM(2); shift(); string slider = args(); bool found = true; for(auto& sl: current.sliders) if(sl.name == slider) { shift_arg_formula(sl.current, sliders_changed); found = true; } if(!found) { println(hlog, "warning: no slider named ", slider, " found"); shift(); } } else return 1; return 0; } auto hook = addHook(hooks_args, 100, readArgs); #endif EX bool in() { return geometry == gArbitrary; } EX string tes = "tessellations/sample/marjorie-rice.tes"; EX bool linespattern(cell *c) { return current.shapes[id_of(c->master)].flags & arcm::sfLINE; } EX bool pseudohept(cell *c) { if(!current.have_ph) return true; return current.shapes[id_of(c->master)].flags & arcm::sfPH; } EX void choose() { dialog::openFileDialog(tes, XLAT("open a tiling"), ".tes", [] () { run(tes); return true; }); } #if MAXMDIM >= 4 auto hooksw = addHook(hooks_swapdim, 100, [] { for(auto& p: {¤t, &slided}) for(auto& s: p->shapes) for(auto& v: s.vertices) swapmatrix(v); for(auto& p: altmap) for(auto& pp: p.second) swapmatrix(pp.second); for(auto& p: arbi_matrix) swapmatrix(p.second.second); }); #endif EX } }