mirrors/hyperrogue
1
0
Fork 0
mirror of https://github.com/zenorogue/hyperrogue.git synced 2024-12-24 17:10:36 +00:00
Code Issues Releases Wiki Activity

type color_t should now be consistently used for colors; reimplemented drawqueue in OO fashion

Browse Source
This commit is contained in:
Zeno Rogue 2018-09-04 19:53:42 +02:00
parent 491183c375
commit 1ab460ffb1
29 changed files with 726 additions and 776 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
basegraph.cpp
View File

@ -65,24 +65,16 @@ TTF_Font *font[256];
#if CAP_SDL #if CAP_SDL
SDL_Surface *s, *s_screen; SDL_Surface *s, *s_screen;
int qpixel_pixel_outside; color_t qpixel_pixel_outside;
int& qpixel(SDL_Surface *surf, int x, int y) { color_t& qpixel(SDL_Surface *surf, int x, int y) {
if(x<0 || y<0 || x >= surf->w || y >= surf->h) return qpixel_pixel_outside; if(x<0 || y<0 || x >= surf->w || y >= surf->h) return qpixel_pixel_outside;
char *p = (char*) surf->pixels; char *p = (char*) surf->pixels;
p += y * surf->pitch; p += y * surf->pitch;
int *pi = (int*) (p); color_t *pi = (color_t*) (p);
return pi[x]; return pi[x];
} }
int qpixel3(SDL_Surface *surf, int x, int y) {
if(x<0 || y<0 || x >= surf->w || y >= surf->h) return qpixel_pixel_outside;
char *p = (char*) surf->pixels;
p += y * surf->pitch;
p += x;
int *pi = (int*) (p);
return pi[0];
}
#endif #endif
#if CAP_SDLTTF #if CAP_SDLTTF
@ -266,7 +258,7 @@ bool model_needs_depth() {
return pmodel == mdBall || pmodel == mdHyperboloid || pmodel == mdHemisphere; return pmodel == mdBall || pmodel == mdHyperboloid || pmodel == mdHemisphere;
} }
void setGLProjection(int col) { void setGLProjection(color_t col) {
DEBB(DF_GRAPH, (debugfile,"setGLProjection\n")); DEBB(DF_GRAPH, (debugfile,"setGLProjection\n"));
GLERR("pre_setGLProjection"); GLERR("pre_setGLProjection");
@ -499,7 +491,7 @@ namespace glhr { void texture_vertices(GLfloat *f, int qty, int stride = 2) {
GLfloat otver[24]; GLfloat otver[24];
vector<glhr::textured_vertex> tver(4); vector<glhr::textured_vertex> tver(4);
bool gl_print(int x, int y, int shift, int size, const char *s, int color, int align) { bool gl_print(int x, int y, int shift, int size, const char *s, color_t color, int align) {
int gsiz = size; int gsiz = size;
if(size > vid.fsize || size > 72) gsiz = 72; if(size > vid.fsize || size > 72) gsiz = 72;
@ -594,7 +586,7 @@ void gdpush(int t) {
graphdata.push_back(t); graphdata.push_back(t);
} }
bool displaychr(int x, int y, int shift, int size, char chr, int col) { bool displaychr(int x, int y, int shift, int size, char chr, color_t col) {
gdpush(2); gdpush(x); gdpush(y); gdpush(8); gdpush(2); gdpush(x); gdpush(y); gdpush(8);
gdpush(col); gdpush(size); gdpush(0); gdpush(col); gdpush(size); gdpush(0);
gdpush(1); gdpush(chr); gdpush(1); gdpush(chr);
@ -621,7 +613,7 @@ void gdpush_utf8(const string& s) {
graphdata[g] = q; graphdata[g] = q;
} }
bool displayfr(int x, int y, int b, int size, const string &s, int color, int align) { bool displayfr(int x, int y, int b, int size, const string &s, color_t color, int align) {
gdpush(2); gdpush(x); gdpush(y); gdpush(align); gdpush(2); gdpush(x); gdpush(y); gdpush(align);
gdpush(color); gdpush(size); gdpush(b); gdpush(color); gdpush(size); gdpush(b);
gdpush_utf8(s); gdpush_utf8(s);
@ -633,16 +625,16 @@ bool displayfr(int x, int y, int b, int size, const string &s, int color, int al
my >= -size*3/4 && my <= +size*3/4; my >= -size*3/4 && my <= +size*3/4;
} }
bool displaystr(int x, int y, int shift, int size, const string &s, int color, int align) { bool displaystr(int x, int y, int shift, int size, const string &s, color_t color, int align) {
return displayfr(x,y,0,size,s,color,align); return displayfr(x,y,0,size,s,color,align);
} }
bool displaystr(int x, int y, int shift, int size, char const *s, int color, int align) { bool displaystr(int x, int y, int shift, int size, char const *s, color_t color, int align) {
return displayfr(x,y,0,size,s,color,align); return displayfr(x,y,0,size,s,color,align);
} }
#else #else
bool displaystr(int x, int y, int shift, int size, const char *str, int color, int align) { bool displaystr(int x, int y, int shift, int size, const char *str, color_t color, int align) {
if(strlen(str) == 0) return false; if(strlen(str) == 0) return false;
@ -687,7 +679,7 @@ bool displaystr(int x, int y, int shift, int size, const char *str, int color, i
SDL_Surface* txt2 = SDL_DisplayFormat(txt); SDL_Surface* txt2 = SDL_DisplayFormat(txt);
SDL_LockSurface(txt2); SDL_LockSurface(txt2);
SDL_LockSurface(s); SDL_LockSurface(s);
int c0 = qpixel(txt2, 0, 0); color_t c0 = qpixel(txt2, 0, 0);
for(int yy=0; yy<rect.h; yy++) for(int yy=0; yy<rect.h; yy++)
for(int xx=0; xx<rect.w; xx++) if(qpixel(txt2, xx, yy) != c0) for(int xx=0; xx<rect.w; xx++) if(qpixel(txt2, xx, yy) != c0)
qpixel(s, rect.x+xx-shift, rect.y+yy) |= color & 0xFF0000, qpixel(s, rect.x+xx-shift, rect.y+yy) |= color & 0xFF0000,
@ -705,11 +697,11 @@ bool displaystr(int x, int y, int shift, int size, const char *str, int color, i
#endif #endif
} }
bool displaystr(int x, int y, int shift, int size, const string &s, int color, int align) { bool displaystr(int x, int y, int shift, int size, const string &s, color_t color, int align) {
return displaystr(x, y, shift, size, s.c_str(), color, align); return displaystr(x, y, shift, size, s.c_str(), color, align);
} }
bool displayfrSP(int x, int y, int sh, int b, int size, const string &s, int color, int align, int p) { bool displayfrSP(int x, int y, int sh, int b, int size, const string &s, color_t color, int align, int p) {
if(b) { if(b) {
displaystr(x-b, y, 0, size, s, p, align); displaystr(x-b, y, 0, size, s, p, align);
displaystr(x+b, y, 0, size, s, p, align); displaystr(x+b, y, 0, size, s, p, align);
@ -726,11 +718,11 @@ bool displayfrSP(int x, int y, int sh, int b, int size, const string &s, int col
return displaystr(x, y, 0, size, s, color, align); return displaystr(x, y, 0, size, s, color, align);
} }
bool displayfr(int x, int y, int b, int size, const string &s, int color, int align) { bool displayfr(int x, int y, int b, int size, const string &s, color_t color, int align) {
return displayfrSP(x, y, 0, b, size, s, color, align, poly_outline>>8); return displayfrSP(x, y, 0, b, size, s, color, align, poly_outline>>8);
} }
bool displaychr(int x, int y, int shift, int size, char chr, int col) { bool displaychr(int x, int y, int shift, int size, char chr, color_t col) {
char buf[2]; char buf[2];
buf[0] = chr; buf[1] = 0; buf[0] = chr; buf[1] = 0;
@ -738,7 +730,7 @@ bool displaychr(int x, int y, int shift, int size, char chr, int col) {
} }
#endif #endif
bool displaynum(int x, int y, int shift, int size, int col, int val, string title) { bool displaynum(int x, int y, int shift, int size, color_t col, int val, string title) {
char buf[64]; char buf[64];
sprintf(buf, "%d", val); sprintf(buf, "%d", val);
bool b1 = displayfr(x-8, y, 1, size, buf, col, 16); bool b1 = displayfr(x-8, y, 1, size, buf, col, 16);
@ -803,7 +795,7 @@ void addMessage(string s, char spamtype) {
addMessageToLog(m, msgs); addMessageToLog(m, msgs);
} }
int colormix(int a, int b, int c) { color_t colormix(color_t a, color_t b, color_t c) {
for(int p=0; p<3; p++) for(int p=0; p<3; p++)
part(a, p) = part(a,p) + (part(b,p) - part(a,p)) * part(c,p) / 255; part(a, p) = part(a,p) + (part(b,p) - part(a,p)) * part(c,p) / 255;
return a; return a;
@ -825,7 +817,7 @@ ld realradius() {
return vradius; return vradius;
} }
void drawmessage(const string& s, int& y, int col) { void drawmessage(const string& s, int& y, color_t col) {
int rrad = (int) realradius(); int rrad = (int) realradius();
int space; int space;
if(y > vid.ycenter + rrad * vid.stretch) if(y > vid.ycenter + rrad * vid.stretch)
@ -879,7 +871,7 @@ void drawmessages() {
for(int j=isize(msgs)-1; j>=0; j--) { for(int j=isize(msgs)-1; j>=0; j--) {
int age = msgs[j].flashout * (t - msgs[j].stamp); int age = msgs[j].flashout * (t - msgs[j].stamp);
poly_outline = gradient(bordcolor, backcolor, 0, age, 256*vid.flashtime) << 8; poly_outline = gradient(bordcolor, backcolor, 0, age, 256*vid.flashtime) << 8;
int col = gradient(forecolor, backcolor, 0, age, 256*vid.flashtime); color_t col = gradient(forecolor, backcolor, 0, age, 256*vid.flashtime);
drawmessage(fullmsg(msgs[j]), y, col); drawmessage(fullmsg(msgs[j]), y, col);
} }
} }
@ -894,19 +886,18 @@ void drawmessages() {
} }
} }
int gradient(int c0, int c1, ld v0, ld v, ld v1) { color_t gradient(color_t c0, color_t c1, ld v0, ld v, ld v1) {
int vv = int(256 * ((v-v0) / (v1-v0))); int vv = int(256 * ((v-v0) / (v1-v0)));
int c = 0; color_t c = 0;
for(int a=0; a<3; a++) { for(int a=0; a<3; a++) {
int p0 = (c0 >> (8*a)) & 255; int p0 = part(c0, a);
int p1 = (c1 >> (8*a)) & 255; int p1 = part(c1, a);
int p = (p0*(256-vv) + p1*vv + 127) >> 8; part(c, a) = (p0*(256-vv) + p1*vv + 127) >> 8;
c |= p << (8*a);
} }
return c; return c;
} }
void drawCircle(int x, int y, int size, int color) { void drawCircle(int x, int y, int size, color_t color) {
if(size < 0) size = -size; if(size < 0) size = -size;
#if CAP_GL #if CAP_GL
if(vid.usingGL) { if(vid.usingGL) {
@ -961,7 +952,7 @@ void displaymm(char c, int x, int y, int rad, int size, const string& title, int
} }
} }
bool displayButtonS(int x, int y, const string& name, int col, int align, int size) { bool displayButtonS(int x, int y, const string& name, color_t col, int align, int size) {
if(displaystr(x, y, 0, size, name, col, align)) { if(displaystr(x, y, 0, size, name, col, align)) {
displaystr(x, y, 0, size, name, 0xFFFF00, align); displaystr(x, y, 0, size, name, 0xFFFF00, align);
return true; return true;
@ -969,7 +960,7 @@ bool displayButtonS(int x, int y, const string& name, int col, int align, int si
else return false; else return false;
} }
void displayColorButton(int x, int y, const string& name, int key, int align, int rad, int color, int color2) { void displayColorButton(int x, int y, const string& name, int key, int align, int rad, color_t color, color_t color2) {
if(displayfr(x, y, rad, vid.fsize, name, color, align)) { if(displayfr(x, y, rad, vid.fsize, name, color, align)) {
if(color2) displayfr(x, y, rad, vid.fsize, name, color2, align); if(color2) displayfr(x, y, rad, vid.fsize, name, color2, align);
getcstat = key; getcstat = key;

2
blizzard.cpp
View File

@ -135,7 +135,7 @@ void drawBlizzards() {
} */ } */
forCellIdEx(c2, i, bc.c) if(bc.c == mouseover || c2 == mouseover) { forCellIdEx(c2, i, bc.c) if(bc.c == mouseover || c2 == mouseover) {
int col = 0x00C00080; color_t col = 0x00C00080;
if(c2 == mouseover) if(c2 == mouseover)
col ^= 0xC0C00000; col ^= 0xC0C00000;
if(isPlayerOn(c2)) if(isPlayerOn(c2))

10
classes.h
View File

@ -1,10 +1,12 @@
namespace hr { namespace hr {
typedef unsigned color_t;
static const int motypes = 162; static const int motypes = 162;
struct monstertype { struct monstertype {
char glyph; char glyph;
int color; color_t color;
const char *name; const char *name;
const char *help; const char *help;
}; };
@ -77,7 +79,7 @@ static const int ittypes = 130;
struct itemtype { struct itemtype {
char glyph; char glyph;
int color; color_t color;
const char *name; const char *name;
const char *help; const char *help;
}; };
@ -126,7 +128,7 @@ static const int walltypes = 109;
struct walltype { struct walltype {
char glyph; char glyph;
int color; color_t color;
const char *name; const char *name;
const char *help; const char *help;
}; };
@ -169,7 +171,7 @@ enum eWall { waNone, waIcewall, waBarrier, waFloorA, waFloorB, waCavewall, waCav
static const int landtypes = 85; static const int landtypes = 85;
struct landtype { struct landtype {
int color; color_t color;
const char *name; const char *name;
const char *help; const char *help;
}; };

2
conformal.cpp
View File

@ -130,7 +130,7 @@ namespace spiral {
bool displayhelp = true; bool displayhelp = true;
int& bandpixel(int x, int y) { color_t& bandpixel(int x, int y) {
int i = 0; int i = 0;
while(i < isize(band) && x >= band[i]->w) while(i < isize(band) && x >= band[i]->w)
x -= band[i]->w, i++; x -= band[i]->w, i++;

20
dialogs.cpp
View File

@ -48,11 +48,11 @@ namespace dialog {
void stopzoom() { zoomoff = true; } void stopzoom() { zoomoff = true; }
bool displayfr(int x, int y, int b, int size, const string &s, int color, int align) { bool displayfr(int x, int y, int b, int size, const string &s, color_t color, int align) {
return hr::displayfr(x * zoomf + shiftx, y * zoomf + shifty, b, size * zoomf, s, color, align); return hr::displayfr(x * zoomf + shiftx, y * zoomf + shifty, b, size * zoomf, s, color, align);
} }
bool displayfr_highlight(int x, int y, int b, int size, const string &s, int color, int align, int hicolor) { bool displayfr_highlight(int x, int y, int b, int size, const string &s, color_t color, int align, int hicolor) {
bool clicked = hr::displayfr(x * zoomf + shiftx, y * zoomf + shifty, b, size * zoomf, s, color, align); bool clicked = hr::displayfr(x * zoomf + shiftx, y * zoomf + shifty, b, size * zoomf, s, color, align);
if(clicked) hr::displayfr(x * zoomf + shiftx, y * zoomf + shifty, b, size * zoomf, s, hicolor, align); if(clicked) hr::displayfr(x * zoomf + shiftx, y * zoomf + shifty, b, size * zoomf, s, hicolor, align);
return clicked; return clicked;
@ -174,7 +174,7 @@ namespace dialog {
items.push_back(it); items.push_back(it);
} }
void addInfo(string body, int color) { void addInfo(string body, color_t color) {
item it; item it;
it.type = diInfo; it.type = diInfo;
it.body = body; it.body = body;
@ -218,7 +218,7 @@ namespace dialog {
return items.size()-1; return items.size()-1;
} }
void addTitle(string body, int color, int scale) { void addTitle(string body, color_t color, int scale) {
item it; item it;
it.type = diTitle; it.type = diTitle;
it.body = body; it.body = body;
@ -227,7 +227,7 @@ namespace dialog {
items.push_back(it); items.push_back(it);
} }
void init(string title, int color, int scale, int brk) { void init(string title, color_t color, int scale, int brk) {
init(); init();
addTitle(title, color, scale); addTitle(title, color, scale);
addBreak(brk); addBreak(brk);
@ -456,17 +456,17 @@ namespace dialog {
} }
} }
unsigned int colorhistory[10] = { color_t colorhistory[10] = {
0x202020FF, 0x800000FF, 0x008000FF, 0x000080FF, 0x202020FF, 0x800000FF, 0x008000FF, 0x000080FF,
0x404040FF, 0xC0C0C0FF, 0x804000FF, 0xC0C000FF, 0x404040FF, 0xC0C0C0FF, 0x804000FF, 0xC0C000FF,
0x408040FF, 0xFFD500FF 0x408040FF, 0xFFD500FF
}, lch; }, lch;
unsigned int *palette; color_t *palette;
int colorp = 0; int colorp = 0;
unsigned int *colorPointer; color_t *colorPointer;
bool handleKeyColor(int sym, int uni) { bool handleKeyColor(int sym, int uni) {
unsigned& color = *colorPointer; unsigned& color = *colorPointer;
@ -524,7 +524,7 @@ namespace dialog {
dcenter = vid.xres - dwidth / 2; dcenter = vid.xres - dwidth / 2;
} }
int color = *colorPointer; color_t color = *colorPointer;
int ash = 8; int ash = 8;
@ -554,7 +554,7 @@ namespace dialog {
for(int i=0; i<4; i++) { for(int i=0; i<4; i++) {
int y = vid.yres / 2 + (2-i) * vid.fsize * 2; int y = vid.yres / 2 + (2-i) * vid.fsize * 2;
int col = ((i==colorp) && !mousing) ? 0xFFD500 : forecolor; color_t col = ((i==colorp) && !mousing) ? 0xFFD500 : forecolor;
displayColorButton(dcenter - dwidth/4, y, "(", 0, 16, 0, col); displayColorButton(dcenter - dwidth/4, y, "(", 0, 16, 0, col);
string rgt = ") "; rgt += "ABGR" [i]; string rgt = ") "; rgt += "ABGR" [i];

13
floorshapes.cpp
View File

@ -608,7 +608,7 @@ void set_floor(const transmatrix& spin, hpcshape& sh) {
qfi.usershape = -1; qfi.usershape = -1;
} }
void draw_shapevec(cell *c, const transmatrix& V, const vector<hpcshape> &shv, int col, PPR prio = PPR::DEFAULT) { void draw_shapevec(cell *c, const transmatrix& V, const vector<hpcshape> &shv, color_t col, PPR prio = PPR::DEFAULT) {
if(!c) queuepolyat(V, shv[0], col, prio); if(!c) queuepolyat(V, shv[0], col, prio);
else if(GOLDBERG) { else if(GOLDBERG) {
int id = gp::get_plainshape_id(c); int id = gp::get_plainshape_id(c);
@ -640,11 +640,11 @@ void draw_shapevec(cell *c, const transmatrix& V, const vector<hpcshape> &shv, i
queuepolyat(V, shv[ctof(c)], col, prio); queuepolyat(V, shv[ctof(c)], col, prio);
} }
void draw_floorshape(cell *c, const transmatrix& V, const floorshape &fsh, int col, PPR prio = PPR::DEFAULT) { void draw_floorshape(cell *c, const transmatrix& V, const floorshape &fsh, color_t col, PPR prio = PPR::DEFAULT) {
draw_shapevec(c, V, fsh.b, col, prio); draw_shapevec(c, V, fsh.b, col, prio);
} }
void draw_qfi(cell *c, const transmatrix& V, int col, PPR prio = PPR::DEFAULT, vector<hpcshape> floorshape::* tab = &floorshape::b) { void draw_qfi(cell *c, const transmatrix& V, color_t col, PPR prio = PPR::DEFAULT, vector<hpcshape> floorshape::* tab = &floorshape::b) {
if(qfi.shape) if(qfi.shape)
queuepolyat(V * qfi.spin, *qfi.shape, col, prio); queuepolyat(V * qfi.spin, *qfi.shape, col, prio);
else if(qfi.usershape >= 0) { else if(qfi.usershape >= 0) {
@ -653,10 +653,9 @@ void draw_qfi(cell *c, const transmatrix& V, int col, PPR prio = PPR::DEFAULT, v
else if(!qfi.fshape) ; else if(!qfi.fshape) ;
#if CAP_TEXTURE #if CAP_TEXTURE
else if(qfi.tinf) { else if(qfi.tinf) {
queuetable(V * qfi.spin, qfi.tinf->vertices, isize(qfi.tinf->vertices), texture::config.mesh_color, texture::config.recolor(col), prio == PPR::DEFAULT ? PPR::FLOOR : prio); auto& poly = queuetable(V * qfi.spin, qfi.tinf->vertices, isize(qfi.tinf->vertices), texture::config.mesh_color, texture::config.recolor(col), prio == PPR::DEFAULT ? PPR::FLOOR : prio);
lastptd().u.poly.tinf = qfi.tinf; poly.tinf = qfi.tinf;
if(true) poly.flags = POLY_INVERSE;
lastptd().u.poly.flags = POLY_INVERSE;
} }
#endif #endif
else draw_shapevec(c, V, (qfi.fshape->*tab), col, prio); else draw_shapevec(c, V, (qfi.fshape->*tab), col, prio);

236
graph.cpp
View File

@ -112,7 +112,7 @@ int weakfirecolor(int phase) {
return gradient(0xFF8000, 0xFF0000, -1, sin((phase + ticks)/500.0), 1); return gradient(0xFF8000, 0xFF0000, -1, sin((phase + ticks)/500.0), 1);
} }
int fc(int ph, int col, int z) { color_t fc(int ph, color_t col, int z) {
if(items[itOrbFire]) col = darkena(firecolor(ph), 0, 0xFF); if(items[itOrbFire]) col = darkena(firecolor(ph), 0, 0xFF);
if(items[itOrbAether]) col = (col &~0XFF) | (col&0xFF) / 2; if(items[itOrbAether]) col = (col &~0XFF) | (col&0xFF) / 2;
for(int i=0; i<numplayers(); i++) if(multi::playerActive(i)) for(int i=0; i<numplayers(); i++) if(multi::playerActive(i))
@ -132,7 +132,7 @@ void drawSafety() { safetyat = ticks; }
void drawShield(const transmatrix& V, eItem it) { void drawShield(const transmatrix& V, eItem it) {
#if CAP_CURVE #if CAP_CURVE
float ds = ticks / 300.; float ds = ticks / 300.;
int col = iinf[it].color; color_t col = iinf[it].color;
if(it == itOrbShield && items[itOrbTime] && !orbused[it]) if(it == itOrbShield && items[itOrbTime] && !orbused[it])
col = (col & 0xFEFEFE) / 2; col = (col & 0xFEFEFE) / 2;
if(sphere && cwt.at->land == laHalloween && !wmblack && !wmascii) if(sphere && cwt.at->land == laHalloween && !wmblack && !wmascii)
@ -148,7 +148,7 @@ void drawShield(const transmatrix& V, eItem it) {
void drawSpeed(const transmatrix& V) { void drawSpeed(const transmatrix& V) {
#if CAP_CURVE #if CAP_CURVE
ld ds = ticks / 10.; ld ds = ticks / 10.;
int col = darkena(iinf[itOrbSpeed].color, 0, 0xFF); color_t col = darkena(iinf[itOrbSpeed].color, 0, 0xFF);
for(int b=0; b<S84; b+=S14) { for(int b=0; b<S84; b+=S14) {
PRING(a) PRING(a)
curvepoint(V*xspinpush0((ds+b+a) * M_PI/S42, hexf*a/S84)); curvepoint(V*xspinpush0((ds+b+a) * M_PI/S42, hexf*a/S84));
@ -174,7 +174,7 @@ int ctof012(cell *c) {
void drawSafety(const transmatrix& V, int ct) { void drawSafety(const transmatrix& V, int ct) {
#if CAP_QUEUE #if CAP_QUEUE
ld ds = ticks / 50.; ld ds = ticks / 50.;
int col = darkena(iinf[itOrbSafety].color, 0, 0xFF); color_t col = darkena(iinf[itOrbSafety].color, 0, 0xFF);
for(int a=0; a<ct; a++) for(int a=0; a<ct; a++)
queueline(V*xspinpush0((ds+a*S84/ct) * M_PI/S42, 2*hexf), V*xspinpush0((ds+(a+(ct-1)/2)*S84/ct) * M_PI / S42, 2*hexf), col, vid.linequality); queueline(V*xspinpush0((ds+a*S84/ct) * M_PI/S42, 2*hexf), V*xspinpush0((ds+(a+(ct-1)/2)*S84/ct) * M_PI / S42, 2*hexf), col, vid.linequality);
#endif #endif
@ -183,7 +183,7 @@ void drawSafety(const transmatrix& V, int ct) {
void drawFlash(const transmatrix& V) { void drawFlash(const transmatrix& V) {
#if CAP_CURVE #if CAP_CURVE
float ds = ticks / 300.; float ds = ticks / 300.;
int col = darkena(iinf[itOrbFlash].color, 0, 0xFF); color_t col = darkena(iinf[itOrbFlash].color, 0, 0xFF);
col &= ~1; col &= ~1;
for(int u=0; u<5; u++) { for(int u=0; u<5; u++) {
ld rad = hexf * (2.5 + .5 * sin(ds+u*.3)); ld rad = hexf * (2.5 + .5 * sin(ds+u*.3));
@ -196,7 +196,7 @@ void drawFlash(const transmatrix& V) {
void drawLove(const transmatrix& V, int hdir) { void drawLove(const transmatrix& V, int hdir) {
#if CAP_CURVE #if CAP_CURVE
float ds = ticks / 300.; float ds = ticks / 300.;
int col = darkena(iinf[itOrbLove].color, 0, 0xFF); color_t col = darkena(iinf[itOrbLove].color, 0, 0xFF);
col &= ~1; col &= ~1;
for(int u=0; u<5; u++) { for(int u=0; u<5; u++) {
PRING(a) { PRING(a) {
@ -215,7 +215,7 @@ void drawLove(const transmatrix& V, int hdir) {
void drawWinter(const transmatrix& V, ld hdir) { void drawWinter(const transmatrix& V, ld hdir) {
#if CAP_QUEUE #if CAP_QUEUE
float ds = ticks / 300.; float ds = ticks / 300.;
int col = darkena(iinf[itOrbWinter].color, 0, 0xFF); color_t col = darkena(iinf[itOrbWinter].color, 0, 0xFF);
for(int u=0; u<20; u++) { for(int u=0; u<20; u++) {
ld rad = sin(ds+u * 2 * M_PI / 20) * M_PI / S7; ld rad = sin(ds+u * 2 * M_PI / 20) * M_PI / S7;
queueline(V*xspinpush0(M_PI+hdir+rad, hexf*.5), V*xspinpush0(M_PI+hdir+rad, hexf*3), col, 2 + vid.linequality); queueline(V*xspinpush0(M_PI+hdir+rad, hexf*.5), V*xspinpush0(M_PI+hdir+rad, hexf*3), col, 2 + vid.linequality);
@ -225,7 +225,7 @@ void drawWinter(const transmatrix& V, ld hdir) {
void drawLightning(const transmatrix& V) { void drawLightning(const transmatrix& V) {
#if CAP_QUEUE #if CAP_QUEUE
int col = darkena(iinf[itOrbLightning].color, 0, 0xFF); color_t col = darkena(iinf[itOrbLightning].color, 0, 0xFF);
for(int u=0; u<20; u++) { for(int u=0; u<20; u++) {
ld leng = 0.5 / (0.1 + (rand() % 100) / 100.0); ld leng = 0.5 / (0.1 + (rand() % 100) / 100.0);
ld rad = rand() % 1000; ld rad = rand() % 1000;
@ -316,7 +316,7 @@ void drawPlayerEffects(const transmatrix& V, cell *c, bool onplayer) {
if(PURE && a%3 != ang%3) continue; if(PURE && a%3 != ang%3) continue;
if((a+S21)%S42 == ang && items[itOrbSword2]) continue; if((a+S21)%S42 == ang && items[itOrbSword2]) continue;
bool longer = sword::pos(cwt.at, a-1) != sword::pos(cwt.at, a+1); bool longer = sword::pos(cwt.at, a-1) != sword::pos(cwt.at, a+1);
int col = darkena(0xC0C0C0, 0, 0xFF); color_t col = darkena(0xC0C0C0, 0, 0xFF);
queueline(Vnow*xspinpush0(dda * M_PI / S42, PURE ? 0.6 * scalefactor : longer ? 0.36 : 0.4), Vnow*xspinpush0(dda * M_PI/S42, PURE ? 0.7 * scalefactor : longer ? 0.44 : 0.42), col, 1); queueline(Vnow*xspinpush0(dda * M_PI / S42, PURE ? 0.6 * scalefactor : longer ? 0.36 : 0.4), Vnow*xspinpush0(dda * M_PI/S42, PURE ? 0.7 * scalefactor : longer ? 0.44 : 0.42), col, 1);
} }
#endif #endif
@ -347,7 +347,7 @@ void drawPlayerEffects(const transmatrix& V, cell *c, bool onplayer) {
for(int u=tim; u<=2500; u++) { for(int u=tim; u<=2500; u++) {
if((u-tim)%250) continue; if((u-tim)%250) continue;
ld rad = hexf * u / 250; ld rad = hexf * u / 250;
int col = darkena(iinf[itOrbSafety].color, 0, 0xFF); color_t col = darkena(iinf[itOrbSafety].color, 0, 0xFF);
PRING(a) PRING(a)
curvepoint(V*xspinpush0(a * M_PI / S42, rad)); curvepoint(V*xspinpush0(a * M_PI / S42, rad));
queuecurve(col, 0, PPR::LINE); queuecurve(col, 0, PPR::LINE);
@ -370,10 +370,10 @@ namespace tortoise {
void draw(const transmatrix& V, int bits, int small, int stuntime) { void draw(const transmatrix& V, int bits, int small, int stuntime) {
#if CAP_POLY #if CAP_POLY
int eyecolor = getBit(bits, tfEyeHue) ? 0xFF0000 : 0xC0C0C0; color_t eyecolor = getBit(bits, tfEyeHue) ? 0xFF0000 : 0xC0C0C0;
int shellcolor = getBit(bits, tfShellHue) ? 0x00C040 : 0xA06000; color_t shellcolor = getBit(bits, tfShellHue) ? 0x00C040 : 0xA06000;
int scutecolor = getBit(bits, tfScuteHue) ? 0x00C040 : 0xA06000; color_t scutecolor = getBit(bits, tfScuteHue) ? 0x00C040 : 0xA06000;
int skincolor = getBit(bits, tfSkinHue) ? 0x00C040 : 0xA06000; color_t skincolor = getBit(bits, tfSkinHue) ? 0x00C040 : 0xA06000;
if(getBit(bits, tfShellSat)) shellcolor = gradient(shellcolor, 0xB0B0B0, 0, .5, 1); if(getBit(bits, tfShellSat)) shellcolor = gradient(shellcolor, 0xB0B0B0, 0, .5, 1);
if(getBit(bits, tfScuteSat)) scutecolor = gradient(scutecolor, 0xB0B0B0, 0, .5, 1); if(getBit(bits, tfScuteSat)) scutecolor = gradient(scutecolor, 0xB0B0B0, 0, .5, 1);
if(getBit(bits, tfSkinSat)) skincolor = gradient(skincolor, 0xB0B0B0, 0, .5, 1); if(getBit(bits, tfSkinSat)) skincolor = gradient(skincolor, 0xB0B0B0, 0, .5, 1);
@ -381,7 +381,7 @@ namespace tortoise {
if(getBit(bits, tfSkinDark)) skincolor = gradient(skincolor, 0, 0, .5, 1); if(getBit(bits, tfSkinDark)) skincolor = gradient(skincolor, 0, 0, .5, 1);
for(int i=0; i<12; i++) { for(int i=0; i<12; i++) {
int col = color_t col =
i == 0 ? shellcolor: i == 0 ? shellcolor:
i < 8 ? scutecolor : i < 8 ? scutecolor :
skincolor; skincolor;
@ -430,7 +430,7 @@ double footfun(double d) {
bool ivoryz; bool ivoryz;
void animallegs(const transmatrix& V, eMonster mo, int col, double footphase) { void animallegs(const transmatrix& V, eMonster mo, color_t col, double footphase) {
#if CAP_POLY #if CAP_POLY
footphase /= SCALE; footphase /= SCALE;
@ -479,14 +479,14 @@ void ShadowV(const transmatrix& V, const hpcshape& bp, PPR prio) {
if(mmspatial) { if(mmspatial) {
if(pmodel == mdHyperboloid || pmodel == mdBall || pmodel == mdHemisphere || noshadow) if(pmodel == mdHyperboloid || pmodel == mdBall || pmodel == mdHemisphere || noshadow)
return; // shadows break the depth testing return; // shadows break the depth testing
dynamicval<int> p(poly_outline, OUTLINE_TRANS); dynamicval<color_t> p(poly_outline, OUTLINE_TRANS);
queuepolyat(V, bp, SHADOW_MON, prio); queuepolyat(V, bp, SHADOW_MON, prio);
} }
#endif #endif
} }
void otherbodyparts(const transmatrix& V, int col, eMonster who, double footphase) { void otherbodyparts(const transmatrix& V, color_t col, eMonster who, double footphase) {
#if CAP_POLY #if CAP_POLY
@ -732,7 +732,7 @@ bool drawItemType(eItem it, cell *c, const transmatrix& V, int icol, int ticks,
if(it == itOrbUndeath) icol = minf[moFriendlyGhost].color; if(it == itOrbUndeath) icol = minf[moFriendlyGhost].color;
if(it == itOrbRecall) icol = 0x101010; if(it == itOrbRecall) icol = 0x101010;
if(it == itOrbSlaying) icol = 0xFF0000; if(it == itOrbSlaying) icol = 0xFF0000;
int col = darkena(icol, 0, int(0x80 + 0x70 * sin(ticks / 300.))); color_t col = darkena(icol, 0, int(0x80 + 0x70 * sin(ticks / 300.)));
if(it == itOrbFish) if(it == itOrbFish)
queuepolyat(V * spin(ticks / 1500.), shFishTail, col, PPR::ITEM_BELOW); queuepolyat(V * spin(ticks / 1500.), shFishTail, col, PPR::ITEM_BELOW);
@ -759,7 +759,7 @@ bool drawItemType(eItem it, cell *c, const transmatrix& V, int icol, int ticks,
void drawTerraWarrior(const transmatrix& V, int t, int hp, double footphase) { void drawTerraWarrior(const transmatrix& V, int t, int hp, double footphase) {
#if CAP_POLY #if CAP_POLY
ShadowV(V, shPBody); ShadowV(V, shPBody);
int col = linf[laTerracotta].color; color_t col = linf[laTerracotta].color;
int bcol = darkena(false ? 0xC0B23E : col, 0, 0xFF); int bcol = darkena(false ? 0xC0B23E : col, 0, 0xFF);
otherbodyparts(V, bcol, moDesertman, footphase); otherbodyparts(V, bcol, moDesertman, footphase);
queuepoly(VBODY, shPBody, bcol); queuepoly(VBODY, shPBody, bcol);
@ -772,7 +772,7 @@ void drawTerraWarrior(const transmatrix& V, int t, int hp, double footphase) {
#endif #endif
} }
bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, int col, double footphase) { bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col, double footphase) {
char xch = minf[m].glyph; char xch = minf[m].glyph;
@ -806,7 +806,7 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, int col, dou
queuepoly(VABODY, shWolfBody, fc(0, cs.skincolor, 0)); queuepoly(VABODY, shWolfBody, fc(0, cs.skincolor, 0));
queuepoly(VAHEAD, shFamiliarHead, fc(500, cs.haircolor, 2)); queuepoly(VAHEAD, shFamiliarHead, fc(500, cs.haircolor, 2));
if(!shmup::on || shmup::curtime >= shmup::getPlayer()->nextshot) { if(!shmup::on || shmup::curtime >= shmup::getPlayer()->nextshot) {
int col = items[itOrbDiscord] ? watercolor(0) : fc(314, cs.swordcolor, 3); color_t col = items[itOrbDiscord] ? watercolor(0) : fc(314, cs.swordcolor, 3);
queuepoly(VAHEAD, shFamiliarEye, col); queuepoly(VAHEAD, shFamiliarEye, col);
queuepoly(VAHEAD * Mirror, shFamiliarEye, col); queuepoly(VAHEAD * Mirror, shFamiliarEye, col);
} }
@ -822,12 +822,12 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, int col, dou
queuepoly(VAHEAD, shDogHead, fc(150, cs.haircolor, 2)); queuepoly(VAHEAD, shDogHead, fc(150, cs.haircolor, 2));
if(!shmup::on || shmup::curtime >= shmup::getPlayer()->nextshot) { if(!shmup::on || shmup::curtime >= shmup::getPlayer()->nextshot) {
int col = items[itOrbDiscord] ? watercolor(0) : fc(314, cs.swordcolor, 3); color_t col = items[itOrbDiscord] ? watercolor(0) : fc(314, cs.swordcolor, 3);
queuepoly(VAHEAD, shWolf1, col); queuepoly(VAHEAD, shWolf1, col);
queuepoly(VAHEAD, shWolf2, col); queuepoly(VAHEAD, shWolf2, col);
} }
int colnose = items[itOrbDiscord] ? watercolor(0) : fc(314, 0xFF, 3); color_t colnose = items[itOrbDiscord] ? watercolor(0) : fc(314, 0xFF, 3);
queuepoly(VAHEAD, shWolf3, colnose); queuepoly(VAHEAD, shWolf3, colnose);
} }
else if(cs.charid >= 4) { else if(cs.charid >= 4) {
@ -840,7 +840,7 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, int col, dou
queuepoly(VABODY, shCatBody, fc(0, cs.skincolor, 0)); queuepoly(VABODY, shCatBody, fc(0, cs.skincolor, 0));
queuepoly(VAHEAD, shCatHead, fc(150, cs.haircolor, 2)); queuepoly(VAHEAD, shCatHead, fc(150, cs.haircolor, 2));
if(!shmup::on || shmup::curtime >= shmup::getPlayer()->nextshot) { if(!shmup::on || shmup::curtime >= shmup::getPlayer()->nextshot) {
int col = items[itOrbDiscord] ? watercolor(0) : fc(314, cs.swordcolor, 3); color_t col = items[itOrbDiscord] ? watercolor(0) : fc(314, cs.swordcolor, 3);
queuepoly(VAHEAD * xpush(.04), shWolf1, col); queuepoly(VAHEAD * xpush(.04), shWolf1, col);
queuepoly(VAHEAD * xpush(.04), shWolf2, col); queuepoly(VAHEAD * xpush(.04), shWolf2, col);
} }
@ -1009,7 +1009,7 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, int col, dou
queuepoly(VBODY, shPBody, darkena(0xC0C0A0, 0, 0xC0)); queuepoly(VBODY, shPBody, darkena(0xC0C0A0, 0, 0xC0));
queuepoly(VBODY, shPSword, darkena(0xFFFF00, 0, 0xFF)); queuepoly(VBODY, shPSword, darkena(0xFFFF00, 0, 0xFF));
queuepoly(VBODY, shKnightArmor, darkena(0xD0D0D0, 1, 0xFF)); queuepoly(VBODY, shKnightArmor, darkena(0xD0D0D0, 1, 0xFF));
int col; color_t col;
if(!eubinary && where && where->master->alt) if(!eubinary && where && where->master->alt)
col = cloakcolor(roundTableRadius(where)); col = cloakcolor(roundTableRadius(where));
else else
@ -1163,7 +1163,7 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, int col, dou
queuepoly(VAHEAD, shDogHead, darkena(col, 0, 0xFF)); queuepoly(VAHEAD, shDogHead, darkena(col, 0, 0xFF));
{ {
dynamicval<int> dp(poly_outline); dynamicval<color_t> dp(poly_outline);
int eyecolor = 0x202020; int eyecolor = 0x202020;
bool redeyes = false; bool redeyes = false;
if(m == moHunterDog) eyecolor = 0xFF0000, redeyes = true; if(m == moHunterDog) eyecolor = 0xFF0000, redeyes = true;
@ -1172,10 +1172,8 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, int col, dou
int eyes = darkena(eyecolor, 0, 0xFF); int eyes = darkena(eyecolor, 0, 0xFF);
if(redeyes) poly_outline = eyes; if(redeyes) poly_outline = eyes;
queuepoly(VAHEAD, shWolf1, eyes); queuepoly(VAHEAD, shWolf1, eyes).flags |= POLY_FORCEWIDE;
if(redeyes) lastptd().u.poly.flags |= POLY_FORCEWIDE; queuepoly(VAHEAD, shWolf2, eyes).flags |= POLY_FORCEWIDE;
queuepoly(VAHEAD, shWolf2, eyes);
if(redeyes) lastptd().u.poly.flags |= POLY_FORCEWIDE;
} }
queuepoly(VAHEAD, shWolf3, darkena(m == moRunDog ? 0x202020 : 0x000000, 0, 0xFF)); queuepoly(VAHEAD, shWolf3, darkena(m == moRunDog ? 0x202020 : 0x000000, 0, 0xFF));
} }
@ -1707,8 +1705,8 @@ bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, int col, dou
#endif #endif
} }
bool drawMonsterTypeDH(eMonster m, cell *where, const transmatrix& V, int col, bool dh, ld footphase) { bool drawMonsterTypeDH(eMonster m, cell *where, const transmatrix& V, color_t col, bool dh, ld footphase) {
dynamicval<int> p(poly_outline, poly_outline); dynamicval<color_t> p(poly_outline, poly_outline);
if(dh) { if(dh) {
poly_outline = OUTLINE_DEAD; poly_outline = OUTLINE_DEAD;
darken++; darken++;
@ -1838,7 +1836,7 @@ void drawWormSegments() {
bool dont_face_pc = false; bool dont_face_pc = false;
bool drawMonster(const transmatrix& Vparam, int ct, cell *c, int col) { bool drawMonster(const transmatrix& Vparam, int ct, cell *c, color_t col) {
bool darkhistory = conformal::includeHistory && conformal::inkillhistory.count(c); bool darkhistory = conformal::includeHistory && conformal::inkillhistory.count(c);
@ -1925,7 +1923,7 @@ bool drawMonster(const transmatrix& Vparam, int ct, cell *c, int col) {
ld wav = hexsnake ? 0 : ld wav = hexsnake ? 0 :
c->monst < moTentacle ? 1/1.5 : c->monst < moTentacle ? 1/1.5 :
1; 1;
int col0 = col; color_t col0 = col;
if(c->monst == moWorm || c->monst == moWormwait) if(c->monst == moWorm || c->monst == moWormwait)
col0 = minf[moWormtail].color; col0 = minf[moWormtail].color;
else if(thead) else if(thead)
@ -1945,7 +1943,7 @@ bool drawMonster(const transmatrix& Vparam, int ct, cell *c, int col) {
else { else {
int hdir = displayspin(c, c->mondir); int hdir = displayspin(c, c->mondir);
int col = darkena(0x606020, 0, 0xFF); color_t col = darkena(0x606020, 0, 0xFF);
for(int u=-1; u<=1; u++) for(int u=-1; u<=1; u++)
queueline(Vparam*xspinpush0(hdir+M_PI/2, u*crossf/5), Vparam*xspinpush(hdir, crossf)*xspinpush0(hdir+M_PI/2, u*crossf/5), col, 2 + vid.linequality); queueline(Vparam*xspinpush0(hdir+M_PI/2, u*crossf/5), Vparam*xspinpush(hdir, crossf)*xspinpush0(hdir+M_PI/2, u*crossf/5), col, 2 + vid.linequality);
} }
@ -2222,13 +2220,13 @@ void clearaura() {
auramemo = 128 * 128 / vid.aurastr; auramemo = 128 * 128 / vid.aurastr;
} }
void addauraspecial(const hyperpoint& h, int col, int dir) { void addauraspecial(const hyperpoint& h, color_t col, int dir) {
if(!haveaura()) return; if(!haveaura()) return;
int r = int(2*AURA + dir + atan2(h[0], h[1]) * AURA / 2 / M_PI) % AURA; int r = int(2*AURA + dir + atan2(h[0], h[1]) * AURA / 2 / M_PI) % AURA;
auraspecials.emplace_back(r, col); auraspecials.emplace_back(r, col);
} }
void addaura(const hyperpoint& h, int col, int fd) { void addaura(const hyperpoint& h, color_t col, int fd) {
if(!haveaura()) return; if(!haveaura()) return;
int r = int(2*AURA + atan2(h[0], h[1]) * AURA / 2 / M_PI) % AURA; int r = int(2*AURA + atan2(h[0], h[1]) * AURA / 2 / M_PI) % AURA;
aurac[r][3] += auramemo << fd; aurac[r][3] += auramemo << fd;
@ -2304,7 +2302,7 @@ void drawaura() {
if(rm<0 || rm >= AURA) continue; if(rm<0 || rm >= AURA) continue;
int& p = qpixel(s, x, y); color_t& p = qpixel(s, x, y);
for(int c=0; c<3; c++) { for(int c=0; c<3; c++) {
double c1 = aurac[rm][2-c] / (aurac[rm][3]+.1); double c1 = aurac[rm][2-c] / (aurac[rm][3]+.1);
double c2 = aurac[rm+1][2-c] / (aurac[rm+1][3]+.1); double c2 = aurac[rm+1][2-c] / (aurac[rm+1][3]+.1);
@ -2465,7 +2463,7 @@ void set_zebrafloor(cell *c) {
void set_maywarp_floor(cell *c); void set_maywarp_floor(cell *c);
void set_reptile_floor(cell *c, const transmatrix& V, int col, bool nodetails = false) { void set_reptile_floor(cell *c, const transmatrix& V, color_t col, bool nodetails = false) {
auto si = auto si =
euclid6 ? euclid6 ?
@ -2511,7 +2509,7 @@ void set_reptile_floor(cell *c, const transmatrix& V, int col, bool nodetails =
if(ecol == -1 || ecol == 0) dcol = darkena(col, 1, 0xFF); if(ecol == -1 || ecol == 0) dcol = darkena(col, 1, 0xFF);
else dcol = darkena(ecol, 0, 0x80); else dcol = darkena(ecol, 0, 0x80);
dynamicval<int> p(poly_outline, dynamicval<color_t> p(poly_outline,
doHighlight() && ecol != -1 && ecol != 0 ? OUTLINE_ENEMY : OUTLINE_DEFAULT); doHighlight() && ecol != -1 && ecol != 0 ? OUTLINE_ENEMY : OUTLINE_DEFAULT);
if(!chasmg) { if(!chasmg) {
@ -2527,7 +2525,7 @@ void set_reptile_floor(cell *c, const transmatrix& V, int col, bool nodetails =
} }
} }
void draw_reptile(cell *c, const transmatrix &V, int col) { void draw_reptile(cell *c, const transmatrix &V, color_t col) {
auto qfib = qfi; auto qfib = qfi;
set_reptile_floor(c, V, col, chasmg == 2); set_reptile_floor(c, V, col, chasmg == 2);
draw_qfi(c, V, col); draw_qfi(c, V, col);
@ -2591,7 +2589,7 @@ void drawMovementArrows(cell *c, transmatrix V) {
if(xc.at == c) { if(xc.at == c) {
transmatrix fixrot = sphereflip * rgpushxto0(sphereflip * tC0(V)); transmatrix fixrot = sphereflip * rgpushxto0(sphereflip * tC0(V));
// make it more transparent // make it more transparent
int col = getcs().uicolor; color_t col = getcs().uicolor;
col -= (col & 0xFF) >> 1; col -= (col & 0xFF) >> 1;
poly_outline = OUTLINE_DEFAULT; poly_outline = OUTLINE_DEFAULT;
queuepoly(fixrot * spin(-d * M_PI/4), shArrow, col); queuepoly(fixrot * spin(-d * M_PI/4), shArrow, col);
@ -2628,7 +2626,7 @@ int reptilecolor(cell *c) {
} }
} }
int fcoltab[4] = {0xe3bb97, 0xc2d1b0, 0xebe5cb, 0xA0A0A0}; color_t fcoltab[4] = {0xe3bb97, 0xc2d1b0, 0xebe5cb, 0xA0A0A0};
return fcoltab[i]; return fcoltab[i];
} }
@ -2642,7 +2640,7 @@ ld wavefun(ld x) {
const unsigned int nestcolors[8] = { 0x800000, 0x008000, 0x000080, 0x404040, 0x700070, 0x007070, 0x707000, 0x606060 }; const unsigned int nestcolors[8] = { 0x800000, 0x008000, 0x000080, 0x404040, 0x700070, 0x007070, 0x707000, 0x606060 };
void setcolors(cell *c, int& wcol, int &fcol) { void setcolors(cell *c, color_t& wcol, color_t& fcol) {
wcol = fcol = winf[c->wall].color; wcol = fcol = winf[c->wall].color;
@ -2833,7 +2831,7 @@ void setcolors(cell *c, int& wcol, int &fcol) {
case laWhirlwind: case laWhirlwind:
if(c->land == laWhirlwind) { if(c->land == laWhirlwind) {
int wcol[4] = {0x404040, 0x404080, 0x2050A0, 0x5050C0}; color_t wcol[4] = {0x404040, 0x404080, 0x2050A0, 0x5050C0};
fcol = wcol[whirlwind::fzebra3(c)]; fcol = wcol[whirlwind::fzebra3(c)];
} }
break; break;
@ -2928,12 +2926,12 @@ void setcolors(cell *c, int& wcol, int &fcol) {
float h = HEAT(c); float h = HEAT(c);
bool showcoc = c->land == laCocytus && chaosmode && !wmescher; bool showcoc = c->land == laCocytus && chaosmode && !wmescher;
int colorN04 = showcoc ? 0x4080FF : 0x4040FF; color_t colorN04 = showcoc ? 0x4080FF : 0x4040FF;
int colorN10 = 0x0000FF; color_t colorN10 = 0x0000FF;
int color0 = c->land == laBlizzard ? 0x5050C0 : showcoc ? 0x80C0FF : 0x8080FF; color_t color0 = c->land == laBlizzard ? 0x5050C0 : showcoc ? 0x80C0FF : 0x8080FF;
int color02 = 0xFFFFFF; color_t color02 = 0xFFFFFF;
int color06 = 0xFF0000; color_t color06 = 0xFF0000;
int color08 = 0xFFFF00; color_t color08 = 0xFFFF00;
if(h < -1) if(h < -1)
wcol = colorN10; wcol = colorN10;
@ -3133,10 +3131,10 @@ bool use_swapped_duals() {
return (masterless && !a4) || GOLDBERG; return (masterless && !a4) || GOLDBERG;
} }
void floorShadow(cell *c, const transmatrix& V, int col) { void floorShadow(cell *c, const transmatrix& V, color_t col) {
if(pmodel == mdHyperboloid || pmodel == mdBall || pmodel == mdHemisphere || noshadow) if(pmodel == mdHyperboloid || pmodel == mdBall || pmodel == mdHemisphere || noshadow)
return; // shadows break the depth testing return; // shadows break the depth testing
dynamicval<int> p(poly_outline, OUTLINE_TRANS); dynamicval<color_t> p(poly_outline, OUTLINE_TRANS);
if(qfi.shape) { if(qfi.shape) {
queuepolyat(V * qfi.spin * shadowmulmatrix, *qfi.shape, col, PPR::WALLSHADOW); queuepolyat(V * qfi.spin * shadowmulmatrix, *qfi.shape, col, PPR::WALLSHADOW);
} }
@ -3167,7 +3165,7 @@ void set_maywarp_floor(cell *c) {
int wavephase; int wavephase;
void escherSidewall(cell *c, int sidepar, const transmatrix& V, int col) { void escherSidewall(cell *c, int sidepar, const transmatrix& V, color_t col) {
if(sidepar >= SIDE_SLEV && sidepar <= SIDE_SLEV+2) { if(sidepar >= SIDE_SLEV && sidepar <= SIDE_SLEV+2) {
int sl = sidepar - SIDE_SLEV; int sl = sidepar - SIDE_SLEV;
for(int z=1; z<=4; z++) if(z == 1 || (z == 4 && detaillevel == 2)) for(int z=1; z<=4; z++) if(z == 1 || (z == 4 && detaillevel == 2))
@ -3196,7 +3194,7 @@ void escherSidewall(cell *c, int sidepar, const transmatrix& V, int col) {
} }
} }
bool placeSidewall(cell *c, int i, int sidepar, const transmatrix& V, int col) { bool placeSidewall(cell *c, int i, int sidepar, const transmatrix& V, color_t col) {
if(!qfi.fshape || !qfi.fshape->is_plain || !validsidepar[sidepar] || qfi.usershape >= 0) { if(!qfi.fshape || !qfi.fshape->is_plain || !validsidepar[sidepar] || qfi.usershape >= 0) {
escherSidewall(c, sidepar, V, col); escherSidewall(c, sidepar, V, col);
@ -3262,7 +3260,7 @@ void pushdown(cell *c, int& q, const transmatrix &V, double down, bool rezoom, b
if(down > 0 && repriority) { if(down > 0 && repriority) {
int qq = q+1; int qq = q+1;
while(qq < isize(ptds)) while(qq < isize(ptds))
if(qq > q && ptds[qq].prio < ptds[qq-1].prio) { if(qq > q && ptds[qq]->prio < ptds[qq-1]->prio) {
swap(ptds[qq], ptds[qq-1]); swap(ptds[qq], ptds[qq-1]);
qq--; qq--;
} }
@ -3270,35 +3268,35 @@ void pushdown(cell *c, int& q, const transmatrix &V, double down, bool rezoom, b
} }
while(q < isize(ptds)) { while(q < isize(ptds)) {
polytodraw& ptd = ptds[q++]; auto pp = dynamic_cast<dqi_poly*> (&*ptds[q++]);
if(ptd.kind == pkPoly) { if(!pp) continue;
auto& ptd = *pp;
double z2;
double z2; double z = zlevel(tC0(ptd.V));
double lev = geom3::factor_to_lev(z);
double nlev = lev - down;
double xyscale = rezoom ? geom3::scale_at_lev(lev) / geom3::scale_at_lev(nlev) : 1;
z2 = geom3::lev_to_factor(nlev);
double zscale = z2 / z;
// xyscale = xyscale + (zscale-xyscale) * (1+sin(ticks / 1000.0)) / 2;
ptd.V = xyzscale( V, xyscale*zscale, zscale)
* inverse(V) * ptd.V;
double z = zlevel(tC0(ptd.u.poly.V)); if(!repriority) ;
double lev = geom3::factor_to_lev(z); else if(nlev < -geom3::lake_bottom-1e-3) {
double nlev = lev - down; ptd.prio = PPR::BELOWBOTTOM_FALLANIM;
if(c->wall != waChasm)
double xyscale = rezoom ? geom3::scale_at_lev(lev) / geom3::scale_at_lev(nlev) : 1; ptd.color = 0; // disappear!
z2 = geom3::lev_to_factor(nlev); }
double zscale = z2 / z; else if(nlev < -geom3::lake_top-1e-3)
ptd.prio = PPR::INLAKEWALL_FALLANIM;
// xyscale = xyscale + (zscale-xyscale) * (1+sin(ticks / 1000.0)) / 2; else if(nlev < 0)
ptd.prio = PPR::LAKEWALL_FALLANIM;
ptd.u.poly.V = xyzscale( V, xyscale*zscale, zscale)
* inverse(V) * ptd.u.poly.V;
if(!repriority) ;
else if(nlev < -geom3::lake_bottom-1e-3) {
ptd.prio = PPR::BELOWBOTTOM_FALLANIM;
if(c->wall != waChasm)
ptd.col = 0; // disappear!
}
else if(nlev < -geom3::lake_top-1e-3)
ptd.prio = PPR::INLAKEWALL_FALLANIM;
else if(nlev < 0)
ptd.prio = PPR::LAKEWALL_FALLANIM;
}
} }
} }
@ -3397,8 +3395,8 @@ int getfd(cell *c) {
} }
} }
int getSnakelevColor(cell *c, int i, int last, int fd, int wcol) { int getSnakelevColor(cell *c, int i, int last, int fd, color_t wcol) {
int col; color_t col;
if(c->wall == waTower) if(c->wall == waTower)
col = 0xD0D0D0-i*0x101010; col = 0xD0D0D0-i*0x101010;
else if(c->land == laSnakeNest) else if(c->land == laSnakeNest)
@ -3410,14 +3408,14 @@ int getSnakelevColor(cell *c, int i, int last, int fd, int wcol) {
return darkena(col, fd, 0xFF); return darkena(col, fd, 0xFF);
} }
void draw_wall(cell *c, const transmatrix& V, int wcol, int& zcol, int ct6, int fd) { void draw_wall(cell *c, const transmatrix& V, color_t wcol, color_t& zcol, int ct6, int fd) {
zcol = wcol; zcol = wcol;
int wcol0 = wcol; color_t wcol0 = wcol;
int starcol = wcol; int starcol = wcol;
if(c->wall == waWarpGate) starcol = 0; if(c->wall == waWarpGate) starcol = 0;
if(c->wall == waVinePlant) starcol = 0x60C000; if(c->wall == waVinePlant) starcol = 0x60C000;
int wcol2 = gradient(0, wcol0, 0, .8, 1); color_t wcol2 = gradient(0, wcol0, 0, .8, 1);
if(c->wall == waClosedGate) { if(c->wall == waClosedGate) {
int hdir = 0; int hdir = 0;
@ -3482,7 +3480,7 @@ void draw_wall(cell *c, const transmatrix& V, int wcol, int& zcol, int ct6, int
bool just_gmatrix; bool just_gmatrix;
int colorhash(int i) { int colorhash(color_t i) {
return (i * 0x471211 + i*i*0x124159 + i*i*i*0x982165) & 0xFFFFFF; return (i * 0x471211 + i*i*0x124159 + i*i*i*0x982165) & 0xFFFFFF;
} }
@ -3603,7 +3601,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
return; return;
} }
// int col = 0xFFFFFF - 0x20 * c->maxdist - 0x2000 * c->cpdist; // color_t col = 0xFFFFFF - 0x20 * c->maxdist - 0x2000 * c->cpdist;
if(!buggyGeneration && c->mpdist > 8 && !cheater && !autocheat) return; // not yet generated if(!buggyGeneration && c->mpdist > 8 && !cheater && !autocheat) return; // not yet generated
/* if(!buggyGeneration && c->mpdist > 7 && !cheater) { /* if(!buggyGeneration && c->mpdist > 7 && !cheater) {
@ -3618,7 +3616,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
} }
char ch = winf[c->wall].glyph; char ch = winf[c->wall].glyph;
int wcol, fcol, asciicol; color_t wcol, fcol, asciicol;
setcolors(c, wcol, fcol); setcolors(c, wcol, fcol);
@ -3634,7 +3632,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
fcol = gradient(fcol, 0xC0C0FF, 0, 0.2, 1); fcol = gradient(fcol, 0xC0C0FF, 0, 0.2, 1);
// addaura(tC0(V), wcol); // addaura(tC0(V), wcol);
int zcol = fcol; color_t zcol = fcol;
if(peace::on && peace::hint && c->land != laTortoise) { if(peace::on && peace::hint && c->land != laTortoise) {
int d = int d =
@ -3929,7 +3927,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
transmatrix Vdepth = mscale(V2, geom3::WALL); transmatrix Vdepth = mscale(V2, geom3::WALL);
queuepolyat(Vdepth, shSemiFloor[0], darkena(vcol, fd, 0xFF), PPR::WALL3A); queuepolyat(Vdepth, shSemiFloor[0], darkena(vcol, fd, 0xFF), PPR::WALL3A);
{dynamicval<int> p(poly_outline, OUTLINE_TRANS); queuepolyat(V2 * spin(M_PI*2/3), shSemiFloorShadow, SHADOW_WALL, PPR::WALLSHADOW); } {dynamicval<color_t> p(poly_outline, OUTLINE_TRANS); queuepolyat(V2 * spin(M_PI*2/3), shSemiFloorShadow, SHADOW_WALL, PPR::WALLSHADOW); }
queuepolyat(V2, shSemiFloorSide[SIDE_WALL], darkena(vcol, fd, 0xFF), PPR::WALL3A-2+away(V2)); queuepolyat(V2, shSemiFloorSide[SIDE_WALL], darkena(vcol, fd, 0xFF), PPR::WALL3A-2+away(V2));
if(validsidepar[SIDE_WALL]) forCellIdEx(c2, j, c) { if(validsidepar[SIDE_WALL]) forCellIdEx(c2, j, c) {
@ -4209,7 +4207,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
} }
else if(chasmg && wmspatial) { else if(chasmg && wmspatial) {
int col = c->land == laCocytus ? 0x080808FF : 0x101010FF; color_t col = c->land == laCocytus ? 0x080808FF : 0x101010FF;
if(qfi.fshape == &shCloudFloor) if(qfi.fshape == &shCloudFloor)
set_floor(shCloudSeabed); set_floor(shCloudSeabed);
@ -4241,13 +4239,13 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
} }
string label = its(si.id & 255); string label = its(si.id & 255);
int col = forecolor ^ colorhash(si.id >> 8); color_t col = forecolor ^ colorhash(si.id >> 8);
queuestr(V, .5, label, 0xFF000000 + col); queuestr(V, .5, label, 0xFF000000 + col);
} }
#endif #endif
if((cmode & sm::NUMBER) && (dialog::editingDetail())) { if((cmode & sm::NUMBER) && (dialog::editingDetail())) {
int col = color_t col =
dist0 < geom3::highdetail ? 0xFF80FF80 : dist0 < geom3::highdetail ? 0xFF80FF80 :
dist0 >= geom3::middetail ? 0xFFFF8080 : dist0 >= geom3::middetail ? 0xFFFF8080 :
0XFFFFFF80; 0XFFFFFF80;
@ -4330,7 +4328,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
case waReptileBridge: { case waReptileBridge: {
Vboat = &(Vboat0 = V); Vboat = &(Vboat0 = V);
dynamicval<qfloorinfo> qfi2(qfi, qfi); dynamicval<qfloorinfo> qfi2(qfi, qfi);
int col = reptilecolor(c); color_t col = reptilecolor(c);
chasmg = 0; chasmg = 0;
set_reptile_floor(c, V, col); set_reptile_floor(c, V, col);
draw_qfi(c, V, col); draw_qfi(c, V, col);
@ -4440,7 +4438,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
case waGlass: case waGlass:
if(wmspatial) { if(wmspatial) {
int col = winf[waGlass].color; color_t col = winf[waGlass].color;
int dcol = darkena(col, 0, 0x80); int dcol = darkena(col, 0, 0x80);
transmatrix Vdepth = mscale((*Vdp), geom3::WALL); transmatrix Vdepth = mscale((*Vdp), geom3::WALL);
draw_floorshape(c, Vdepth, shMFloor, dcol, PPR::WALL); // GLASS draw_floorshape(c, Vdepth, shMFloor, dcol, PPR::WALL); // GLASS
@ -4510,7 +4508,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
poly_outline = (c->land == laMirror) ? OUTLINE_TREASURE : OUTLINE_ORB; poly_outline = (c->land == laMirror) ? OUTLINE_TREASURE : OUTLINE_ORB;
if(wmspatial) { if(wmspatial) {
int col = winf[c->wall].color; color_t col = winf[c->wall].color;
int dcol = darkena(col, 0, 0xC0); int dcol = darkena(col, 0, 0xC0);
transmatrix Vdepth = mscale((*Vdp), geom3::WALL); transmatrix Vdepth = mscale((*Vdp), geom3::WALL);
draw_floorshape(c, Vdepth, shMFloor, dcol, PPR::WALL); // GLASS draw_floorshape(c, Vdepth, shMFloor, dcol, PPR::WALL); // GLASS
@ -4559,7 +4557,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
int sha = shallow(c); int sha = shallow(c);
if(wmspatial && sha) { if(wmspatial && sha) {
int col = (highwall(c) || c->wall == waTower) ? wcol : fcol; color_t col = (highwall(c) || c->wall == waTower) ? wcol : fcol;
if(!chasmg) { if(!chasmg) {
#define D(v) darkena(gradient(0, col, 0, v * (sphere ? spherity(V * cellrelmatrix(c,i)) : 1), 1), fd, 0xFF) #define D(v) darkena(gradient(0, col, 0, v * (sphere ? spherity(V * cellrelmatrix(c,i)) : 1), 1), fd, 0xFF)
@ -4597,9 +4595,9 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
forCellIdEx(c2, i, c) if(chasmgraph(c2) == 0) { forCellIdEx(c2, i, c) if(chasmgraph(c2) == 0) {
transmatrix V2 = V * cellrelmatrix(c, i); transmatrix V2 = V * cellrelmatrix(c, i);
// if(!behindsphere(V2)) continue; // if(!behindsphere(V2)) continue;
int wcol2, fcol2; color_t wcol2, fcol2;
setcolors(c2, wcol2, fcol2); setcolors(c2, wcol2, fcol2);
int col = (highwall(c2) || c->wall == waTower) ? wcol2 : fcol2; color_t col = (highwall(c2) || c->wall == waTower) ? wcol2 : fcol2;
col = gradient(0, col, 0, spherity(V), 1); col = gradient(0, col, 0, spherity(V), 1);
int j = c->c.spin(i); int j = c->c.spin(i);
if(ticks % 500 < -250) { if(ticks % 500 < -250) {
@ -4625,7 +4623,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
if(fa.walltype == waNone) if(fa.walltype == waNone)
draw_qfi(c, V, darkena(fcol, fd, 0xFF), PPR::FLOOR); draw_qfi(c, V, darkena(fcol, fd, 0xFF), PPR::FLOOR);
else { else {
int wcol2, fcol2; color_t wcol2, fcol2;
eWall w = c->wall; int p = c->wparam; eWall w = c->wall; int p = c->wparam;
c->wall = fa.walltype; c->wparam = fa.m; c->wall = fa.walltype; c->wparam = fa.m;
setcolors(c, wcol2, fcol2); setcolors(c, wcol2, fcol2);
@ -4786,8 +4784,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
if(vid.linequality > 0) steps <<= vid.linequality; if(vid.linequality > 0) steps <<= vid.linequality;
if(vid.linequality < 0) steps >>= -vid.linequality; if(vid.linequality < 0) steps >>= -vid.linequality;
for(int i=0; i<=steps; i++) curvepoint(V * get_horopoint(y, x1 + (x2-x1) * i / steps)); for(int i=0; i<=steps; i++) curvepoint(V * get_horopoint(y, x1 + (x2-x1) * i / steps));
queuecurve(gridcolor(c, c->move(dir)), 0, PPR::LINE); queuecurve(gridcolor(c, c->move(dir)), 0, PPR::LINE).linewidth = linewidthat(V * get_horopoint(y, (x1+x2)/2), vid.linewidth, 0);
lastptd().u.poly.linewidth = linewidthat(V * get_horopoint(y, (x1+x2)/2), vid.linewidth, 0);
}; };
horizontal(yy, 2*xx, xx, 4, binary::bd_up_right); horizontal(yy, 2*xx, xx, 4, binary::bd_up_right);
horizontal(yy, xx, -xx, 8, binary::bd_up); horizontal(yy, xx, -xx, 8, binary::bd_up);
@ -4879,7 +4876,7 @@ void drawcell(cell *c, transmatrix V, int spinv, bool mirrored) {
if(vid.grid && c->bardir != NODIR && c->bardir != NOBARRIERS && c->land != laHauntedWall && if(vid.grid && c->bardir != NODIR && c->bardir != NOBARRIERS && c->land != laHauntedWall &&
c->barleft != NOWALLSEP_USED) { c->barleft != NOWALLSEP_USED) {
int col = darkena(0x505050, 0, 0xFF); color_t col = darkena(0x505050, 0, 0xFF);
queueline(tC0(V), V*tC0(heptmove[c->bardir]), col, 2 + vid.linequality); queueline(tC0(V), V*tC0(heptmove[c->bardir]), col, 2 + vid.linequality);
queueline(tC0(V), V*tC0(hexmove[c->bardir]), col, 2 + vid.linequality); queueline(tC0(V), V*tC0(hexmove[c->bardir]), col, 2 + vid.linequality);
} }
@ -4896,8 +4893,8 @@ struct flashdata {
cell *where; cell *where;
double angle; double angle;
int spd; // 0 for flashes, >0 for particles int spd; // 0 for flashes, >0 for particles
int color; color_t color;
flashdata(int _t, int _s, cell *_w, int col, int sped) { flashdata(int _t, int _s, cell *_w, color_t col, int sped) {
t=_t; size=_s; where=_w; color = col; t=_t; size=_s; where=_w; color = col;
angle = rand() % 1000; spd = sped; angle = rand() % 1000; spd = sped;
} }
@ -4911,11 +4908,11 @@ void drawFlash(cell *c) {
void drawBigFlash(cell *c) { void drawBigFlash(cell *c) {
flashes.push_back(flashdata(ticks, 2000, c, 0xC0FF00, 0)); flashes.push_back(flashdata(ticks, 2000, c, 0xC0FF00, 0));
} }
void drawParticle(cell *c, int col, int maxspeed) { void drawParticle(cell *c, color_t col, int maxspeed) {
if(vid.particles && !confusingGeometry()) if(vid.particles && !confusingGeometry())
flashes.push_back(flashdata(ticks, rand() % 16, c, col, 1+rand() % maxspeed)); flashes.push_back(flashdata(ticks, rand() % 16, c, col, 1+rand() % maxspeed));
} }
void drawParticles(cell *c, int col, int qty, int maxspeed) { void drawParticles(cell *c, color_t col, int qty, int maxspeed) {
if(vid.particles) if(vid.particles)
while(qty--) drawParticle(c,col, maxspeed); while(qty--) drawParticle(c,col, maxspeed);
} }
@ -4940,11 +4937,11 @@ void fallingMonsterAnimation(cell *c, eMonster m, int id) {
// drawParticles(c, darkenedby(linf[c->land].color, 1), 4, 50); // drawParticles(c, darkenedby(linf[c->land].color, 1), 4, 50);
} }
void queuecircleat(cell *c, double rad, int col) { void queuecircleat(cell *c, double rad, color_t col) {
if(!c) return; if(!c) return;
if(!gmatrix.count(c)) return; if(!gmatrix.count(c)) return;
if(stereo::mode || sphere) { if(stereo::mode || sphere) {
dynamicval<int> p(poly_outline, col); dynamicval<color_t> p(poly_outline, col);
queuepolyat(gmatrix[c] * spin(ticks / 100.), shGem[1], 0, PPR::LINE); queuepolyat(gmatrix[c] * spin(ticks / 100.), shGem[1], 0, PPR::LINE);
return; return;
} }
@ -5394,7 +5391,7 @@ void drawmovestar(double dx, double dy) {
#endif #endif
else for(int d=0; d<8; d++) { else for(int d=0; d<8; d++) {
int col = starcol; color_t col = starcol;
#if ISPANDORA #if ISPANDORA
if(leftclick && (d == 2 || d == 6 || d == 1 || d == 7)) col &= 0xFFFFFF3F; if(leftclick && (d == 2 || d == 6 || d == 1 || d == 7)) col &= 0xFFFFFF3F;
if(rightclick && (d == 2 || d == 6 || d == 3 || d == 5)) col &= 0xFFFFFF3F; if(rightclick && (d == 2 || d == 6 || d == 3 || d == 5)) col &= 0xFFFFFF3F;
@ -5556,15 +5553,14 @@ void drawfullmap() {
} }
if(rad && !haveaura()) { if(rad && !haveaura()) {
queuecircle(vid.xcenter, vid.ycenter, rad, ringcolor, queuecircle(vid.xcenter, vid.ycenter, rad, ringcolor,
vid.usingGL ? PPR::CIRCLE : PPR::OUTCIRCLE); vid.usingGL ? PPR::CIRCLE : PPR::OUTCIRCLE, isbnd);
if(isbnd) lastptd().u.cir.boundary = true;
} }
if(pmodel == mdBall) ballgeometry(); if(pmodel == mdBall) ballgeometry();
} }
if(pmodel == mdHyperboloid) { if(pmodel == mdHyperboloid) {
#if CAP_QUEUE #if CAP_QUEUE
int col = darkena(0x80, 0, 0x80); color_t col = darkena(0x80, 0, 0x80);
queueline(hpxyz(0,0,1), hpxyz(0,0,-vid.alpha), col, 0, PPR::CIRCLE); queueline(hpxyz(0,0,1), hpxyz(0,0,-vid.alpha), col, 0, PPR::CIRCLE);
queueline(xpush0(+4), hpxyz(0,0,0), col, 0, PPR::CIRCLE); queueline(xpush0(+4), hpxyz(0,0,0), col, 0, PPR::CIRCLE);
queueline(xpush0(+4), hpxyz(0,0,-vid.alpha), col, 0, PPR::CIRCLE); queueline(xpush0(+4), hpxyz(0,0,-vid.alpha), col, 0, PPR::CIRCLE);
@ -5739,7 +5735,7 @@ void drawscreen() {
screens.back()(); screens.back()();
#if !ISMOBILE #if !ISMOBILE
int col = linf[cwt.at->land].color; color_t col = linf[cwt.at->land].color;
if(cwt.at->land == laRedRock) col = 0xC00000; if(cwt.at->land == laRedRock) col = 0xC00000;
if(!nohelp) if(!nohelp)
displayfr(vid.xres/2, vid.fsize, 2, vid.fsize, mouseovers, col, 8); displayfr(vid.xres/2, vid.fsize, 2, vid.fsize, mouseovers, col, 8);
@ -5772,7 +5768,7 @@ void drawscreen() {
if((minefieldNearby || tmines) && !items[itOrbAether] && darken == 0 && normal) { if((minefieldNearby || tmines) && !items[itOrbAether] && darken == 0 && normal) {
string s; string s;
if(tmines > 7) tmines = 7; if(tmines > 7) tmines = 7;
int col = minecolors[tmines]; color_t col = minecolors[tmines];
if(tmines == 7) seenSevenMines = true; if(tmines == 7) seenSevenMines = true;
@ -5931,7 +5927,7 @@ void animateReplacement(cell *a, cell *b, int layer, int direction_hinta, int di
animateMovement(&c1, a, layer, direction_hintb); animateMovement(&c1, a, layer, direction_hintb);
} }
void drawBug(const cellwalker& cw, int col) { void drawBug(const cellwalker& cw, color_t col) {
#if CAP_POLY #if CAP_POLY
initquickqueue(); initquickqueue();
transmatrix V = ggmatrix(cw.at); transmatrix V = ggmatrix(cw.at);

2
help.cpp
View File

@ -177,7 +177,7 @@ string princedesc() {
return XLAT("Apparently a princess is kept locked somewhere, but you won't ever find her in this hyperbolic palace. "); return XLAT("Apparently a princess is kept locked somewhere, but you won't ever find her in this hyperbolic palace. ");
} }
string helptitle(string s, int col) { string helptitle(string s, color_t col) {
return "@" + its(col) + "\t" + s + "\n"; return "@" + its(col) + "\t" + s + "\n";
} }

8
hud.cpp
View File

@ -163,7 +163,7 @@ bool graphglyph() {
return vid.graphglyph == 2 || (vid.graphglyph == 1 && vid.monmode); return vid.graphglyph == 2 || (vid.graphglyph == 1 && vid.monmode);
} }
bool displayglyph(int cx, int cy, int buttonsize, char glyph, int color, int qty, int flags, int id) { bool displayglyph(int cx, int cy, int buttonsize, char glyph, color_t color, int qty, int flags, int id) {
bool b = bool b =
mousex >= cx && mousex < cx+buttonsize && mousey >= cy-buttonsize/2 && mousey <= cy-buttonsize/2+buttonsize; mousex >= cx && mousex < cx+buttonsize && mousey >= cy-buttonsize/2 && mousey <= cy-buttonsize/2+buttonsize;
@ -244,7 +244,7 @@ bool displayglyph(int cx, int cy, int buttonsize, char glyph, int color, int qty
void displayglyph2(int cx, int cy, int buttonsize, int i) { void displayglyph2(int cx, int cy, int buttonsize, int i) {
char glyph = i < ittypes ? iinf[i].glyph : minf[i-ittypes].glyph; char glyph = i < ittypes ? iinf[i].glyph : minf[i-ittypes].glyph;
int color = i < ittypes ? iinf[i].color : minf[i-ittypes].color; color_t color = i < ittypes ? iinf[i].color : minf[i-ittypes].color;
int imp = glyphflags(i); int imp = glyphflags(i);
if(displayglyph(cx, cy, buttonsize, glyph, color, ikmerge(i), imp, i)) { if(displayglyph(cx, cy, buttonsize, glyph, color, ikmerge(i), imp, i)) {
@ -310,12 +310,12 @@ void drawMobileArrow(int i) {
transmatrix T; transmatrix T;
if(!compute_relamatrix(c, cwt.at, i, T)) return; if(!compute_relamatrix(c, cwt.at, i, T)) return;
// int col = getcs().uicolor; // color_t col = getcs().uicolor;
// col -= (col & 0xFF) >> 1; // col -= (col & 0xFF) >> 1;
bool invalid = !legalmoves[dir]; bool invalid = !legalmoves[dir];
int col = cellcolor(c); color_t col = cellcolor(c);
if(col == OUTLINE_NONE) col = 0xC0C0C0FF; if(col == OUTLINE_NONE) col = 0xC0C0C0FF;
col -= (col & 0xFF) >> 1; col -= (col & 0xFF) >> 1;
if(invalid) col -= (col & 0xFF) >> 1; if(invalid) col -= (col & 0xFF) >> 1;

252
hyper.h
View File

@ -44,6 +44,7 @@ using std::out_of_range;
using std::get; using std::get;
using std::move; using std::move;
using std::make_tuple; using std::make_tuple;
using std::unique_ptr;
using std::abs; using std::abs;
using std::isfinite; using std::isfinite;
@ -299,6 +300,7 @@ struct gcell {
// improved tracking in Trollheim // improved tracking in Trollheim
union { union {
int32_t landpar; int32_t landpar;
unsigned int landpar_color;
float heat; float heat;
char bytes[4]; char bytes[4];
struct fieldinfo { struct fieldinfo {
@ -324,6 +326,7 @@ struct gcell {
}; };
#define landparam LHU.landpar #define landparam LHU.landpar
#define landparam_color LHU.landpar_color
#define fval LHU.fi.fieldval #define fval LHU.fi.fieldval
@ -724,7 +727,7 @@ void activateActiv(cell *c, bool msg);
struct charstyle { struct charstyle {
int charid; int charid;
unsigned skincolor, haircolor, dresscolor, swordcolor, dresscolor2, uicolor; color_t skincolor, haircolor, dresscolor, swordcolor, dresscolor2, uicolor;
}; };
string csname(charstyle& cs); string csname(charstyle& cs);
@ -892,8 +895,8 @@ void resetmusic();
void drawFlash(cell* c); void drawFlash(cell* c);
void drawBigFlash(cell* c); void drawBigFlash(cell* c);
void drawParticle(cell *c, int col, int maxspeed = 100); void drawParticle(cell *c, color_t col, int maxspeed = 100);
void drawParticles(cell *c, int col, int qty, int maxspeed = 100); void drawParticles(cell *c, color_t col, int qty, int maxspeed = 100);
void drawFireParticles(cell *c, int qty, int maxspeed = 100); void drawFireParticles(cell *c, int qty, int maxspeed = 100);
int firecolor(int phase); int firecolor(int phase);
@ -904,18 +907,20 @@ void movepckeydir(int);
void centerpc(ld aspd); void centerpc(ld aspd);
typedef color_t color_t;
void displayButton(int x, int y, const string& name, int key, int align, int rad = 0); void displayButton(int x, int y, const string& name, int key, int align, int rad = 0);
void displayColorButton(int x, int y, const string& name, int key, int align, int rad, int color, int color2 = 0); void displayColorButton(int x, int y, const string& name, int key, int align, int rad, color_t color, color_t color2 = 0);
inline string ONOFF(bool b) { return XLAT(b ? "ON" : "OFF"); } inline string ONOFF(bool b) { return XLAT(b ? "ON" : "OFF"); }
int darkened(int c); int darkened(int c);
extern int getcstat; extern int getcstat;
bool displaychr(int x, int y, int shift, int size, char chr, int col); bool displaychr(int x, int y, int shift, int size, char chr, color_t col);
bool displayfr(int x, int y, int b, int size, const string &s, int color, int align); bool displayfr(int x, int y, int b, int size, const string &s, color_t color, int align);
bool displayfrSP(int x, int y, int sh, int b, int size, const string &s, int color, int align, int p); bool displayfrSP(int x, int y, int sh, int b, int size, const string &s, color_t color, int align, int p);
bool outofmap(hyperpoint h); bool outofmap(hyperpoint h);
void applymodel(hyperpoint H, hyperpoint& Hscr); void applymodel(hyperpoint H, hyperpoint& Hscr);
void drawCircle(int x, int y, int size, int color); void drawCircle(int x, int y, int size, color_t color);
void fixcolor(int& col); void fixcolor(int& col);
ld displayspin(cell *c, int d); ld displayspin(cell *c, int d);
hyperpoint gethyper(ld x, ld y); hyperpoint gethyper(ld x, ld y);
@ -923,14 +928,14 @@ void resetview(); extern heptspin viewctr; extern cellwalker centerover;
void drawthemap(); void drawthemap();
void drawfullmap(); void drawfullmap();
extern function<void()> wrap_drawfullmap; extern function<void()> wrap_drawfullmap;
bool displaystr(int x, int y, int shift, int size, const char *str, int color, int align); bool displaystr(int x, int y, int shift, int size, const char *str, color_t color, int align);
bool displaystr(int x, int y, int shift, int size, const string& str, int color, int align); bool displaystr(int x, int y, int shift, int size, const string& str, color_t color, int align);
extern int darken, inmirrorcount; extern int darken, inmirrorcount;
void calcparam(); void calcparam();
#if CAP_SDL #if CAP_SDL
int& qpixel(SDL_Surface *surf, int x, int y); color_t& qpixel(SDL_Surface *surf, int x, int y);
void setvideomode(); void setvideomode();
void saveHighQualityShot(const char *fname = NULL, const char *caption = NULL, int fade = 255); void saveHighQualityShot(const char *fname = NULL, const char *caption = NULL, int fade = 255);
#endif #endif
@ -1288,9 +1293,9 @@ void selectEyeGL(int ed);
void selectEyeMask(int ed); void selectEyeMask(int ed);
extern int ticks; extern int ticks;
extern unsigned backcolor, bordcolor, forecolor; extern color_t backcolor, bordcolor, forecolor;
void setGLProjection(int col = backcolor); void setGLProjection(color_t col = backcolor);
// passable flags // passable flags
@ -1658,7 +1663,7 @@ namespace dialog {
string value; string value;
string keycaption; string keycaption;
int key; int key;
int color, colorv, colork, colors, colorc; color_t color, colorv, colork, colors, colorc;
int scale; int scale;
double param; double param;
int position; int position;
@ -1682,7 +1687,7 @@ namespace dialog {
extern reaction_t reaction, extra_options; extern reaction_t reaction, extra_options;
item& lastItem(); item& lastItem();
extern unsigned int *palette; extern color_t *palette;
string keyname(int k); string keyname(int k);
@ -1691,15 +1696,15 @@ namespace dialog {
void addBoolItem(string body, bool value, int key); void addBoolItem(string body, bool value, int key);
void addBigItem(string body, int key); void addBigItem(string body, int key);
void addColorItem(string body, int value, int key); void addColorItem(string body, int value, int key);
void openColorDialog(unsigned int& col, unsigned int *pal = palette); void openColorDialog(color_t& col, color_t *pal = palette);
void addHelp(string body); void addHelp(string body);
void addInfo(string body, int color = 0xC0C0C0); void addInfo(string body, color_t color = 0xC0C0C0);
void addItem(string body, int key); void addItem(string body, int key);
int addBreak(int val); int addBreak(int val);
void addTitle(string body, int color, int scale); void addTitle(string body, color_t color, int scale);
void init(); void init();
void init(string title, int color = 0xE8E8E8, int scale = 150, int brk = 60); void init(string title, color_t color = 0xE8E8E8, int scale = 150, int brk = 60);
void display(); void display();
void editNumber(ld& x, ld vmin, ld vmax, ld step, ld dft, string title, string help); void editNumber(ld& x, ld vmin, ld vmax, ld step, ld dft, string title, string help);
@ -1709,8 +1714,8 @@ namespace dialog {
void handleNavigation(int &sym, int &uni); void handleNavigation(int &sym, int &uni);
namespace zoom { namespace zoom {
bool displayfr(int x, int y, int b, int size, const string &s, int color, int align); bool displayfr(int x, int y, int b, int size, const string &s, color_t color, int align);
bool displayfr_highlight(int x, int y, int b, int size, const string &s, int color, int align, int hicolor = 0xFFFF00); bool displayfr_highlight(int x, int y, int b, int size, const string &s, color_t color, int align, int hicolor = 0xFFFF00);
} }
bool editingDetail(); bool editingDetail();
@ -1721,7 +1726,7 @@ namespace dialog {
extern bool sidedialog; extern bool sidedialog;
extern int dialogflags; extern int dialogflags;
extern int dcenter; extern int dcenter;
int displaycolor(unsigned col); int displaycolor(color_t col);
void openFileDialog(string& filename, string fcap, string ext, bool_reaction_t action); void openFileDialog(string& filename, string fcap, string ext, bool_reaction_t action);
@ -1744,11 +1749,11 @@ void clearMessages();
void resetGeometry(); void resetGeometry();
namespace svg { namespace svg {
void circle(int x, int y, int size, int col); void circle(int x, int y, int size, color_t col);
void polygon(int *polyx, int *polyy, int polyi, int col, int outline, double linewidth); void polygon(int *polyx, int *polyy, int polyi, color_t col, int outline, double linewidth);
void text(int x, int y, int size, const string& str, bool frame, int col, int align); void text(int x, int y, int size, const string& str, bool frame, color_t col, int align);
extern bool in; extern bool in;
extern const string *link; extern string link;
void render(const char *fname = NULL, const function<void()>& what = drawfullmap); void render(const char *fname = NULL, const function<void()>& what = drawfullmap);
} }
@ -1770,7 +1775,7 @@ extern bool ivoryz;
#define SHADOW_SL 0x18 #define SHADOW_SL 0x18
#define SHADOW_MON 0x30 #define SHADOW_MON 0x30
bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, int col, double footphase); bool drawMonsterType(eMonster m, cell *where, const transmatrix& V, color_t col, double footphase);
void drawPlayerEffects(const transmatrix& V, cell *c, bool onPlayer); void drawPlayerEffects(const transmatrix& V, cell *c, bool onPlayer);
@ -1868,7 +1873,7 @@ inline PPR operator - (PPR x, int y) { return PPR(int(x) - y); }
inline int operator - (PPR x, PPR y) { return int(x) - int(y); } inline int operator - (PPR x, PPR y) { return int(x) - int(y); }
namespace mapeditor { namespace mapeditor {
bool drawUserShape(const transmatrix& V, eShapegroup group, int id, int color, cell *c, PPR prio = PPR::DEFAULT); bool drawUserShape(const transmatrix& V, eShapegroup group, int id, color_t color, cell *c, PPR prio = PPR::DEFAULT);
} }
void ShadowV(const transmatrix& V, const struct hpcshape& bp, PPR prio = PPR::MONSTER_SHADOW); void ShadowV(const transmatrix& V, const struct hpcshape& bp, PPR prio = PPR::MONSTER_SHADOW);
@ -1970,7 +1975,7 @@ void setcameraangle(bool b);
#define MODELCOUNT ((int) mdGUARD) #define MODELCOUNT ((int) mdGUARD)
void drawShape(pair<ld,ld>* coords, int qty, int color); void drawShape(pair<ld,ld>* coords, int qty, color_t color);
extern eModel pmodel; extern eModel pmodel;
@ -2149,10 +2154,10 @@ namespace linepatterns {
}; };
void clearAll(); void clearAll();
void setColor(ePattern id, int col); void setColor(ePattern id, color_t col);
void drawAll(); void drawAll();
void showMenu(); void showMenu();
void switchAlpha(ePattern id, int col); void switchAlpha(ePattern id, color_t col);
}; };
transmatrix ddspin(cell *c, int d, ld bonus = 0); transmatrix ddspin(cell *c, int d, ld bonus = 0);
@ -2371,7 +2376,7 @@ bool inmirror(eLand l);
bool inmirror(cell *c); bool inmirror(cell *c);
bool inmirror(const cellwalker& cw); bool inmirror(const cellwalker& cw);
void queuemarkerat(const transmatrix& V, int col); void queuemarkerat(const transmatrix& V, color_t col);
void check_total_victory(); void check_total_victory();
void applyBoxNum(int& i, string name = ""); void applyBoxNum(int& i, string name = "");
@ -2380,7 +2385,7 @@ extern int hinttoshow;
bool isShmupLifeOrb(eItem it); bool isShmupLifeOrb(eItem it);
int orbcharges(eItem it); int orbcharges(eItem it);
int gradient(int c0, int c1, ld v0, ld v, ld v1); color_t gradient(color_t c0, color_t c1, ld v0, ld v, ld v1);
struct hint { struct hint {
time_t last; time_t last;
@ -2405,10 +2410,10 @@ extern bool longclick;
extern bool useRangedOrb; extern bool useRangedOrb;
#endif #endif
void addaura(const hyperpoint& h, int col, int fd); void addaura(const hyperpoint& h, color_t col, int fd);
void addauraspecial(const hyperpoint& h, int col, int dir); void addauraspecial(const hyperpoint& h, color_t col, int dir);
void drawBug(const cellwalker& cw, int col); void drawBug(const cellwalker& cw, color_t col);
void mainloop(); void mainloop();
void mainloopiter(); void mainloopiter();
@ -2525,60 +2530,60 @@ struct textureinfo {
int current_type, symmetries; int current_type, symmetries;
}; };
struct qpoly { struct drawqueueitem {
transmatrix V;
const vector<glvertex> *tab;
int offset, cnt;
int outline;
double linewidth;
int flags;
textureinfo *tinf;
};
struct qline {
hyperpoint H1, H2;
int prf;
double width;
};
#define MAXQCHR 64
struct qchr {
char str[MAXQCHR];
int x, y, shift, size, frame;
int align;
};
struct qcir {
int x, y, size;
bool boundary;
};
// set a link for SVG
struct qlink {
const string *link;
};
enum eKind { pkPoly, pkLine, pkString, pkCircle, pkShape, pkResetModel, pkSpecial, pkLink };
union polyunion {
qpoly poly;
qline line;
qchr chr;
qcir cir;
double dvalue;
qlink link;
polyunion() {}
};
struct polytodraw {
eKind kind;
PPR prio; PPR prio;
int col; color_t color;
polyunion u; virtual void draw() = 0;
polytodraw() {} virtual void draw_back() {}
virtual void draw_pre() {}
virtual ~drawqueueitem() {}
void draw_darker();
}; };
struct dqi_poly : drawqueueitem {
transmatrix V;
const vector<glvertex> *tab;
int offset, cnt;
int outline;
double linewidth;
int flags;
textureinfo *tinf;
void draw();
void gldraw();
void draw_back();
};
struct dqi_line : drawqueueitem {
hyperpoint H1, H2;
int prf;
double width;
void draw();
void draw_back();
};
struct dqi_string : drawqueueitem {
string str;
int x, y, shift, size, frame;
int align;
void draw();
};
struct dqi_circle : drawqueueitem {
int x, y, size;
void draw();
};
struct dqi_boundary_circle : dqi_circle {
int x, y, size;
void draw_pre();
};
struct dqi_action : drawqueueitem {
reaction_t action;
dqi_action(const reaction_t& a) : action(a) {}
void draw() { action(); }
};
extern int emeraldtable[100][7]; extern int emeraldtable[100][7];
// extern cell *cwpeek(cellwalker cw, int dir); // extern cell *cwpeek(cellwalker cw, int dir);
@ -2952,7 +2957,7 @@ int emeraldval(cell *c);
int inpair(cell *c, int colorpair); int inpair(cell *c, int colorpair);
int snake_pair(cell *c); int snake_pair(cell *c);
extern const unsigned int nestcolors[8]; extern const color_t nestcolors[8];
#if CAP_TEXTURE #if CAP_TEXTURE
namespace texture { namespace texture {
@ -2967,13 +2972,13 @@ namespace texture {
texture_data() { textureid = 0; twidth = 2048; } texture_data() { textureid = 0; twidth = 2048; }
vector<unsigned> texture_pixels; vector<color_t> texture_pixels;
unsigned& get_texture_pixel(int x, int y) { color_t& get_texture_pixel(int x, int y) {
return texture_pixels[(y&(twidth-1))*twidth+(x&(twidth-1))]; return texture_pixels[(y&(twidth-1))*twidth+(x&(twidth-1))];
} }
vector<pair<unsigned*, unsigned>> undos; vector<pair<color_t*, color_t>> undos;
vector<tuple<cell*, hyperpoint, int> > pixels_to_draw; vector<tuple<cell*, hyperpoint, int> > pixels_to_draw;
bool loadTextureGL(); bool loadTextureGL();
@ -2989,22 +2994,22 @@ namespace texture {
struct texture_config { struct texture_config {
string texturename; string texturename;
string configname; string configname;
unsigned paint_color; color_t paint_color;
eTextureState tstate; eTextureState tstate;
eTextureState tstate_max; eTextureState tstate_max;
transmatrix itt; transmatrix itt;
unsigned grid_color; color_t grid_color;
unsigned mesh_color; color_t mesh_color;
unsigned master_color; color_t master_color;
unsigned slave_color; color_t slave_color;
int color_alpha; int color_alpha;
int gsplits; int gsplits;
int recolor(int col); int recolor(color_t col);
typedef tuple<eGeometry, eVariation, char, int, eModel, ld, ld> texture_parameters; typedef tuple<eGeometry, eVariation, char, int, eModel, ld, ld> texture_parameters;
texture_parameters orig_texture_parameters; texture_parameters orig_texture_parameters;
@ -3016,7 +3021,7 @@ namespace texture {
string texture_tuner; string texture_tuner;
vector<hyperpoint*> tuned_vertices; vector<hyperpoint*> tuned_vertices;
bool apply(cell *c, const transmatrix &V, int col); bool apply(cell *c, const transmatrix &V, color_t col);
void mark_triangles(); void mark_triangles();
void clear_texture_map(); void clear_texture_map();
@ -3062,11 +3067,11 @@ namespace texture {
void showMenu(); void showMenu();
void drawPixel(cell *c, hyperpoint h, int col); void drawPixel(cell *c, hyperpoint h, color_t col);
extern cell *where; extern cell *where;
// compute 'c' automatically, based on the hint in 'where' // compute 'c' automatically, based on the hint in 'where'
void drawPixel(hyperpoint h, int col); void drawPixel(hyperpoint h, color_t col);
void drawLine(hyperpoint h1, hyperpoint h2, int col, int steps = 10); void drawLine(hyperpoint h1, hyperpoint h2, color_t col, int steps = 10);
extern bool texturesym; extern bool texturesym;
@ -3077,15 +3082,17 @@ namespace texture {
} }
#endif #endif
void queueline(const hyperpoint& H1, const hyperpoint& H2, int col, int prf = 0, PPR prio = PPR::LINE); dqi_line& queueline(const hyperpoint& H1, const hyperpoint& H2, color_t col, int prf = 0, PPR prio = PPR::LINE);
void queuelink(const string *link, PPR prio);
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 tessf, crossf, hexf, hcrossf, hexhexdist, hexvdist, hepvdist, rhexf;
extern ld scalefactor, orbsize, floorrad0, floorrad1, zhexf; extern ld scalefactor, orbsize, floorrad0, floorrad1, zhexf;
unsigned char& part(int& col, int i); unsigned char& part(color_t& col, int i);
unsigned char& part(unsigned& col, int i);
transmatrix applyPatterndir(cell *c, const patterns::patterninfo& si); transmatrix applyPatterndir(cell *c, const patterns::patterninfo& si);
@ -3172,7 +3179,7 @@ struct renderbuffer {
renderbuffer(int x, int y, bool gl); renderbuffer(int x, int y, bool gl);
~renderbuffer(); ~renderbuffer();
void enable(); void enable();
void clear(int col); void clear(color_t col);
}; };
struct resetbuffer { struct resetbuffer {
@ -3283,7 +3290,7 @@ extern void initializeCLI();
static const int max_vec = (1<<14); static const int max_vec = (1<<14);
string helptitle(string s, int col); string helptitle(string s, color_t col);
pair<int, int> cell_to_pair(cell *c); pair<int, int> cell_to_pair(cell *c);
extern bool nohud, nofps, nomap; extern bool nohud, nofps, nomap;
@ -3296,7 +3303,7 @@ ld hypot3(const hyperpoint& h);
extern const hyperpoint Hypc; extern const hyperpoint Hypc;
ld det(const transmatrix& T); ld det(const transmatrix& T);
void queuechr(const hyperpoint& h, int size, char chr, int col, int frame = 0); void queuechr(const hyperpoint& h, int size, char chr, color_t col, int frame = 0);
string fts(float x); string fts(float x);
bool model_needs_depth(); bool model_needs_depth();
@ -3494,7 +3501,7 @@ template<> struct saver<ld> : dsaver<ld> {
}; };
#endif #endif
extern vector<polytodraw> ptds; extern vector<unique_ptr<drawqueueitem>> ptds;
extern ld intval(const hyperpoint &h1, const hyperpoint &h2); extern ld intval(const hyperpoint &h1, const hyperpoint &h2);
extern ld intvalxy(const hyperpoint &h1, const hyperpoint &h2); extern ld intvalxy(const hyperpoint &h1, const hyperpoint &h2);
transmatrix euscalezoom(hyperpoint h); transmatrix euscalezoom(hyperpoint h);
@ -3520,7 +3527,7 @@ namespace glhr {
void set_depthtest(bool b); void set_depthtest(bool b);
glmatrix translate(ld x, ld y, ld z); glmatrix translate(ld x, ld y, ld z);
void color2(int color, ld part = 1); void color2(color_t color, ld part = 1);
void be_textured(); void be_textured();
void set_modelview(const glmatrix& m); void set_modelview(const glmatrix& m);
hyperpoint gltopoint(const glvertex& t); hyperpoint gltopoint(const glvertex& t);
@ -3563,10 +3570,9 @@ namespace glhr {
void prepare(vector<ct_vertex>& v); void prepare(vector<ct_vertex>& v);
} }
void prettypoly(const vector<hyperpoint>& t, int fillcol, int linecol, int lev); void prettypoly(const vector<hyperpoint>& t, color_t fillcol, color_t linecol, int lev);
polytodraw& lastptd(); dqi_poly& queuepolyat(const transmatrix& V, const hpcshape& h, color_t col, PPR prio);
void queuepolyat(const transmatrix& V, const hpcshape& h, int col, PPR prio); dqi_poly& queuetable(const transmatrix& V, const vector<glvertex>& f, int cnt, color_t linecol, color_t fillcol, PPR prio);
void queuetable(const transmatrix& V, const vector<glvertex>& f, int cnt, int linecol, int fillcol, PPR prio);
struct floorshape; struct floorshape;
@ -3593,9 +3599,9 @@ int fix6(int a);
int fix7(int a); int fix7(int a);
int fixdir(int a, cell *c); int fixdir(int a, cell *c);
cell *newCell(int type, heptagon *master); cell *newCell(int type, heptagon *master);
extern int qpixel_pixel_outside; extern color_t qpixel_pixel_outside;
void queuechr(int x, int y, int shift, int size, char chr, int col, int frame = 0, int align = 8); void queuechr(int x, int y, int shift, int size, char chr, color_t col, int frame = 0, int align = 8);
int zebra3(cell *c); int zebra3(cell *c);
int geosupport_threecolor(); int geosupport_threecolor();
@ -3717,11 +3723,11 @@ namespace gp {
extern bool debug_geometry; extern bool debug_geometry;
void queuepoly(const transmatrix& V, const hpcshape& h, int col); dqi_poly& queuepoly(const transmatrix& V, const hpcshape& h, color_t col);
void queuepolyat(const transmatrix& V, const hpcshape& h, int col, PPR prio); dqi_poly& queuepolyat(const transmatrix& V, const hpcshape& h, color_t col, PPR prio);
void queuestr(const hyperpoint& h, int size, const string& chr, int col, int frame = 0); void queuestr(const hyperpoint& h, int size, const string& chr, color_t col, int frame = 0);
void queuechr(const transmatrix& V, double size, char chr, int col, int frame = 0); void queuechr(const transmatrix& V, double size, char chr, color_t col, int frame = 0);
extern bool just_gmatrix; extern bool just_gmatrix;
void drawrec(const heptspin& hs, hstate s, const transmatrix& V); void drawrec(const heptspin& hs, hstate s, const transmatrix& V);
@ -3868,12 +3874,12 @@ namespace geom3 {
extern ld BODY; extern ld BODY;
} }
void queuestr(const transmatrix& V, double size, const string& chr, int col, int frame = 0, int align = 8); void queuestr(const transmatrix& V, double size, const string& chr, color_t col, int frame = 0, int align = 8);
void queuestr(int x, int y, int shift, int size, string str, int col, int frame = 0, int align = 8); void queuestr(int x, int y, int shift, int size, string str, color_t col, int frame = 0, int align = 8);
ld frac(ld x); ld frac(ld x);
extern int poly_outline; extern color_t poly_outline;
extern hpcshape shDisk, shTriangle, shHeptaMarker, shSnowball, shDiskT, shDiskS, shDiskSq, shDiskM; extern hpcshape shDisk, shTriangle, shHeptaMarker, shSnowball, shDiskT, shDiskS, shDiskSq, shDiskM;

2
inventory.cpp
View File

@ -544,7 +544,7 @@ namespace hr { namespace inv {
eLand pl = getPrizeLand(); eLand pl = getPrizeLand();
eOrbLandRelation olr = getOLR(which, pl); eOrbLandRelation olr = getOLR(which, pl);
int col = 0; color_t col = 0;
const char *fmsg = NULL; const char *fmsg = NULL;
if(olr == olrDangerous) if(olr == olrDangerous)
col = 0xC00000, col = 0xC00000,

18
mapeditor.cpp
View File

@ -898,7 +898,7 @@ namespace mapeditor {
int dslayer; int dslayer;
bool coloring; bool coloring;
unsigned int colortouse = 0xC0C0C0FFu; color_t colortouse = 0xC0C0C0FFu;
// fake key sent to change the color // fake key sent to change the color
static const int COLORKEY = (-10000); static const int COLORKEY = (-10000);
@ -1180,20 +1180,20 @@ namespace mapeditor {
initShape(sg, id); initShape(sg, id);
for(int i=0; i<isize(ptds); i++) { for(int i=0; i<isize(ptds); i++) {
auto& ptd = ptds[i]; auto pp = dynamic_cast<dqi_poly*> (&*ptds[i]);
if(ptd.kind != pkPoly) continue; if(!pp) continue;
auto& ptd = *pp;
auto& p = ptd.u.poly; int cnt = ptd.cnt;
int cnt = p.cnt;
usershapelayer *dsCur = &usershapes[sg][id]->d[layer]; usershapelayer *dsCur = &usershapes[sg][id]->d[layer];
dsCur->list.clear(); dsCur->list.clear();
dsCur->color = ptd.col; dsCur->color = ptd.color;
dsCur->sym = false; dsCur->sym = false;
dsCur->rots = 1; dsCur->rots = 1;
for(auto& v: symmetriesAt) for(auto& v: symmetriesAt)
if(v[0] == p.offset) { if(v[0] == ptd.offset) {
dsCur->rots = v[1]; dsCur->rots = v[1];
dsCur->sym = v[2] == 2; dsCur->sym = v[2] == 2;
} }
@ -1201,7 +1201,7 @@ namespace mapeditor {
int d = dsCur->rots * (dsCur->sym ? 2 : 1); int d = dsCur->rots * (dsCur->sym ? 2 : 1);
for(int i=0; i < cnt/d; i++) for(int i=0; i < cnt/d; i++)
dsCur->list.push_back(p.V * glhr::gltopoint((*p.tab)[i+p.offset])); dsCur->list.push_back(ptd.V * glhr::gltopoint((*ptd.tab)[i+ptd.offset]));
layer++; layer++;
if(layer == USERLAYERS) break; if(layer == USERLAYERS) break;
@ -1699,7 +1699,7 @@ namespace mapeditor {
#endif #endif
} }
bool drawUserShape(const transmatrix& V, eShapegroup group, int id, int color, cell *c, PPR prio) { bool drawUserShape(const transmatrix& V, eShapegroup group, int id, color_t color, cell *c, PPR prio) {
#if !CAP_EDIT #if !CAP_EDIT
return false; return false;
#else #else

2
menus.cpp
View File

@ -73,7 +73,7 @@ void showOverview() {
eLand l = landlist[lstart + i]; eLand l = landlist[lstart + i];
int xr = vid.xres / 64; int xr = vid.xres / 64;
int i0 = 56 + vid.fsize + i * vf; int i0 = 56 + vid.fsize + i * vf;
int col; color_t col;
if(landUnlocked(l)) col = linf[l].color; else col = 0x404040; if(landUnlocked(l)) col = linf[l].color; else col = 0x404040;
if(l == curland) if(l == curland)
displayfrZ(1, i0, 1, vf-4, "*", forecolor, 0); displayfrZ(1, i0, 1, vf-4, "*", forecolor, 0);

6
monstergen.cpp
View File

@ -674,9 +674,9 @@ void wandering() {
} }
} }
void generateSnake(cell *c, int i, int color) { void generateSnake(cell *c, int i, int snakecolor) {
c->monst = moHexSnake; c->monst = moHexSnake;
c->hitpoints = color; c->hitpoints = snakecolor;
int cpair = (1<<pattern_threecolor(c)) | (1<<pattern_threecolor(c->move(i))); int cpair = (1<<pattern_threecolor(c)) | (1<<pattern_threecolor(c->move(i)));
preventbarriers(c); preventbarriers(c);
int len = BITRUNCATED ? ROCKSNAKELENGTH : 2; int len = BITRUNCATED ? ROCKSNAKELENGTH : 2;
@ -691,7 +691,7 @@ void generateSnake(cell *c, int i, int color) {
cell *c3 = c2->move(i); cell *c3 = c2->move(i);
if(c3->monst || c3->bardir != NODIR || c3->wall) break; if(c3->monst || c3->bardir != NODIR || c3->wall) break;
c2 = c3; c2 = c3;
c2->monst = moHexSnakeTail; c2->hitpoints = color; c2->monst = moHexSnakeTail; c2->hitpoints = snakecolor;
i = (j + (c2->type%4 == 0 ? c2->type/2 : (len%2 ? 2 : c2->type - 2))) % c2->type; i = (j + (c2->type%4 == 0 ? c2->type/2 : (len%2 ? 2 : c2->type - 2))) % c2->type;
createMov(c2, i); createMov(c2, i);
if(!inpair(c2->move(i), cpair)) { if(!inpair(c2->move(i), cpair)) {

14
netgen.cpp
View File

@ -213,13 +213,13 @@ namespace hr { namespace netgen {
// Simple graphical functions // Simple graphical functions
//============================ //============================
void blackline(vec v1, vec v2, int col = 0x000000FF) { void blackline(vec v1, vec v2, color_t col = 0x000000FF) {
#if CAP_SDLGFX==1 #if CAP_SDLGFX==1
aalineColor(s, int(v1.x), int(v1.y), int(v2.x), int(v2.y), col); aalineColor(s, int(v1.x), int(v1.y), int(v2.x), int(v2.y), col);
#endif #endif
} }
void drawtriangle(vec v1, vec v2, vec v3, int col) { void drawtriangle(vec v1, vec v2, vec v3, color_t col) {
#if CAP_SDLGFX==1 #if CAP_SDLGFX==1
polyx[0] = int(v1.x); polyx[0] = int(v1.x);
polyx[1] = int(v2.x); polyx[1] = int(v2.x);
@ -231,7 +231,7 @@ namespace hr { namespace netgen {
#endif #endif
} }
void blackcircle(vec v, int r, int col = 0x000000FF) { void blackcircle(vec v, int r, color_t col = 0x000000FF) {
#if CAP_SDLGFX #if CAP_SDLGFX
aacircleColor(s, int(v.x), int(v.y), r, col); aacircleColor(s, int(v.x), int(v.y), r, col);
#endif #endif
@ -257,7 +257,7 @@ namespace hr { namespace netgen {
SDL_Surface *net, *hqsurface; SDL_Surface *net, *hqsurface;
int& hqpixel(hyperpoint h) { color_t& hqpixel(hyperpoint h) {
int hx, hy, hs; int hx, hy, hs;
getcoord0(h, hx, hy, hs); getcoord0(h, hx, hy, hs);
return qpixel(hqsurface, hx, hy); return qpixel(hqsurface, hx, hy);
@ -388,7 +388,7 @@ namespace hr { namespace netgen {
"!@#$%^&*+=~:;<>?/|\"., [{(\\]})" [(pateks++) % 85]; "!@#$%^&*+=~:;<>?/|\"., [{(\\]})" [(pateks++) % 85];
} }
int col = 0xFFFFFFFF; color_t col = 0xFFFFFFFF;
int p = patek[i][e]; int p = patek[i][e];
col -= 0x8000 * (p&1); p /= 2; col -= 0x8000 * (p&1); p /= 2;
col -= 0x800000 * (p&1); p /= 2; col -= 0x800000 * (p&1); p /= 2;
@ -520,7 +520,7 @@ namespace hr { namespace netgen {
if(i == bei && e == bee) cedist = norm(v3-mousepos); if(i == bei && e == bee) cedist = norm(v3-mousepos);
} }
int col = color_t col =
i == bei && e == bee ? 0x40FF40FF: i == bei && e == bee ? 0x40FF40FF:
i == nei[bei][bee] && nei[i][e] == bei ? 0x40FF40FF : i == nei[bei][bee] && nei[i][e] == bei ? 0x40FF40FF :
nei[i][e] == glued[i] ? 0x303030FF : nei[i][e] == glued[i] ? 0x303030FF :
@ -640,7 +640,7 @@ namespace hr { namespace netgen {
int t = ct[i]; int t = ct[i];
int ofs = t == 7 ? 0 : 5; int ofs = t == 7 ? 0 : 5;
for(int e=0; e<t; e++) { for(int e=0; e<t; e++) {
int col = color_t col =
nei[i][e] == glued[i] && glued[i] >= 0 ? 0x303030 : nei[i][e] == glued[i] && glued[i] >= 0 ? 0x303030 :
nei[i][e] >= 0 && glued[nei[i][e]] == i ? 0x303030 : nei[i][e] >= 0 && glued[nei[i][e]] == i ? 0x303030 :
nei[i][e] >= 0 ? 0x808080 : nei[i][e] >= 0 ? 0x808080 :

34
pattern2.cpp
View File

@ -1327,12 +1327,12 @@ namespace patterns {
if(whichCanvas == 'r') if(whichCanvas == 'r')
return hrand(0xFFFFFF + 1); return hrand(0xFFFFFF + 1);
if(whichCanvas == 'e') { if(whichCanvas == 'e') {
static unsigned int fcol[4] = { 0x404040, 0x800000, 0x008000, 0x000080 }; static color_t fcol[4] = { 0x404040, 0x800000, 0x008000, 0x000080 };
int fv = emeraldval(c); int fv = emeraldval(c);
return fcol[fv&3]; return fcol[fv&3];
} }
if(whichCanvas == 'a') { if(whichCanvas == 'a') {
static unsigned int fcol8[8] = { static color_t fcol8[8] = {
0x800000, 0x800000,
0x503000, 0x503000,
0x206000, 0x206000,
@ -1344,32 +1344,32 @@ namespace patterns {
}; };
if(c->wall == waNone) { if(c->wall == waNone) {
int col = fcol8[land50(c)]; color_t col = fcol8[land50(c)];
if(polara50(c)) col += 0x181818; if(polara50(c)) col += 0x181818;
return col; return col;
} }
} }
if(whichCanvas == 'b') { if(whichCanvas == 'b') {
static unsigned int fcol[4] = { 0x404040, 0x800000, 0x008000, 0x000080 }; static color_t fcol[4] = { 0x404040, 0x800000, 0x008000, 0x000080 };
return fcol[polara50(c) + 2 * polarb50(c)]; return fcol[polara50(c) + 2 * polarb50(c)];
} }
if(whichCanvas == 'z') { if(whichCanvas == 'z') {
static unsigned int fcol[4] = { 0xC0C0C0, 0xE0E0E0, 0x404040, 0x606060 }; static color_t fcol[4] = { 0xC0C0C0, 0xE0E0E0, 0x404040, 0x606060 };
int fv = zebra40(c); int fv = zebra40(c);
return fcol[fv&3]; return fcol[fv&3];
} }
if(whichCanvas == 't') { if(whichCanvas == 't') {
static unsigned int fcol[4] = { 0x804040, 0x408040, 0x404080, 0x808040 }; static color_t fcol[4] = { 0x804040, 0x408040, 0x404080, 0x808040 };
int fv = zebra40(c); int fv = zebra40(c);
if(fv/4 == 4 || fv/4 == 6 || fv/4 == 5 || fv/4 == 10) fv ^= 2; if(fv/4 == 4 || fv/4 == 6 || fv/4 == 5 || fv/4 == 10) fv ^= 2;
return fcol[fv&3]; return fcol[fv&3];
} }
if(whichCanvas == 'x') { if(whichCanvas == 'x') {
static unsigned int fcol[4] = { 0xC0C0C0, 0x800000, 0x008000, 0x000080 }; static color_t fcol[4] = { 0xC0C0C0, 0x800000, 0x008000, 0x000080 };
return fcol[zebra3(c)]; return fcol[zebra3(c)];
} }
if(whichCanvas == 'w') { if(whichCanvas == 'w') {
static unsigned int fcol[2] = { 0x303030, 0xC0C0C0 }; static color_t fcol[2] = { 0x303030, 0xC0C0C0 };
return fcol[randpattern(c, subcanvas) ? 1 : 0]; return fcol[randpattern(c, subcanvas) ? 1 : 0];
} }
if(whichCanvas == 'l') { if(whichCanvas == 'l') {
@ -1935,16 +1935,16 @@ bool is_master(cell *c) {
namespace linepatterns { namespace linepatterns {
int lessalpha(int col, int m) { color_t lessalpha(color_t col, int m) {
part(col, 0) /= m; part(col, 0) /= m;
return col; return col;
} }
int lessalphaif(int col, bool b) { color_t lessalphaif(color_t col, bool b) {
return b?lessalpha(col, 4):col; return b?lessalpha(col, 4):col;
} }
int lessalphaif(int col, bool b1, bool b2) { color_t lessalphaif(color_t col, bool b1, bool b2) {
if(b1) col = lessalpha(col, 2); if(b1) col = lessalpha(col, 2);
if(b2) col = lessalpha(col, 2); if(b2) col = lessalpha(col, 2);
return col; return col;
@ -1953,7 +1953,7 @@ namespace linepatterns {
struct { struct {
int id; int id;
const char *lpname; const char *lpname;
unsigned int color; color_t color;
} patterns[] = { } patterns[] = {
{patTriNet, "triangle grid: not rings", 0xFFFFFF00}, {patTriNet, "triangle grid: not rings", 0xFFFFFF00},
@ -1987,17 +1987,17 @@ namespace linepatterns {
return false; return false;
} }
void setColor(ePattern id, int col) { void setColor(ePattern id, color_t col) {
for(int k=0; patterns[k].lpname; k++) for(int k=0; patterns[k].lpname; k++)
if(patterns[k].id == id) patterns[k].color = col; if(patterns[k].id == id) patterns[k].color = col;
} }
void switchAlpha(ePattern id, int col) { void switchAlpha(ePattern id, color_t col) {
for(int k=0; patterns[k].lpname; k++) for(int k=0; patterns[k].lpname; k++)
if(patterns[k].id == id) patterns[k].color ^= col; if(patterns[k].id == id) patterns[k].color ^= col;
} }
void queuelinef(const hyperpoint& h1, const hyperpoint& h2, int col, int par) { void queuelinef(const hyperpoint& h1, const hyperpoint& h2, color_t col, int par) {
if(!elliptic) if(!elliptic)
queueline(h1, h2, col, par); queueline(h1, h2, col, par);
else { else {
@ -2012,7 +2012,7 @@ namespace linepatterns {
} }
} }
void drawPattern(int id, int col, cell *c, const transmatrix& V) { void drawPattern(int id, color_t col, cell *c, const transmatrix& V) {
switch(id) { switch(id) {
@ -2212,7 +2212,7 @@ namespace linepatterns {
transmatrix& V = it->second; transmatrix& V = it->second;
for(int k=0; patterns[k].lpname; k++) { for(int k=0; patterns[k].lpname; k++) {
int col = patterns[k].color; color_t col = patterns[k].color;
if(!(col & 255)) continue; if(!(col & 255)) continue;
int id = patterns[k].id; int id = patterns[k].id;

4
patterngen.cpp
View File

@ -14,7 +14,7 @@ int style = 3;
struct state50 { struct state50 {
bool polarity1; bool polarity1;
bool polarity2; bool polarity2;
int color, color2, wc2; color_t color, color2, wc2;
}; };
void progress(cell *c, state50 s); void progress(cell *c, state50 s);
@ -173,7 +173,7 @@ void patternFiftyAt(cell *c) {
int sgn = s.polarity2 ? 1 : -1; int sgn = s.polarity2 ? 1 : -1;
int sgn1 = s.polarity1 ? 1 : -1; int sgn1 = s.polarity1 ? 1 : -1;
int col2 = s.color2, sw = s.wc2; color_t col2 = s.color2, sw = s.wc2;
while(col2 != 7-s.color) { while(col2 != 7-s.color) {
sw += (s.polarity1?1:-1); sw %= 7; sw += (s.polarity1?1:-1); sw %= 7;

657
polygons.cpp
View File

File diff suppressed because it is too large Load Diff

2
renderbuffer.cpp
View File

@ -184,7 +184,7 @@ renderbuffer::~renderbuffer() {
#endif #endif
} }
void renderbuffer::clear(int col) { void renderbuffer::clear(color_t col) {
#if CAP_GL #if CAP_GL
if(FramebufferName) { if(FramebufferName) {
setGLProjection(0); setGLProjection(0);

13
rogueviz-banachtarski.cpp
View File

@ -288,11 +288,6 @@ ld alphaof(hyperpoint h) {
return atan2(h[1], h[0]); return atan2(h[1], h[0]);
} }
struct bantar_special {
polytodraw *actual;
ld xpos, ypos;
};
#define ForInfos for(auto& cci: infos) #define ForInfos for(auto& cci: infos)
void bantar_frame() { void bantar_frame() {
@ -308,7 +303,7 @@ void bantar_frame() {
calcparam(); calcparam();
stereo::set_projection(0); stereo::set_projection(0);
vector<polytodraw> subscr[4]; vector<unique_ptr<drawqueueitem>> subscr[4];
compute_graphical_distance(); compute_graphical_distance();
@ -399,14 +394,14 @@ void bantar_frame() {
subscr[i] = move(ptds); subscr[i] = move(ptds);
} }
map<int, map<int, vector<polytodraw>>> xptds; map<int, map<int, vector<unique_ptr<drawqueueitem>>>> xptds;
for(int i=0; i<4; i++) for(auto& p: subscr[i]) for(int i=0; i<4; i++) for(auto& p: subscr[i])
xptds[int(p.prio)][i].push_back(p); xptds[int(p->prio)][i].push_back(move(p));
for(auto& sm: xptds) for(auto& sm2: sm.second) { for(auto& sm: xptds) for(auto& sm2: sm.second) {
int i = sm2.first; int i = sm2.first;
ptds.clear(); ptds.clear();
for(auto& p: sm2.second) ptds.push_back(p); for(auto& p: sm2.second) ptds.push_back(move(p));
vid.scale = .5; vid.scale = .5;
vid.xposition = (!(i&2)) ? xdst : -xdst; vid.xposition = (!(i&2)) ? xdst : -xdst;

53
rogueviz-kohonen.cpp
View File

@ -6,7 +6,7 @@
namespace rogueviz { namespace kohonen { namespace rogueviz { namespace kohonen {
int cols; int columns;
typedef vector<double> kohvec; typedef vector<double> kohvec;
@ -28,7 +28,7 @@ struct neuron {
cell *where; cell *where;
double udist; double udist;
int lpbak; int lpbak;
int col; color_t col;
int allsamples, drawn_samples, csample, bestsample, max_group_here; int allsamples, drawn_samples, csample, bestsample, max_group_here;
neuron() { drawn_samples = allsamples = bestsample = 0; max_group_here = max_group; } neuron() { drawn_samples = allsamples = bestsample = 0; max_group_here = max_group; }
}; };
@ -41,7 +41,7 @@ vector<neuron> net;
int neuronId(neuron& n) { return &n - &(net[0]); } int neuronId(neuron& n) { return &n - &(net[0]); }
void alloc(kohvec& k) { k.resize(cols); } void alloc(kohvec& k) { k.resize(columns); }
bool neurons_indexed = false; bool neurons_indexed = false;
@ -53,7 +53,7 @@ vector<neuron*> whowon;
void normalize() { void normalize() {
alloc(weights); alloc(weights);
for(int k=0; k<cols; k++) { for(int k=0; k<columns; k++) {
double sum = 0, sqsum = 0; double sum = 0, sqsum = 0;
for(sample& s: data) for(sample& s: data)
sum += s.val[k], sum += s.val[k],
@ -65,7 +65,7 @@ void normalize() {
double vnorm(kohvec& a, kohvec& b) { double vnorm(kohvec& a, kohvec& b) {
double diff = 0; double diff = 0;
for(int k=0; k<cols; k++) diff += sqr((a[k]-b[k]) * weights[k]); for(int k=0; k<columns; k++) diff += sqr((a[k]-b[k]) * weights[k]);
return diff; return diff;
} }
@ -82,7 +82,7 @@ void loadsamples(const string& fname) {
fprintf(stderr, "Could not load samples: %s\n", fname.c_str()); fprintf(stderr, "Could not load samples: %s\n", fname.c_str());
return; return;
} }
if(fscanf(f, "%d", &cols) != 1) { if(fscanf(f, "%d", &columns) != 1) {
printf("Bad format: %s\n", fname.c_str()); printf("Bad format: %s\n", fname.c_str());
fclose(f); return; fclose(f); return;
} }
@ -92,7 +92,7 @@ void loadsamples(const string& fname) {
bool shown = false; bool shown = false;
alloc(s.val); alloc(s.val);
if(feof(f)) break; if(feof(f)) break;
for(int i=0; i<cols; i++) for(int i=0; i<columns; i++)
if(fscanf(f, "%lf", &s.val[i]) != 1) { goto bigbreak; } if(fscanf(f, "%lf", &s.val[i]) != 1) { goto bigbreak; }
fgetc(f); fgetc(f);
while(true) { while(true) {
@ -109,8 +109,8 @@ void loadsamples(const string& fname) {
fclose(f); fclose(f);
samples = isize(data); samples = isize(data);
normalize(); normalize();
colnames.resize(cols); colnames.resize(columns);
for(int i=0; i<cols; i++) colnames[i] = "Column " + its(i); for(int i=0; i<columns; i++) colnames[i] = "Column " + its(i);
uninit(0); sominit(1); uninit(0); sominit(1);
} }
@ -184,8 +184,9 @@ void coloring() {
} }
} }
for(int i=0; i<cells; i++) for(int i=0; i<cells; i++) {
part(net[i].where->landparam, pid) = part(vdata[net[i].bestsample].cp.color1, pid+1); part(net[i].where->landparam_color, pid) = part(vdata[net[i].bestsample].cp.color1, pid+1);
}
} }
else { else {
@ -220,7 +221,7 @@ void coloring() {
if(maxl-minl < 1e-3) maxl = minl+1e-3; if(maxl-minl < 1e-3) maxl = minl+1e-3;
for(int i=0; i<cells; i++) for(int i=0; i<cells; i++)
part(net[i].where->landparam, pid) = (255 * (listing[i] - minl)) / (maxl - minl); part(net[i].where->landparam_color, pid) = (255 * (listing[i] - minl)) / (maxl - minl);
} }
} }
} }
@ -534,7 +535,7 @@ void step() {
// nu *= exp(-t*(double)maxdist/perdist); // nu *= exp(-t*(double)maxdist/perdist);
// nu *= exp(-t/t2); // nu *= exp(-t/t2);
nu *= exp(-sqr(d/sigma)); nu *= exp(-sqr(d/sigma));
for(int k=0; k<cols; k++) for(int k=0; k<columns; k++)
n2.net[k] += nu * (irisdata[id][k] - n2.net[k]); n2.net[k] += nu * (irisdata[id][k] - n2.net[k]);
} */ } */
@ -555,7 +556,7 @@ void step() {
else else
nu *= *(it++); nu *= *(it++);
for(int k=0; k<cols; k++) for(int k=0; k<columns; k++)
n2->net[k] += nu * (data[id].val[k] - n2->net[k]); n2->net[k] += nu * (data[id].val[k] - n2->net[k]);
} }
@ -659,7 +660,7 @@ void sominit(int initto) {
net[i].where->land = laCanvas; net[i].where->land = laCanvas;
alloc(net[i].net); alloc(net[i].net);
for(int k=0; k<cols; k++) for(int k=0; k<columns; k++)
for(int z=0; z<initdiv; z++) for(int z=0; z<initdiv; z++)
net[i].net[k] += data[hrand(samples)].val[k] / initdiv; net[i].net[k] += data[hrand(samples)].val[k] / initdiv;
} }
@ -720,7 +721,7 @@ void describe_cell(cell *c) {
neuron *n = getNeuronSlow(c); neuron *n = getNeuronSlow(c);
if(!n) return; if(!n) return;
help += "cell number: " + its(neuronId(*n)) + " (" + its(n->allsamples) + ")\n"; help += "cell number: " + its(neuronId(*n)) + " (" + its(n->allsamples) + ")\n";
help += "parameters:"; for(int k=0; k<cols; k++) help += " " + fts(n->net[k]); help += "parameters:"; for(int k=0; k<columns; k++) help += " " + fts(n->net[k]);
help += ", u-matrix = " + fts(n->udist); help += ", u-matrix = " + fts(n->udist);
help += "\n"; help += "\n";
vector<pair<double, int>> v; vector<pair<double, int>> v;
@ -731,7 +732,7 @@ void describe_cell(cell *c) {
for(int i=0; i<isize(v) && i<20; i++) { for(int i=0; i<isize(v) && i<20; i++) {
int s = v[i].second; int s = v[i].second;
help += "sample "+its(s)+":"; help += "sample "+its(s)+":";
for(int k=0; k<cols; k++) help += " " + fts(data[s].val[k]); for(int k=0; k<columns; k++) help += " " + fts(data[s].val[k]);
help += " "; help += data[s].name; help += "\n"; help += " "; help += data[s].name; help += "\n";
} }
} }
@ -740,7 +741,7 @@ namespace levelline {
struct levelline { struct levelline {
int column, qty; int column, qty;
unsigned int color; color_t color;
vector<double> values; vector<double> values;
bool modified; bool modified;
}; };
@ -751,7 +752,7 @@ namespace levelline {
void create() { void create() {
int xlalpha = part(default_edgetype.color, 0); int xlalpha = part(default_edgetype.color, 0);
for(int i=0; i<cols; i++) { for(int i=0; i<columns; i++) {
levellines.emplace_back(); levellines.emplace_back();
levelline& lv = levellines.back(); levelline& lv = levellines.back();
lv.column = i; lv.column = i;
@ -874,7 +875,7 @@ void ksave(const string& fname) {
} }
fprintf(f, "%d %d\n", cells, t); fprintf(f, "%d %d\n", cells, t);
for(neuron& n: net) { for(neuron& n: net) {
for(int k=0; k<cols; k++) for(int k=0; k<columns; k++)
fprintf(f, "%.9lf ", n.net[k]); fprintf(f, "%.9lf ", n.net[k]);
fprintf(f, "\n"); fprintf(f, "\n");
} }
@ -899,7 +900,7 @@ void kload(const string& fname) {
exit(1); exit(1);
} }
for(neuron& n: net) { for(neuron& n: net) {
for(int k=0; k<cols; k++) if(fscanf(f, "%lf", &n.net[k]) != 1) return; for(int k=0; k<columns; k++) if(fscanf(f, "%lf", &n.net[k]) != 1) return;
} }
fclose(f); fclose(f);
analyze(); analyze();
@ -913,7 +914,7 @@ void ksavew(const string& fname) {
return; return;
} }
printf("Saving the network to %s...\n", fname.c_str()); printf("Saving the network to %s...\n", fname.c_str());
for(int i=0; i<cols; i++) for(int i=0; i<columns; i++)
fprintf(f, "%s=%.9lf\n", colnames[i].c_str(), weights[i]); fprintf(f, "%s=%.9lf\n", colnames[i].c_str(), weights[i]);
fclose(f); fclose(f);
} }
@ -925,7 +926,7 @@ void kloadw(const string& fname) {
fprintf(stderr, "Could not load the weights\n"); fprintf(stderr, "Could not load the weights\n");
return; return;
} }
for(int i=0; i<cols; i++) { for(int i=0; i<columns; i++) {
string s1, s2; string s1, s2;
char kind = 0; char kind = 0;
while(true) { while(true) {
@ -1122,12 +1123,12 @@ void klistsamples(const string& fname_samples, bool best, bool colorformat) {
fprintf(f, "%s;+#%d\n", data[id].name.c_str(), neu); fprintf(f, "%s;+#%d\n", data[id].name.c_str(), neu);
} }
else { else {
for(int k=0; k<cols; k++) for(int k=0; k<columns; k++)
fprintf(f, "%.4lf ", data[id].val[k]); fprintf(f, "%.4lf ", data[id].val[k]);
fprintf(f, "!%s\n", data[id].name.c_str()); fprintf(f, "!%s\n", data[id].name.c_str());
} }
}; };
if(!colorformat) fprintf(f, "%d\n", cols); if(!colorformat) fprintf(f, "%d\n", columns);
if(best) if(best)
for(int n=0; n<cells; n++) { for(int n=0; n<cells; n++) {
if(!net[n].allsamples && !net[n].drawn_samples) { if(!colorformat) fprintf(f, "\n"); continue; } if(!net[n].allsamples && !net[n].drawn_samples) { if(!colorformat) fprintf(f, "\n"); continue; }
@ -1188,7 +1189,7 @@ bool handleMenu(int sym, int uni) {
if(uni >= '1' && uni <= '3') { if(uni >= '1' && uni <= '3') {
int i = uni - '1'; int i = uni - '1';
whattodraw[i]++; whattodraw[i]++;
if(whattodraw[i] == cols) whattodraw[i] = -5; if(whattodraw[i] == columns) whattodraw[i] = -5;
coloring(); coloring();
return true; return true;
} }

21
rogueviz.cpp
View File

@ -1056,14 +1056,14 @@ void queuedisk(const transmatrix& V, const colorpair& cp, bool legend, const str
int p = poly_outline; poly_outline = OUTLINE_TRANS; int p = poly_outline; poly_outline = OUTLINE_TRANS;
queuepolyat(V, sh, 0x80, PPR::MONSTER_SHADOW); queuepolyat(V, sh, 0x80, PPR::MONSTER_SHADOW);
poly_outline = p; poly_outline = p;
if(info) queuelink(info, PPR::MONSTER_HEAD); if(info) queueaction(PPR::MONSTER_HEAD, [info] () { svg::link = *info; });
queuepolyat(V1 = mscale(V, geom3::BODY), sh, cp.color1, PPR::MONSTER_HEAD); queuepolyat(V1 = mscale(V, geom3::BODY), sh, cp.color1, PPR::MONSTER_HEAD);
if(info) queuelink(NULL, PPR::MONSTER_HEAD); if(info) queueaction(PPR::MONSTER_HEAD, [info] () { svg::link = ""; });
} }
else { else {
if(info) queuelink(info, sh.prio); if(info) queueaction(PPR::MONSTER_HEAD, [info] () { svg::link = *info; });
queuepoly(V1 = V, sh, cp.color1); queuepoly(V1 = V, sh, cp.color1);
if(info) queuelink(NULL, sh.prio); if(info) queueaction(PPR::MONSTER_HEAD, [info] () { svg::link = ""; });
} }
if(cp.shade == 't') queuepoly(V1, shDiskT, cp.color2); if(cp.shade == 't') queuepoly(V1, shDiskT, cp.color2);
if(cp.shade == 's') queuepoly(V1, shDiskS, cp.color2); if(cp.shade == 's') queuepoly(V1, shDiskS, cp.color2);
@ -1116,7 +1116,7 @@ bool drawVertex(const transmatrix &V, cell *c, shmup::monster *m) {
if(ei->lastdraw < frameid || multidraw) { if(ei->lastdraw < frameid || multidraw) {
ei->lastdraw = frameid; ei->lastdraw = frameid;
int col = ei->type->color; color_t col = ei->type->color;
auto& alpha = part(col, 0); auto& alpha = part(col, 0);
if(kind == kSAG) { if(kind == kSAG) {
@ -1173,14 +1173,12 @@ bool drawVertex(const transmatrix &V, cell *c, shmup::monster *m) {
hyperpoint l1 = T*tC0(spiral::at(1+ei->i)); hyperpoint l1 = T*tC0(spiral::at(1+ei->i));
for(int z=1; z<=prec; z++) { for(int z=1; z<=prec; z++) {
hyperpoint l2 = T*tC0(spiral::at(1+ei->i+(ei->j-ei->i) * z / (prec+.0))); hyperpoint l2 = T*tC0(spiral::at(1+ei->i+(ei->j-ei->i) * z / (prec+.0)));
queueline(l1, l2, col, vid.linequality); queueline(l1, l2, col, vid.linequality).prio = PPR::STRUCT0;
l1 = l2; l1 = l2;
lastptd().prio = PPR::STRUCT0;
} }
} }
else { else {
queueline(h1, h2, col, 2 + vid.linequality); queueline(h1, h2, col, 2 + vid.linequality).prio = PPR::STRUCT0;
lastptd().prio = PPR::STRUCT0;
} }
} }
else { else {
@ -1233,9 +1231,10 @@ bool drawVertex(const transmatrix &V, cell *c, shmup::monster *m) {
hyperpoint h = tC0(V * m->at); hyperpoint h = tC0(V * m->at);
transmatrix V2 = rgpushxto0(h) * ypush(PURE ? .3 : .2); // todo-variation transmatrix V2 = rgpushxto0(h) * ypush(PURE ? .3 : .2); // todo-variation
if(doshow && !behindsphere(V2)) { if(doshow && !behindsphere(V2)) {
if(vd.info) queuelink(vd.info, PPR::TEXT); auto info = vd.info;
if(info) queueaction(PPR::MONSTER_HEAD, [info] () { svg::link = *info; });
queuestr(V2, (svg::in ? .28 : .2) * crossf / hcrossf, vd.name, backcolor ? 0x000000 : 0xFFFF00, svg::in ? 0 : 1); queuestr(V2, (svg::in ? .28 : .2) * crossf / hcrossf, vd.name, backcolor ? 0x000000 : 0xFFFF00, svg::in ? 0 : 1);
if(vd.info) queuelink(NULL, PPR::TEXT); if(info) queueaction(PPR::MONSTER_HEAD, [info] () { svg::link = ""; });
} }
} }

4
rogueviz.h
View File

@ -32,9 +32,9 @@ namespace rogueviz {
}; };
struct colorpair { struct colorpair {
int color1, color2; color_t color1, color2;
char shade; char shade;
colorpair(int col = 0xC0C0C0FF) { shade = 0; color1 = col; } colorpair(color_t col = 0xC0C0C0FF) { shade = 0; color1 = col; }
}; };
struct vertexdata { struct vertexdata {

2
scores.cpp
View File

@ -202,7 +202,7 @@ void show() {
for(int i=0; i<POSSCORE; i++) S.box[i] = savebox[i]; for(int i=0; i<POSSCORE; i++) S.box[i] = savebox[i];
S.box[0] = S.box[65]; S.box[0] = S.box[65];
} }
int col = cur ? 0xFFD500 : 0xC0C0C0; color_t col = cur ? 0xFFD500 : 0xC0C0C0;
rank++; rank++;

18
screenshot.cpp
View File

@ -15,13 +15,13 @@ namespace svg {
FILE *f; FILE *f;
bool in = false; bool in = false;
ld cta(int col) { ld cta(color_t col) {
// col >>= 24; // col >>= 24;
col &= 0xFF; col &= 0xFF;
return col / 255.0; return col / 255.0;
} }
bool invisible(int col) { return (col & 0xFF) == 0; } bool invisible(color_t col) { return (col & 0xFF) == 0; }
ld gamma = .5; ld gamma = .5;
@ -71,7 +71,7 @@ namespace svg {
return buf; return buf;
} }
void circle(int x, int y, int size, int col) { void circle(int x, int y, int size, color_t col) {
int ba = (backcolor << 8) + 0xFF; int ba = (backcolor << 8) + 0xFF;
if(!invisible(col)) { if(!invisible(col)) {
if(vid.stretch == 1) if(vid.stretch == 1)
@ -83,19 +83,19 @@ namespace svg {
} }
} }
const string *link; string link;
void startstring() { void startstring() {
if(link) fprintf(f, "<a xlink:href=\"%s\" xlink:show=\"replace\">", link->c_str()); if(link != "") fprintf(f, "<a xlink:href=\"%s\" xlink:show=\"replace\">", link.c_str());
} }
void stopstring() { void stopstring() {
if(link) fprintf(f, "</a>"); if(link != "") fprintf(f, "</a>");
} }
string font = "Times"; string font = "Times";
void text(int x, int y, int size, const string& str, bool frame, int col, int align) { void text(int x, int y, int size, const string& str, bool frame, color_t col, int align) {
double dfc = (x - vid.xcenter) * (x - vid.xcenter) + double dfc = (x - vid.xcenter) * (x - vid.xcenter) +
(y - vid.ycenter) * (y - vid.ycenter); (y - vid.ycenter) * (y - vid.ycenter);
@ -136,7 +136,7 @@ namespace svg {
} }
} }
void polygon(int *polyx, int *polyy, int polyi, int col, int outline, double linewidth) { void polygon(int *polyx, int *polyy, int polyi, color_t col, int outline, double linewidth) {
if(invisible(col) && invisible(outline)) return; if(invisible(col) && invisible(outline)) return;
if(polyi < 2) return; if(polyi < 2) return;
@ -297,7 +297,7 @@ void saveHighQualityShot(const char *fname, const char *caption, int fade) {
if(fade < 255) if(fade < 255)
for(int y=0; y<vid.yres; y++) for(int y=0; y<vid.yres; y++)
for(int x=0; x<vid.xres; x++) { for(int x=0; x<vid.xres; x++) {
int& p = qpixel(s, x, y); color_t& p = qpixel(s, x, y);
for(int i=0; i<3; i++) { for(int i=0; i<3; i++) {
part(p,i) = (part(p,i) * fade + 127) / 255; part(p,i) = (part(p,i) * fade + 127) / 255;
} }

4
shaders.cpp
View File

@ -300,7 +300,7 @@ void id_modelview() {
#endif #endif
void color2(int color, ld part) { void color2(color_t color, ld part) {
unsigned char *c = (unsigned char*) (&color); unsigned char *c = (unsigned char*) (&color);
GLfloat cols[4]; GLfloat cols[4];
for(int i=0; i<4; i++) cols[i] = c[3-i] / 255.0 * part; for(int i=0; i<4; i++) cols[i] = c[3-i] / 255.0 * part;
@ -312,7 +312,7 @@ void color2(int color, ld part) {
#endif #endif
} }
void colorClear(int color) { void colorClear(color_t color) {
unsigned char *c = (unsigned char*) (&color); unsigned char *c = (unsigned char*) (&color);
glClearColor(c[3] / 255.0, c[2] / 255.0, c[1]/255.0, c[0] / 255.0); glClearColor(c[3] / 255.0, c[2] / 255.0, c[1]/255.0, c[0] / 255.0);
} }

4
shmup.cpp
View File

@ -3202,7 +3202,7 @@ bool drawMonster(const transmatrix& V, cell *c, const transmatrix*& Vboat, trans
break; break;
case moBullet: { case moBullet: {
int col; color_t col;
cpid = m->pid; cpid = m->pid;
if(m->parenttype == moPlayer) if(m->parenttype == moPlayer)
col = getcs().swordcolor; col = getcs().swordcolor;
@ -3249,7 +3249,7 @@ bool drawMonster(const transmatrix& V, cell *c, const transmatrix*& Vboat, trans
default: default:
if(m->inBoat) m->footphase = 0; if(m->inBoat) m->footphase = 0;
int col = minf[m->type].color; color_t col = minf[m->type].color;
if(m->type == moMimic) if(m->type == moMimic)
col = mirrorcolor(det(view) < 0); col = mirrorcolor(det(view) < 0);
if(m->type == moSlime) { if(m->type == moSlime) {

34
textures.cpp
View File

@ -49,7 +49,7 @@ template<class T, class U> void scale_colorarray(int origdim, int targetdim, con
while(tx < targetdim) { while(tx < targetdim) {
int fv = min(omissing, tmissing); int fv = min(omissing, tmissing);
int c = src(ox); color_t c = src(ox);
for(int p=0; p<4; p++) for(int p=0; p<4; p++)
partials[p] += part(c, p) * fv; partials[p] += part(c, p) * fv;
omissing -= fv; tmissing -= fv; omissing -= fv; tmissing -= fv;
@ -57,7 +57,7 @@ template<class T, class U> void scale_colorarray(int origdim, int targetdim, con
ox++; omissing = targetdim; ox++; omissing = targetdim;
} }
if(tmissing == 0) { if(tmissing == 0) {
int target; color_t target;
for(int p=0; p<4; p++) { for(int p=0; p<4; p++) {
part(target, p) = partials[p] / origdim; part(target, p) = partials[p] / origdim;
partials[p] = 0; partials[p] = 0;
@ -151,7 +151,7 @@ bool texture_data::readtexture(string tn) {
// read png // read png
vector<png_bytep> row_pointers(ty); vector<png_bytep> row_pointers(ty);
vector<int> origpixels(ty * tx); vector<color_t> origpixels(ty * tx);
for(int y = 0; y < ty; y++) for(int y = 0; y < ty; y++)
row_pointers[y] = (png_bytep) & origpixels[y * tx]; row_pointers[y] = (png_bytep) & origpixels[y * tx];
@ -163,7 +163,7 @@ bool texture_data::readtexture(string tn) {
swap(part(origpixels[i], 0), part(origpixels[i], 2)); swap(part(origpixels[i], 0), part(origpixels[i], 2));
auto pix = [&] (int x, int y) { auto pix = [&] (int x, int y) {
if(x<0 || y<0 || x >= tx || y >= ty) return 0; if(x<0 || y<0 || x >= tx || y >= ty) return (color_t) 0;
return origpixels[y*tx + x]; return origpixels[y*tx + x];
}; };
@ -316,7 +316,7 @@ void texture_config::mapTexture2(textureinfo& mi) {
mapTextureTriangle(mi, t.v, t.tv); mapTextureTriangle(mi, t.v, t.tv);
} }
int texture_config::recolor(int col) { int texture_config::recolor(color_t col) {
if(color_alpha == 0) return col; if(color_alpha == 0) return col;
for(int i=1; i<4; i++) for(int i=1; i<4; i++)
part(col, i) = color_alpha + ((255-color_alpha) * part(col,i) + 127) / 255; part(col, i) = color_alpha + ((255-color_alpha) * part(col,i) + 127) / 255;
@ -329,15 +329,15 @@ bool using_aura() {
return texture_aura && config.tstate == texture::tsActive; return texture_aura && config.tstate == texture::tsActive;
} }
bool texture_config::apply(cell *c, const transmatrix &V, int col) { bool texture_config::apply(cell *c, const transmatrix &V, color_t col) {
if(config.tstate == tsOff || !correctly_mapped) return false; if(config.tstate == tsOff || !correctly_mapped) return false;
using namespace patterns; using namespace patterns;
auto si = getpatterninfo0(c); auto si = getpatterninfo0(c);
if(config.tstate == tsAdjusting) { if(config.tstate == tsAdjusting) {
dynamicval<color_t> d(poly_outline, slave_color);
draw_floorshape(c, V, shFullFloor, 0, PPR::LINE); draw_floorshape(c, V, shFullFloor, 0, PPR::LINE);
lastptd().u.poly.outline = slave_color;
curvepoint(V * C0); curvepoint(V * C0);
for(int i=0; i<c->type; i++) for(int i=0; i<c->type; i++)
@ -354,8 +354,8 @@ bool texture_config::apply(cell *c, const transmatrix &V, int col) {
qfi.spin = applyPatterndir(c, si); qfi.spin = applyPatterndir(c, si);
if(grid_color) { if(grid_color) {
dynamicval<color_t> d(poly_outline, grid_color);
draw_floorshape(c, V, shFullFloor, 0, PPR::FLOOR); draw_floorshape(c, V, shFullFloor, 0, PPR::FLOOR);
lastptd().u.poly.outline = grid_color;
} }
if(using_aura()) { if(using_aura()) {
@ -472,8 +472,8 @@ void texture_config::finish_mapping() {
void texture_config::saveFullTexture(string tn) { void texture_config::saveFullTexture(string tn) {
addMessage(XLAT("Saving full texture to %1...", tn)); addMessage(XLAT("Saving full texture to %1...", tn));
dynamicval<unsigned> dd(grid_color, 0); dynamicval<color_t> dd(grid_color, 0);
dynamicval<unsigned> dm(mesh_color, 0); dynamicval<color_t> dm(mesh_color, 0);
dynamicval<ld> dx(vid.xposition, 0); dynamicval<ld> dx(vid.xposition, 0);
dynamicval<ld> dy(vid.yposition, 0); dynamicval<ld> dy(vid.yposition, 0);
dynamicval<ld> dvs(vid.scale, (pmodel == mdDisk && !euclid) ? 1 : vid.scale); dynamicval<ld> dvs(vid.scale, (pmodel == mdDisk && !euclid) ? 1 : vid.scale);
@ -1339,7 +1339,7 @@ void texture_data::undoLock() {
undos.emplace_back(nullptr, 1); undos.emplace_back(nullptr, 1);
} }
void filltriangle(const array<hyperpoint, 3>& v, const array<point, 3>& p, int col, int lev) { void filltriangle(const array<hyperpoint, 3>& v, const array<point, 3>& p, color_t col, int lev) {
int d2 = texture_distance(p[0], p[1]), d1 = texture_distance(p[0], p[2]), d0 = texture_distance(p[1], p[2]); int d2 = texture_distance(p[0], p[1]), d1 = texture_distance(p[0], p[2]), d0 = texture_distance(p[1], p[2]);
@ -1363,7 +1363,7 @@ void filltriangle(const array<hyperpoint, 3>& v, const array<point, 3>& p, int c
filltriangle(make_array(v[c], v[b], v3), make_array(p[c], p[b], p3), col, lev+1); filltriangle(make_array(v[c], v[b], v3), make_array(p[c], p[b], p3), col, lev+1);
} }
void splitseg(const transmatrix& A, const array<ld, 2>& angles, const array<hyperpoint, 2>& h, const array<point, 2>& p, int col, int lev) { void splitseg(const transmatrix& A, const array<ld, 2>& angles, const array<hyperpoint, 2>& h, const array<point, 2>& p, color_t col, int lev) {
ld newangle = (angles[0] + angles[1]) / 2; ld newangle = (angles[0] + angles[1]) / 2;
hyperpoint nh = A * xspinpush0(newangle, penwidth); hyperpoint nh = A * xspinpush0(newangle, penwidth);
auto np = ptc(nh); auto np = ptc(nh);
@ -1377,7 +1377,7 @@ void splitseg(const transmatrix& A, const array<ld, 2>& angles, const array<hype
} }
} }
void fillcircle(hyperpoint h, int col) { void fillcircle(hyperpoint h, color_t col) {
transmatrix A = rgpushxto0(h); transmatrix A = rgpushxto0(h);
ld step = M_PI * 2/3; ld step = M_PI * 2/3;
@ -1396,7 +1396,7 @@ void fillcircle(hyperpoint h, int col) {
bool texturesym = false; bool texturesym = false;
void actDrawPixel(cell *c, hyperpoint h, int col) { void actDrawPixel(cell *c, hyperpoint h, color_t col) {
try { try {
transmatrix M = gmatrix.at(c); transmatrix M = gmatrix.at(c);
auto si = patterns::getpatterninfo0(c); auto si = patterns::getpatterninfo0(c);
@ -1411,13 +1411,13 @@ void actDrawPixel(cell *c, hyperpoint h, int col) {
catch(out_of_range&) {} catch(out_of_range&) {}
} }
void drawPixel(cell *c, hyperpoint h, int col) { void drawPixel(cell *c, hyperpoint h, color_t col) {
config.data.pixels_to_draw.emplace_back(c, h, col); config.data.pixels_to_draw.emplace_back(c, h, col);
} }
cell *where; cell *where;
void drawPixel(hyperpoint h, int col) { void drawPixel(hyperpoint h, color_t col) {
try { try {
again: again:
transmatrix g0 = gmatrix[where]; transmatrix g0 = gmatrix[where];
@ -1439,7 +1439,7 @@ void drawPixel(hyperpoint h, int col) {
catch(out_of_range&) {} catch(out_of_range&) {}
} }
void drawLine(hyperpoint h1, hyperpoint h2, int col, int steps) { void drawLine(hyperpoint h1, hyperpoint h2, color_t col, int steps) {
if(steps > 0 && hdist(h1, h2) > penwidth / 3) { if(steps > 0 && hdist(h1, h2) > penwidth / 3) {
hyperpoint h3 = mid(h1, h2); hyperpoint h3 = mid(h1, h2);
drawLine(h1, h3, col, steps-1); drawLine(h1, h3, col, steps-1);

2
yendor.cpp
View File

@ -702,7 +702,7 @@ namespace tactic {
eLand l = landlist[i1]; eLand l = landlist[i1];
int i0 = 56 + i * vf; int i0 = 56 + i * vf;
int col; color_t col;
int ch = chances(l); int ch = chances(l);