mirror of
https://github.com/zenorogue/hyperrogue.git
synced 2025-04-25 20:23:12 +00:00
MAJOR refactoring: all geometry-dependent data (tessf, geom3::, shapes, hpc) are now contained in a structure
This commit is contained in:
Zeno Rogue
parent
9c5344289a
commit
b6e303ec7d
232
3d-models.cpp
232
3d-models.cpp
@ -11,8 +11,8 @@ ld eyepos;
|
||||
|
||||
#if MAXMDIM >= 4
|
||||
|
||||
#define S (scalefactor / 0.805578)
|
||||
#define SH (scalefactor / 0.805578 * geom3::height_width / 1.5)
|
||||
#define S (cgi.scalefactor / 0.805578)
|
||||
#define SH (cgi.scalefactor / 0.805578 * geom3::height_width / 1.5)
|
||||
|
||||
#define revZ (WDIM == 2 ? -1 : 1)
|
||||
|
||||
@ -22,7 +22,7 @@ hyperpoint front_leg, rear_leg;
|
||||
transmatrix front_leg_move, rear_leg_move, front_leg_move_inverse, rear_leg_move_inverse;
|
||||
ld leg_length;
|
||||
|
||||
vector<hyperpoint> get_shape(hpcshape sh) {
|
||||
vector<hyperpoint> geometry_information::get_shape(hpcshape sh) {
|
||||
vector<hyperpoint> res;
|
||||
for(int i=sh.s; i<sh.e-1; i++) res.push_back(hpc[i]);
|
||||
return res;
|
||||
@ -37,15 +37,15 @@ hyperpoint get_center(const vector<hyperpoint>& vh) {
|
||||
|
||||
ld zc(ld z) {
|
||||
if(WDIM == 2 && GDIM == 3)
|
||||
return geom3::lev_to_factor(geom3::human_height * z);
|
||||
return geom3::human_height * (z - 0.5);
|
||||
return geom3::lev_to_factor(cgi.human_height * z);
|
||||
return cgi.human_height * (z - 0.5);
|
||||
}
|
||||
|
||||
transmatrix zpush(ld z) {
|
||||
return cpush(2, z);
|
||||
}
|
||||
|
||||
void add_cone(ld z0, const vector<hyperpoint>& vh, ld z1) {
|
||||
void geometry_information::add_cone(ld z0, const vector<hyperpoint>& vh, ld z1) {
|
||||
last->flags |= POLY_TRIANGLES;
|
||||
for(int i=0; i<isize(vh); i++) {
|
||||
hpcpush(zpush(z0) * vh[i]);
|
||||
@ -54,7 +54,7 @@ void add_cone(ld z0, const vector<hyperpoint>& vh, ld z1) {
|
||||
}
|
||||
}
|
||||
|
||||
void add_prism_sync(ld z0, vector<hyperpoint> vh0, ld z1, vector<hyperpoint> vh1) {
|
||||
void geometry_information::add_prism_sync(ld z0, vector<hyperpoint> vh0, ld z1, vector<hyperpoint> vh1) {
|
||||
last->flags |= POLY_TRIANGLES;
|
||||
for(int i=0; i<isize(vh0); i++) {
|
||||
int i1 = (i+1) % isize(vh0);
|
||||
@ -67,7 +67,7 @@ void add_prism_sync(ld z0, vector<hyperpoint> vh0, ld z1, vector<hyperpoint> vh1
|
||||
}
|
||||
}
|
||||
|
||||
void add_prism(ld z0, vector<hyperpoint> vh0, ld z1, vector<hyperpoint> vh1) {
|
||||
void geometry_information::add_prism(ld z0, vector<hyperpoint> vh0, ld z1, vector<hyperpoint> vh1) {
|
||||
last->flags |= POLY_TRIANGLES;
|
||||
|
||||
struct mixed {
|
||||
@ -97,15 +97,15 @@ void add_prism(ld z0, vector<hyperpoint> vh0, ld z1, vector<hyperpoint> vh1) {
|
||||
}
|
||||
}
|
||||
|
||||
void shift_last(ld z) {
|
||||
void geometry_information::shift_last(ld z) {
|
||||
for(int i=last->s; i<isize(hpc); i++) hpc[i] = zshift(hpc[i], z);
|
||||
}
|
||||
|
||||
void shift_shape(hpcshape& sh, ld z) {
|
||||
void geometry_information::shift_shape(hpcshape& sh, ld z) {
|
||||
for(int i=sh.s; i<sh.e; i++) hpc[i] = zshift(hpc[i], z);
|
||||
}
|
||||
|
||||
void shift_shape_orthogonally(hpcshape& sh, ld z) {
|
||||
void geometry_information::shift_shape_orthogonally(hpcshape& sh, ld z) {
|
||||
for(int i=sh.s; i<sh.e; i++) hpc[i] = orthogonal_move(hpc[i], z);
|
||||
}
|
||||
|
||||
@ -113,7 +113,7 @@ extern renderbuffer *floor_textures;
|
||||
|
||||
basic_textureinfo models_texture;
|
||||
|
||||
void add_texture(hpcshape& sh) {
|
||||
void geometry_information::add_texture(hpcshape& sh) {
|
||||
if(!floor_textures) return;
|
||||
auto& utt = models_texture;
|
||||
sh.tinf = &utt;
|
||||
@ -133,7 +133,7 @@ vector<hyperpoint> scaleshape(const vector<hyperpoint>& vh, ld s) {
|
||||
return res;
|
||||
}
|
||||
|
||||
void make_ha_3d(hpcshape& sh, bool isarmor, ld scale) {
|
||||
void geometry_information::make_ha_3d(hpcshape& sh, bool isarmor, ld scale) {
|
||||
shcenter = C0;
|
||||
|
||||
auto groin = get_shape(shHumanGroin);
|
||||
@ -191,14 +191,14 @@ void make_ha_3d(hpcshape& sh, bool isarmor, ld scale) {
|
||||
add_cone(zc(0.8), neck, zc(0.83));
|
||||
|
||||
int at0 = isize(hpc);
|
||||
ld h = geom3::human_height;
|
||||
ld h = human_height;
|
||||
|
||||
if(isize(arm) > 3) {
|
||||
shcenter = get_center(arm);
|
||||
int arm0 = isize(hpc);
|
||||
add_prism_sync(geom3::BODY - h*.03, arm, geom3::BODY + h*.03, arm);
|
||||
add_cone(geom3::BODY + h*.03, arm, geom3::BODY + h*.05);
|
||||
add_cone(geom3::BODY - h*.03, arm, geom3::BODY - h*.05);
|
||||
add_prism_sync(BODY - h*.03, arm, BODY + h*.03, arm);
|
||||
add_cone(BODY + h*.03, arm, BODY + h*.05);
|
||||
add_cone(BODY - h*.03, arm, BODY - h*.05);
|
||||
int arm1 = isize(hpc);
|
||||
for(int i=arm0; i<arm1; i++) {
|
||||
hyperpoint h = hpc[i];
|
||||
@ -207,7 +207,7 @@ void make_ha_3d(hpcshape& sh, bool isarmor, ld scale) {
|
||||
ld rad = hdist0(h);
|
||||
rad = (rad - 0.1124*S) / (0.2804*S - 0.1124*S);
|
||||
rad = 1 - rad;
|
||||
rad *= zc(0.7) - geom3::BODY;
|
||||
rad *= zc(0.7) - BODY;
|
||||
hpc[i] = zpush(rad) * hpc[i];
|
||||
}
|
||||
}
|
||||
@ -216,15 +216,15 @@ void make_ha_3d(hpcshape& sh, bool isarmor, ld scale) {
|
||||
|
||||
if(isize(hand) > 3) {
|
||||
shcenter = get_center(hand);
|
||||
add_cone(geom3::BODY, hand, geom3::BODY + 0.05 * geom3::human_height);
|
||||
add_cone(geom3::BODY, hand, geom3::BODY - 0.05 * geom3::human_height);
|
||||
add_cone(BODY, hand, BODY + 0.05 * human_height);
|
||||
add_cone(BODY, hand, BODY - 0.05 * human_height);
|
||||
}
|
||||
|
||||
int at1 = isize(hpc);
|
||||
for(int i=at0; i<at1; i++) hpc.push_back(Mirror * hpc[i]);
|
||||
|
||||
add_texture(shPBody);
|
||||
shift_last(-geom3::BODY);
|
||||
shift_last(-BODY);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -232,9 +232,9 @@ void make_humanoid_3d(hpcshape& sh) { make_ha_3d(sh, false, 0.90); }
|
||||
void make_armor_3d(hpcshape& sh, ld scale = 1) { make_ha_3d(sh, true, scale); }
|
||||
*/
|
||||
|
||||
void make_humanoid_3d(hpcshape& sh) { make_ha_3d(sh, false, 1); }
|
||||
void geometry_information::make_humanoid_3d(hpcshape& sh) { make_ha_3d(sh, false, 1); }
|
||||
|
||||
void addtri(array<hyperpoint, 3> hs, int kind) {
|
||||
void geometry_information::addtri(array<hyperpoint, 3> hs, int kind) {
|
||||
ld ds[3];
|
||||
ds[0] = hdist(hs[0], hs[1]);
|
||||
ds[1] = hdist(hs[1], hs[2]);
|
||||
@ -287,7 +287,7 @@ void addtri(array<hyperpoint, 3> hs, int kind) {
|
||||
}
|
||||
ld levels[6] = {0, 0.125, 0.125, 0.250, 0.375, 0.5};
|
||||
for(int a=0; a<6; a++) for(int i=0; i<3; i++)
|
||||
htx[a][i] = zpush(-min(shi[i], levels[a]) * geom3::human_height * revZ) * htx[a][i];
|
||||
htx[a][i] = zpush(-min(shi[i], levels[a]) * human_height * revZ) * htx[a][i];
|
||||
|
||||
hpcpush(htx[0][0]);
|
||||
hpcpush(htx[0][1]);
|
||||
@ -320,7 +320,7 @@ void addtri(array<hyperpoint, 3> hs, int kind) {
|
||||
}
|
||||
}
|
||||
|
||||
void make_armor_3d(hpcshape& sh, int kind = 1) {
|
||||
void geometry_information::make_armor_3d(hpcshape& sh, int kind) {
|
||||
|
||||
auto body = get_shape(sh);
|
||||
vector<vector<array<ld, 2> >> pts(2);
|
||||
@ -345,12 +345,12 @@ void make_armor_3d(hpcshape& sh, int kind = 1) {
|
||||
|
||||
add_texture(sh);
|
||||
if(&sh == &shHood || &sh == &shWightCloak || &sh == &shArmor)
|
||||
shift_last(-geom3::HEAD);
|
||||
shift_last(-HEAD);
|
||||
else
|
||||
shift_last(-geom3::BODY);
|
||||
shift_last(-BODY);
|
||||
}
|
||||
|
||||
void make_foot_3d(hpcshape& sh) {
|
||||
void geometry_information::make_foot_3d(hpcshape& sh) {
|
||||
auto foot = get_shape(sh);
|
||||
auto leg = get_shape(shHumanLeg);
|
||||
auto leg5 = scaleshape(leg, 0.8);
|
||||
@ -362,13 +362,13 @@ void make_foot_3d(hpcshape& sh) {
|
||||
add_prism_sync(zc(0.1), leg, zc(0.4), leg5);
|
||||
add_cone(zc(0.4), leg5, zc(0.45));
|
||||
add_texture(sh);
|
||||
// shift_last(-geom3::LEG0);
|
||||
// shift_last(-LEG0);
|
||||
for(int i=last->s; i<isize(hpc); i++) hpc[i] = cpush(0, -0.0125*S) * hpc[i];
|
||||
}
|
||||
|
||||
void make_head_only() {
|
||||
void geometry_information::make_head_only() {
|
||||
|
||||
auto addpt = [] (int d, int u) {
|
||||
auto addpt = [this] (int d, int u) {
|
||||
hpcpush(zpush(zc(eyepos) + 0.06 * SH * sin(u * degree)) * xspinpush0(d * degree, 0.05 * S * cos(u * degree)));
|
||||
};
|
||||
|
||||
@ -385,11 +385,11 @@ void make_head_only() {
|
||||
}
|
||||
|
||||
add_texture(shPHeadOnly);
|
||||
shift_last(-geom3::HEAD - revZ * 0.01 * SH);
|
||||
shift_last(-HEAD - revZ * 0.01 * SH);
|
||||
}
|
||||
|
||||
|
||||
void make_head_3d(hpcshape& sh) {
|
||||
void geometry_information::make_head_3d(hpcshape& sh) {
|
||||
auto head = get_shape(sh);
|
||||
vector<vector<array<ld, 2> >> pts(2);
|
||||
|
||||
@ -414,10 +414,10 @@ void make_head_3d(hpcshape& sh) {
|
||||
}
|
||||
|
||||
add_texture(sh);
|
||||
shift_last(-geom3::HEAD);
|
||||
shift_last(-HEAD);
|
||||
}
|
||||
|
||||
void make_paw_3d(hpcshape& sh, hpcshape& legsh) {
|
||||
void geometry_information::make_paw_3d(hpcshape& sh, hpcshape& legsh) {
|
||||
auto foot = get_shape(sh);
|
||||
auto leg = get_shape(legsh);
|
||||
|
||||
@ -430,7 +430,7 @@ void make_paw_3d(hpcshape& sh, hpcshape& legsh) {
|
||||
add_texture(sh);
|
||||
}
|
||||
|
||||
void make_abody_3d(hpcshape& sh, ld tail) {
|
||||
void geometry_information::make_abody_3d(hpcshape& sh, ld tail) {
|
||||
auto body = get_shape(sh);
|
||||
shcenter = get_center(body);
|
||||
|
||||
@ -448,10 +448,10 @@ void make_abody_3d(hpcshape& sh, ld tail) {
|
||||
add_cone(zc(0.4), body8, zc(0.36));
|
||||
add_cone(zc(0.6), body8, zc(0.64));
|
||||
add_texture(sh);
|
||||
if(GDIM == 3 && WDIM == 2) shift_last(-geom3::ABODY);
|
||||
if(GDIM == 3 && WDIM == 2) shift_last(-ABODY);
|
||||
}
|
||||
|
||||
void make_ahead_3d(hpcshape& sh) {
|
||||
void geometry_information::make_ahead_3d(hpcshape& sh) {
|
||||
auto body = get_shape(sh);
|
||||
shcenter = get_center(body);
|
||||
auto body8 = scaleshape(body, 0.5);
|
||||
@ -464,7 +464,7 @@ void make_ahead_3d(hpcshape& sh) {
|
||||
add_texture(sh);
|
||||
}
|
||||
|
||||
void make_skeletal(hpcshape& sh, ld push = 0) {
|
||||
void geometry_information::make_skeletal(hpcshape& sh, ld push) {
|
||||
auto body = get_shape(sh);
|
||||
shcenter = get_center(body);
|
||||
|
||||
@ -477,7 +477,7 @@ void make_skeletal(hpcshape& sh, ld push = 0) {
|
||||
shift_last(-push);
|
||||
}
|
||||
|
||||
void make_revolution(hpcshape& sh, int mx = 180, ld push = 0) {
|
||||
void geometry_information::make_revolution(hpcshape& sh, int mx, ld push) {
|
||||
auto body = get_shape(sh);
|
||||
bshape(sh, PPR::MONSTER_BODY);
|
||||
int step = (mx == 360 ? 24 : 10);
|
||||
@ -498,7 +498,7 @@ void make_revolution(hpcshape& sh, int mx = 180, ld push = 0) {
|
||||
shift_last(-push);
|
||||
}
|
||||
|
||||
void make_revolution_cut(hpcshape &sh, int each = 180, ld push = 0, ld width = 99) {
|
||||
void geometry_information::make_revolution_cut(hpcshape &sh, int each, ld push, ld width) {
|
||||
auto body = get_shape(sh);
|
||||
body.resize(isize(body) / 2);
|
||||
ld fx = body[0][0];
|
||||
@ -570,14 +570,14 @@ void disable(hpcshape& sh) {
|
||||
sh.s = sh.e = 0;
|
||||
}
|
||||
|
||||
void clone_shape(hpcshape& sh, hpcshape& target) {
|
||||
void geometry_information::clone_shape(hpcshape& sh, hpcshape& target) {
|
||||
target = sh;
|
||||
target.s = isize(hpc);
|
||||
for(int i=sh.s; i<sh.e; i++) hpc.push_back(hpc[i]);
|
||||
target.e = isize(hpc);
|
||||
}
|
||||
|
||||
void animate_bird(hpcshape& orig, hpcshape animated[30], ld body) {
|
||||
void geometry_information::animate_bird(hpcshape& orig, hpcshape animated[30], ld body) {
|
||||
for(int i=0; i<30; i++) {
|
||||
auto& tgt = animated[i];
|
||||
clone_shape(orig, tgt);
|
||||
@ -591,11 +591,11 @@ void animate_bird(hpcshape& orig, hpcshape animated[30], ld body) {
|
||||
}
|
||||
}
|
||||
}
|
||||
// for(int i=0; i<30; i++) shift_shape(animated[i], geom3::BIRD);
|
||||
// shift_shape(orig, geom3::BIRD);
|
||||
// for(int i=0; i<30; i++) shift_shape(animated[i], BIRD);
|
||||
// shift_shape(orig, BIRD);
|
||||
}
|
||||
|
||||
void slimetriangle(hyperpoint a, hyperpoint b, hyperpoint c, ld rad, int lev) {
|
||||
void geometry_information::slimetriangle(hyperpoint a, hyperpoint b, hyperpoint c, ld rad, int lev) {
|
||||
dynamicval<int> d(vid.texture_step, 8);
|
||||
texture_order([&] (ld x, ld y) {
|
||||
using namespace hyperpoint_vec;
|
||||
@ -606,7 +606,7 @@ void slimetriangle(hyperpoint a, hyperpoint b, hyperpoint c, ld rad, int lev) {
|
||||
});
|
||||
}
|
||||
|
||||
void balltriangle(hyperpoint a, hyperpoint b, hyperpoint c, ld rad, int lev) {
|
||||
void geometry_information::balltriangle(hyperpoint a, hyperpoint b, hyperpoint c, ld rad, int lev) {
|
||||
if(lev == 0) {
|
||||
hpcpush(a);
|
||||
hpcpush(b);
|
||||
@ -623,7 +623,7 @@ void balltriangle(hyperpoint a, hyperpoint b, hyperpoint c, ld rad, int lev) {
|
||||
}
|
||||
}
|
||||
|
||||
void make_ball(hpcshape& sh, ld rad, int lev) {
|
||||
void geometry_information::make_ball(hpcshape& sh, ld rad, int lev) {
|
||||
bshape(sh, sh.prio);
|
||||
sh.flags |= POLY_TRIANGLES;
|
||||
hyperpoint tip = xpush0(rad);
|
||||
@ -652,7 +652,7 @@ hyperpoint psmin(hyperpoint H) {
|
||||
return res;
|
||||
}
|
||||
|
||||
void adjust_eye(hpcshape& eye, hpcshape head, ld shift_eye, ld shift_head, int q, ld zoom=1) {
|
||||
void geometry_information::adjust_eye(hpcshape& eye, hpcshape head, ld shift_eye, ld shift_head, int q, ld zoom) {
|
||||
using namespace hyperpoint_vec;
|
||||
hyperpoint center = Hypc;
|
||||
for(int i=eye.s; i<eye.e; i++) if(q == 1 || hpc[i][1] > 0) center += hpc[i];
|
||||
@ -697,7 +697,7 @@ void adjust_eye(hpcshape& eye, hpcshape head, ld shift_eye, ld shift_head, int q
|
||||
// eye.prio = PPR::SUPERLINE;
|
||||
}
|
||||
|
||||
void shift_last_straight(ld z) {
|
||||
void geometry_information::shift_last_straight(ld z) {
|
||||
for(int i=last->s; i<isize(hpc); i++) hpc[i] = zpush(z) * hpc[i];
|
||||
}
|
||||
|
||||
@ -742,13 +742,13 @@ void queueball(const transmatrix& V, ld rad, color_t col, eItem what) {
|
||||
}
|
||||
}
|
||||
|
||||
void make_shadow(hpcshape& sh) {
|
||||
void geometry_information::make_shadow(hpcshape& sh) {
|
||||
sh.shs = isize(hpc);
|
||||
for(int i=sh.s; i < sh.e; i++) hpcpush(orthogonal_move(hpc[i], geom3::FLOOR - geom3::human_height / 100));
|
||||
for(int i=sh.s; i < sh.e; i++) hpcpush(orthogonal_move(hpc[i], FLOOR - human_height / 100));
|
||||
sh.she = isize(hpc);
|
||||
}
|
||||
|
||||
void make_3d_models() {
|
||||
void geometry_information::make_3d_models() {
|
||||
if(DIM == 2) return;
|
||||
eyepos = WDIM == 2 ? 0.875 : 0.925;
|
||||
DEBBI(DF_POLY, ("make_3d_models"));
|
||||
@ -832,7 +832,7 @@ void make_3d_models() {
|
||||
DEBB(DF_POLY, ("feet and paws"));
|
||||
make_foot_3d(shHumanFoot);
|
||||
make_foot_3d(shYetiFoot);
|
||||
make_skeletal(shSkeletalFoot, WDIM == 2 ? zc(0.5) + geom3::human_height/40 - geom3::FLOOR : 0);
|
||||
make_skeletal(shSkeletalFoot, WDIM == 2 ? zc(0.5) + human_height/40 - FLOOR : 0);
|
||||
|
||||
hyperpoint front_leg = Hypc;
|
||||
hyperpoint rear_leg = Hypc;
|
||||
@ -856,29 +856,29 @@ void make_3d_models() {
|
||||
// make_abody_3d(shWolfBody, 0.01);
|
||||
// make_ahead_3d(shWolfHead);
|
||||
// make_ahead_3d(shFamiliarHead);
|
||||
ld g = WDIM == 2 ? geom3::ABODY - zc(0.4) : 0;
|
||||
ld g = WDIM == 2 ? ABODY - zc(0.4) : 0;
|
||||
|
||||
make_revolution_cut(shWolfBody, 30, g, 0.01*S);
|
||||
make_revolution_cut(shWolfHead, 180, geom3::AHEAD - geom3::ABODY +g);
|
||||
make_revolution_cut(shRatHead, 180, geom3::AHEAD - geom3::ABODY +g, 0.04*scalefactor);
|
||||
make_revolution_cut(shRatCape1, 180, geom3::AHEAD - geom3::ABODY +g);
|
||||
make_revolution_cut(shFamiliarHead, 30, geom3::AHEAD - geom3::ABODY +g);
|
||||
make_revolution_cut(shWolfHead, 180, AHEAD - ABODY +g);
|
||||
make_revolution_cut(shRatHead, 180, AHEAD - ABODY +g, 0.04*scalefactor);
|
||||
make_revolution_cut(shRatCape1, 180, AHEAD - ABODY +g);
|
||||
make_revolution_cut(shFamiliarHead, 30, AHEAD - ABODY +g);
|
||||
|
||||
// make_abody_3d(shDogTorso, 0.01);
|
||||
make_revolution_cut(shDogTorso, 30, +g);
|
||||
make_revolution_cut(shDogHead, 180, geom3::AHEAD - geom3::ABODY +g);
|
||||
make_revolution_cut(shDogHead, 180, AHEAD - ABODY +g);
|
||||
// make_ahead_3d(shDogHead);
|
||||
|
||||
// make_abody_3d(shCatBody, 0.05);
|
||||
// make_ahead_3d(shCatHead);
|
||||
make_revolution_cut(shCatBody, 30, +g);
|
||||
make_revolution_cut(shCatHead, 180, geom3::AHEAD - geom3::ABODY +g, 0.055 * scalefactor);
|
||||
make_revolution_cut(shCatHead, 180, AHEAD - ABODY +g, 0.055 * scalefactor);
|
||||
|
||||
make_paw_3d(shReptileFrontFoot, shReptileFrontLeg);
|
||||
make_paw_3d(shReptileRearFoot, shReptileRearLeg);
|
||||
make_abody_3d(shReptileBody, -1);
|
||||
// make_ahead_3d(shReptileHead);
|
||||
make_revolution_cut(shReptileHead, 180, geom3::AHEAD - geom3::ABODY+g);
|
||||
make_revolution_cut(shReptileHead, 180, AHEAD - ABODY+g);
|
||||
|
||||
make_paw_3d(shBullFrontHoof, shBullFrontHoof);
|
||||
make_paw_3d(shBullRearHoof, shBullRearHoof);
|
||||
@ -886,19 +886,19 @@ void make_3d_models() {
|
||||
// make_ahead_3d(shBullHead);
|
||||
// make_ahead_3d(shBullHorn);
|
||||
make_revolution_cut(shBullBody, 180, +g);
|
||||
make_revolution_cut(shBullHead, 60, geom3::AHEAD - geom3::ABODY +g);
|
||||
shift_shape(shBullHorn, -g-(geom3::AHEAD - geom3::ABODY));
|
||||
// make_revolution_cut(shBullHorn, 180, geom3::AHEAD - geom3::ABODY);
|
||||
make_revolution_cut(shBullHead, 60, AHEAD - ABODY +g);
|
||||
shift_shape(shBullHorn, -g-(AHEAD - ABODY));
|
||||
// make_revolution_cut(shBullHorn, 180, AHEAD - ABODY);
|
||||
|
||||
make_paw_3d(shTrylobiteFrontClaw, shTrylobiteFrontLeg);
|
||||
make_paw_3d(shTrylobiteRearClaw, shTrylobiteRearLeg);
|
||||
make_abody_3d(shTrylobiteBody, 0);
|
||||
// make_ahead_3d(shTrylobiteHead);
|
||||
make_revolution_cut(shTrylobiteHead, 180, geom3::AHEAD - geom3::ABODY +g);
|
||||
make_revolution_cut(shTrylobiteHead, 180, AHEAD - ABODY +g);
|
||||
|
||||
make_revolution_cut(shShark, 180, WDIM == 2 ? -geom3::FLOOR : 0);
|
||||
make_revolution_cut(shShark, 180, WDIM == 2 ? -FLOOR : 0);
|
||||
|
||||
make_revolution_cut(shGhost, 60, geom3::GHOST + g);
|
||||
make_revolution_cut(shGhost, 60, GHOST + g);
|
||||
|
||||
make_revolution_cut(shEagle, 180, 0, 0.05*S);
|
||||
make_revolution_cut(shHawk, 180, 0, 0.05*S);
|
||||
@ -913,8 +913,8 @@ void make_3d_models() {
|
||||
make_revolution_cut(shBatWings, 180, 0, 0.05*S);
|
||||
make_revolution_cut(shBatBody, 180, 0, 0.05*S);
|
||||
|
||||
make_revolution_cut(shMouse, 180, -geom3::FLOOR);
|
||||
shift_shape(shMouseLegs, geom3::FLOOR - geom3::human_height / 200);
|
||||
make_revolution_cut(shMouse, 180, -FLOOR);
|
||||
shift_shape(shMouseLegs, FLOOR - human_height / 200);
|
||||
|
||||
make_revolution_cut(shJelly, 60);
|
||||
make_revolution(shFoxTail1);
|
||||
@ -925,8 +925,8 @@ void make_3d_models() {
|
||||
|
||||
make_revolution_cut(shBugLeg, 60);
|
||||
|
||||
make_revolution(shBugArmor, 180, geom3::ABODY);
|
||||
make_revolution_cut(shBugAntenna, 90, geom3::ABODY);
|
||||
make_revolution(shBugArmor, 180, ABODY);
|
||||
make_revolution_cut(shBugAntenna, 90, ABODY);
|
||||
|
||||
make_revolution_cut(shButterflyBody, 180, 0);
|
||||
make_revolution_cut(shButterflyWing, 180, 0, 0.05*S);
|
||||
@ -963,8 +963,8 @@ void make_3d_models() {
|
||||
make_revolution_cut(shWormTail, 60, g);
|
||||
make_revolution_cut(shSmallWormTail, 60, g);
|
||||
make_revolution_cut(shTentHead, 60, g);
|
||||
make_revolution_cut(shKrakenHead, 60, -geom3::FLOOR);
|
||||
make_revolution_cut(shSeaTentacle, 60, -geom3::FLOOR);
|
||||
make_revolution_cut(shKrakenHead, 60, -FLOOR);
|
||||
make_revolution_cut(shSeaTentacle, 60, -FLOOR);
|
||||
make_revolution_cut(shDragonLegs, 60, g);
|
||||
make_revolution_cut(shDragonWings, 60, g);
|
||||
disable(shDragonNostril);
|
||||
@ -981,36 +981,36 @@ void make_3d_models() {
|
||||
if(WDIM == 2) {
|
||||
for(int i=0; i<3; i++) {
|
||||
clone_shape(shHalfFloor[i], shHalfFloor[i+3]);
|
||||
shift_shape_orthogonally(shHalfFloor[i], geom3::FLOOR - geom3::human_height * .007);
|
||||
shift_shape_orthogonally(shHalfFloor[i+3], geom3::WALL + geom3::human_height * .007);
|
||||
shift_shape_orthogonally(shHalfFloor[i], FLOOR - human_height * .007);
|
||||
shift_shape_orthogonally(shHalfFloor[i+3], WALL + human_height * .007);
|
||||
}
|
||||
}
|
||||
|
||||
shift_shape(shBoatOuter, geom3::FLOOR);
|
||||
shift_shape(shBoatInner, (geom3::FLOOR+geom3::LAKE)/2);
|
||||
shift_shape(shBoatOuter, FLOOR);
|
||||
shift_shape(shBoatInner, (FLOOR+LAKE)/2);
|
||||
|
||||
for(int i=0; i<14; i++)
|
||||
shift_shape(shTriheptaSpecial[i], geom3::FLOOR);
|
||||
shift_shape(shTriheptaSpecial[i], FLOOR);
|
||||
|
||||
shift_shape_orthogonally(shBigCarpet1, geom3::FLOOR - geom3::human_height * 1/40);
|
||||
shift_shape_orthogonally(shBigCarpet2, geom3::FLOOR - geom3::human_height * 2/40);
|
||||
shift_shape_orthogonally(shBigCarpet3, geom3::FLOOR - geom3::human_height * 3/40);
|
||||
shift_shape_orthogonally(shBigCarpet1, FLOOR - human_height * 1/40);
|
||||
shift_shape_orthogonally(shBigCarpet2, FLOOR - human_height * 2/40);
|
||||
shift_shape_orthogonally(shBigCarpet3, FLOOR - human_height * 3/40);
|
||||
for(int a=0; a<5; a++) for(int b=0; b<4; b++)
|
||||
shift_shape(shReptile[a][b], geom3::FLOOR - geom3::human_height * min(b, 2) / 40);
|
||||
shift_shape(shReptile[a][b], FLOOR - human_height * min(b, 2) / 40);
|
||||
|
||||
shift_shape(shMineMark[0], geom3::FLOOR - geom3::human_height * 1/40);
|
||||
shift_shape(shMineMark[1], geom3::FLOOR - geom3::human_height * 1/40);
|
||||
shift_shape(shMineMark[0], FLOOR - human_height * 1/40);
|
||||
shift_shape(shMineMark[1], FLOOR - human_height * 1/40);
|
||||
|
||||
for(int a=0; a<5; a++) shift_shape(shZebra[a], geom3::FLOOR);
|
||||
for(int a=0; a<5; a++) shift_shape(shZebra[a], FLOOR);
|
||||
|
||||
for(int t=0; t<13; t++) for(int u=0; u<6; u++)
|
||||
shift_shape(shTortoise[t][u], geom3::FLOOR - geom3::human_height * (t+1) / 120);
|
||||
shift_shape(shTortoise[t][u], FLOOR - human_height * (t+1) / 120);
|
||||
|
||||
make_revolution_cut(shStatue, 60);
|
||||
|
||||
shift_shape(shThorns, geom3::FLOOR - geom3::human_height * 1/40);
|
||||
shift_shape(shThorns, FLOOR - human_height * 1/40);
|
||||
clone_shape(shRose, shRoseItem);
|
||||
shift_shape(shRose, geom3::FLOOR - geom3::human_height * 1/20);
|
||||
shift_shape(shRose, FLOOR - human_height * 1/20);
|
||||
|
||||
DEBB(DF_POLY, ("slime"));
|
||||
bshape(shSlime, PPR::MONSTER_BODY);
|
||||
@ -1029,17 +1029,17 @@ void make_3d_models() {
|
||||
}
|
||||
last->flags |= POLY_TRIANGLES;
|
||||
add_texture(*last);
|
||||
if(WDIM == 2) shift_last_straight(geom3::FLOOR);
|
||||
if(WDIM == 2) shift_last_straight(FLOOR);
|
||||
finishshape();
|
||||
shJelly = shSlime;
|
||||
|
||||
shift_shape(shMagicSword, geom3::ABODY);
|
||||
shift_shape(shMagicShovel, geom3::ABODY);
|
||||
shift_shape(shMagicSword, ABODY);
|
||||
shift_shape(shMagicShovel, ABODY);
|
||||
|
||||
DEBB(DF_POLY, ("eyes"));
|
||||
adjust_eye(shSlimeEyes, shSlime, geom3::FLATEYE, 0, 2, 2);
|
||||
adjust_eye(shGhostEyes, shGhost, geom3::GHOST, geom3::GHOST, 2, WDIM == 2 ? 2 : 4);
|
||||
adjust_eye(shMiniEyes, shMiniGhost, geom3::GHOST, geom3::GHOST, 2, 2);
|
||||
adjust_eye(shSlimeEyes, shSlime, FLATEYE, 0, 2, 2);
|
||||
adjust_eye(shGhostEyes, shGhost, GHOST, GHOST, 2, WDIM == 2 ? 2 : 4);
|
||||
adjust_eye(shMiniEyes, shMiniGhost, GHOST, GHOST, 2, 2);
|
||||
adjust_eye(shWormEyes, shWormHead, 0, 0, 2, 4);
|
||||
adjust_eye(shDragonEyes, shDragonHead, 0, 0, 2, 4);
|
||||
|
||||
@ -1050,31 +1050,31 @@ void make_3d_models() {
|
||||
shRatEye2 = shWolf2;
|
||||
shRatEye3 = shWolf3;
|
||||
|
||||
adjust_eye(shWolf1, shDogHead, geom3::AHEAD, geom3::AHEAD, 1);
|
||||
adjust_eye(shWolf2, shDogHead, geom3::AHEAD, geom3::AHEAD, 1);
|
||||
adjust_eye(shWolf3, shDogHead, geom3::AHEAD, geom3::AHEAD, 1);
|
||||
adjust_eye(shFamiliarEye, shWolfHead, geom3::AHEAD, geom3::AHEAD, 1);
|
||||
adjust_eye(shWolf1, shDogHead, AHEAD, AHEAD, 1);
|
||||
adjust_eye(shWolf2, shDogHead, AHEAD, AHEAD, 1);
|
||||
adjust_eye(shWolf3, shDogHead, AHEAD, AHEAD, 1);
|
||||
adjust_eye(shFamiliarEye, shWolfHead, AHEAD, AHEAD, 1);
|
||||
|
||||
adjust_eye(shRatEye1, shRatHead, geom3::AHEAD, geom3::AHEAD, 1);
|
||||
adjust_eye(shRatEye2, shRatHead, geom3::AHEAD, geom3::AHEAD, 1);
|
||||
adjust_eye(shRatEye1, shRatHead, AHEAD, AHEAD, 1);
|
||||
adjust_eye(shRatEye2, shRatHead, AHEAD, AHEAD, 1);
|
||||
for(int i=shRatEye3.s; i<shRatEye3.e; i++) hpc[i] = xpush(-scalefactor * 0.02) * hpc[i];
|
||||
adjust_eye(shRatEye3, shRatHead, geom3::AHEAD, geom3::AHEAD, 1);
|
||||
adjust_eye(shRatEye3, shRatHead, AHEAD, AHEAD, 1);
|
||||
|
||||
adjust_eye(shWolfEyes, shWolfHead, geom3::AHEAD, geom3::AHEAD, 1);
|
||||
adjust_eye(shWolfEyes, shWolfHead, AHEAD, AHEAD, 1);
|
||||
|
||||
adjust_eye(shReptileEye, shReptileHead, geom3::AHEAD, geom3::AHEAD, 1);
|
||||
adjust_eye(shReptileEye, shReptileHead, AHEAD, AHEAD, 1);
|
||||
adjust_eye(shGadflyEye, shGadflyBody, 0, 0, 1);
|
||||
|
||||
adjust_eye(shSkullEyes, shPHeadOnly, geom3::HEAD1, geom3::HEAD, 2, 2);
|
||||
adjust_eye(shSkullEyes, shPHeadOnly, HEAD1, HEAD, 2, 2);
|
||||
shSkullEyes.tinf = NULL;
|
||||
|
||||
adjust_eye(shMouseEyes, shMouse, geom3::FLOOR, geom3::FLOOR, 2, 1);
|
||||
adjust_eye(shMouseEyes, shMouse, FLOOR, FLOOR, 2, 1);
|
||||
|
||||
shift_shape(shRatTail, zc(0.5) - geom3::LEG);
|
||||
shift_shape(shRatTail, zc(0.5) - LEG);
|
||||
for(int i=shRatTail.s; i<shRatTail.e; i++) hpc[i] = xpush(-scalefactor * 0.1) * hpc[i];
|
||||
|
||||
shift_shape(shSemiFloorShadow, geom3::FLOOR - geom3::human_height / 100);
|
||||
shift_shape(shSemiFloor[0], geom3::WALL);
|
||||
shift_shape(shSemiFloorShadow, FLOOR - human_height / 100);
|
||||
shift_shape(shSemiFloor[0], WALL);
|
||||
|
||||
bshape(shPalaceGate, PPR::WALL);
|
||||
for(int i=0; i<4; i++) {
|
||||
@ -1082,12 +1082,12 @@ void make_3d_models() {
|
||||
for(int j=0; j<12; j++) {
|
||||
hyperpoint left = xpush(x) * xspinpush0(j * 30 * degree, 0.02);
|
||||
hyperpoint right = xpush(x) * xspinpush0((j+1) * 30 * degree, 0.02);
|
||||
hpcpush(orthogonal_move(left, geom3::FLOOR));
|
||||
hpcpush(orthogonal_move(right, geom3::FLOOR));
|
||||
hpcpush(orthogonal_move(left, geom3::WALL));
|
||||
hpcpush(orthogonal_move(right, geom3::FLOOR));
|
||||
hpcpush(orthogonal_move(left, geom3::WALL));
|
||||
hpcpush(orthogonal_move(right, geom3::WALL));
|
||||
hpcpush(orthogonal_move(left, FLOOR));
|
||||
hpcpush(orthogonal_move(right, FLOOR));
|
||||
hpcpush(orthogonal_move(left, WALL));
|
||||
hpcpush(orthogonal_move(right, FLOOR));
|
||||
hpcpush(orthogonal_move(left, WALL));
|
||||
hpcpush(orthogonal_move(right, WALL));
|
||||
}
|
||||
}
|
||||
shPalaceGate.flags |= POLY_TRIANGLES;
|
||||
@ -1108,7 +1108,7 @@ void make_3d_models() {
|
||||
hyperpoint hz = C0;
|
||||
hyperpoint h = hx * x + hy * y + hz * z;
|
||||
h = mid(h, h);
|
||||
h = orthogonal_move(h, geom3::FLOOR - geom3::human_height * (i+2.5) / 100 * (x+y+1)/2);
|
||||
h = orthogonal_move(h, FLOOR - human_height * (i+2.5) / 100 * (x+y+1)/2);
|
||||
hpcpush(h);
|
||||
});
|
||||
}
|
||||
|
||||
@ -434,10 +434,10 @@ struct hrmap_archimedean : hrmap {
|
||||
origin->move(1)->c.connect(1, origin->move(0), 2*current.N-1, false);
|
||||
}
|
||||
|
||||
base_distlimit = 0;
|
||||
cgi.base_distlimit = 0;
|
||||
celllister cl(origin->c7, 1000, 200, NULL);
|
||||
ginf[geometry].distlimit[!BITRUNCATED] = base_distlimit = cl.dists.back();
|
||||
if(sphere) base_distlimit = SEE_ALL;
|
||||
ginf[geometry].distlimit[!BITRUNCATED] = cgi.base_distlimit = cl.dists.back();
|
||||
if(sphere) cgi.base_distlimit = SEE_ALL;
|
||||
}
|
||||
|
||||
~hrmap_archimedean() {
|
||||
@ -784,7 +784,6 @@ int readArgs() {
|
||||
}
|
||||
else {
|
||||
set_geometry(gArchimedean);
|
||||
need_reset_geometry = true;
|
||||
current = at;
|
||||
showstartmenu = false;
|
||||
}
|
||||
@ -982,7 +981,6 @@ void next_variation() {
|
||||
PURE ? eVariation::dual :
|
||||
DUAL ? eVariation::bitruncated :
|
||||
eVariation::pure);
|
||||
need_reset_geometry = true;
|
||||
start_game();
|
||||
}
|
||||
|
||||
@ -1012,7 +1010,6 @@ void enable(archimedean_tiling& arct) {
|
||||
}
|
||||
}
|
||||
#endif
|
||||
need_reset_geometry = true;
|
||||
start_game();
|
||||
}
|
||||
|
||||
|
||||
@ -693,7 +693,8 @@ void resetGL() {
|
||||
floor_textures = NULL;
|
||||
}
|
||||
#endif
|
||||
resetGeometry(); // includes buildPoly
|
||||
cgi.require_shapes();
|
||||
cgi.initPolyForGL();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1101,7 +1102,7 @@ void displayColorButton(int x, int y, const string& name, int key, int align, in
|
||||
}
|
||||
|
||||
ld textscale() {
|
||||
return vid.fsize / (current_display->radius * crossf) * (1+vid.alpha) * 2;
|
||||
return vid.fsize / (current_display->radius * cgi.crossf) * (1+vid.alpha) * 2;
|
||||
}
|
||||
|
||||
// bool notgl = false;
|
||||
@ -1238,7 +1239,7 @@ void initgraph() {
|
||||
#if CAP_COMMANDLINE
|
||||
arg::read(2);
|
||||
#endif
|
||||
precalc();
|
||||
cgi.prepare_basics();
|
||||
|
||||
#if CAP_SDL
|
||||
setvideomode();
|
||||
|
||||
@ -601,7 +601,7 @@ namespace binary {
|
||||
auto bt_config = addHook(hooks_args, 0, [] () {
|
||||
using namespace arg;
|
||||
if(argis("-btwidth")) {
|
||||
shift_arg_formula(vid.binary_width, delayed_geo_reset);
|
||||
shift_arg_formula(vid.binary_width);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
|
||||
10
blizzard.cpp
10
blizzard.cpp
@ -121,7 +121,7 @@ void drawBlizzards() {
|
||||
if(wmascii || wmblack)
|
||||
queuechr(tpartial, .2, '.', 0xFFFFFF);
|
||||
else
|
||||
queuepoly(tpartial, shSnowball, 0xFFFFFF80);
|
||||
queuepoly(tpartial, cgi.shSnowball, 0xFFFFFF80);
|
||||
}
|
||||
}
|
||||
|
||||
@ -130,9 +130,9 @@ void drawBlizzards() {
|
||||
|
||||
/* if(isNeighbor(bc.c, mouseover)) {
|
||||
if(againstWind(mouseover, bc.c))
|
||||
queuepoly(*bc.gm, shHeptaMarker, 0x00C00040);
|
||||
queuepoly(*bc.gm, cgi.shHeptaMarker, 0x00C00040);
|
||||
if(againstWind(bc.c, mouseover))
|
||||
queuepoly(*bc.gm, shHeptaMarker, 0xC0000040);
|
||||
queuepoly(*bc.gm, cgi.shHeptaMarker, 0xC0000040);
|
||||
} */
|
||||
|
||||
forCellIdEx(c2, i, bc.c) if(bc.c == mouseover || c2 == mouseover) {
|
||||
@ -144,7 +144,7 @@ void drawBlizzards() {
|
||||
if(isPlayerOn(bc.c))
|
||||
col ^= 0x00000040;
|
||||
if(againstWind(bc.c, c2))
|
||||
queuepoly(*bc.gm * ddspin(bc.c, i) * xpush(cellgfxdist(bc.c, i)/2), shWindArrow, col);
|
||||
queuepoly(*bc.gm * ddspin(bc.c, i) * xpush(cellgfxdist(bc.c, i)/2), cgi.shWindArrow, col);
|
||||
}
|
||||
|
||||
int B = isize(bc.outorder);
|
||||
@ -230,7 +230,7 @@ void drawArrowTraps() {
|
||||
transmatrix& tv = u ? t1 : t0;
|
||||
hyperpoint trel = inverse(tu) * tC0(tv);
|
||||
transmatrix tpartial = tu * rspintox(trel) * xpush(hdist0(trel) * tt / 401.0);
|
||||
queuepoly(tpartial * ypush(.05), shTrapArrow, 0xFFFFFFFF);
|
||||
queuepoly(tpartial * ypush(.05), cgi.shTrapArrow, 0xFFFFFFFF);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -67,6 +67,8 @@ namespace hr { namespace inv { bool on, activating; } }
|
||||
#include "polygons.cpp"
|
||||
#include "3d-models.cpp"
|
||||
#include "floorshapes.cpp"
|
||||
#include "usershapes.cpp"
|
||||
#include "drawing.cpp"
|
||||
#include "mapeditor.cpp"
|
||||
#if CAP_MODEL
|
||||
#include "netgen.cpp"
|
||||
|
||||
34
config.cpp
34
config.cpp
@ -648,7 +648,8 @@ void loadConfig() {
|
||||
}
|
||||
|
||||
polygonal::solve();
|
||||
precalc();
|
||||
check_cgi();
|
||||
cgi.prepare_basics();
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -855,7 +856,6 @@ void showGraphConfig() {
|
||||
else if(xuni == 'L') {
|
||||
dialog::editNumber(vid.linequality, -3, 5, 1, 1, XLAT("line quality"),
|
||||
XLAT("Higher numbers make the curved lines smoother, but reduce the performance."));
|
||||
dialog::reaction = delayed_geo_reset;
|
||||
}
|
||||
|
||||
#if CAP_FRAMELIMIT
|
||||
@ -913,7 +913,6 @@ void edit_whatever(char type, int index) {
|
||||
dialog::editNumber(whateveri[index], -10, 10, 1, 0, XLAT("whatever"),
|
||||
"i:" + its(index));
|
||||
}
|
||||
dialog::reaction = delayed_geo_reset;
|
||||
dialog::extra_options = [type, index] {
|
||||
dialog::addItem(XLAT("integer"), 'X');
|
||||
dialog::add_action( [index] { popScreen(); edit_whatever('i', index); });
|
||||
@ -1259,7 +1258,6 @@ void add_edit_wall_quality(char c) {
|
||||
floor_textures = NULL;
|
||||
}
|
||||
#endif
|
||||
need_reset_geometry = true;
|
||||
};
|
||||
});
|
||||
}
|
||||
@ -1395,7 +1393,6 @@ void show3D() {
|
||||
else if(uni == 'c' && WDIM == 2)
|
||||
tc_camera = ticks,
|
||||
dialog::editNumber(geom3::camera, 0, 5, .1, 1, XLAT(GDIM == 2 ? "Camera level above the plane" : "Z shift"), ""),
|
||||
dialog::reaction = [] { if(GDIM == 2) need_reset_geometry = true; },
|
||||
dialog::extra_options = [] {
|
||||
dialog::addHelp(GDIM == 2 ? XLAT(
|
||||
"Camera is placed %1 absolute units above a plane P in a three-dimensional "
|
||||
@ -1415,7 +1412,6 @@ void show3D() {
|
||||
else if(uni == 'g' && WDIM == 2)
|
||||
tc_depth = ticks,
|
||||
dialog::editNumber(geom3::depth, 0, 5, .1, 1, XLAT("Ground level below the plane"), ""),
|
||||
dialog::reaction = delayed_geo_reset,
|
||||
dialog::extra_options = [] {
|
||||
dialog::addHelp(XLAT(
|
||||
"Ground level is actually an equidistant surface, "
|
||||
@ -1438,28 +1434,21 @@ void show3D() {
|
||||
projectionDialog();
|
||||
else if(uni == 'w' && WDIM == 2) {
|
||||
dialog::editNumber(geom3::wall_height, 0, 1, .1, .3, XLAT("Height of walls"), "");
|
||||
dialog::reaction = delayed_geo_reset;
|
||||
dialog::extra_options = [] () {
|
||||
dialog::addHelp(XLAT(
|
||||
"The height of walls, in absolute units. For the current values of g and c, "
|
||||
"wall height of %1 absolute units corresponds to projection value of %2.",
|
||||
fts(actual_wall_height()), fts(factor_to_projection(geom3::WALL))));
|
||||
fts(actual_wall_height()), fts(factor_to_projection(cgi.WALL))));
|
||||
dialog::addBoolItem(XLAT("auto-adjust in Goldberg grids"), geom3::gp_autoscale_heights, 'O');
|
||||
dialog::add_action([] () {
|
||||
geom3::gp_autoscale_heights = !geom3::gp_autoscale_heights;
|
||||
buildpolys();
|
||||
#if CAP_GL
|
||||
resetGL();
|
||||
#endif
|
||||
});
|
||||
};
|
||||
}
|
||||
else if(uni == 'l' && WDIM == 2)
|
||||
dialog::editNumber(geom3::lake_top, 0, 1, .1, .25, XLAT("Level of water surface"), ""),
|
||||
dialog::reaction = delayed_geo_reset;
|
||||
dialog::editNumber(geom3::lake_top, 0, 1, .1, .25, XLAT("Level of water surface"), "");
|
||||
else if(uni == 'k' && WDIM == 2)
|
||||
dialog::editNumber(geom3::lake_bottom, 0, 1, .1, .9, XLAT("Level of water bottom"), ""),
|
||||
dialog::reaction = delayed_geo_reset;
|
||||
dialog::editNumber(geom3::lake_bottom, 0, 1, .1, .9, XLAT("Level of water bottom"), "");
|
||||
else if(uni == 'r' && WDIM == 2)
|
||||
dialog::editNumber(geom3::rock_wall_ratio, 0, 1, .1, .9, XLAT("Rock-III to wall ratio"), ""),
|
||||
dialog::extra_options = [] { dialog::addHelp(XLAT(
|
||||
@ -1468,11 +1457,9 @@ void show3D() {
|
||||
"ground level.",
|
||||
fts(rock_wall_ratio), fts(wall_height * rock_wall_ratio),
|
||||
fts(cosh(depth - wall_height * rock_wall_ratio) / cosh(depth))));
|
||||
},
|
||||
dialog::reaction = delayed_geo_reset;
|
||||
};
|
||||
else if(uni == 'h' && WDIM == 2)
|
||||
dialog::editNumber(geom3::human_wall_ratio, 0, 1, .1, .7, XLAT("Human to wall ratio"), ""),
|
||||
dialog::reaction = delayed_geo_reset,
|
||||
dialog::extra_options = [] { dialog::addHelp(XLAT(
|
||||
"Humans are %1 "
|
||||
"absolute units high. Your head travels %2 times the distance travelled by your "
|
||||
@ -1482,11 +1469,9 @@ void show3D() {
|
||||
);
|
||||
};
|
||||
else if(uni == 'h' && WDIM == 3)
|
||||
dialog::editNumber(geom3::height_width, 0, 1, .1, .7, XLAT("Height to width"), ""),
|
||||
dialog::reaction = delayed_geo_reset;
|
||||
dialog::editNumber(geom3::height_width, 0, 1, .1, .7, XLAT("Height to width"), "");
|
||||
else if(uni == 'c' && WDIM == 3)
|
||||
dialog::editNumber(geom3::creature_scale, 0, 1, .1, .7, XLAT("Creature scale"), ""),
|
||||
dialog::reaction = delayed_geo_reset;
|
||||
dialog::editNumber(geom3::creature_scale, 0, 1, .1, .7, XLAT("Creature scale"), "");
|
||||
|
||||
else if(uni == 'e')
|
||||
pushScreen(showStereo);
|
||||
@ -1566,7 +1551,8 @@ void showCustomizeChar() {
|
||||
transmatrix V = atscreenpos(vid.xres/2, firsty, scale);
|
||||
|
||||
double alpha = atan2(mousex - vid.xres/2, mousey - firsty) - M_PI/2;
|
||||
drawMonsterType(moPlayer, NULL, V * spin(alpha), 0, cc_footphase / scale);
|
||||
V = V * spin(alpha);
|
||||
drawMonsterType(moPlayer, NULL, V, 0, cc_footphase / scale);
|
||||
quickqueue();
|
||||
|
||||
keyhandler = [] (int sym, int uni) {
|
||||
|
||||
@ -300,13 +300,13 @@ void handlePanning(int sym, int uni) {
|
||||
if(conformal::on)
|
||||
conformal::rotation++;
|
||||
else
|
||||
View = spin(M_PI/S21/2*shiftmul) * View, didsomething = true;
|
||||
View = spin(M_PI/cgi.S21/2*shiftmul) * View, didsomething = true;
|
||||
}
|
||||
if(sym == SDLK_PAGEDOWN) {
|
||||
if(conformal::on)
|
||||
conformal::rotation++;
|
||||
else
|
||||
View = spin(-M_PI/S21/2*shiftmul) * View, didsomething = true;
|
||||
View = spin(-M_PI/cgi.S21/2*shiftmul) * View, didsomething = true;
|
||||
}
|
||||
|
||||
if(sym == SDLK_PAGEUP || sym == SDLK_PAGEDOWN)
|
||||
@ -338,7 +338,6 @@ bool handleTune(int sym, int uni) {
|
||||
else if(uni == 'z')
|
||||
bscale7 = bscale6 = 1, brot7 = brot6 = 0;
|
||||
else return false;
|
||||
resetGeometry();
|
||||
println(hlog, spaced(bscale7, brot7, bscale6, brot6));
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -1025,7 +1025,6 @@ void set_crystal(int sides) {
|
||||
static char buf[20];
|
||||
sprintf(buf, "{%d,4}", sides);
|
||||
ginf[gCrystal].tiling_name = buf;
|
||||
need_reset_geometry = true;
|
||||
if(sides < MAX_EDGE)
|
||||
ginf[gCrystal].distlimit = distlimit_table[sides];
|
||||
}
|
||||
@ -1329,7 +1328,6 @@ coord euclid3_to_crystal(euclid3::coord x) {
|
||||
void transform_crystal_to_euclid () {
|
||||
euclid3::clear_torus3();
|
||||
geometry = gCubeTiling;
|
||||
need_reset_geometry = true;
|
||||
auto e = new euclid3::hrmap_euclid3;
|
||||
auto m = crystal_map();
|
||||
auto infront = cwt.cpeek();
|
||||
@ -1391,7 +1389,6 @@ void transform_euclid_to_crystal () {
|
||||
ginf[gCrystal].sides = 6;
|
||||
ginf[gCrystal].vertex = 4;
|
||||
ginf[gCrystal].tiling_name = "{6,4}";
|
||||
need_reset_geometry = true;
|
||||
ginf[gCrystal].distlimit = distlimit_table[6];
|
||||
|
||||
auto e = euclid3::cubemap();
|
||||
|
||||
@ -338,7 +338,7 @@ struct debugScreen {
|
||||
|
||||
if(what) {
|
||||
#if CAP_SHAPES
|
||||
queuepoly(gmatrix[what], shAsymmetric, 0x80808080);
|
||||
queuepoly(gmatrix[what], cgi.shAsymmetric, 0x80808080);
|
||||
#endif
|
||||
char buf[200];
|
||||
sprintf(buf, "%p", what);
|
||||
@ -682,13 +682,12 @@ int read_cheat_args() {
|
||||
else if(argis("-wef")) {
|
||||
PHASEFROM(2);
|
||||
shift(); int index = argi();
|
||||
shift_arg_formula(whatever[index], delayed_geo_reset);
|
||||
shift_arg_formula(whatever[index]);
|
||||
}
|
||||
else if(argis("-wei")) {
|
||||
PHASEFROM(2);
|
||||
shift(); int index = argi();
|
||||
shift(); whateveri[index] = argi();
|
||||
delayed_geo_reset();
|
||||
}
|
||||
else if(argis("-W3")) {
|
||||
shift(); top_land = readland(args()); cheat();
|
||||
|
||||
1680
drawing.cpp
Normal file
1680
drawing.cpp
Normal file
File diff suppressed because it is too large
Load Diff
@ -323,6 +323,7 @@ ld expansion_analyzer::get_growth() {
|
||||
if(!N) preliminary_grouping(), reduce_grouping();
|
||||
vector<ld> eigen(N, 1);
|
||||
ld total;
|
||||
|
||||
for(int iter=0; iter<100000; iter++) {
|
||||
total = 0;
|
||||
vector<ld> neweigen(N, 0);
|
||||
@ -828,7 +829,6 @@ int expansion_readArgs() {
|
||||
if(x+y > 10) continue;
|
||||
stop_game();
|
||||
gp::param = gp::loc(x, y);
|
||||
need_reset_geometry = true;
|
||||
set_variation(eVariation::goldberg);
|
||||
compute_coefficients();
|
||||
}
|
||||
|
||||
306
floorshapes.cpp
306
floorshapes.cpp
@ -1,40 +1,61 @@
|
||||
namespace hr {
|
||||
#if CAP_SHAPES
|
||||
vector<plain_floorshape*> all_plain_floorshapes;
|
||||
vector<escher_floorshape*> all_escher_floorshapes;
|
||||
|
||||
plain_floorshape
|
||||
shFloor,
|
||||
shMFloor, shMFloor2, shMFloor3, shMFloor4, shFullFloor,
|
||||
shBigTriangle, shTriheptaFloor, shBigHepta;
|
||||
vector<basic_textureinfo> floor_texture_vertices;
|
||||
renderbuffer *floor_textures;
|
||||
|
||||
escher_floorshape shStarFloor(1,2),
|
||||
shCloudFloor(3, 4),
|
||||
shCrossFloor(5, 6, 2, 54),
|
||||
shChargedFloor(7, 385, 1, 10),
|
||||
shSStarFloor(11, 12),
|
||||
shOverFloor(13, 15, 1, 14),
|
||||
shTriFloor(17, 18, 0, 385),
|
||||
shFeatherFloor(19, 21, 1, 20),
|
||||
shBarrowFloor(23, 24, 1, 25),
|
||||
shNewFloor(26, 27, 2, 54),
|
||||
shTrollFloor(28, 29),
|
||||
shButterflyFloor(325, 326, 1, 178),
|
||||
shLavaFloor(359, 360, 1, 178),
|
||||
shLavaSeabed(386, 387, 1, 178),
|
||||
shSeabed(334, 335),
|
||||
shCloudSeabed(336, 337),
|
||||
shCaveSeabed(338, 339, 2, 54),
|
||||
shPalaceFloor(45, 46, 0, 385),
|
||||
shDemonFloor(51, 50, 1, 178),
|
||||
shCaveFloor(52, 53, 2, 54),
|
||||
shDesertFloor(55, 56, 0, 4),
|
||||
shPowerFloor(57, 58, 0, 12), /* dragon */
|
||||
shRoseFloor(174, 175, 1, 173),
|
||||
shSwitchFloor(377, 378, 1, 379),
|
||||
shTurtleFloor(176, 177, 1, 178),
|
||||
shRedRockFloor[3] = {{55, 56}, {55, 56}, {55, 56}}, // 1 - .1 * i
|
||||
shDragonFloor(181, 182, 2, 183); /* dragon */
|
||||
void geometry_information::init_floorshapes() {
|
||||
all_escher_floorshapes.clear();
|
||||
all_plain_floorshapes = {
|
||||
&shFloor, &shMFloor, &shMFloor2, &shMFloor3, &shMFloor4,
|
||||
&shFullFloor, &shBigTriangle, &shTriheptaFloor, &shBigHepta
|
||||
};
|
||||
|
||||
for(auto s: all_plain_floorshapes) s->is_plain = true;
|
||||
|
||||
auto init_escher = [this] (escher_floorshape& sh, int s0, int s1, int noft=0, int s2=0) {
|
||||
sh.shapeid0 = s0;
|
||||
sh.shapeid1 = s1;
|
||||
sh.noftype = noft;
|
||||
sh.shapeid2 = s2;
|
||||
sh.scale = 1;
|
||||
sh.is_plain = false;
|
||||
all_escher_floorshapes.push_back(&sh);
|
||||
};
|
||||
|
||||
init_escher(shStarFloor, 1,2);
|
||||
init_escher(shCloudFloor, 3, 4);
|
||||
init_escher(shCrossFloor, 5, 6, 2, 54);
|
||||
init_escher(shChargedFloor, 7, 385, 1, 10);
|
||||
init_escher(shSStarFloor, 11, 12);
|
||||
init_escher(shOverFloor, 13, 15, 1, 14);
|
||||
init_escher(shTriFloor, 17, 18, 0, 385);
|
||||
init_escher(shFeatherFloor, 19, 21, 1, 20);
|
||||
init_escher(shBarrowFloor, 23, 24, 1, 25);
|
||||
init_escher(shNewFloor, 26, 27, 2, 54);
|
||||
init_escher(shTrollFloor, 28, 29);
|
||||
init_escher(shButterflyFloor, 325, 326, 1, 178);
|
||||
init_escher(shLavaFloor, 359, 360, 1, 178);
|
||||
init_escher(shLavaSeabed, 386, 387, 1, 178);
|
||||
init_escher(shSeabed, 334, 335);
|
||||
init_escher(shCloudSeabed, 336, 337);
|
||||
init_escher(shCaveSeabed, 338, 339, 2, 54);
|
||||
init_escher(shPalaceFloor, 45, 46, 0, 385);
|
||||
init_escher(shDemonFloor, 51, 50, 1, 178);
|
||||
init_escher(shCaveFloor, 52, 53, 2, 54);
|
||||
init_escher(shDesertFloor, 55, 56, 0, 4);
|
||||
init_escher(shPowerFloor, 57, 58, 0, 12); /* dragon */
|
||||
init_escher(shRoseFloor, 174, 175, 1, 173);
|
||||
init_escher(shSwitchFloor, 377, 378, 1, 379);
|
||||
init_escher(shTurtleFloor, 176, 177, 1, 178);
|
||||
for(int i: {0,1,2})
|
||||
init_escher(shRedRockFloor[i], 55, 56);
|
||||
init_escher(shDragonFloor, 181, 182, 2, 183); /* dragon */
|
||||
|
||||
int ids = 0;
|
||||
for(auto sh: all_plain_floorshapes) sh->id = ids++;
|
||||
for(auto sh: all_escher_floorshapes) sh->id = ids++;
|
||||
}
|
||||
|
||||
typedef pair<transmatrix, array<transmatrix, MAX_EDGE>> matrixitem;
|
||||
|
||||
@ -108,7 +129,7 @@ void generate_matrices_scale(ld scale, int noft) {
|
||||
mesher ohex = msh(gNormal, 6, 0.329036, 0.566256, 0.620672, 0, 1);
|
||||
mesher ohept = msh(gNormal, 7, hexf7, hcrossf7, hcrossf7, M_PI/7, 1);
|
||||
if(!BITRUNCATED) {
|
||||
mesher nall = msh(geometry, S7, rhexf, tessf, tessf, -M_PI, scale);
|
||||
mesher nall = msh(geometry, S7, cgi.rhexf, cgi.tessf, cgi.tessf, -M_PI, scale);
|
||||
bool use = geosupport_football() < 2;
|
||||
if(use && noft == 1) {
|
||||
mesher opure = msh(gNormal, 7, 0.620672, 1.090550, 1.090550, M_PI/7, 1);
|
||||
@ -127,12 +148,12 @@ void generate_matrices_scale(ld scale, int noft) {
|
||||
}
|
||||
}
|
||||
else {
|
||||
generate_matrices(hex_matrices, ohex, msh(geometry, S6, hexvdist, hexhexdist, hcrossf, (S3-3)*M_PI/S3, scale));
|
||||
generate_matrices(hept_matrices, ohept, msh(geometry, S7, rhexf, hcrossf, hcrossf, euclid6?0:euclid4?0:M_PI/S7, scale));
|
||||
generate_matrices(hex_matrices, ohex, msh(geometry, S6, cgi.hexvdist, cgi.hexhexdist, cgi.hcrossf, (S3-3)*M_PI/S3, scale));
|
||||
generate_matrices(hept_matrices, ohept, msh(geometry, S7, cgi.rhexf, cgi.hcrossf, cgi.hcrossf, euclid6?0:euclid4?0:M_PI/S7, scale));
|
||||
}
|
||||
}
|
||||
|
||||
void bshape2(hpcshape& sh, PPR prio, int shapeid, matrixlist& m) {
|
||||
void geometry_information::bshape2(hpcshape& sh, PPR prio, int shapeid, matrixlist& m) {
|
||||
auto& matrices = m.v;
|
||||
int osym = m.o.sym;
|
||||
int nsym = m.n.sym;
|
||||
@ -196,7 +217,7 @@ void bshape2(hpcshape& sh, PPR prio, int shapeid, matrixlist& m) {
|
||||
hpcpush(hpc[last->s]);
|
||||
}
|
||||
|
||||
void bshape_regular(floorshape &fsh, int id, int sides, int shift, ld size) {
|
||||
void geometry_information::bshape_regular(floorshape &fsh, int id, int sides, int shift, ld size) {
|
||||
|
||||
fsh.b.resize(2);
|
||||
fsh.shadow.resize(2);
|
||||
@ -272,7 +293,7 @@ template<class T> void sizeto(T& t, int n) {
|
||||
|
||||
// !siid equals pseudohept(c)
|
||||
|
||||
void generate_floorshapes_for(int id, cell *c, int siid, int sidir) {
|
||||
void geometry_information::generate_floorshapes_for(int id, cell *c, int siid, int sidir) {
|
||||
DEBBI(DF_POLY, ("generate_floorshapes_for ", id));
|
||||
|
||||
for(auto pfsh: all_plain_floorshapes) {
|
||||
@ -470,13 +491,13 @@ void generate_floorshapes_for(int id, cell *c, int siid, int sidir) {
|
||||
auto& fsh = *pfsh;
|
||||
|
||||
for(int i=fsh.shadow[id].s; i<fsh.shadow[id].e; i++)
|
||||
hpc[i] = orthogonal_move(hpc[i], geom3::FLOOR - geom3::human_height / 100);
|
||||
hpc[i] = orthogonal_move(hpc[i], FLOOR - human_height / 100);
|
||||
|
||||
for(int k=0; k<SIDEPARS; k++) {
|
||||
sizeto(fsh.levels[k], id);
|
||||
bshape(fsh.levels[k][id], fsh.prio);
|
||||
last->flags |= POLY_TRIANGLES;
|
||||
last->tinf = &fsh.tinf3;
|
||||
last->tinf = &floor_texture_vertices[fsh.id];
|
||||
last->texture_offset = 0;
|
||||
|
||||
#if CAP_BT
|
||||
@ -506,10 +527,10 @@ void generate_floorshapes_for(int id, cell *c, int siid, int sidir) {
|
||||
sizeto(fsh.cone[co], id);
|
||||
bshape(fsh.cone[co][id], fsh.prio);
|
||||
last->flags |= POLY_TRIANGLES;
|
||||
last->tinf = &fsh.tinf3;
|
||||
last->tinf = &floor_texture_vertices[fsh.id];
|
||||
last->texture_offset = 0;
|
||||
ld h = (geom3::FLOOR - geom3::WALL) / (co+1);
|
||||
ld top = co ? (geom3::FLOOR + geom3::WALL) / 2 : geom3::WALL;
|
||||
ld h = (FLOOR - WALL) / (co+1);
|
||||
ld top = co ? (FLOOR + WALL) / 2 : WALL;
|
||||
#if CAP_BT
|
||||
if(binarytiling)
|
||||
for(int t=0; t<c->type; t++)
|
||||
@ -534,9 +555,9 @@ void generate_floorshapes_for(int id, cell *c, int siid, int sidir) {
|
||||
}
|
||||
|
||||
for(int l=0; l<SIDEPARS; l++) {
|
||||
for(auto& li: fsh.side[l]) li.tinf = &fsh.tinf3;
|
||||
for(auto& li: fsh.side[l]) li.tinf = &floor_texture_vertices[fsh.id];
|
||||
for(int e=0; e<MAX_EDGE; e++)
|
||||
for(auto& li: fsh.gpside[l][e]) li.tinf = &fsh.tinf3;
|
||||
for(auto& li: fsh.gpside[l][e]) li.tinf = &floor_texture_vertices[fsh.id];
|
||||
}
|
||||
}
|
||||
|
||||
@ -546,18 +567,18 @@ void generate_floorshapes_for(int id, cell *c, int siid, int sidir) {
|
||||
for(int l=0; l<SIDEPARS; l++) {
|
||||
fsh.levels[l] = shFullFloor.levels[l];
|
||||
fsh.shadow = shFullFloor.shadow;
|
||||
for(auto& li: fsh.levels[l]) li.tinf = &fsh.tinf3;
|
||||
for(auto& li: fsh.levels[l]) li.tinf = &floor_texture_vertices[fsh.id];
|
||||
fsh.side[l] = shFullFloor.side[l];
|
||||
for(auto& li: fsh.side[l]) li.tinf = &fsh.tinf3;
|
||||
for(auto& li: fsh.side[l]) li.tinf = &floor_texture_vertices[fsh.id];
|
||||
for(int e=0; e<MAX_EDGE; e++) {
|
||||
fsh.gpside[l][e] = shFullFloor.gpside[l][e];
|
||||
for(auto& li: fsh.gpside[l][e]) li.tinf = &fsh.tinf3;
|
||||
for(auto& li: fsh.gpside[l][e]) li.tinf = &floor_texture_vertices[fsh.id];
|
||||
}
|
||||
fsh.cone[0] = shFullFloor.cone[0];
|
||||
fsh.cone[1] = shFullFloor.cone[1];
|
||||
for(int c=0; c<2; c++)
|
||||
for(auto& li: fsh.cone[c])
|
||||
li.tinf = &fsh.tinf3;
|
||||
li.tinf = &floor_texture_vertices[fsh.id];
|
||||
}
|
||||
}
|
||||
finishshape();
|
||||
@ -565,9 +586,10 @@ void generate_floorshapes_for(int id, cell *c, int siid, int sidir) {
|
||||
#endif
|
||||
}
|
||||
|
||||
void generate_floorshapes() {
|
||||
void geometry_information::generate_floorshapes() {
|
||||
|
||||
DEBBI(DF_POLY, ("generate_floorshapes"));
|
||||
|
||||
if(WDIM == 3) ;
|
||||
|
||||
#if CAP_IRR
|
||||
@ -645,10 +667,10 @@ namespace gp {
|
||||
if(master) li.last_dir = -1;
|
||||
DEBB(DF_GP, (format("last=%d at=%d,%d tot=%d siid=%d sidir=%d cor=%d id=%d\n", li.last_dir, li.relative.first, li.relative.second, li.total_dir, siid, sidir, cor, id)));
|
||||
|
||||
generate_floorshapes_for(id, c0, siid, sidir);
|
||||
cgi.generate_floorshapes_for(id, c0, siid, sidir);
|
||||
|
||||
finishshape(); last = NULL;
|
||||
extra_vertices();
|
||||
cgi.finishshape();
|
||||
cgi.extra_vertices();
|
||||
}
|
||||
|
||||
int get_plainshape_id(cell *c) {
|
||||
@ -670,7 +692,7 @@ namespace gp {
|
||||
sidir = 0;
|
||||
}
|
||||
auto& id = pshid[siid][sidir][draw_li.relative.first&31][draw_li.relative.second&31][fix6(draw_li.total_dir)];
|
||||
if(id == -1 && sphere && isize(shFloor.b) > 0) {
|
||||
if(id == -1 && sphere && isize(cgi.shFloor.b) > 0) {
|
||||
forCellEx(c1, c) if(!gmatrix0.count(c1)) return 0;
|
||||
}
|
||||
if(id == -1) build_plainshape(id, draw_li, c, siid, sidir);
|
||||
@ -811,13 +833,12 @@ auto floor_hook =
|
||||
|
||||
#if MAXMDIM >= 4
|
||||
|
||||
renderbuffer *floor_textures;
|
||||
void draw_shape_for_texture(floorshape* sh) {
|
||||
|
||||
void draw_shape_for_texture(floorshape* sh, int& id) {
|
||||
int id = sh->id;
|
||||
|
||||
ld gx = (id % 8) * 1.5 - 3.5 * 1.5;
|
||||
ld gy = (id / 8) * 1.5 - 3.5 * 1.5;
|
||||
id++;
|
||||
|
||||
if(1) {
|
||||
dynamicval<ld> v(vid.linewidth, 8);
|
||||
@ -835,8 +856,8 @@ void draw_shape_for_texture(floorshape* sh, int& id) {
|
||||
for(int b=-1; b<=1; b++)
|
||||
queuepoly(eupush(gx+a/2., gy+b/2.), sh->b[0], 0xFFFFFFFF);
|
||||
|
||||
if(sh == &shCrossFloor) {
|
||||
queuepoly(eupush(gx, gy) * spin(M_PI/4), shCross, 0x808080FF);
|
||||
if(sh == &cgi.shCrossFloor) {
|
||||
queuepoly(eupush(gx, gy) * spin(M_PI/4), cgi.shCross, 0x808080FF);
|
||||
}
|
||||
|
||||
if(1) {
|
||||
@ -849,8 +870,9 @@ void draw_shape_for_texture(floorshape* sh, int& id) {
|
||||
queuecurve(0x40404000 + sh->fstrength * 192/10, 0, PPR::LINE);
|
||||
}
|
||||
|
||||
sh->tinf3.tvertices.clear();
|
||||
sh->tinf3.texture_id = floor_textures->renderedTexture;
|
||||
auto& ftv = floor_texture_vertices[sh->id];
|
||||
ftv.tvertices.clear();
|
||||
ftv.texture_id = floor_textures->renderedTexture;
|
||||
|
||||
using namespace hyperpoint_vec;
|
||||
hyperpoint center = eupush(gx, gy) * C0;
|
||||
@ -865,94 +887,98 @@ void draw_shape_for_texture(floorshape* sh, int& id) {
|
||||
glvec2 v;
|
||||
v[0] = (1 + inmodel[0] * vid.scale) / 2;
|
||||
v[1] = (1 - inmodel[1] * vid.scale) / 2;
|
||||
sh->tinf3.tvertices.push_back(glhr::makevertex(v[0], v[1], 0));
|
||||
ftv.tvertices.push_back(glhr::makevertex(v[0], v[1], 0));
|
||||
});
|
||||
}
|
||||
|
||||
const int FLOORTEXTURESIZE = 4096;
|
||||
|
||||
void make_floor_textures() {
|
||||
if(1) {
|
||||
DEBBI(DF_POLY, ("make_floor_textures"));
|
||||
dynamicval<eGeometry> g(geometry, gEuclidSquare);
|
||||
dynamicval<eModel> gm(pmodel, mdDisk);
|
||||
dynamicval<eVariation> va(variation, eVariation::pure);
|
||||
dynamicval<bool> a3(geom3::always3, false);
|
||||
dynamicval<bool> hq(inHighQual, true);
|
||||
dynamicval<int> hd(darken, 0);
|
||||
dynamicval<ld> gd(geom3::depth, 1);
|
||||
dynamicval<ld> gc(geom3::camera, 1);
|
||||
void geometry_information::make_floor_textures_here() {
|
||||
require_shapes();
|
||||
|
||||
dynamicval<videopar> vi(vid, vid);
|
||||
vid.xres = FLOORTEXTURESIZE;
|
||||
vid.yres = FLOORTEXTURESIZE;
|
||||
vid.scale = 0.25;
|
||||
vid.camera_angle = 0;
|
||||
vid.alpha = 1;
|
||||
dynamicval<ld> lw(vid.linewidth, 2);
|
||||
|
||||
floor_textures = new renderbuffer(vid.xres, vid.yres, vid.usingGL);
|
||||
resetbuffer rb;
|
||||
|
||||
floor_texture_vertices.resize(isize(all_escher_floorshapes) + isize(all_plain_floorshapes));
|
||||
|
||||
resetGeometry();
|
||||
dynamicval<videopar> vi(vid, vid);
|
||||
vid.xres = FLOORTEXTURESIZE;
|
||||
vid.yres = FLOORTEXTURESIZE;
|
||||
vid.scale = 0.25;
|
||||
vid.camera_angle = 0;
|
||||
vid.alpha = 1;
|
||||
dynamicval<ld> lw(vid.linewidth, 2);
|
||||
auto cd = current_display;
|
||||
cd->xtop = cd->ytop = 0;
|
||||
cd->xsize = cd->ysize = FLOORTEXTURESIZE;
|
||||
cd->xcenter = cd->ycenter = cd->scrsize = FLOORTEXTURESIZE/2;
|
||||
|
||||
cd->radius = cd->scrsize * vid.scale;
|
||||
|
||||
floor_textures = new renderbuffer(vid.xres, vid.yres, vid.usingGL);
|
||||
resetbuffer rb;
|
||||
floor_textures->enable();
|
||||
floor_textures->clear(0); // 0xE8E8E8 = 1
|
||||
|
||||
// gradient vertices
|
||||
vector<glhr::colored_vertex> gv;
|
||||
current_display->scrdist = 0;
|
||||
gv.emplace_back(-1, -1, 0, 0, 0);
|
||||
gv.emplace_back(+1, -1, 0, 0, 0);
|
||||
gv.emplace_back(+1, +1, 1, 1, 1);
|
||||
gv.emplace_back(-1, -1, 0, 0, 0);
|
||||
gv.emplace_back(+1, +1, 1, 1, 1);
|
||||
gv.emplace_back(-1, +1, 1, 1, 1);
|
||||
|
||||
auto cd = current_display;
|
||||
cd->xtop = cd->ytop = 0;
|
||||
cd->xsize = cd->ysize = FLOORTEXTURESIZE;
|
||||
cd->xcenter = cd->ycenter = cd->scrsize = FLOORTEXTURESIZE/2;
|
||||
|
||||
cd->radius = cd->scrsize * vid.scale;
|
||||
glhr::switch_mode(glhr::gmVarColored, glhr::shader_projection::standard);
|
||||
current_display->set_all(0);
|
||||
glhr::new_projection();
|
||||
glhr::id_modelview();
|
||||
glhr::prepare(gv);
|
||||
glhr::set_depthtest(false);
|
||||
glDrawArrays(GL_TRIANGLES, 0, isize(gv));
|
||||
|
||||
shOverFloor.pstrength = 20;
|
||||
shFeatherFloor.pstrength = 40;
|
||||
shFeatherFloor.fstrength = 5;
|
||||
shTrollFloor.pstrength = 25;
|
||||
shCaveFloor.pstrength = 40;
|
||||
shCaveFloor.fstrength = 0;
|
||||
shDesertFloor.pstrength = 30;
|
||||
shDesertFloor.fstrength =10;
|
||||
shRoseFloor.pstrength = 30;
|
||||
shDragonFloor.pstrength = 30;
|
||||
shBarrowFloor.pstrength = 40;
|
||||
|
||||
floor_textures->enable();
|
||||
floor_textures->clear(0); // 0xE8E8E8 = 1
|
||||
|
||||
// gradient vertices
|
||||
vector<glhr::colored_vertex> gv;
|
||||
current_display->scrdist = 0;
|
||||
gv.emplace_back(-1, -1, 0, 0, 0);
|
||||
gv.emplace_back(+1, -1, 0, 0, 0);
|
||||
gv.emplace_back(+1, +1, 1, 1, 1);
|
||||
gv.emplace_back(-1, -1, 0, 0, 0);
|
||||
gv.emplace_back(+1, +1, 1, 1, 1);
|
||||
gv.emplace_back(-1, +1, 1, 1, 1);
|
||||
// all using Tortoise
|
||||
for(auto v: all_escher_floorshapes) if(v->shapeid2 == 178) v->pstrength = 20;
|
||||
|
||||
ptds.clear();
|
||||
|
||||
for(auto v: all_plain_floorshapes) draw_shape_for_texture(v);
|
||||
for(auto v: all_escher_floorshapes) draw_shape_for_texture(v);
|
||||
|
||||
drawqueue();
|
||||
|
||||
/*
|
||||
SDL_Surface *sdark = floor_textures->render();
|
||||
IMAGESAVE(sdark, "texture-test.png");
|
||||
*/
|
||||
rb.reset();
|
||||
}
|
||||
|
||||
glhr::switch_mode(glhr::gmVarColored, glhr::shader_projection::standard);
|
||||
current_display->set_all(0);
|
||||
glhr::new_projection();
|
||||
glhr::id_modelview();
|
||||
glhr::prepare(gv);
|
||||
glhr::set_depthtest(false);
|
||||
glDrawArrays(GL_TRIANGLES, 0, isize(gv));
|
||||
|
||||
shOverFloor.pstrength = 20;
|
||||
shFeatherFloor.pstrength = 40;
|
||||
shFeatherFloor.fstrength = 5;
|
||||
shTrollFloor.pstrength = 25;
|
||||
shCaveFloor.pstrength = 40;
|
||||
shCaveFloor.fstrength = 0;
|
||||
shDesertFloor.pstrength = 30;
|
||||
shDesertFloor.fstrength =10;
|
||||
shRoseFloor.pstrength = 30;
|
||||
shDragonFloor.pstrength = 30;
|
||||
shBarrowFloor.pstrength = 40;
|
||||
|
||||
// all using Tortoise
|
||||
for(auto v: all_escher_floorshapes) if(v->shapeid2 == 178) v->pstrength = 20;
|
||||
|
||||
ptds.clear();
|
||||
|
||||
int id = 0;
|
||||
|
||||
for(auto v: all_plain_floorshapes) draw_shape_for_texture(v, id);
|
||||
for(auto v: all_escher_floorshapes) draw_shape_for_texture(v, id);
|
||||
|
||||
drawqueue();
|
||||
|
||||
/*
|
||||
SDL_Surface *sdark = floor_textures->render();
|
||||
IMAGESAVE(sdark, "texture-test.png");
|
||||
*/
|
||||
rb.reset();
|
||||
}
|
||||
void make_floor_textures() {
|
||||
DEBBI(DF_POLY, ("make_floor_textures"));
|
||||
dynamicval<eGeometry> g(geometry, gEuclidSquare);
|
||||
dynamicval<eModel> gm(pmodel, mdDisk);
|
||||
dynamicval<eVariation> va(variation, eVariation::pure);
|
||||
dynamicval<bool> a3(geom3::always3, false);
|
||||
dynamicval<bool> hq(inHighQual, true);
|
||||
dynamicval<int> hd(darken, 0);
|
||||
dynamicval<ld> gd(geom3::depth, 1);
|
||||
dynamicval<ld> gc(geom3::camera, 1);
|
||||
dynamicval<geometry_information*> dcgip(cgip, cgip);
|
||||
check_cgi();
|
||||
cgi.make_floor_textures_here();
|
||||
}
|
||||
|
||||
|
||||
|
||||
2
game.cpp
2
game.cpp
@ -2916,7 +2916,7 @@ void buildRosemap() {
|
||||
|
||||
}
|
||||
|
||||
int getDistLimit() { return base_distlimit; }
|
||||
int getDistLimit() { return cgi.base_distlimit; }
|
||||
|
||||
bool nogoSlow(cell *to, cell *from) {
|
||||
if(cellEdgeUnstable(to) && gravityLevelDiff(to, from) >= 0) return true;
|
||||
|
||||
@ -484,10 +484,10 @@ void showEuclideanMenu() {
|
||||
|
||||
#if CAP_GP
|
||||
if(GOLDBERG && S3)
|
||||
nom = 2 * (2*tv + ts * (gp::area-1));
|
||||
nom = 2 * (2*tv + ts * (cgi.gpdata->area-1));
|
||||
|
||||
if(GOLDBERG && S3 == 4)
|
||||
nom = 2 * (2*tv + 2 * ts * (gp::area-1));
|
||||
nom = 2 * (2*tv + 2 * ts * (cgi.gpdata->area-1));
|
||||
#endif
|
||||
|
||||
int worldsize;
|
||||
@ -625,7 +625,6 @@ void showEuclideanMenu() {
|
||||
dialog::add_action([] {
|
||||
dialog::editNumber(vid.binary_width, 0, 2, 0.1, 1, XLAT("binary tiling width"), "");
|
||||
dialog::reaction = [] () {
|
||||
need_reset_geometry = true;
|
||||
#if CAP_TEXTURE
|
||||
texture::config.remap();
|
||||
#endif
|
||||
|
||||
100
geometry.cpp
100
geometry.cpp
@ -5,30 +5,6 @@
|
||||
|
||||
namespace hr {
|
||||
|
||||
ld tessf, crossf, hexf, hcrossf, hexhexdist, hexvdist, hepvdist, rhexf;
|
||||
|
||||
// tessf: distance from heptagon center to another heptagon center
|
||||
// hexf: distance from heptagon center to small heptagon vertex
|
||||
// hcrossf: distance from heptagon center to big heptagon vertex
|
||||
// crossf: distance from heptagon center to adjacent cell center (either hcrossf or tessf)
|
||||
// hexhexdist: distance between adjacent hexagon vertices
|
||||
// hexvdist: distance between hexagon vertex and hexagon center
|
||||
// hepvdist: distance between heptagon vertex and hexagon center (either hcrossf or something else)
|
||||
// rhexf: distance from heptagon center to heptagon vertex (either hexf or hcrossf)
|
||||
|
||||
int base_distlimit;
|
||||
|
||||
transmatrix heptmove[MAX_EDGE], hexmove[MAX_EDGE];
|
||||
transmatrix invheptmove[MAX_EDGE], invhexmove[MAX_EDGE];
|
||||
|
||||
ld hexshift;
|
||||
|
||||
ld sword_size = 0;
|
||||
|
||||
ld corner_bonus = 0;
|
||||
|
||||
ld asteroid_size[8];
|
||||
|
||||
// the results are:
|
||||
// hexf = 0.378077 hcrossf = 0.620672 tessf = 1.090550
|
||||
// hexhexdist = 0.566256
|
||||
@ -36,13 +12,11 @@ ld asteroid_size[8];
|
||||
ld hcrossf7 = 0.620672;
|
||||
ld hexf7 = 0.378077;
|
||||
|
||||
ld scalefactor, orbsize, floorrad0, floorrad1, zhexf;
|
||||
|
||||
// the distance between two hexagon centers
|
||||
|
||||
void precalc() {
|
||||
void geometry_information::prepare_basics() {
|
||||
|
||||
DEBBI(DF_INIT | DF_POLY | DF_GEOM, ("precalc"));
|
||||
DEBBI(DF_INIT | DF_POLY | DF_GEOM, ("prepare_basics"));
|
||||
|
||||
hexshift = 0;
|
||||
|
||||
@ -53,7 +27,6 @@ void precalc() {
|
||||
|
||||
if(euclid) {
|
||||
// dynamicval<eGeometry> g(geometry, gNormal);
|
||||
// precalc(); }
|
||||
// for(int i=0; i<S84; i++) spinmatrix[i] = spin(i * M_PI / S42);
|
||||
if(a4 && !BITRUNCATED) {
|
||||
crossf = .5;
|
||||
@ -187,6 +160,10 @@ void precalc() {
|
||||
}
|
||||
|
||||
set_sibling_limit();
|
||||
|
||||
prepare_compute3();
|
||||
if(hyperbolic && &currfp != &fieldpattern::fp_invalid)
|
||||
currfp.analyze();
|
||||
}
|
||||
|
||||
transmatrix xspinpush(ld dir, ld dist) {
|
||||
@ -206,11 +183,9 @@ namespace geom3 {
|
||||
ld depth = 1; // world below the plane
|
||||
ld camera = 1; // camera above the plane
|
||||
ld wall_height = .3;
|
||||
ld slev = .08;
|
||||
ld lake_top = .25, lake_bottom = .9;
|
||||
ld rock_wall_ratio = .9;
|
||||
ld human_wall_ratio = .7;
|
||||
ld human_height;
|
||||
bool gp_autoscale_heights = true;
|
||||
|
||||
ld creature_scale, height_width;
|
||||
@ -263,13 +238,6 @@ namespace geom3 {
|
||||
return cosh(depth - lev);
|
||||
}
|
||||
|
||||
ld INFDEEP, BOTTOM, HELLSPIKE, LAKE, WALL, FLOOR, STUFF,
|
||||
SLEV[4], FLATEYE,
|
||||
LEG0, LEG1, LEG, LEG3, GROIN, GROIN1, GHOST,
|
||||
BODY, BODY1, BODY2, BODY3,
|
||||
NECK1, NECK, NECK3, HEAD, HEAD1, HEAD2, HEAD3,
|
||||
ALEG0, ALEG, ABODY, AHEAD, BIRD, LOWSKY, SKY, HIGH, HIGH2;
|
||||
|
||||
string invalid;
|
||||
|
||||
ld actual_wall_height() {
|
||||
@ -279,8 +247,10 @@ namespace geom3 {
|
||||
#endif
|
||||
return wall_height;
|
||||
}
|
||||
}
|
||||
|
||||
void compute() {
|
||||
void geometry_information::prepare_compute3() {
|
||||
using namespace geom3;
|
||||
DEBBI(DF_INIT | DF_POLY | DF_GEOM, ("geom3::compute"));
|
||||
// tanh(depth) / tanh(camera) == vid.alpha
|
||||
invalid = "";
|
||||
@ -388,11 +358,11 @@ namespace geom3 {
|
||||
}
|
||||
}
|
||||
|
||||
namespace geom3 {
|
||||
#if MAXMDIM >= 4
|
||||
void switch_always3() {
|
||||
if(rug::rugged) rug::close();
|
||||
geom3::always3 = !geom3::always3;
|
||||
need_reset_geometry = true;
|
||||
swapmatrix(View);
|
||||
callhooks(hooks_swapdim);
|
||||
}
|
||||
@ -431,7 +401,6 @@ void switch_always3() {
|
||||
geom3::human_wall_ratio = 0.8;
|
||||
geom3::camera = 0;
|
||||
if(pmodel == mdDisk) pmodel = mdPerspective;
|
||||
need_reset_geometry = true;
|
||||
swapmatrix(View);
|
||||
callhooks(hooks_swapdim);
|
||||
#if CAP_RACING
|
||||
@ -445,7 +414,6 @@ void switch_always3() {
|
||||
geom3::camera = 1;
|
||||
geom3::depth = 1;
|
||||
if(pmodel == mdPerspective) pmodel = mdDisk;
|
||||
need_reset_geometry = true;
|
||||
swapmatrix(View);
|
||||
callhooks(hooks_swapdim);
|
||||
}
|
||||
@ -454,8 +422,50 @@ void switch_always3() {
|
||||
|
||||
}
|
||||
|
||||
void initgeo() {
|
||||
// printf("%Lf\n", (ld) hdist0(xpush(-1)*ypush(0.01)*xpush(1)*C0));
|
||||
precalc();
|
||||
geometry_information *cgip;
|
||||
map<string, geometry_information> cgis;
|
||||
|
||||
void check_cgi() {
|
||||
string s;
|
||||
auto V = [&] (string a, string b) { s += a; s += ": "; s += b; s += "; "; };
|
||||
V("GEO", its(int(geometry)));
|
||||
V("VAR", its(int(variation)));
|
||||
|
||||
if(GOLDBERG) V("GP", its(gp::param.first) + "," + its(gp::param.second));
|
||||
if(IRREGULAR) V("IRR", its(irr::irrid));
|
||||
|
||||
if(geometry == gArchimedean) V("ARCM", arcm::current.symbol);
|
||||
|
||||
if(geometry == gCrystal) V("CRYSTAL", its(ginf[gCrystal].sides) + its(ginf[gCrystal].vertex));
|
||||
|
||||
if(binarytiling || DIM == 3) V("WQ", its(vid.texture_step));
|
||||
|
||||
if(binarytiling) V("BT", fts(vid.binary_width));
|
||||
|
||||
if(GDIM == 2) {
|
||||
V("CAMERA", fts(geom3::camera));
|
||||
}
|
||||
|
||||
if(WDIM == 2) {
|
||||
V("WH", fts(geom3::wall_height));
|
||||
V("HW", fts(geom3::human_wall_ratio));
|
||||
V("RW", fts(geom3::rock_wall_ratio));
|
||||
V("DEPTH", fts(geom3::depth));
|
||||
V("ASH", ONOFF(geom3::gp_autoscale_heights));
|
||||
V("LT", fts(geom3::lake_top));
|
||||
V("LB", fts(geom3::lake_bottom));
|
||||
}
|
||||
|
||||
V("3D", ONOFF(geom3::always3));
|
||||
|
||||
if(WDIM == 3) {
|
||||
V("CS", fts(geom3::creature_scale));
|
||||
V("HTW", fts(geom3::height_width));
|
||||
}
|
||||
|
||||
V("LQ", its(vid.linequality));
|
||||
|
||||
cgip = &cgis[s];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -35,7 +35,7 @@ transmatrix master_relative(cell *c, bool get_inverse) {
|
||||
}
|
||||
else {
|
||||
auto li = gp::get_local_info(c);
|
||||
transmatrix T = spin(master_to_c7_angle()) * gp::Tf[li.last_dir][li.relative.first&31][li.relative.second&31][gp::fixg6(li.total_dir)];
|
||||
transmatrix T = spin(master_to_c7_angle()) * cgi.gpdata->Tf[li.last_dir][li.relative.first&31][li.relative.second&31][gp::fixg6(li.total_dir)];
|
||||
if(get_inverse) T = inverse(T);
|
||||
return T;
|
||||
}
|
||||
@ -43,7 +43,7 @@ transmatrix master_relative(cell *c, bool get_inverse) {
|
||||
#endif
|
||||
else if(BITRUNCATED && !euclid) {
|
||||
for(int d=0; d<S7; d++) if(c->master->c7->move(d) == c)
|
||||
return (get_inverse?invhexmove:hexmove)[d];
|
||||
return (get_inverse?cgi.invhexmove:cgi.hexmove)[d];
|
||||
return Id;
|
||||
}
|
||||
else if(WDIM == 3 || euclid)
|
||||
@ -90,8 +90,8 @@ transmatrix hrmap_standard::relative_matrix(cell *c2, cell *c1, const hyperpoint
|
||||
ld bestdist = 1e9;
|
||||
for(int d=0; d<S7; d++) if(h2->move(d)) {
|
||||
int sp = h2->c.spin(d);
|
||||
transmatrix S = heptmove[sp] * spin(2*M_PI*d/S7);
|
||||
if(h2->c.mirror(d)) S = heptmove[sp] * Mirror * spin(2*M_PI*d/S7);
|
||||
transmatrix S = cgi.heptmove[sp] * spin(2*M_PI*d/S7);
|
||||
if(h2->c.mirror(d)) S = cgi.heptmove[sp] * Mirror * spin(2*M_PI*d/S7);
|
||||
if(h2->move(d) == h1) {
|
||||
transmatrix T1 = gm * S * where;
|
||||
auto curdist = hdist(tC0(T1), point_hint);
|
||||
@ -99,7 +99,7 @@ transmatrix hrmap_standard::relative_matrix(cell *c2, cell *c1, const hyperpoint
|
||||
}
|
||||
if(geometry != gMinimal) for(int e=0; e<S7; e++) if(h2->move(d)->move(e) == h1) {
|
||||
int sp2 = h2->move(d)->c.spin(e);
|
||||
transmatrix T1 = gm * heptmove[sp2] * spin(2*M_PI*e/S7) * S * where;
|
||||
transmatrix T1 = gm * cgi.heptmove[sp2] * spin(2*M_PI*e/S7) * S * where;
|
||||
auto curdist = hdist(tC0(T1), point_hint);
|
||||
if(curdist < bestdist) T = T1, bestdist = curdist;
|
||||
}
|
||||
@ -108,7 +108,7 @@ transmatrix hrmap_standard::relative_matrix(cell *c2, cell *c1, const hyperpoint
|
||||
}
|
||||
for(int d=0; d<S7; d++) if(h2->move(d) == h1) {
|
||||
int sp = h2->c.spin(d);
|
||||
return gm * heptmove[sp] * spin(2*M_PI*d/S7) * where;
|
||||
return gm * cgi.heptmove[sp] * spin(2*M_PI*d/S7) * where;
|
||||
}
|
||||
if(among(geometry, gFieldQuotient, gBring, gMacbeath)) {
|
||||
int bestdist = 1000000, bestd = 0;
|
||||
@ -117,7 +117,7 @@ transmatrix hrmap_standard::relative_matrix(cell *c2, cell *c1, const hyperpoint
|
||||
if(dist < bestdist) bestdist = dist, bestd = d;
|
||||
}
|
||||
int sp = h2->c.spin(bestd);
|
||||
where = heptmove[sp] * spin(2*M_PI*bestd/S7) * where;
|
||||
where = cgi.heptmove[sp] * spin(2*M_PI*bestd/S7) * where;
|
||||
h2 = h2->move(bestd);
|
||||
}
|
||||
#if CAP_CRYSTAL
|
||||
@ -127,7 +127,7 @@ transmatrix hrmap_standard::relative_matrix(cell *c2, cell *c1, const hyperpoint
|
||||
if(visited.count(h3)) continue;
|
||||
visited.insert(h3);
|
||||
int sp3 = h2->c.spin(d3);
|
||||
transmatrix where3 = heptmove[sp3] * spin(2*M_PI*d3/S7) * where;
|
||||
transmatrix where3 = cgi.heptmove[sp3] * spin(2*M_PI*d3/S7) * where;
|
||||
ld dist = crystal::space_distance(h3->c7, c1);
|
||||
hbdist[dist].emplace_back(h3, where3);
|
||||
}
|
||||
@ -140,12 +140,12 @@ transmatrix hrmap_standard::relative_matrix(cell *c2, cell *c1, const hyperpoint
|
||||
else if(h1->distance < h2->distance) {
|
||||
int sp = h2->c.spin(0);
|
||||
h2 = h2->move(0);
|
||||
where = heptmove[sp] * where;
|
||||
where = cgi.heptmove[sp] * where;
|
||||
}
|
||||
else {
|
||||
int sp = h1->c.spin(0);
|
||||
h1 = h1->move(0);
|
||||
gm = gm * invheptmove[sp];
|
||||
gm = gm * cgi.invheptmove[sp];
|
||||
}
|
||||
}
|
||||
/*if(hsol) {
|
||||
@ -184,11 +184,11 @@ transmatrix calc_relative_matrix_help(cell *c, heptagon *h1) {
|
||||
#if CAP_GP
|
||||
else if(GOLDBERG && c != c->master->c7) {
|
||||
auto li = gp::get_local_info(c);
|
||||
where = gp::Tf[li.last_dir][li.relative.first&31][li.relative.second&31][fix6(li.total_dir)];
|
||||
where = cgi.gpdata->Tf[li.last_dir][li.relative.first&31][li.relative.second&31][fix6(li.total_dir)];
|
||||
}
|
||||
#endif
|
||||
else if(BITRUNCATED) for(int d=0; d<S7; d++) if(h2->c7->move(d) == c)
|
||||
where = hexmove[d];
|
||||
where = cgi.hexmove[d];
|
||||
// always add to last!
|
||||
while(h1 != h2) {
|
||||
for(int d=0; d<S7; d++) if(h1->move(d) == h2) printf("(adj) ");
|
||||
@ -196,13 +196,13 @@ transmatrix calc_relative_matrix_help(cell *c, heptagon *h1) {
|
||||
int sp = h2->c.spin(0);
|
||||
printf("A%d ", sp);
|
||||
h2 = h2->move(0);
|
||||
where = heptmove[sp] * where;
|
||||
where = cgi.heptmove[sp] * where;
|
||||
}
|
||||
else {
|
||||
int sp = h1->c.spin(0);
|
||||
printf("B%d ", sp);
|
||||
h1 = h1->move(0);
|
||||
gm = gm * invheptmove[sp];
|
||||
gm = gm * cgi.invheptmove[sp];
|
||||
}
|
||||
}
|
||||
println(hlog, "OK");
|
||||
@ -286,7 +286,7 @@ void virtualRebase(cell*& base, T& at, bool tohex, const U& check) {
|
||||
if(WDIM == 2 && !binarytiling) for(int d=0; d<S7; d++) {
|
||||
heptspin hs(h, d, false);
|
||||
heptspin hs2 = hs + wstep;
|
||||
transmatrix V2 = spin(-hs2.spin*2*M_PI/S7) * invheptmove[d];
|
||||
transmatrix V2 = spin(-hs2.spin*2*M_PI/S7) * cgi.invheptmove[d];
|
||||
horo_distance newz(check(V2 * at));
|
||||
if(newz < currz) {
|
||||
currz = newz;
|
||||
@ -302,7 +302,7 @@ void virtualRebase(cell*& base, T& at, bool tohex, const U& check) {
|
||||
else {
|
||||
if(tohex && BITRUNCATED) for(int d=0; d<S7; d++) {
|
||||
cell *c = createMov(base, d);
|
||||
transmatrix V2 = spin(-base->c.spin(d)*2*M_PI/S6) * invhexmove[d];
|
||||
transmatrix V2 = spin(-base->c.spin(d)*2*M_PI/S6) * cgi.invhexmove[d];
|
||||
horo_distance newz(check(V2 * at));
|
||||
if(newz < currz) {
|
||||
currz = newz;
|
||||
@ -367,7 +367,7 @@ void virtualRebaseSimple(heptagon*& base, transmatrix& at) {
|
||||
for(int d=0; d<S7; d++) {
|
||||
heptspin hs(h, d, false);
|
||||
heptspin hs2 = hs + wstep;
|
||||
transmatrix V2 = spin(-hs2.spin*2*M_PI/S7) * invheptmove[d] * at;
|
||||
transmatrix V2 = spin(-hs2.spin*2*M_PI/S7) * cgi.invheptmove[d] * at;
|
||||
double newz = V2[GDIM][GDIM];
|
||||
if(newz < currz) {
|
||||
currz = newz;
|
||||
@ -388,11 +388,11 @@ void virtualRebaseSimple(heptagon*& base, transmatrix& at) {
|
||||
|
||||
double cellgfxdist(cell *c, int i) {
|
||||
if(euclid) {
|
||||
if(c->type == 8 && (i&1)) return crossf * sqrt(2);
|
||||
return crossf;
|
||||
if(c->type == 8 && (i&1)) return cgi.crossf * sqrt(2);
|
||||
return cgi.crossf;
|
||||
}
|
||||
if(NONSTDVAR || archimedean || WDIM == 3) return hdist0(tC0(calc_relative_matrix(c->move(i), c, i)));
|
||||
return !BITRUNCATED ? tessf : (c->type == 6 && (i&1)) ? hexhexdist : crossf;
|
||||
return !BITRUNCATED ? cgi.tessf : (c->type == 6 && (i&1)) ? cgi.hexhexdist : cgi.crossf;
|
||||
}
|
||||
|
||||
transmatrix cellrelmatrix(cell *c, int i) {
|
||||
@ -415,7 +415,7 @@ hyperpoint randomPointIn(int t) {
|
||||
while(true) {
|
||||
hyperpoint h = xspinpush0(2*M_PI*(randd()-.5)/t, asinh(randd()));
|
||||
double d =
|
||||
PURE ? tessf : t == 6 ? hexhexdist : crossf;
|
||||
PURE ? cgi.tessf : t == 6 ? cgi.hexhexdist : cgi.crossf;
|
||||
if(hdist0(h) < hdist0(xpush(-d) * h))
|
||||
return spin(2*M_PI/t * (rand() % t)) * h;
|
||||
}
|
||||
@ -462,13 +462,13 @@ hyperpoint get_corner_position(cell *c, int cid, ld cf) {
|
||||
}
|
||||
#endif
|
||||
if(PURE) {
|
||||
return ddspin(c,cid,M_PI/S7) * xpush0(hcrossf * 3 / cf);
|
||||
return ddspin(c,cid,M_PI/S7) * xpush0(cgi.hcrossf * 3 / cf);
|
||||
}
|
||||
if(BITRUNCATED) {
|
||||
if(!ishept(c))
|
||||
return ddspin(c,cid,M_PI/S6) * xpush0(hexvdist * 3 / cf);
|
||||
return ddspin(c,cid,M_PI/S6) * xpush0(cgi.hexvdist * 3 / cf);
|
||||
else
|
||||
return ddspin(c,cid,M_PI/S7) * xpush0(rhexf * 3 / cf);
|
||||
return ddspin(c,cid,M_PI/S7) * xpush0(cgi.rhexf * 3 / cf);
|
||||
}
|
||||
return C0;
|
||||
}
|
||||
@ -613,7 +613,7 @@ hyperpoint get_warp_corner(cell *c, int cid) {
|
||||
#if CAP_IRR || CAP_ARCM
|
||||
if(IRREGULAR || archimedean) return midcorner(c, cid, .5);
|
||||
#endif
|
||||
return ddspin(c,cid,M_PI/S7) * xpush0(tessf/2);
|
||||
return ddspin(c,cid,M_PI/S7) * xpush0(cgi.tessf/2);
|
||||
}
|
||||
|
||||
vector<hyperpoint> hrmap::get_vertices(cell* c) {
|
||||
|
||||
61
goldberg.cpp
61
goldberg.cpp
@ -46,8 +46,6 @@ namespace hr { namespace gp {
|
||||
loc param(1, 0);
|
||||
|
||||
hyperpoint next;
|
||||
ld alpha;
|
||||
int area;
|
||||
|
||||
struct goldberg_mapping_t {
|
||||
cellwalker cw;
|
||||
@ -504,22 +502,18 @@ namespace hr { namespace gp {
|
||||
return normalize(spin(2*M_PI*sp/S7) * cornmul(T, corner));
|
||||
}
|
||||
|
||||
transmatrix Tf[MAX_EDGE][32][32][6];
|
||||
|
||||
transmatrix corners;
|
||||
|
||||
transmatrix dir_matrix(int i) {
|
||||
cell cc; cc.type = S7;
|
||||
return spin(-alpha) * build_matrix(
|
||||
return spin(-cgi.gpdata->alpha) * build_matrix(
|
||||
C0,
|
||||
ddspin(&cc, i) * xpush0(tessf),
|
||||
ddspin(&cc, i+1) * xpush0(tessf),
|
||||
ddspin(&cc, i) * xpush0(cgi.tessf),
|
||||
ddspin(&cc, i+1) * xpush0(cgi.tessf),
|
||||
C03
|
||||
);
|
||||
}
|
||||
|
||||
void prepare_matrices() {
|
||||
corners = inverse(build_matrix(
|
||||
cgi.gpdata->corners = inverse(build_matrix(
|
||||
loctoh_ort(loc(0,0)),
|
||||
loctoh_ort(param),
|
||||
loctoh_ort(param * loc(0,1)),
|
||||
@ -532,9 +526,9 @@ namespace hr { namespace gp {
|
||||
for(int d=0; d<(S3==3?6:4); d++) {
|
||||
loc at = loc(x, y);
|
||||
|
||||
hyperpoint h = atz(T, corners, at, 6);
|
||||
hyperpoint hl = atz(T, corners, at + eudir(d), 6);
|
||||
Tf[i][x&31][y&31][d] = rgpushxto0(h) * rspintox(gpushxto0(h) * hl) * spin(M_PI);
|
||||
hyperpoint h = atz(T, cgi.gpdata->corners, at, 6);
|
||||
hyperpoint hl = atz(T, cgi.gpdata->corners, at + eudir(d), 6);
|
||||
cgi.gpdata->Tf[i][x&31][y&31][d] = rgpushxto0(h) * rspintox(gpushxto0(h) * hl) * spin(M_PI);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -542,10 +536,10 @@ namespace hr { namespace gp {
|
||||
hyperpoint get_corner_position(const local_info& li, int cid, ld cf = 3) {
|
||||
int i = li.last_dir;
|
||||
if(i == -1)
|
||||
return atz(dir_matrix(cid), corners, li.relative, 0, cf);
|
||||
return atz(dir_matrix(cid), cgi.gpdata->corners, li.relative, 0, cf);
|
||||
else {
|
||||
auto& cellmatrix = Tf[i][li.relative.first&31][li.relative.second&31][fixg6(li.total_dir)];
|
||||
return inverse(cellmatrix) * atz(dir_matrix(i), corners, li.relative, fixg6(cid + li.total_dir), cf);
|
||||
auto& cellmatrix = cgi.gpdata->Tf[i][li.relative.first&31][li.relative.second&31][fixg6(li.total_dir)];
|
||||
return inverse(cellmatrix) * atz(dir_matrix(i), cgi.gpdata->corners, li.relative, fixg6(cid + li.total_dir), cf);
|
||||
}
|
||||
}
|
||||
|
||||
@ -558,36 +552,34 @@ namespace hr { namespace gp {
|
||||
void compute_geometry() {
|
||||
center_locs.clear();
|
||||
if(GOLDBERG) {
|
||||
if(!cgi.gpdata) cgi.gpdata = make_shared<geometry_information::gpdata_t>();
|
||||
int x = param.first;
|
||||
int y = param.second;
|
||||
if(S3 == 3)
|
||||
area = ((2*x+y) * (2*x+y) + y*y*3) / 4;
|
||||
cgi.gpdata->area = ((2*x+y) * (2*x+y) + y*y*3) / 4;
|
||||
else
|
||||
area = x * x + y * y;
|
||||
cgi.gpdata->area = x * x + y * y;
|
||||
next = point3(x+y/2., -y * sqrt(3) / 2, 0);
|
||||
ld scale = 1 / hypot_d(2, next);
|
||||
crossf *= scale;
|
||||
hepvdist *= scale;
|
||||
hexhexdist *= scale;
|
||||
hexvdist *= scale;
|
||||
rhexf *= scale;
|
||||
cgi.crossf *= scale;
|
||||
cgi.hepvdist *= scale;
|
||||
cgi.hexhexdist *= scale;
|
||||
cgi.hexvdist *= scale;
|
||||
cgi.rhexf *= scale;
|
||||
// spin = spintox(next);
|
||||
// ispin = rspintox(next);
|
||||
alpha = -atan2(next[1], next[0]) * 6 / S7;
|
||||
cgi.gpdata->alpha = -atan2(next[1], next[0]) * 6 / S7;
|
||||
if(S3 == 3)
|
||||
base_distlimit = (base_distlimit + log(scale) / log(2.618)) / scale;
|
||||
cgi.base_distlimit = (cgi.base_distlimit + log(scale) / log(2.618)) / scale;
|
||||
else
|
||||
base_distlimit = 3 * max(param.first, param.second) + 2 * min(param.first, param.second);
|
||||
cgi.base_distlimit = 3 * max(param.first, param.second) + 2 * min(param.first, param.second);
|
||||
if(S7 == 12)
|
||||
base_distlimit = 2 * param.first + 2 * param.second + 1;
|
||||
if(base_distlimit > SEE_ALL)
|
||||
base_distlimit = SEE_ALL;
|
||||
cgi.base_distlimit = 2 * param.first + 2 * param.second + 1;
|
||||
if(cgi.base_distlimit > SEE_ALL)
|
||||
cgi.base_distlimit = SEE_ALL;
|
||||
prepare_matrices();
|
||||
DEBB(DF_GEOM | DF_POLY, ("scale = ", scale));
|
||||
}
|
||||
else {
|
||||
alpha = 0;
|
||||
}
|
||||
}
|
||||
|
||||
loc config;
|
||||
@ -625,7 +617,6 @@ namespace hr { namespace gp {
|
||||
stop_game(); set_variation(eVariation::bitruncated);
|
||||
}
|
||||
else {
|
||||
if(param != xy) need_reset_geometry = true;
|
||||
param = xy;
|
||||
stop_game(); set_variation(eVariation::goldberg);
|
||||
}
|
||||
@ -765,7 +756,7 @@ namespace hr { namespace gp {
|
||||
int sp = 0;
|
||||
auto& at = li.relative;
|
||||
again:
|
||||
auto corner = corners * loctoh_ort(at);
|
||||
auto corner = cgi.gpdata->corners * loctoh_ort(at);
|
||||
if(corner[1] < -1e-6 || corner[2] < -1e-6) {
|
||||
at = at * eudir(1);
|
||||
sp++;
|
||||
@ -832,7 +823,7 @@ namespace hr { namespace gp {
|
||||
hyperpoint get_master_coordinates(cell *c) {
|
||||
auto li = get_local_info(c);
|
||||
be_in_triangle(li);
|
||||
return corners * loctoh_ort(li.relative);
|
||||
return cgi.gpdata->corners * loctoh_ort(li.relative);
|
||||
}
|
||||
|
||||
int compute_dist(cell *c, int master_function(cell*)) {
|
||||
|
||||
10
hud.cpp
10
hud.cpp
@ -187,9 +187,9 @@ bool displayglyph(int cx, int cy, int buttonsize, char glyph, color_t color, int
|
||||
if(m == moKrakenT || m == moDragonTail) bsize /= 2;
|
||||
if(m == moSlime) bsize = (2*bsize+1)/3;
|
||||
transmatrix V = atscreenpos(cx+buttonsize/2, cy, bsize*zoom);
|
||||
if(isWorm(m) && wormscale != 1)
|
||||
if(isWorm(m) && cgi.wormscale != 1)
|
||||
for(int i=0; i<DIM; i++)
|
||||
V[i][i] /= wormscale;
|
||||
V[i][i] /= cgi.wormscale;
|
||||
int mcol = color;
|
||||
mcol -= (color & 0xFCFCFC) >> 2;
|
||||
drawMonsterType(m, NULL, V, mcol, glyphphase[id]/500.0);
|
||||
@ -345,7 +345,7 @@ void drawMobileArrow(int i) {
|
||||
double dx = xmove + rad*(1+SKIPFAC-.2)/2 * cos(alpha);
|
||||
double dy = yb + rad*(1+SKIPFAC-.2)/2 * sin(alpha);
|
||||
|
||||
queuepolyat(atscreenpos(dx, dy, scale) * spin(-alpha), shArrow, col, PPR::MOBILE_ARROW);
|
||||
queuepolyat(atscreenpos(dx, dy, scale) * spin(-alpha), cgi.shArrow, col, PPR::MOBILE_ARROW);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -403,11 +403,11 @@ void draw_radar(bool cornermode) {
|
||||
if(d3) displaychr(int(cx + rad * r.h[0]), int(cy - rad * r.h[2] * si + rad * r.h[1] * co), 0, 8, r.glyph, r.color);
|
||||
else if(sph) displaychr(int(cx + (rad-10) * r.h[0]), int(cy + (rad-10) * r.h[2] * si + (rad-10) * r.h[1] * co), 0, +r.h[1] * si > r.h[2] * co ? 8 : 16, r.glyph, r.color);
|
||||
else if(hyp) {
|
||||
int siz = 1/(1+r.h[3]) * scalefactor * current_display->radius / (inHighQual ? 10 : 6);
|
||||
int siz = 1/(1+r.h[3]) * cgi.scalefactor * current_display->radius / (inHighQual ? 10 : 6);
|
||||
displaychr(int(cx + rad * r.h[0]), int(cy + rad * r.h[1]), 0, siz, r.glyph, r.color);
|
||||
}
|
||||
else {
|
||||
displaychr(int(cx + rad * r.h[0]), int(cy + rad * r.h[1]), 0, rad * scalefactor / (max_eu_dist + scalefactor/4) * 0.8, r.glyph, r.color);
|
||||
displaychr(int(cx + rad * r.h[0]), int(cy + rad * r.h[1]), 0, rad * cgi.scalefactor / (max_eu_dist + cgi.scalefactor/4) * 0.8, r.glyph, r.color);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
396
hyper.h
396
hyper.h
@ -2019,8 +2019,6 @@ void checkStunKill(cell *dest);
|
||||
|
||||
void clearMessages();
|
||||
|
||||
void resetGeometry();
|
||||
|
||||
namespace shot {
|
||||
#if CAP_SHOT
|
||||
extern int shotx, shoty, shotformat;
|
||||
@ -3174,6 +3172,7 @@ namespace irr {
|
||||
extern int place_attempts;
|
||||
extern int rearrange_max_attempts;
|
||||
extern int rearrange_less;
|
||||
extern int irrid;
|
||||
void link_to_base(heptagon *h, heptspin base);
|
||||
void link_start(heptagon *h);
|
||||
void link_next(heptagon *h, int d);
|
||||
@ -3309,7 +3308,6 @@ transmatrix screenpos(ld x, ld y);
|
||||
extern ld backbrightness;
|
||||
|
||||
void initcells();
|
||||
void precalc();
|
||||
extern const hyperpoint C02, C03;
|
||||
|
||||
#define C0 (DIM == 2 ? C02 : C03)
|
||||
@ -3336,10 +3334,6 @@ extern bool fixseed;
|
||||
extern eLand firstland0;
|
||||
extern int startseed;
|
||||
|
||||
|
||||
extern transmatrix heptmove[MAX_EDGE], hexmove[MAX_EDGE];
|
||||
extern transmatrix invheptmove[MAX_EDGE], invhexmove[MAX_EDGE];
|
||||
|
||||
// heptspin hsstep(const heptspin &hs, int spin);
|
||||
|
||||
extern void fixmatrix(transmatrix&);
|
||||
@ -3512,12 +3506,6 @@ dqi_line& queueline(const hyperpoint& H1, const hyperpoint& H2, color_t col, int
|
||||
dqi_action& queueaction(PPR prio, const reaction_t& action);
|
||||
void queuereset(eModel m, PPR prio);
|
||||
|
||||
|
||||
extern ld tessf, crossf, hexf, hcrossf, hexhexdist, hexvdist, hepvdist, rhexf;
|
||||
extern ld sword_size;
|
||||
|
||||
extern ld scalefactor, orbsize, floorrad0, floorrad1, zhexf;
|
||||
|
||||
unsigned char& part(color_t& col, int i);
|
||||
|
||||
transmatrix applyPatterndir(cell *c, const patterns::patterninfo& si);
|
||||
@ -3608,6 +3596,8 @@ struct renderbuffer {
|
||||
void clear(color_t col);
|
||||
};
|
||||
|
||||
extern renderbuffer *floor_textures;
|
||||
|
||||
struct resetbuffer {
|
||||
GLint drawFboId, readFboId;
|
||||
SDL_Surface *sreset;
|
||||
@ -3791,12 +3781,9 @@ namespace gp {
|
||||
void compute_geometry();
|
||||
void extend_map(cell *c, int d);
|
||||
extern loc param;
|
||||
extern int area;
|
||||
extern int pseudohept_val(cell *);
|
||||
extern int last_dir(cell *c);
|
||||
extern void configure();
|
||||
extern ld alpha;
|
||||
extern transmatrix Tf[MAX_EDGE][32][32][6];
|
||||
|
||||
struct local_info {
|
||||
int last_dir;
|
||||
@ -3831,8 +3818,6 @@ int gamerange();
|
||||
|
||||
int numplayers();
|
||||
|
||||
extern int base_distlimit;
|
||||
|
||||
bool has_nice_dual();
|
||||
|
||||
extern hyperpoint mid(const hyperpoint &h1, const hyperpoint &h2);
|
||||
@ -4055,16 +4040,6 @@ struct hpcshape {
|
||||
int shs, she;
|
||||
};
|
||||
|
||||
extern hpcshape shFullCross[2];
|
||||
|
||||
void bshape(hpcshape& sh, PPR prio);
|
||||
void hpcpush(hyperpoint h);
|
||||
void finishshape();
|
||||
void extra_vertices();
|
||||
extern vector<hyperpoint> hpc;
|
||||
|
||||
extern hpcshape *last;
|
||||
|
||||
extern vector<hpcshape> shPlainWall3D, shWireframe3D, shWall3D, shMiniWall3D;
|
||||
#endif
|
||||
|
||||
@ -4262,20 +4237,16 @@ void set_blizzard_frame(cell *c, int frameid);
|
||||
struct floorshape {
|
||||
bool is_plain;
|
||||
int shapeid;
|
||||
int id;
|
||||
int pstrength; // pattern strength in 3D
|
||||
int fstrength; // frame strength in 3D
|
||||
PPR prio;
|
||||
vector<hpcshape> b, shadow, side[SIDEPARS], gpside[SIDEPARS][MAX_EDGE], levels[SIDEPARS], cone[2];
|
||||
basic_textureinfo tinf3;
|
||||
floorshape() { prio = PPR::FLOOR; pstrength = fstrength = 10; }
|
||||
};
|
||||
|
||||
extern vector<struct plain_floorshape*> all_plain_floorshapes;
|
||||
extern vector<struct escher_floorshape*> all_escher_floorshapes;
|
||||
|
||||
struct plain_floorshape : floorshape {
|
||||
ld rad0, rad1;
|
||||
plain_floorshape() { is_plain = true; all_plain_floorshapes.push_back(this); }
|
||||
void configure(ld r0, ld r1) { rad0 = r0; rad1 = r1; }
|
||||
};
|
||||
|
||||
@ -4283,18 +4254,311 @@ struct plain_floorshape : floorshape {
|
||||
struct escher_floorshape : floorshape {
|
||||
int shapeid0, shapeid1, noftype, shapeid2;
|
||||
ld scale;
|
||||
escher_floorshape(int s0, int s1, int noft=0, int s2=0) : shapeid0(s0), shapeid1(s1), noftype(noft), shapeid2(s2) {
|
||||
all_escher_floorshapes.push_back(this); scale = 1; is_plain = false;
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
struct usershapelayer {
|
||||
vector<hyperpoint> list;
|
||||
bool sym;
|
||||
int rots;
|
||||
color_t color;
|
||||
hyperpoint shift, spin;
|
||||
ld zlevel;
|
||||
int texture_offset;
|
||||
PPR prio;
|
||||
};
|
||||
|
||||
extern plain_floorshape
|
||||
shFloor,
|
||||
shMFloor, shMFloor2, shMFloor3, shMFloor4, shFullFloor,
|
||||
shBigTriangle, shTriheptaFloor, shBigHepta;
|
||||
static const int USERLAYERS = 32;
|
||||
|
||||
extern escher_floorshape shDragonFloor, shPowerFloor, shRedRockFloor[3];
|
||||
#endif
|
||||
struct usershape { usershapelayer d[USERLAYERS]; };
|
||||
|
||||
extern array<map<int, usershape*>, mapeditor::USERSHAPEGROUPS> usershapes;
|
||||
void initShape(int sg, int id);
|
||||
|
||||
extern int usershape_changes;
|
||||
|
||||
struct geometry_information {
|
||||
|
||||
/* basic geometry parameters */
|
||||
|
||||
// tessf: distance from heptagon center to another heptagon center
|
||||
// hexf: distance from heptagon center to small heptagon vertex
|
||||
// hcrossf: distance from heptagon center to big heptagon vertex
|
||||
// crossf: distance from heptagon center to adjacent cell center (either hcrossf or tessf)
|
||||
// hexhexdist: distance between adjacent hexagon vertices
|
||||
// hexvdist: distance between hexagon vertex and hexagon center
|
||||
// hepvdist: distance between heptagon vertex and hexagon center (either hcrossf or something else)
|
||||
// rhexf: distance from heptagon center to heptagon vertex (either hexf or hcrossf)
|
||||
ld tessf, crossf, hexf, hcrossf, hexhexdist, hexvdist, hepvdist, rhexf;
|
||||
|
||||
transmatrix heptmove[MAX_EDGE], hexmove[MAX_EDGE];
|
||||
transmatrix invheptmove[MAX_EDGE], invhexmove[MAX_EDGE];
|
||||
|
||||
int base_distlimit;
|
||||
|
||||
/* shape parameters */
|
||||
ld sword_size;
|
||||
ld scalefactor, orbsize, floorrad0, floorrad1, zhexf;
|
||||
ld corner_bonus;
|
||||
ld hexshift;
|
||||
ld asteroid_size[8];
|
||||
ld wormscale;
|
||||
ld tentacle_length;
|
||||
|
||||
/* 3D parameters */
|
||||
ld INFDEEP, BOTTOM, HELLSPIKE, LAKE, WALL, FLOOR, STUFF,
|
||||
SLEV[4], FLATEYE,
|
||||
LEG0, LEG1, LEG, LEG3, GROIN, GROIN1, GHOST,
|
||||
BODY, BODY1, BODY2, BODY3,
|
||||
NECK1, NECK, NECK3, HEAD, HEAD1, HEAD2, HEAD3,
|
||||
ALEG0, ALEG, ABODY, AHEAD, BIRD, LOWSKY, SKY, HIGH, HIGH2;
|
||||
ld human_height, slev;
|
||||
|
||||
#if CAP_SHAPES
|
||||
hpcshape
|
||||
shSemiFloorSide[SIDEPARS],
|
||||
shBFloor[2],
|
||||
shWave[8][2],
|
||||
shCircleFloor,
|
||||
shBarrel,
|
||||
shWall[2], shMineMark[2], shBigMineMark[2], shFan,
|
||||
shZebra[5],
|
||||
shSwitchDisk,
|
||||
shTower[11],
|
||||
shEmeraldFloor[6],
|
||||
shSemiFeatherFloor[2],
|
||||
shSemiFloor[2], shSemiBFloor[2], shSemiFloorShadow,
|
||||
shMercuryBridge[2],
|
||||
shTriheptaSpecial[14],
|
||||
shCross, shGiantStar[2], shLake, shMirror,
|
||||
shHalfFloor[6], shHalfMirror[3],
|
||||
shGem[2], shStar, shDisk, shDiskT, shDiskS, shDiskM, shDiskSq, shRing,
|
||||
shTinyBird, shTinyShark,
|
||||
shEgg,
|
||||
shSpikedRing, shTargetRing, shSawRing, shGearRing, shPeaceRing, shHeptaRing,
|
||||
shSpearRing, shLoveRing,
|
||||
shDaisy, shTriangle, shNecro, shStatue, shKey, shWindArrow,
|
||||
shGun,
|
||||
shFigurine, shTreat,
|
||||
shElementalShard,
|
||||
// shBranch,
|
||||
shIBranch, shTentacle, shTentacleX, shILeaf[2],
|
||||
shMovestar,
|
||||
shWolf, shYeti, shDemon, shGDemon, shEagle, shGargoyleWings, shGargoyleBody,
|
||||
shFoxTail1, shFoxTail2,
|
||||
shDogBody, shDogHead, shDogFrontLeg, shDogRearLeg, shDogFrontPaw, shDogRearPaw,
|
||||
shDogTorso,
|
||||
shHawk,
|
||||
shCatBody, shCatLegs, shCatHead, shFamiliarHead, shFamiliarEye,
|
||||
shWolf1, shWolf2, shWolf3,
|
||||
shRatEye1, shRatEye2, shRatEye3,
|
||||
shDogStripes,
|
||||
shPBody, shPSword, shPKnife,
|
||||
shFerocityM, shFerocityF,
|
||||
shHumanFoot, shHumanLeg, shHumanGroin, shHumanNeck, shSkeletalFoot, shYetiFoot,
|
||||
shMagicSword, shMagicShovel, shSeaTentacle, shKrakenHead, shKrakenEye, shKrakenEye2,
|
||||
shArrow,
|
||||
shPHead, shPFace, shGolemhead, shHood, shArmor,
|
||||
shAztecHead, shAztecCap,
|
||||
shSabre, shTurban1, shTurban2, shVikingHelmet, shRaiderHelmet, shRaiderArmor, shRaiderBody, shRaiderShirt,
|
||||
shWestHat1, shWestHat2, shGunInHand,
|
||||
shKnightArmor, shKnightCloak, shWightCloak,
|
||||
shGhost, shEyes, shSlime, shJelly, shJoint, shWormHead, shTentHead, shShark, shWormSegment, shSmallWormSegment, shWormTail, shSmallWormTail,
|
||||
shSlimeEyes, shDragonEyes, shWormEyes, shGhostEyes,
|
||||
shMiniGhost, shMiniEyes,
|
||||
shHedgehogBlade, shHedgehogBladePlayer,
|
||||
shWolfBody, shWolfHead, shWolfLegs, shWolfEyes,
|
||||
shWolfFrontLeg, shWolfRearLeg, shWolfFrontPaw, shWolfRearPaw,
|
||||
shFemaleBody, shFemaleHair, shFemaleDress, shWitchDress,
|
||||
shWitchHair, shBeautyHair, shFlowerHair, shFlowerHand, shSuspenders, shTrophy,
|
||||
shBugBody, shBugArmor, shBugLeg, shBugAntenna,
|
||||
shPickAxe, shPike, shFlailBall, shFlailTrunk, shFlailChain, shHammerHead,
|
||||
shBook, shBookCover, shGrail,
|
||||
shBoatOuter, shBoatInner, shCompass1, shCompass2, shCompass3,
|
||||
shKnife, shTongue, shFlailMissile, shTrapArrow,
|
||||
shPirateHook, shPirateHood, shEyepatch, shPirateX,
|
||||
// shScratch,
|
||||
shHeptaMarker, shSnowball, shSun, shNightStar,
|
||||
shSkeletonBody, shSkull, shSkullEyes, shFatBody, shWaterElemental,
|
||||
shPalaceGate, shFishTail,
|
||||
shMouse, shMouseLegs, shMouseEyes,
|
||||
shPrincessDress, shPrinceDress,
|
||||
shWizardCape1, shWizardCape2,
|
||||
shBigCarpet1, shBigCarpet2, shBigCarpet3,
|
||||
shGoatHead, shRose, shRoseItem, shThorns,
|
||||
shRatHead, shRatTail, shRatEyes, shRatCape1, shRatCape2,
|
||||
shWizardHat1, shWizardHat2,
|
||||
shTortoise[13][6],
|
||||
shDragonLegs, shDragonTail, shDragonHead, shDragonSegment, shDragonNostril,
|
||||
shDragonWings,
|
||||
shSolidBranch, shWeakBranch, shBead0, shBead1,
|
||||
shBatWings, shBatBody, shBatMouth, shBatFang, shBatEye,
|
||||
shParticle[16], shAsteroid[8],
|
||||
shReptile[5][4],
|
||||
shReptileBody, shReptileHead, shReptileFrontFoot, shReptileRearFoot,
|
||||
shReptileFrontLeg, shReptileRearLeg, shReptileTail, shReptileEye,
|
||||
|
||||
shTrylobite, shTrylobiteHead, shTrylobiteBody,
|
||||
shTrylobiteFrontLeg, shTrylobiteRearLeg, shTrylobiteFrontClaw, shTrylobiteRearClaw,
|
||||
|
||||
shBullBody, shBullHead, shBullHorn, shBullRearHoof, shBullFrontHoof,
|
||||
|
||||
shButterflyBody, shButterflyWing, shGadflyBody, shGadflyWing, shGadflyEye,
|
||||
|
||||
shTerraArmor1, shTerraArmor2, shTerraArmor3, shTerraHead, shTerraFace,
|
||||
shJiangShi, shJiangShiDress, shJiangShiCap1, shJiangShiCap2,
|
||||
|
||||
shAsymmetric,
|
||||
|
||||
shPBodyOnly, shPBodyArm, shPBodyHand, shPHeadOnly,
|
||||
|
||||
shAnimatedEagle[30], shAnimatedTinyEagle[30], shAnimatedGadfly[30], shAnimatedHawk[30], shAnimatedButterfly[30],
|
||||
shAnimatedGargoyle[30], shAnimatedGargoyle2[30], shAnimatedBat[30], shAnimatedBat2[30],
|
||||
|
||||
shDodeca;
|
||||
|
||||
vector<hpcshape> shPlainWall3D, shWireframe3D, shWall3D, shMiniWall3D;
|
||||
|
||||
vector<plain_floorshape*> all_plain_floorshapes;
|
||||
vector<escher_floorshape*> all_escher_floorshapes;
|
||||
|
||||
plain_floorshape
|
||||
shFloor,
|
||||
shMFloor, shMFloor2, shMFloor3, shMFloor4, shFullFloor,
|
||||
shBigTriangle, shTriheptaFloor, shBigHepta;
|
||||
|
||||
escher_floorshape
|
||||
shStarFloor, shCloudFloor, shCrossFloor, shChargedFloor,
|
||||
shSStarFloor, shOverFloor, shTriFloor, shFeatherFloor,
|
||||
shBarrowFloor, shNewFloor, shTrollFloor, shButterflyFloor,
|
||||
shLavaFloor, shLavaSeabed, shSeabed, shCloudSeabed,
|
||||
shCaveSeabed, shPalaceFloor, shDemonFloor, shCaveFloor,
|
||||
shDesertFloor, shPowerFloor, shRoseFloor, shSwitchFloor,
|
||||
shTurtleFloor, shRedRockFloor[3], shDragonFloor;
|
||||
|
||||
ld dlow_table[SIDEPARS], dhi_table[SIDEPARS], dfloor_table[SIDEPARS];
|
||||
|
||||
int prehpc;
|
||||
vector<hyperpoint> hpc;
|
||||
bool first;
|
||||
|
||||
bool validsidepar[SIDEPARS];
|
||||
|
||||
vector<glvertex> ourshape;
|
||||
#endif
|
||||
|
||||
hpcshape shFullCross[2];
|
||||
hpcshape *last;
|
||||
|
||||
int SD3, SD6, SD7, S12, S14, S21, S28, S42, S36, S84;
|
||||
|
||||
vector<array<int, 3>> symmetriesAt;
|
||||
|
||||
#ifndef SCALETUNER
|
||||
static constexpr
|
||||
#endif
|
||||
double bscale7 = 1, brot7 = 0, bscale6 = 1, brot6 = 0;
|
||||
|
||||
vector<hpcshape*> allshapes;
|
||||
|
||||
transmatrix shadowmulmatrix;
|
||||
|
||||
map<usershapelayer*, hpcshape> ushr;
|
||||
|
||||
void prepare_basics();
|
||||
void prepare_compute3();
|
||||
void prepare_shapes();
|
||||
void prepare_usershapes();
|
||||
|
||||
void hpcpush(hyperpoint h);
|
||||
void chasmifyPoly(double fac, double fac2, int k);
|
||||
void shift(hpcshape& sh, double dx, double dy, double dz);
|
||||
void initPolyForGL();
|
||||
void extra_vertices();
|
||||
transmatrix ddi(int a, ld x);
|
||||
void drawTentacle(hpcshape &h, ld rad, ld var, ld divby);
|
||||
hyperpoint hpxyzsc(double x, double y, double z);
|
||||
hyperpoint turtlevertex(int u, double x, double y, double z);
|
||||
|
||||
void bshape(hpcshape& sh, PPR prio);
|
||||
void finishshape();
|
||||
void bshape(hpcshape& sh, PPR prio, double shzoom, int shapeid, double bonus = 0, flagtype flags = 0);
|
||||
|
||||
void copyshape(hpcshape& sh, hpcshape& orig, PPR prio);
|
||||
void zoomShape(hpcshape& old, hpcshape& newsh, double factor, PPR prio);
|
||||
void pushShape(usershapelayer& ds);
|
||||
void make_sidewalls();
|
||||
void procedural_shapes();
|
||||
void make_wall(int id, vector<hyperpoint> vertices, bool force_triangles = false);
|
||||
void create_wall3d();
|
||||
void configure_floorshapes();
|
||||
|
||||
void init_floorshapes();
|
||||
void bshape2(hpcshape& sh, PPR prio, int shapeid, struct matrixlist& m);
|
||||
void bshape_regular(floorshape &fsh, int id, int sides, int shift, ld size);
|
||||
void generate_floorshapes_for(int id, cell *c, int siid, int sidir);
|
||||
void generate_floorshapes();
|
||||
void make_floor_textures_here();
|
||||
|
||||
vector<hyperpoint> get_shape(hpcshape sh);
|
||||
void add_cone(ld z0, const vector<hyperpoint>& vh, ld z1);
|
||||
void add_prism_sync(ld z0, vector<hyperpoint> vh0, ld z1, vector<hyperpoint> vh1);
|
||||
void add_prism(ld z0, vector<hyperpoint> vh0, ld z1, vector<hyperpoint> vh1);
|
||||
void shift_last(ld z);
|
||||
void shift_shape(hpcshape& sh, ld z);
|
||||
void shift_shape_orthogonally(hpcshape& sh, ld z);
|
||||
void add_texture(hpcshape& sh);
|
||||
void make_ha_3d(hpcshape& sh, bool isarmor, ld scale);
|
||||
void make_humanoid_3d(hpcshape& sh);
|
||||
void addtri(array<hyperpoint, 3> hs, int kind);
|
||||
void make_armor_3d(hpcshape& sh, int kind = 1);
|
||||
void make_foot_3d(hpcshape& sh);
|
||||
void make_head_only();
|
||||
void make_head_3d(hpcshape& sh);
|
||||
void make_paw_3d(hpcshape& sh, hpcshape& legsh);
|
||||
void make_abody_3d(hpcshape& sh, ld tail);
|
||||
void make_ahead_3d(hpcshape& sh);
|
||||
void make_skeletal(hpcshape& sh, ld push = 0);
|
||||
void make_revolution(hpcshape& sh, int mx = 180, ld push = 0);
|
||||
void make_revolution_cut(hpcshape &sh, int each = 180, ld push = 0, ld width = 99);
|
||||
void clone_shape(hpcshape& sh, hpcshape& target);
|
||||
void animate_bird(hpcshape& orig, hpcshape animated[30], ld body);
|
||||
void slimetriangle(hyperpoint a, hyperpoint b, hyperpoint c, ld rad, int lev);
|
||||
void balltriangle(hyperpoint a, hyperpoint b, hyperpoint c, ld rad, int lev);
|
||||
void make_ball(hpcshape& sh, ld rad, int lev);
|
||||
void adjust_eye(hpcshape& eye, hpcshape head, ld shift_eye, ld shift_head, int q, ld zoom=1);
|
||||
void shift_last_straight(ld z);
|
||||
void queueball(const transmatrix& V, ld rad, color_t col, eItem what);
|
||||
void make_shadow(hpcshape& sh);
|
||||
void make_3d_models();
|
||||
|
||||
/* Goldberg parameters */
|
||||
#if CAP_GP
|
||||
struct gpdata_t {
|
||||
transmatrix Tf[MAX_EDGE][32][32][6];
|
||||
transmatrix corners;
|
||||
ld alpha;
|
||||
int area;
|
||||
};
|
||||
shared_ptr<gpdata_t> gpdata;
|
||||
#endif
|
||||
|
||||
int state;
|
||||
int usershape_state;
|
||||
|
||||
geometry_information() { last = NULL; state = usershape_state = 0; gpdata = NULL; }
|
||||
|
||||
void require_basics() { if(state & 1) return; state |= 1; prepare_basics(); }
|
||||
void require_shapes() { if(state & 2) return; state |= 2; prepare_shapes(); }
|
||||
void require_usershapes() { if(usershape_state == usershape_changes) return; usershape_state = usershape_state; prepare_usershapes(); }
|
||||
};
|
||||
|
||||
void make_floor_textures();
|
||||
|
||||
extern map<string, geometry_information> cgis;
|
||||
extern geometry_information *cgip;
|
||||
void check_cgi();
|
||||
#define cgi (*cgip)
|
||||
|
||||
#if ISMOBILE
|
||||
bool buttonclicked;
|
||||
@ -4335,7 +4599,6 @@ extern int timetowait;
|
||||
|
||||
extern vector<pair<cell*, int> > airmap;
|
||||
extern void compute_graphical_distance();
|
||||
extern ld scalef;
|
||||
|
||||
struct help_extension {
|
||||
char key;
|
||||
@ -4354,7 +4617,6 @@ namespace gamestack {
|
||||
}
|
||||
|
||||
namespace geom3 {
|
||||
extern ld BODY;
|
||||
extern ld depth, camera, wall_height, creature_scale, height_width;
|
||||
void switch_always3();
|
||||
void switch_fpp();
|
||||
@ -4368,23 +4630,14 @@ ld frac(ld x);
|
||||
|
||||
extern color_t poly_outline;
|
||||
|
||||
#if CAP_SHAPES
|
||||
extern hpcshape shDisk, shTriangle, shHeptaMarker, shSnowball, shDiskT, shDiskS, shDiskSq, shDiskM, shTinyBird, shTinyShark, shAsymmetric;
|
||||
#endif
|
||||
|
||||
extern std::mt19937 hrngen;
|
||||
|
||||
bool anglestraight(cell *c, int d1, int d2);
|
||||
|
||||
hyperpoint randomPointIn(int t);
|
||||
|
||||
void buildpolys();
|
||||
|
||||
bool compute_relamatrix(cell *src, cell *tgt, int direction_hint, transmatrix& T);
|
||||
|
||||
extern bool need_reset_geometry;
|
||||
extern ld hexshift;
|
||||
|
||||
extern bool noshadow, bright, nohelp, dont_face_pc;
|
||||
extern void switchHardcore();
|
||||
|
||||
@ -4403,10 +4656,10 @@ namespace ors {
|
||||
|
||||
bool saved_tortoise_on(cell *c);
|
||||
|
||||
#define RING(i) for(double i=0; i<=S84+1e-6; i+=SD3 * pow(.5, vid.linequality))
|
||||
#define REVRING(i) for(double i=S84; i>=-1e-6; i-=SD3 * pow(.5, vid.linequality))
|
||||
#define PRING(i) for(double i=0; i<=S84+1e-6; i+= pow(.5, vid.linequality))
|
||||
#define REVPRING(i) for(double i=S84; i>=-1e-6; i-=pow(.5, vid.linequality))
|
||||
#define RING(i) for(double i=0; i<=cgi.S84+1e-6; i+=SD3 * pow(.5, vid.linequality))
|
||||
#define REVRING(i) for(double i=cgi.S84; i>=-1e-6; i-=SD3 * pow(.5, vid.linequality))
|
||||
#define PRING(i) for(double i=0; i<=cgi.S84+1e-6; i+= pow(.5, vid.linequality))
|
||||
#define REVPRING(i) for(double i=cgi.S84; i>=-1e-6; i-=pow(.5, vid.linequality))
|
||||
#if CAP_BT
|
||||
|
||||
namespace binary {
|
||||
@ -4794,6 +5047,7 @@ extern void calcTidalPhase();
|
||||
|
||||
void curvepoint(const hyperpoint& H1);
|
||||
dqi_poly& queuecurve(color_t linecol, color_t fillcol, PPR prio);
|
||||
void queueball(const transmatrix& V, ld rad, color_t col, eItem what);
|
||||
|
||||
ld cos_auto(ld x);
|
||||
ld sin_auto(ld x);
|
||||
@ -5028,8 +5282,6 @@ struct bandfixer {
|
||||
bandfixer(transmatrix& T) : bw(band_shift, band_shift) { fix_the_band(T); }
|
||||
};
|
||||
|
||||
inline void delayed_geo_reset() { need_reset_geometry = true; }
|
||||
|
||||
extern unordered_map<string, ld&> params;
|
||||
|
||||
namespace dq {
|
||||
@ -5129,5 +5381,31 @@ inline void reset_projection() { new_projection_needed = true; }
|
||||
extern ld ptick(int period, ld phase = 0);
|
||||
void gridline(const transmatrix& V1, const hyperpoint h1, const transmatrix& V2, const hyperpoint h2, color_t col, int prec);
|
||||
void gridline(const transmatrix& V, const hyperpoint h1, const hyperpoint h2, color_t col, int prec);
|
||||
|
||||
static const int POLY_DRAWLINES = 1; // draw the lines
|
||||
static const int POLY_DRAWAREA = 2; // draw the area
|
||||
static const int POLY_INVERSE = 4; // draw the inverse -- useful in stereographic projection
|
||||
static const int POLY_ISSIDE = 8; // never draw in inverse
|
||||
static const int POLY_BEHIND = 16; // there are points behind the camera
|
||||
static const int POLY_TOOLARGE = 32; // some coordinates are too large -- best not to draw to avoid glitches
|
||||
static const int POLY_INFRONT = 64; // on the sphere (orthogonal projection), do not draw without any points in front
|
||||
static const int POLY_HASWALLS = 128; // floor shapes which have their sidewalls
|
||||
static const int POLY_PLAIN = 256; // plain floors
|
||||
static const int POLY_FULL = 512; // full floors
|
||||
static const int POLY_HASSHADOW = 1024; // floor shapes which have their shadows, or can use shFloorShadow
|
||||
static const int POLY_GP = 2048; // Goldberg shapes
|
||||
static const int POLY_VCONVEX = 4096; // Convex shape (vertex)
|
||||
static const int POLY_CCONVEX = 8192; // Convex shape (central)
|
||||
static const int POLY_CENTERIN = 16384; // new system of side checking
|
||||
static const int POLY_FORCEWIDE = (1<<15); // force wide lines
|
||||
static const int POLY_NOTINFRONT = (1<<16); // points not in front
|
||||
static const int POLY_NIF_ERROR = (1<<17); // points moved to the outline cross the image, disable
|
||||
static const int POLY_BADCENTERIN = (1<<18); // new system of side checking
|
||||
static const int POLY_PRECISE_WIDE = (1<<19); // precise width calculation
|
||||
static const int POLY_FORCE_INVERTED = (1<<20); // force inverted
|
||||
static const int POLY_ALWAYS_IN = (1<<21); // always draw this
|
||||
static const int POLY_TRIANGLES = (1<<22); // made of TRIANGLES, not TRIANGLE_FAN
|
||||
static const int POLY_INTENSE = (1<<23); // extra intense colors
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -777,4 +777,21 @@ hyperpoint orthogonal_of_C0(hyperpoint h0, hyperpoint h1, hyperpoint h2) {
|
||||
return normalize(h);
|
||||
}
|
||||
|
||||
hyperpoint zshift(hyperpoint x, ld z) {
|
||||
if(DIM == 3 && WDIM == 2) return orthogonal_move(x, z);
|
||||
else return mscale(x, z);
|
||||
}
|
||||
|
||||
hyperpoint hpxd(ld d, ld x, ld y, ld z) {
|
||||
hyperpoint H = hpxyz(d*x, d*y, z);
|
||||
H = mid(H, H);
|
||||
return H;
|
||||
}
|
||||
|
||||
ld signum(ld x) { return x<0?-1:x>0?1:0; }
|
||||
|
||||
bool asign(ld y1, ld y2) { return signum(y1) != signum(y2); }
|
||||
|
||||
ld xcross(ld x1, ld y1, ld x2, ld y2) { return x1 + (x2 - x1) * y1 / (y1 - y2); }
|
||||
|
||||
}
|
||||
|
||||
55
hypgraph.cpp
55
hypgraph.cpp
@ -672,7 +672,7 @@ bool outofmap(hyperpoint h) {
|
||||
if(GDIM == 3)
|
||||
return false;
|
||||
else if(euclid)
|
||||
return h[2] < .5; // false; // h[0] * h[0] + h[1] * h[1] > 15 * crossf;
|
||||
return h[2] < .5; // false; // h[0] * h[0] + h[1] * h[1] > 15 * cgi.crossf;
|
||||
else if(sphere)
|
||||
return h[2] < .1 && h[2] > -.1 && h[1] > -.1 && h[1] < .1 && h[0] > -.1 && h[0] < .1;
|
||||
else
|
||||
@ -755,10 +755,9 @@ bool confusingGeometry() {
|
||||
}
|
||||
|
||||
ld master_to_c7_angle() {
|
||||
ld alpha = 0;
|
||||
#if CAP_GP
|
||||
auto alpha = gp::alpha;
|
||||
#else
|
||||
auto alpha = 0;
|
||||
if(cgi.gpdata) alpha = cgi.gpdata->alpha;
|
||||
#endif
|
||||
return (!BITRUNCATED && !binarytiling && !archimedean) ? M_PI + alpha : 0;
|
||||
}
|
||||
@ -825,11 +824,11 @@ bool in_smart_range(const transmatrix& T) {
|
||||
if(DIM == 3) {
|
||||
if(-h1[2] + 2 * dz < conformal::clip_min || -h1[2] - 2 * dz > conformal::clip_max) return false;
|
||||
sort(dh, dh+DIM);
|
||||
ld scale = sqrt(dh[1] * dh[2]) * scalefactor * hcrossf7;
|
||||
ld scale = sqrt(dh[1] * dh[2]) * cgi.scalefactor * hcrossf7;
|
||||
if(scale <= (WDIM == 2 ? vid.smart_range_detail : vid.smart_range_detail_3)) return false;
|
||||
}
|
||||
else {
|
||||
ld scale = sqrt(dh[0] * dh[1]) * scalefactor * hcrossf7;
|
||||
ld scale = sqrt(dh[0] * dh[1]) * cgi.scalefactor * hcrossf7;
|
||||
if(scale <= vid.smart_range_detail) return false;
|
||||
}
|
||||
|
||||
@ -852,7 +851,7 @@ void drawrec(cell *c, const transmatrix& V) {
|
||||
if(!c2) continue;
|
||||
if(c2->move(0) != c) continue;
|
||||
if(c2 == c2->master->c7) continue;
|
||||
transmatrix V1 = V * ddspin(c, i) * xpush(crossf) * iddspin(c2, 0) * spin(M_PI);
|
||||
transmatrix V1 = V * ddspin(c, i) * xpush(cgi.crossf) * iddspin(c2, 0) * spin(M_PI);
|
||||
drawrec(c2, V1);
|
||||
}
|
||||
} */
|
||||
@ -861,7 +860,7 @@ void drawrec(cell *c, const transmatrix& V) {
|
||||
|
||||
bool drawrec(cell *c, const transmatrix& V, gp::loc at, int dir, int maindir) {
|
||||
bool res = false;
|
||||
transmatrix V1 = V * Tf[draw_li.last_dir][at.first&31][at.second&31][fixg6(dir)];
|
||||
transmatrix V1 = V * cgi.gpdata->Tf[draw_li.last_dir][at.first&31][at.second&31][fixg6(dir)];
|
||||
if(do_draw(c, V1)) {
|
||||
/* auto li = get_local_info(c);
|
||||
if(fix6(dir) != fix6(li.total_dir)) printf("totaldir %d/%d\n", dir, li.total_dir);
|
||||
@ -985,7 +984,7 @@ void hrmap_standard::draw() {
|
||||
int ds = hs.at->c.fix(hs.spin + d);
|
||||
// createMov(c, ds);
|
||||
if(c->move(ds) && c->c.spin(ds) == 0) {
|
||||
transmatrix V2 = V1 * hexmove[d];
|
||||
transmatrix V2 = V1 * cgi.hexmove[d];
|
||||
if(do_draw(c->move(ds), V2))
|
||||
draw = true,
|
||||
drawcell(c->move(ds), V2, 0, hs.mirrored ^ c->c.mirror(ds));
|
||||
@ -999,7 +998,7 @@ void hrmap_standard::draw() {
|
||||
hstate s2 = transition(s, d);
|
||||
if(s2 == hsError) continue;
|
||||
heptspin hs2 = hs + d + wstep;
|
||||
transmatrix Vd = V * heptmove[d];
|
||||
transmatrix Vd = V * cgi.heptmove[d];
|
||||
bandfixer bf(Vd);
|
||||
drawn_cells.emplace_back(hs2, s2, Vd, band_shift);
|
||||
}
|
||||
@ -1013,22 +1012,22 @@ transmatrix eumove(ld x, ld y) {
|
||||
Mat[DIM][DIM] = 1;
|
||||
|
||||
if(a4) {
|
||||
Mat[0][DIM] += x * crossf;
|
||||
Mat[1][DIM] += y * crossf;
|
||||
Mat[0][DIM] += x * cgi.crossf;
|
||||
Mat[1][DIM] += y * cgi.crossf;
|
||||
}
|
||||
else {
|
||||
Mat[0][DIM] += (x + y * .5) * crossf;
|
||||
// Mat[DIM][0] += (x + y * .5) * crossf;
|
||||
Mat[1][DIM] += y * q3 /2 * crossf;
|
||||
// Mat[DIM][1] += y * q3 /2 * crossf;
|
||||
Mat[0][DIM] += (x + y * .5) * cgi.crossf;
|
||||
// Mat[DIM][0] += (x + y * .5) * cgi.crossf;
|
||||
Mat[1][DIM] += y * q3 /2 * cgi.crossf;
|
||||
// Mat[DIM][1] += y * q3 /2 * cgi.crossf;
|
||||
}
|
||||
|
||||
ld v = a4 ? 1 : q3;
|
||||
|
||||
while(Mat[0][DIM] <= -16384 * crossf) Mat[0][DIM] += 32768 * crossf;
|
||||
while(Mat[0][DIM] >= 16384 * crossf) Mat[0][DIM] -= 32768 * crossf;
|
||||
while(Mat[1][DIM] <= -16384 * v * crossf) Mat[1][DIM] += 32768 * v * crossf;
|
||||
while(Mat[1][DIM] >= 16384 * v * crossf) Mat[1][DIM] -= 32768 * v * crossf;
|
||||
while(Mat[0][DIM] <= -16384 * cgi.crossf) Mat[0][DIM] += 32768 * cgi.crossf;
|
||||
while(Mat[0][DIM] >= 16384 * cgi.crossf) Mat[0][DIM] -= 32768 * cgi.crossf;
|
||||
while(Mat[1][DIM] <= -16384 * v * cgi.crossf) Mat[1][DIM] += 32768 * v * cgi.crossf;
|
||||
while(Mat[1][DIM] >= 16384 * v * cgi.crossf) Mat[1][DIM] -= 32768 * v * cgi.crossf;
|
||||
return Mat;
|
||||
}
|
||||
|
||||
@ -1118,7 +1117,7 @@ void centerpc(ld aspd) {
|
||||
transmatrix T = shmup::pc[id]->at;
|
||||
if(WDIM == 2 && !masterless) T = master_relative(shmup::pc[id]->base) * T;
|
||||
int sl = snakelevel(cwt.at);
|
||||
if(sl) T = T * zpush(geom3::SLEV[sl] - geom3::FLOOR);
|
||||
if(sl) T = T * zpush(cgi.SLEV[sl] - cgi.FLOOR);
|
||||
View = inverse(T);
|
||||
if(WDIM == 2) View = cspin(0, 1, M_PI) * cspin(2, 1, M_PI/2 + shmup::playerturny[id]) * spin(-M_PI/2) * View;
|
||||
return;
|
||||
@ -1135,7 +1134,7 @@ void centerpc(ld aspd) {
|
||||
#if MAXMDIM >= 4
|
||||
if(GDIM == 3 && WDIM == 2) {
|
||||
int sl = snakelevel(cwt.at);
|
||||
if(sl) T = T * zpush(geom3::SLEV[sl] - geom3::FLOOR);
|
||||
if(sl) T = T * zpush(cgi.SLEV[sl] - cgi.FLOOR);
|
||||
}
|
||||
#endif
|
||||
hyperpoint H = inverse(actual_view_transform) * tC0(T);
|
||||
@ -1223,7 +1222,7 @@ void optimizeview() {
|
||||
for(int i=-1; i<S7; i++) {
|
||||
|
||||
ld trot = -i * M_PI * 2 / (S7+.0);
|
||||
transmatrix T = i < 0 ? Id : spin(trot) * xpush(tessf) * pispin;
|
||||
transmatrix T = i < 0 ? Id : spin(trot) * xpush(cgi.tessf) * pispin;
|
||||
hyperpoint H = View * tC0(T);
|
||||
if(H[DIM] < best) best = H[DIM], turn = i, TB = T;
|
||||
}
|
||||
@ -1308,14 +1307,14 @@ transmatrix atscreenpos(ld x, ld y, ld size) {
|
||||
if(pmodel == mdFlatten) {
|
||||
V[0][3] += (x - current_display->xcenter);
|
||||
V[1][3] += (y - current_display->ycenter);
|
||||
V[0][0] = size * 2 * hcrossf / crossf;
|
||||
V[1][1] = size * 2 * hcrossf / crossf;
|
||||
V[0][0] = size * 2 * cgi.hcrossf / cgi.crossf;
|
||||
V[1][1] = size * 2 * cgi.hcrossf / cgi.crossf;
|
||||
}
|
||||
else {
|
||||
V[0][2] += (x - current_display->xcenter);
|
||||
V[1][2] += (y - current_display->ycenter);
|
||||
V[0][0] = size * 2 * hcrossf / crossf;
|
||||
V[1][1] = size * 2 * hcrossf / crossf;
|
||||
V[0][0] = size * 2 * cgi.hcrossf / cgi.crossf;
|
||||
V[1][1] = size * 2 * cgi.hcrossf / cgi.crossf;
|
||||
V[2][2] = current_display->scrdist;
|
||||
}
|
||||
|
||||
@ -1718,7 +1717,7 @@ bool do_draw(cell *c, const transmatrix& T) {
|
||||
}
|
||||
else {
|
||||
ld dist = hdist0(tC0(T));
|
||||
if(dist > sightranges[geometry] + (vid.sloppy_3d ? 0 : corner_bonus)) return false;
|
||||
if(dist > sightranges[geometry] + (vid.sloppy_3d ? 0 : cgi.corner_bonus)) return false;
|
||||
if(dist <= extra_generation_distance && !limited_generation(c)) return false;
|
||||
}
|
||||
return true;
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
namespace hr { namespace irr {
|
||||
|
||||
int irrid;
|
||||
|
||||
#if CAP_IRR
|
||||
ld density = 2;
|
||||
ld quality = .2;
|
||||
@ -487,12 +489,12 @@ bool step(int delta) {
|
||||
|
||||
for(auto& s: cells) {
|
||||
int d = -1;
|
||||
ld dist = hcrossf / 2;
|
||||
ld dist = cgi.hcrossf / 2;
|
||||
ld dists[8];
|
||||
for(int i=0; i<S7; i++) {
|
||||
dists[i] = hdist(s.p, xspinpush0(hexshift - i * ALPHA, -hcrossf));
|
||||
dists[i] = hdist(s.p, xspinpush0(cgi.hexshift - i * ALPHA, -cgi.hcrossf));
|
||||
if(dists[i] < dist)
|
||||
d = i, dist = dists[i];
|
||||
d = i, dist = dists[i];
|
||||
}
|
||||
if(d != -1 && dists[(d+1) % S7] > dists[(d+S7-1) % S7])
|
||||
d = (d + S7 - 1) % S7;
|
||||
@ -512,13 +514,13 @@ bool step(int delta) {
|
||||
void compute_geometry() {
|
||||
if(IRREGULAR) {
|
||||
ld scale = sqrt(isize(cells_of_heptagon) * 1. / isize(cells));
|
||||
crossf *= scale;
|
||||
hepvdist *= scale;
|
||||
rhexf *= scale;
|
||||
hexhexdist *= scale;
|
||||
hexvdist *= scale;
|
||||
base_distlimit = (base_distlimit + log(scale) / log(2.618)) / scale;
|
||||
if(base_distlimit > 25) base_distlimit = 25;
|
||||
cgi.crossf *= scale;
|
||||
cgi.hepvdist *= scale;
|
||||
cgi.rhexf *= scale;
|
||||
cgi.hexhexdist *= scale;
|
||||
cgi.hexvdist *= scale;
|
||||
cgi.base_distlimit = (cgi.base_distlimit + log(scale) / log(2.618)) / scale;
|
||||
if(cgi.base_distlimit > 25) cgi.base_distlimit = 25;
|
||||
}
|
||||
}
|
||||
|
||||
@ -806,7 +808,7 @@ void start_game_on_created_map() {
|
||||
stop_game();
|
||||
geometry = orig_geometry;
|
||||
variation = eVariation::irregular;
|
||||
need_reset_geometry = true;
|
||||
irrid++;
|
||||
gridmaking = false;
|
||||
start_game();
|
||||
}
|
||||
@ -874,7 +876,6 @@ void cancel_map_creation() {
|
||||
gridmaking = false;
|
||||
stop_game();
|
||||
geometry = orig_geometry;
|
||||
need_reset_geometry = true;
|
||||
start_game();
|
||||
}
|
||||
|
||||
@ -986,7 +987,6 @@ void visual_creator() {
|
||||
}
|
||||
|
||||
variation = eVariation::pure;
|
||||
need_reset_geometry = true;
|
||||
start_game();
|
||||
if(base) delete base;
|
||||
base = currentmap;
|
||||
|
||||
@ -322,7 +322,7 @@ namespace mapstream {
|
||||
#endif
|
||||
}
|
||||
|
||||
need_reset_geometry = true;
|
||||
usershape_changes++;
|
||||
|
||||
initcells();
|
||||
if(shmup::on) shmup::init();
|
||||
@ -496,9 +496,9 @@ namespace mapstream {
|
||||
}
|
||||
|
||||
cellbyid.clear();
|
||||
buildpolys();
|
||||
check_cgi();
|
||||
cgi.require_basics();
|
||||
bfs();
|
||||
restartGraph();
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -1056,7 +1056,7 @@ namespace mapeditor {
|
||||
dsCur->list.clear();
|
||||
dsCur->sym = d==2;
|
||||
for(int i=sh.s; i < sh.s + (sh.e-sh.s)/d; i++)
|
||||
dsCur->list.push_back(hpc[i]);
|
||||
dsCur->list.push_back(cgi.hpc[i]);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -1121,25 +1121,25 @@ namespace mapeditor {
|
||||
if(front_config == eFront::equidistants) for(int i=0; i<4; i+=2) {
|
||||
for(int u=2; u<=20; u++) {
|
||||
PRING(d) {
|
||||
curvepoint(d2 * xspinpush(M_PI*d/S42, u/20.) * zpush(front_edit) * C0);
|
||||
curvepoint(d2 * xspinpush(M_PI*d/cgi.S42, u/20.) * zpush(front_edit) * C0);
|
||||
}
|
||||
queuecurve(cols[i + (u%5 != 0)], 0, i < 2 ? PPR::LINE : PPR::SUPERLINE);
|
||||
}
|
||||
for(int d=0; d<S84; d++) {
|
||||
for(int u=0; u<=20; u++) curvepoint(d2 * xspinpush(M_PI*d/S42, u/20.) * zpush(front_edit) * C0);
|
||||
queuecurve(cols[i + (d % (S84/drawcell->type) != 0)], 0, i < 2 ? PPR::LINE : PPR::SUPERLINE);
|
||||
for(int d=0; d<cgi.S84; d++) {
|
||||
for(int u=0; u<=20; u++) curvepoint(d2 * xspinpush(M_PI*d/cgi.S42, u/20.) * zpush(front_edit) * C0);
|
||||
queuecurve(cols[i + (d % (cgi.S84/drawcell->type) != 0)], 0, i < 2 ? PPR::LINE : PPR::SUPERLINE);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
for(int d=0; d<S84; d++) {
|
||||
unsigned col = (d % (S84/drawcell->type) == 0) ? gridcolor : lightgrid;
|
||||
queueline(d2 * C0, d2 * xspinpush0(M_PI*d/S42, 1), col, 4 + vid.linequality);
|
||||
for(int d=0; d<cgi.S84; d++) {
|
||||
unsigned col = (d % (cgi.S84/drawcell->type) == 0) ? gridcolor : lightgrid;
|
||||
queueline(d2 * C0, d2 * xspinpush0(M_PI*d/cgi.S42, 1), col, 4 + vid.linequality);
|
||||
}
|
||||
for(int u=2; u<=20; u++) {
|
||||
PRING(d) {
|
||||
curvepoint(d2 * xspinpush0(M_PI*d/S42, u/20.));
|
||||
curvepoint(d2 * xspinpush0(M_PI*d/cgi.S42, u/20.));
|
||||
}
|
||||
queuecurve((u%5==0) ? gridcolor : lightgrid, 0, PPR::LINE);
|
||||
}
|
||||
@ -1174,8 +1174,8 @@ namespace mapeditor {
|
||||
ld compute_area(hpcshape& sh) {
|
||||
ld area = 0;
|
||||
for(int i=sh.s; i<sh.e-1; i++) {
|
||||
hyperpoint h1 = hpc[i];
|
||||
hyperpoint h2 = hpc[i+1];
|
||||
hyperpoint h1 = cgi.hpc[i];
|
||||
hyperpoint h2 = cgi.hpc[i+1];
|
||||
if(euclid)
|
||||
area += (h2[1] + h1[1]) * (h2[0] - h1[0]) / 2;
|
||||
else {
|
||||
@ -1379,7 +1379,8 @@ namespace mapeditor {
|
||||
}
|
||||
|
||||
if(us) {
|
||||
auto& sh = us->d[dslayer].sh;
|
||||
cgi.require_usershapes();
|
||||
auto& sh = cgi.ushr[&us->d[dslayer]];
|
||||
if(sh.e >= sh.s + 3)
|
||||
displayButton(vid.xres-8, vid.yres-8-fs*8, XLAT("area: %1", area_in_pi ? fts(compute_area(sh) / M_PI, 4) + "π" : fts(compute_area(sh), 4)), 'w', 16);
|
||||
}
|
||||
@ -1393,8 +1394,6 @@ namespace mapeditor {
|
||||
#endif
|
||||
}
|
||||
|
||||
bool rebuildPolys = false;
|
||||
|
||||
#if CAP_POLY
|
||||
void loadShapes(int sg, int id) {
|
||||
delete usershapes[sg][id];
|
||||
@ -1437,7 +1436,7 @@ namespace mapeditor {
|
||||
dsCur->rots = 1;
|
||||
dsCur->zlevel = 0;
|
||||
|
||||
for(auto& v: symmetriesAt)
|
||||
for(auto& v: cgi.symmetriesAt)
|
||||
if(v[0] == ptd.offset) {
|
||||
dsCur->rots = v[1];
|
||||
dsCur->sym = v[2] == 2;
|
||||
@ -1451,7 +1450,7 @@ namespace mapeditor {
|
||||
layer++;
|
||||
if(layer == USERLAYERS) break;
|
||||
}
|
||||
rebuildPolys = true;
|
||||
usershape_changes++;
|
||||
}
|
||||
|
||||
void applyToShape(int sg, int id, int uni, hyperpoint mh) {
|
||||
@ -1477,7 +1476,7 @@ namespace mapeditor {
|
||||
if(uni == 'n' || xnew) {
|
||||
dsCur->list.clear();
|
||||
dsCur->list.push_back(mh);
|
||||
rebuildPolys = true;
|
||||
usershape_changes++;
|
||||
}
|
||||
|
||||
if(uni == 'u')
|
||||
@ -1491,7 +1490,7 @@ namespace mapeditor {
|
||||
if(uni == 'a') {
|
||||
dsCur->list.push_back(mh);
|
||||
uni = 0;
|
||||
rebuildPolys = true;
|
||||
usershape_changes++;
|
||||
}
|
||||
else if(uni == 'c' || uni == 'd' || uni == 'm') {
|
||||
hyperpoint best = mh;
|
||||
@ -1521,7 +1520,7 @@ namespace mapeditor {
|
||||
if(oldlist[i] != best)
|
||||
dsCur->list.push_back(oldlist[i]);
|
||||
}
|
||||
rebuildPolys = true;
|
||||
usershape_changes++;
|
||||
uni = 0;
|
||||
}
|
||||
else if(uni == COLORKEY) dsCur->color = colortouse;
|
||||
@ -1537,7 +1536,7 @@ namespace mapeditor {
|
||||
|
||||
dsCur->list.insert(dsCur->list.begin()+ew.pointid+(ew.side?1:0), mh);
|
||||
if(ew.side) ew.pointid++;
|
||||
rebuildPolys = true;
|
||||
usershape_changes++;
|
||||
}
|
||||
|
||||
if(uni == 'D') {
|
||||
@ -1561,41 +1560,41 @@ namespace mapeditor {
|
||||
if(ew.side == 1 && ew.pointid >= i) ew.pointid--;
|
||||
if(ew.side == 0 && ew.pointid > i) ew.pointid--;
|
||||
}
|
||||
rebuildPolys = true;
|
||||
usershape_changes++;
|
||||
}
|
||||
|
||||
if(uni == 'K') {
|
||||
if(vid.cs.charid >= 4) {
|
||||
loadShape(sg, id, shCatBody, 2, 0);
|
||||
loadShape(sg, id, shCatHead, 2, 1);
|
||||
loadShape(sg, id, cgi.shCatBody, 2, 0);
|
||||
loadShape(sg, id, cgi.shCatHead, 2, 1);
|
||||
}
|
||||
else {
|
||||
if(!(vid.cs.charid&1)) loadShape(sg, id, shPBody, 2, 0);
|
||||
else loadShape(sg, id, shFemaleBody, 2, 0);
|
||||
if(!(vid.cs.charid&1)) loadShape(sg, id, cgi.shPBody, 2, 0);
|
||||
else loadShape(sg, id, cgi.shFemaleBody, 2, 0);
|
||||
|
||||
loadShape(sg, id, shPSword, 1, 1);
|
||||
loadShape(sg, id, cgi.shPSword, 1, 1);
|
||||
|
||||
if(vid.cs.charid&1)
|
||||
loadShape(sg, id, shFemaleDress, 2, 2);
|
||||
loadShape(sg, id, cgi.shFemaleDress, 2, 2);
|
||||
|
||||
/* if(vid.cs.charid&1)
|
||||
loadShape(sg, id, shPrincessDress, 1, 3);
|
||||
loadShape(sg, id, cgi.shPrincessDress, 1, 3);
|
||||
else
|
||||
loadShape(sg, id, shPrinceDress, 2, 3); */
|
||||
loadShape(sg, id, cgi.shPrinceDress, 2, 3); */
|
||||
|
||||
loadShape(sg, id, shRatCape2, 1, 3);
|
||||
loadShape(sg, id, cgi.shRatCape2, 1, 3);
|
||||
|
||||
if(vid.cs.charid&1)
|
||||
loadShape(sg, id, shFemaleHair, 2, 4);
|
||||
loadShape(sg, id, cgi.shFemaleHair, 2, 4);
|
||||
else
|
||||
loadShape(sg, id, shPHead, 2, 4);
|
||||
loadShape(sg, id, cgi.shPHead, 2, 4);
|
||||
|
||||
loadShape(sg, id, shPFace, 2, 5);
|
||||
loadShape(sg, id, cgi.shPFace, 2, 5);
|
||||
}
|
||||
|
||||
// loadShape(sg, id, shWolf, 2, dslayer);
|
||||
// loadShape(sg, id, cgi.shWolf, 2, dslayer);
|
||||
|
||||
rebuildPolys = true;
|
||||
usershape_changes++;
|
||||
}
|
||||
|
||||
if(uni == '+') dsCur->rots++;
|
||||
@ -1603,20 +1602,20 @@ namespace mapeditor {
|
||||
if(uni >= '1' && uni <= '9') {
|
||||
dsCur->rots = uni - '0';
|
||||
if(dsCur->rots == 9) dsCur->rots = 21;
|
||||
rebuildPolys = true;
|
||||
usershape_changes++;
|
||||
}
|
||||
if(uni == '0') {
|
||||
dsCur->sym = !dsCur->sym;
|
||||
rebuildPolys = true;
|
||||
usershape_changes++;
|
||||
}
|
||||
|
||||
if(uni == 't') {
|
||||
dsCur->shift = mh;
|
||||
rebuildPolys = true;
|
||||
usershape_changes++;
|
||||
}
|
||||
if(uni == 'y') {
|
||||
dsCur->spin = mh;
|
||||
rebuildPolys = true;
|
||||
usershape_changes++;
|
||||
}
|
||||
|
||||
if(uni == COLORKEY) dsCur->color = colortouse;
|
||||
@ -1691,7 +1690,7 @@ namespace mapeditor {
|
||||
}
|
||||
addMessage(XLAT("Pictures loaded from %1", picfile));
|
||||
|
||||
buildpolys();
|
||||
usershape_changes++;
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -1945,9 +1944,6 @@ namespace mapeditor {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(rebuildPolys)
|
||||
add_user_shapes(), rebuildPolys = false;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -2053,10 +2049,11 @@ namespace mapeditor {
|
||||
|
||||
usershape *us = usershapes[group][id];
|
||||
if(us) {
|
||||
cgi.require_usershapes();
|
||||
for(int i=0; i<USERLAYERS; i++) {
|
||||
if(i != dslayer && onelayeronly) continue;
|
||||
usershapelayer& ds(us->d[i]);
|
||||
hpcshape& sh(ds.sh);
|
||||
hpcshape& sh(cgi.ushr[&ds]);
|
||||
|
||||
if(sh.s != sh.e) {
|
||||
auto& last = queuepolyat(mmscale(V, DIM == 3 ? 0 : geom3::lev_to_factor(ds.zlevel)), sh, ds.color ? ds.color : color, prio);
|
||||
|
||||
@ -79,7 +79,7 @@ namespace hr { namespace netgen {
|
||||
|
||||
int hdir = displayspin(c, i) + M_PI / S7;
|
||||
|
||||
transmatrix V2 = V * spin(hdir) * xpush(hexf);
|
||||
transmatrix V2 = V * spin(hdir) * xpush(cgi.hexf);
|
||||
|
||||
hcenter[ii][i] = V2 * C0;
|
||||
}
|
||||
@ -91,7 +91,7 @@ namespace hr { namespace netgen {
|
||||
int hdir = displayspin(c, i);
|
||||
|
||||
transmatrix V2 =
|
||||
V * spin(hdir) * xpush(crossf) * spin(M_PI+M_PI/S7) * xpush(hexf);
|
||||
V * spin(hdir) * xpush(cgi.crossf) * spin(M_PI+M_PI/S7) * xpush(cgi.hexf);
|
||||
|
||||
hcenter[ii][i] = V2 * C0;
|
||||
}
|
||||
|
||||
24
pattern2.cpp
24
pattern2.cpp
@ -491,7 +491,7 @@ int getHemisphere(cell *c, int which) {
|
||||
else if(GOLDBERG) {
|
||||
auto li = gp::get_local_info(c);
|
||||
gp::be_in_triangle(li);
|
||||
auto corner = gp::corners * gp::loctoh_ort(li.relative);
|
||||
auto corner = cgi.gpdata->corners * gp::loctoh_ort(li.relative);
|
||||
ld scored =
|
||||
corner[0] * getHemisphere(c->master->c7, which)
|
||||
+ corner[1] * getHemisphere(c->master->move(li.last_dir)->c7, which)
|
||||
@ -2223,7 +2223,7 @@ namespace linepatterns {
|
||||
if(fv2/4 == 4 || fv2/4 == 6 || fv2/4 == 5 || fv2/4 == 10) fv2 ^= 2;
|
||||
if((fv1&1) == (fv2&1)) continue;
|
||||
|
||||
double x = hexhexdist / 2; // sphere?.3651:euclid?.2611:.2849;
|
||||
double x = cgi.hexhexdist / 2; // sphere?.3651:euclid?.2611:.2849;
|
||||
|
||||
gridlinef(V, ddspin(c,i,-M_PI/S3) * xpush0(x),
|
||||
ddspin(c,i,M_PI/S3) * xpush0(x),
|
||||
@ -2291,8 +2291,8 @@ namespace linepatterns {
|
||||
cell *c1 = createMov(c, (i+3) % 7);
|
||||
cell *c2 = createMov(c, (i+4) % 7);
|
||||
if(polarb50(c1) != a && polarb50(c2) != a)
|
||||
gridlinef(V, ddspin(c,i,M_PI*5/7) * xpush0(tessf/2),
|
||||
ddspin(c,i,M_PI*9/7) * xpush0(tessf/2),
|
||||
gridlinef(V, ddspin(c,i,M_PI*5/7) * xpush0(cgi.tessf/2),
|
||||
ddspin(c,i,M_PI*9/7) * xpush0(cgi.tessf/2),
|
||||
col, 1 + vid.linequality);
|
||||
}
|
||||
break;
|
||||
@ -2300,15 +2300,15 @@ namespace linepatterns {
|
||||
|
||||
case patPalacelike:
|
||||
if(pseudohept(c)) for(int i=0; i<7; i++)
|
||||
gridlinef(V, ddspin(c,i,M_PI*5/7) * xpush0(tessf/2),
|
||||
ddspin(c,i,M_PI*9/7) * xpush0(tessf/2),
|
||||
gridlinef(V, ddspin(c,i,M_PI*5/7) * xpush0(cgi.tessf/2),
|
||||
ddspin(c,i,M_PI*9/7) * xpush0(cgi.tessf/2),
|
||||
col, 1 + vid.linequality);
|
||||
break;
|
||||
|
||||
case patBigTriangles: {
|
||||
if(is_master(c) && !euclid) for(int i=0; i<S7; i++)
|
||||
if(c->master->move(i) && c->master->move(i) < c->master) {
|
||||
gridlinef(V, C0, xspinpush0(-2*M_PI*i/S7 - master_to_c7_angle(), tessf), col, 2 + vid.linequality);
|
||||
gridlinef(V, C0, xspinpush0(-2*M_PI*i/S7 - master_to_c7_angle(), cgi.tessf), col, 2 + vid.linequality);
|
||||
}
|
||||
break;
|
||||
}
|
||||
@ -2316,7 +2316,7 @@ namespace linepatterns {
|
||||
case patBigRings: {
|
||||
if(is_master(c) && !euclid) for(int i=0; i<S7; i++)
|
||||
if(c->master->move(i) && c->master->move(i) < c->master && c->master->move(i)->dm4 == c->master->dm4)
|
||||
gridlinef(V, C0, xspinpush0(-2*M_PI*i/S7 - master_to_c7_angle(), tessf), col, 2 + vid.linequality);
|
||||
gridlinef(V, C0, xspinpush0(-2*M_PI*i/S7 - master_to_c7_angle(), cgi.tessf), col, 2 + vid.linequality);
|
||||
break;
|
||||
}
|
||||
|
||||
@ -2362,10 +2362,10 @@ namespace linepatterns {
|
||||
}
|
||||
else {
|
||||
int p = emeraldval(c);
|
||||
double hdist = hdist0(heptmove[0] * heptmove[2] * C0);
|
||||
double hdist = hdist0(cgi.heptmove[0] * cgi.heptmove[2] * C0);
|
||||
if(pseudohept(c) && (p/4 == 10 || p/4 == 8))
|
||||
for(int i=0; i<S7; i++) if(c->move(i) && emeraldval(c->move(i)) == p-4) {
|
||||
gridlinef(V, C0, tC0(heptmove[i]), col, 2 + vid.linequality);
|
||||
gridlinef(V, C0, tC0(cgi.heptmove[i]), col, 2 + vid.linequality);
|
||||
gridlinef(V, C0, xspinpush0(-i * ALPHA, -hdist/2), col, 2 + vid.linequality);
|
||||
}
|
||||
}
|
||||
@ -2392,8 +2392,8 @@ namespace linepatterns {
|
||||
heptagon *h2 = c->master->modmove(i-1);
|
||||
if(!h1 || !h2) continue;
|
||||
if(emeraldval(h1->c7)/4 == 8 && emeraldval(h2->c7)/4 == 8)
|
||||
gridlinef(V, ddspin(c,i,M_PI*5/7) * xpush0(tessf/2),
|
||||
ddspin(c,i,M_PI*9/7) * xpush0(tessf/2),
|
||||
gridlinef(V, ddspin(c,i,M_PI*5/7) * xpush0(cgi.tessf/2),
|
||||
ddspin(c,i,M_PI*9/7) * xpush0(cgi.tessf/2),
|
||||
col, 1 + vid.linequality);
|
||||
}
|
||||
}
|
||||
|
||||
2455
polygons.cpp
2455
polygons.cpp
File diff suppressed because it is too large
Load Diff
@ -1316,7 +1316,7 @@ void markers() {
|
||||
draw_ghost(ghost);
|
||||
|
||||
if(gmatrix.count(track[0])) {
|
||||
hyperpoint h = WDIM == 2 && GDIM == 3 ? zpush(geom3::FLOOR - geom3::human_height/80) * C0 : C0;
|
||||
hyperpoint h = WDIM == 2 && GDIM == 3 ? zpush(cgi.FLOOR - cgi.human_height/80) * C0 : C0;
|
||||
for(ld z=-start_line_width; z<=start_line_width; z+=0.1)
|
||||
curvepoint(ggmatrix(track[0]) * straight * parabolic1(z) * h);
|
||||
queuecurve(0xFFFFFFFF, 0, PPR::BFLOOR);
|
||||
|
||||
2
rug.cpp
2
rug.cpp
@ -476,7 +476,7 @@ void buildTorusRug() {
|
||||
println(hlog, "factor = ", make_tuple(xfactor, yfactor, factor));
|
||||
println(hlog, "scales = ", make_tuple(xscale, yscale));
|
||||
|
||||
modelscale = xscale / crossf;
|
||||
modelscale = xscale / cgi.crossf;
|
||||
}
|
||||
|
||||
map<pair<int, int>, rugpoint*> glues;
|
||||
|
||||
@ -677,7 +677,6 @@ void apply() {
|
||||
}
|
||||
}
|
||||
apply_animated_parameters();
|
||||
if(need_reset_geometry) resetGeometry(), need_reset_geometry = false;
|
||||
calcparam();
|
||||
}
|
||||
|
||||
@ -1120,12 +1119,12 @@ reaction_t add_to_frame;
|
||||
#if CAP_STARTANIM
|
||||
void draw_ghost(const transmatrix V, int id) {
|
||||
if(id % 13 == 0) {
|
||||
queuepoly(V, shMiniGhost, 0xFFFF00C0);
|
||||
queuepoly(V, shMiniEyes, 0xFF);
|
||||
queuepoly(V, cgi.shMiniGhost, 0xFFFF00C0);
|
||||
queuepoly(V, cgi.shMiniEyes, 0xFF);
|
||||
}
|
||||
else {
|
||||
queuepoly(V, shMiniGhost, 0xFFFFFFC0);
|
||||
queuepoly(V, shMiniEyes, 0xFF);
|
||||
queuepoly(V, cgi.shMiniGhost, 0xFFFFFFC0);
|
||||
queuepoly(V, cgi.shMiniEyes, 0xFF);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
56
shmup.cpp
56
shmup.cpp
@ -950,7 +950,7 @@ void profile(const char *buf) {
|
||||
}
|
||||
*/
|
||||
|
||||
#define SCALE scalefactor
|
||||
#define SCALE cgi.scalefactor
|
||||
#define SCALE2 (SCALE*SCALE)
|
||||
|
||||
namespace shmup {
|
||||
@ -1076,7 +1076,7 @@ bool trackroute(monster *m, transmatrix goal, double spd) {
|
||||
d += spd;
|
||||
transmatrix nat = m->pat * rspintox(mat * C0) * xpush(d);
|
||||
|
||||
// queuepoly(nat, shKnife, 0xFFFFFFC0);
|
||||
// queuepoly(nat, cgi.shKnife, 0xFFFFFFC0);
|
||||
|
||||
cell *c2 = findbaseAround(nat, c);
|
||||
if(c2 != c && !passable_for(m->type, c2, c, P_CHAIN | P_ONPLAYER)) {
|
||||
@ -1418,7 +1418,7 @@ void roseCurrents(transmatrix& nat, monster *m, int delta) {
|
||||
|
||||
hyperpoint keytarget(int i) {
|
||||
double d = 2 + sin(curtime / 350.);
|
||||
return pc[i]->pat * cpush0(WDIM == 3 ? 2 : 0, d * scalefactor);
|
||||
return pc[i]->pat * cpush0(WDIM == 3 ? 2 : 0, d * cgi.scalefactor);
|
||||
}
|
||||
|
||||
/* int charidof(int pid) {
|
||||
@ -1428,8 +1428,8 @@ hyperpoint keytarget(int i) {
|
||||
return 0;
|
||||
} */
|
||||
|
||||
ld getSwordSize() { return sword_size; }
|
||||
ld getHornsSize() { return scalefactor * 0.33; }
|
||||
ld getSwordSize() { return cgi.sword_size; }
|
||||
ld getHornsSize() { return cgi.scalefactor * 0.33; }
|
||||
|
||||
// used in 3D
|
||||
transmatrix swordmatrix[MAXPLAYER];
|
||||
@ -1777,7 +1777,7 @@ void movePlayer(monster *m, int delta) {
|
||||
|
||||
if(isReptile(m->base->wall)) m->base->wparam = reptilemax();
|
||||
|
||||
int steps = 1 + abs(int(playergo[cpid] / (.2 * scalefactor)));
|
||||
int steps = 1 + abs(int(playergo[cpid] / (.2 * cgi.scalefactor)));
|
||||
|
||||
playergo[cpid] /= steps;
|
||||
|
||||
@ -2385,7 +2385,7 @@ transmatrix frontpush(ld x) {
|
||||
|
||||
ld collision_distance(monster *bullet, monster *target) {
|
||||
if(target->type == moAsteroid)
|
||||
return SCALE * 0.15 + asteroid_size[target->hitpoints & 7];
|
||||
return SCALE * 0.15 + cgi.asteroid_size[target->hitpoints & 7];
|
||||
return SCALE * 0.3;
|
||||
}
|
||||
|
||||
@ -3601,12 +3601,12 @@ bool drawMonster(const transmatrix& V, cell *c, const transmatrix*& Vboat, trans
|
||||
color_t incolor = magic ? 0x0060C0FF : 0x804000FF;
|
||||
|
||||
if(WDIM == 2) {
|
||||
queuepoly(Vboat0, shBoatOuter, outcolor);
|
||||
queuepoly(Vboat0, shBoatInner, incolor);
|
||||
queuepoly(Vboat0, cgi.shBoatOuter, outcolor);
|
||||
queuepoly(Vboat0, cgi.shBoatInner, incolor);
|
||||
}
|
||||
if(WDIM == 3) {
|
||||
queuepoly(mscale(Vboat0, scalefactor/2), shBoatOuter, outcolor);
|
||||
queuepoly(mscale(Vboat0, scalefactor/2-0.01), shBoatInner, incolor);
|
||||
queuepoly(mscale(Vboat0, cgi.scalefactor/2), cgi.shBoatOuter, outcolor);
|
||||
queuepoly(mscale(Vboat0, cgi.scalefactor/2-0.01), cgi.shBoatInner, incolor);
|
||||
}
|
||||
}
|
||||
|
||||
@ -3651,7 +3651,7 @@ bool drawMonster(const transmatrix& V, cell *c, const transmatrix*& Vboat, trans
|
||||
queuechr(h, vid.fsize, '+', iinf[keyresult[cpid]].color);
|
||||
else {
|
||||
dynamicval<color_t> p(poly_outline, darkena(iinf[keyresult[cpid]].color, 0, 255));
|
||||
queuepoly(rgpushxto0(h) * cspin(0, 1, ticks / 140.), shGem[1], 0);
|
||||
queuepoly(rgpushxto0(h) * cspin(0, 1, ticks / 140.), cgi.shGem[1], 0);
|
||||
}
|
||||
}
|
||||
|
||||
@ -3667,39 +3667,39 @@ bool drawMonster(const transmatrix& V, cell *c, const transmatrix*& Vboat, trans
|
||||
else
|
||||
col = (minf[m->parenttype].color << 8) | 0xFF;
|
||||
if(getcs().charid >= 4) {
|
||||
queuepoly(mmscale(view, 1.15), shPHead, col);
|
||||
ShadowV(view, shPHead);
|
||||
queuepoly(mmscale(view, 1.15), cgi.shPHead, col);
|
||||
ShadowV(view, cgi.shPHead);
|
||||
}
|
||||
else if(peace::on) {
|
||||
queuepolyat(mmscale(view, 1.15), shDisk, col, PPR::MISSILE);
|
||||
ShadowV(view, shPHead);
|
||||
queuepolyat(mmscale(view, 1.15), cgi.shDisk, col, PPR::MISSILE);
|
||||
ShadowV(view, cgi.shPHead);
|
||||
}
|
||||
else {
|
||||
transmatrix t = view * spin(curtime / 50.0);
|
||||
queuepoly(WDIM == 3 ? t : DIM == 3 ? mscale(t, geom3::BODY) : mmscale(t, 1.15), shKnife, col);
|
||||
ShadowV(t, shKnife);
|
||||
queuepoly(WDIM == 3 ? t : DIM == 3 ? mscale(t, cgi.BODY) : mmscale(t, 1.15), cgi.shKnife, col);
|
||||
ShadowV(t, cgi.shKnife);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case moArrowTrap: {
|
||||
queuepoly(mmscale(view, 1.15), shTrapArrow, 0xFFFFFFFF);
|
||||
ShadowV(view, shTrapArrow);
|
||||
queuepoly(mmscale(view, 1.15), cgi.shTrapArrow, 0xFFFFFFFF);
|
||||
ShadowV(view, cgi.shTrapArrow);
|
||||
break;
|
||||
}
|
||||
case moTongue: {
|
||||
queuepoly(mmscale(view, 1.15), shTongue, (minf[m->parenttype].color << 8) | 0xFF);
|
||||
ShadowV(view, shTongue);
|
||||
queuepoly(mmscale(view, 1.15), cgi.shTongue, (minf[m->parenttype].color << 8) | 0xFF);
|
||||
ShadowV(view, cgi.shTongue);
|
||||
break;
|
||||
}
|
||||
case moFireball: case moAirball: { // case moLightningBolt:
|
||||
queuepoly(mmscale(view, 1.15), shPHead, (minf[m->type].color << 8) | 0xFF);
|
||||
ShadowV(view, shPHead);
|
||||
queuepoly(mmscale(view, 1.15), cgi.shPHead, (minf[m->type].color << 8) | 0xFF);
|
||||
ShadowV(view, cgi.shPHead);
|
||||
break;
|
||||
}
|
||||
case moFlailBullet: case moCrushball: {
|
||||
transmatrix t = view * spin(curtime / 50.0);
|
||||
queuepoly(mmscale(t, 1.15), shFlailMissile, (minf[m->type].color << 8) | 0xFF);
|
||||
ShadowV(view, shFlailMissile);
|
||||
queuepoly(mmscale(t, 1.15), cgi.shFlailMissile, (minf[m->type].color << 8) | 0xFF);
|
||||
ShadowV(view, cgi.shFlailMissile);
|
||||
break;
|
||||
}
|
||||
case moAsteroid: {
|
||||
@ -3707,11 +3707,11 @@ bool drawMonster(const transmatrix& V, cell *c, const transmatrix*& Vboat, trans
|
||||
transmatrix t = view;
|
||||
if(WDIM == 3) t = face_the_player(t);
|
||||
t = t * spin(curtime / 500.0);
|
||||
ShadowV(t, shAsteroid[m->hitpoints & 7]);
|
||||
ShadowV(t, cgi.shAsteroid[m->hitpoints & 7]);
|
||||
if(WDIM == 2) t = mmscale(t, 1.15);
|
||||
color_t col = WDIM == 3 ? 0xFFFFFF : minf[m->type].color;
|
||||
col <<= 8;
|
||||
queuepoly(t, shAsteroid[m->hitpoints & 7], col | 0xFF);
|
||||
queuepoly(t, cgi.shAsteroid[m->hitpoints & 7], col | 0xFF);
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
55
system.cpp
55
system.cpp
@ -6,8 +6,6 @@
|
||||
|
||||
namespace hr {
|
||||
|
||||
bool need_reset_geometry = true;
|
||||
|
||||
bool game_active;
|
||||
|
||||
bool cblind;
|
||||
@ -1091,39 +1089,48 @@ namespace gamestack {
|
||||
eGeometry geometry;
|
||||
eVariation variation;
|
||||
bool shmup;
|
||||
void store();
|
||||
void restore();
|
||||
};
|
||||
|
||||
vector<gamedata> gd;
|
||||
|
||||
bool pushed() { return isize(gd); }
|
||||
|
||||
void gamedata::store() {
|
||||
hmap = currentmap;
|
||||
cwt = hr::cwt;
|
||||
geometry = hr::geometry;
|
||||
shmup = hr::shmup::on;
|
||||
variation = hr::variation;
|
||||
d = *current_display;
|
||||
}
|
||||
|
||||
void gamedata::restore() {
|
||||
currentmap = hmap;
|
||||
hr::cwt = cwt;
|
||||
hr::geometry = geometry;
|
||||
hr::variation = variation;
|
||||
if(shmup::on) shmup::clearMonsters();
|
||||
shmup::on = shmup;
|
||||
check_cgi();
|
||||
cgi.require_basics();
|
||||
*current_display = d;
|
||||
bfs();
|
||||
}
|
||||
|
||||
void push() {
|
||||
if(geometry) {
|
||||
printf("ERROR: push implemented only in non-hyperbolic geometry\n");
|
||||
exit(1);
|
||||
}
|
||||
gamedata gdn;
|
||||
gdn.hmap = currentmap;
|
||||
gdn.cwt = cwt;
|
||||
gdn.geometry = geometry;
|
||||
gdn.shmup = shmup::on;
|
||||
gdn.variation = variation;
|
||||
gdn.d = *current_display;
|
||||
gd.push_back(gdn);
|
||||
gd.emplace_back();
|
||||
gd.back().store();
|
||||
}
|
||||
|
||||
void pop() {
|
||||
gamedata& gdn = gd[isize(gd)-1];
|
||||
currentmap = gdn.hmap;
|
||||
cwt = gdn.cwt;
|
||||
geometry = gdn.geometry;
|
||||
variation = gdn.variation;
|
||||
if(shmup::on) shmup::clearMonsters();
|
||||
shmup::on = gdn.shmup;
|
||||
resetGeometry();
|
||||
*current_display = gdn.d;
|
||||
gd.back().restore();
|
||||
gd.pop_back();
|
||||
bfs();
|
||||
}
|
||||
|
||||
};
|
||||
@ -1215,8 +1222,6 @@ void set_geometry(eGeometry target) {
|
||||
#endif
|
||||
if(DIM == 3 && old_DIM == 2 && pmodel == mdDisk) pmodel = mdPerspective;
|
||||
if(DIM == 2 && pmodel == mdPerspective) pmodel = mdDisk;
|
||||
|
||||
need_reset_geometry = true;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1231,7 +1236,6 @@ void set_variation(eVariation target) {
|
||||
target = eVariation::pure;
|
||||
}
|
||||
variation = target;
|
||||
need_reset_geometry = true;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1256,7 +1260,6 @@ void switch_game_mode(char switchWhat) {
|
||||
case rg::chaos:
|
||||
if(tactic::on) firstland = laIce;
|
||||
yendor::on = tactic::on = princess::challenge = false;
|
||||
need_reset_geometry = true;
|
||||
chaosmode = !chaosmode;
|
||||
if(bounded) set_geometry(gNormal);
|
||||
racing::on = false;
|
||||
@ -1272,7 +1275,6 @@ void switch_game_mode(char switchWhat) {
|
||||
gp::param = gp::loc(1, 1);
|
||||
#endif
|
||||
shmup::on = false;
|
||||
need_reset_geometry = true;
|
||||
tour::on = !tour::on;
|
||||
racing::on = false;
|
||||
break;
|
||||
@ -1359,7 +1361,8 @@ void start_game() {
|
||||
restart:
|
||||
game_active = true;
|
||||
gamegen_failure = false;
|
||||
if(need_reset_geometry) resetGeometry(), need_reset_geometry = false;
|
||||
check_cgi();
|
||||
cgi.require_basics();
|
||||
initcells();
|
||||
expansion.reset();
|
||||
|
||||
|
||||
@ -337,7 +337,7 @@ bool texture_config::apply(cell *c, const transmatrix &V, color_t col) {
|
||||
|
||||
if(config.tstate == tsAdjusting) {
|
||||
dynamicval<color_t> d(poly_outline, slave_color);
|
||||
draw_floorshape(c, V, shFullFloor, 0, PPR::LINE);
|
||||
draw_floorshape(c, V, cgi.shFullFloor, 0, PPR::LINE);
|
||||
|
||||
curvepoint(V * C0);
|
||||
for(int i=0; i<c->type; i++)
|
||||
@ -349,13 +349,13 @@ bool texture_config::apply(cell *c, const transmatrix &V, color_t col) {
|
||||
try {
|
||||
auto& mi = texture_map.at(si.id);
|
||||
|
||||
set_floor(shFullFloor);
|
||||
set_floor(cgi.shFullFloor);
|
||||
qfi.tinf = &mi;
|
||||
qfi.spin = applyPatterndir(c, si);
|
||||
|
||||
if(grid_color) {
|
||||
dynamicval<color_t> d(poly_outline, grid_color);
|
||||
draw_floorshape(c, V, shFullFloor, 0, PPR::FLOOR);
|
||||
draw_floorshape(c, V, cgi.shFullFloor, 0, PPR::FLOOR);
|
||||
}
|
||||
|
||||
if(using_aura()) {
|
||||
@ -1571,7 +1571,6 @@ int textureArgs() {
|
||||
else if(argis("-txcl")) {
|
||||
PHASE(3); drawscreen();
|
||||
config.load();
|
||||
need_reset_geometry = true;
|
||||
}
|
||||
|
||||
else return 1;
|
||||
|
||||
108
usershapes.cpp
Normal file
108
usershapes.cpp
Normal file
@ -0,0 +1,108 @@
|
||||
#if CAP_SHAPES
|
||||
|
||||
// HyperRogue, some functions for user-defined shapes
|
||||
|
||||
// Copyright (C) 2011-2019 Zeno Rogue, see 'hyper.cpp' for details
|
||||
|
||||
namespace hr {
|
||||
|
||||
int usershape_changes;
|
||||
|
||||
array<map<int, usershape*>, mapeditor::USERSHAPEGROUPS> usershapes;
|
||||
void initShape(int sg, int id) {
|
||||
|
||||
if(!usershapes[sg][id]) {
|
||||
usershape *us = new usershape;
|
||||
usershapes[sg][id] = us;
|
||||
|
||||
for(int i=0; i<USERLAYERS; i++) {
|
||||
us->d[i].prio = PPR((sg == 3 ? 1:50) + i);
|
||||
|
||||
us->d[i].rots = 1;
|
||||
us->d[i].sym = 0;
|
||||
us->d[i].shift = C0;
|
||||
us->d[i].spin = Cx1;
|
||||
us->d[i].color = 0;
|
||||
us->d[i].zlevel = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
basic_textureinfo user_triangles_texture;
|
||||
|
||||
void geometry_information::pushShape(usershapelayer& ds) {
|
||||
|
||||
if(ds.list.empty()) return;
|
||||
if(DIM == 3) last->flags |= POLY_TRIANGLES;
|
||||
|
||||
transmatrix T = rgpushxto0(ds.shift) * rspintox(ds.spin);
|
||||
|
||||
int z = DIM == 3 ? 3 : 1;
|
||||
|
||||
for(int r=0; r<ds.rots; r++) {
|
||||
for(int i=0; i<isize(ds.list)/z*z; i++)
|
||||
hpcpush(T * spin(2*M_PI*r/ds.rots) * ds.list[i]);
|
||||
|
||||
if(ds.sym) {
|
||||
|
||||
transmatrix mirrortrans = Id; mirrortrans[1][1] = -1;
|
||||
for(int i=isize(ds.list)-1; i>=0; i--)
|
||||
hpcpush(T * spin(2*M_PI*r/ds.rots) * mirrortrans * ds.list[i]);
|
||||
}
|
||||
}
|
||||
|
||||
if(DIM == 2) hpcpush(T * ds.list[0]);
|
||||
|
||||
#if MAXMDIM >= 4
|
||||
if(DIM == 3) {
|
||||
auto& utt = user_triangles_texture;
|
||||
utt.texture_id = floor_textures->renderedTexture;
|
||||
ds.texture_offset = isize(utt.tvertices);
|
||||
for(int i=0; i<isize(ds.list)-2; i+=3) {
|
||||
hyperpoint h = orthogonal_of_C0(ds.list[i], ds.list[i+1], ds.list[i+2]);
|
||||
ld rad = hypot_d(3, h);
|
||||
ld factor = 0.49 + (0.17 * h[2] + 0.13 * h[1] + 0.20 * h[0]) / rad;
|
||||
for(int i=0; i<3; i++)
|
||||
utt.tvertices.push_back(glhr::makevertex(-1, factor, 0));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void geometry_information::prepare_usershapes() {
|
||||
hpc.resize(prehpc);
|
||||
last = NULL;
|
||||
DEBB(DF_POLY, ("hpc = ", prehpc));
|
||||
|
||||
user_triangles_texture.tvertices.clear();
|
||||
|
||||
for(int i=0; i<mapeditor::USERSHAPEGROUPS; i++) for(auto usp: usershapes[i]) {
|
||||
auto us = usp.second;
|
||||
if(!us) continue;
|
||||
for(int l=0; l<USERLAYERS; l++) {
|
||||
bshape(ushr[&us->d[l]], us->d[l].prio);
|
||||
pushShape(us->d[l]);
|
||||
finishshape();
|
||||
}
|
||||
}
|
||||
|
||||
static int qhpc0;
|
||||
int qhpc = isize(hpc);
|
||||
if(qhpc != qhpc0 && (debugflags & (DF_GEOM | DF_POLY))) {
|
||||
println(hlog, "qhpc = ", qhpc0=qhpc, " (", prehpc, "+", qhpc-prehpc, ")");
|
||||
println(hlog, "shapes = ", isize(allshapes));
|
||||
int inve=0, issi=0, vcon=0, ccon=0;
|
||||
for(auto sh: allshapes) {
|
||||
if(sh->flags & POLY_INVERSE) inve++;
|
||||
if(sh->flags & POLY_ISSIDE) issi++;
|
||||
if(sh->flags & POLY_VCONVEX) vcon++;
|
||||
if(sh->flags & POLY_CCONVEX) ccon++;
|
||||
}
|
||||
println(hlog, format("inverse = %d isside = %d vcon = %d ccon = %d", inve, issi, vcon, ccon));
|
||||
}
|
||||
|
||||
initPolyForGL();
|
||||
}
|
||||
|
||||
}
|
||||
#endif
|
||||
Loading…
x
Reference in New Issue
Block a user