mirrors/hyperrogue
1
0
Fork 0
mirror of https://github.com/zenorogue/hyperrogue.git synced 2024-12-21 16:00:27 +00:00
Code Issues Releases Wiki Activity
3c8d4d91b5
hyperrogue/textures.cpp
Zeno Rogue 3e0f751a2c texture editing
2017-12-18 00:24:56 +01:00

865 lines
25 KiB
C++
Raw Blame History

#include <SDL/SDL_image.h>
namespace texture {
GLuint textureid = 0;
SDL_Surface *convertSurface(SDL_Surface* s) {
SDL_PixelFormat fmt;
// fmt.format = SDL_PIXELFORMAT_BGRA8888;
fmt.BitsPerPixel = 32;
fmt.BytesPerPixel = 4;
fmt.Ashift=24;
fmt.Rshift=16;
fmt.Gshift=8;
fmt.Bshift=0;
fmt.Amask=0xff<<24;
fmt.Rmask=0xff<<16;
fmt.Gmask=0xff<<8;
fmt.Bmask=0xff;
fmt.Aloss = fmt.Rloss = fmt.Gloss = fmt.Bloss = 0;
fmt.palette = NULL;
#ifndef SDL2
fmt.alpha = 0;
fmt.colorkey = 0x1ffffff;
#endif
return SDL_ConvertSurface(s, &fmt, SDL_SWSURFACE);
}
int twidth = 2048;
vector<int> expanded_data;
string texturename = "hyperrogue-texture.png";
string configname = "hyperrogue.txc";
eTextureState tstate;
eTextureState tstate_max;
template<class T, class U> void scale_colorarray(int origdim, const T& src, const U& dest) {
int ox = 0, tx = 0, partials[4];
int omissing = twidth, tmissing = origdim;
for(int p=0; p<4; p++) partials[p] = 0;
while(tx < twidth) {
int fv = min(omissing, tmissing);
int c = src(ox);
for(int p=0; p<4; p++)
partials[p] += part(c, p) * fv;
omissing -= fv; tmissing -= fv;
if(omissing == 0) {
ox++; omissing = twidth;
}
if(tmissing == 0) {
int target;
for(int p=0; p<4; p++) {
part(target, p) = partials[p] / origdim;
partials[p] = 0;
}
dest(tx++, target);
tmissing = origdim;
}
}
}
bool loadTextureGL() {
if(textureid == 0) glGenTextures(1, &textureid );
glBindTexture( GL_TEXTURE_2D, textureid);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, twidth, twidth, 0,
GL_BGRA, GL_UNSIGNED_BYTE,
&expanded_data[0] );
return true;
}
bool whitetexture() {
expanded_data.resize(0);
expanded_data.resize(twidth * twidth, 0xFFFFFFFF);
return true;
}
bool readtexture() {
SDL_Surface *txt = IMG_Load(texturename.c_str());
if(!txt) {
addMessage(XLAT("Failed to load %1", texturename));
return false;
}
auto txt2 = convertSurface(txt);
int tx = txt->w, ty = txt->h;
SDL_FreeSurface(txt);
vector<int> half_expanded(twidth * ty);
expanded_data.resize(twidth * twidth);
int origdim = max(tx, ty);
int base_x = tx/2 - origdim/2;
int base_y = ty/2 - origdim/2;
ZZ = 0; // outside is black
/* for(int y=0; y<twidth; y++)
for(int x=0; x<twidth; x++)
expanded_data[y*twidth+x] = qpixel(txt2, y%ty, x%tx); */
for(int x=0; x<twidth; x++)
scale_colorarray(origdim,
[&] (int y) { return base_y+y < 0 || base_y+y >= ty ? 0 : half_expanded[x + (base_y + y) * twidth]; },
[&] (int y, int v) { expanded_data[twidth * y + x] = v; }
);
for(int y=0; y<ty; y++)
scale_colorarray(origdim,
[&] (int x) { return qpixel(txt2, base_x + x, y); },
[&] (int x, int v) { half_expanded[twidth * y + x] = v; }
);
SDL_FreeSurface(txt2);
return true;
}
transmatrix itt = Id;
unsigned grid_color = 0;
unsigned mesh_color = 0;
unsigned master_color = 0xFFFFFF10;
unsigned slave_color = 0xFF000008;
int color_alpha = 0;
int gsplits = 1;
void mapTextureTriangle(textureinfo &mi, array<hyperpoint, 3> vview, array<hyperpoint, 3> vmap, int splits = gsplits) {
if(splits) {
array<hyperpoint, 3> vview2 = { mid(vview[1], vview[2]), mid(vview[2], vview[0]), mid(vview[0], vview[1]) };
array<hyperpoint, 3> vmap2 = { mid(vmap [1], vmap [2]), mid(vmap [2], vmap [0]), mid(vmap [0], vmap [1]) };
mapTextureTriangle(mi, {vview[0], vview2[1], vview2[2]}, {vmap[0], vmap2[1], vmap2[2]}, splits-1);
mapTextureTriangle(mi, {vview[1], vview2[2], vview2[0]}, {vmap[1], vmap2[2], vmap2[0]}, splits-1);
mapTextureTriangle(mi, {vview[2], vview2[0], vview2[1]}, {vmap[2], vmap2[0], vmap2[1]}, splits-1);
mapTextureTriangle(mi, {vview2[0], vview2[1], vview2[2]}, {vmap2[0], vmap2[1], vmap2[2]}, splits-1);
return;
}
for(int i=0; i<3; i++) {
for(int j=0; j<3; j++)
mi.vertices.push_back(vview[i][j]);
hyperpoint inmodel;
applymodel(mi.M * vmap[i], inmodel);
inmodel = itt * inmodel;
inmodel[0] *= vid.radius * 1. / vid.scrsize;
inmodel[1] *= vid.radius * 1. / vid.scrsize;
mi.tvertices.push_back((inmodel[0]+1)/2);
mi.tvertices.push_back((inmodel[1]+1)/2);
mi.tvertices.push_back(0);
}
}
map<int, textureinfo> texture_map;
set<cell*> models;
void mapTexture(cell *c, textureinfo& mi, patterns::patterninfo &si, const transmatrix& T) {
mi.c = c;
mi.vertices.clear();
mi.tvertices.clear();
mi.symmetries = si.symmetries;
mi.current_type = c->type;
mi.current_geometry = geometry;
mi.current_trunc = nontruncated;
mi.M = T * applyPatterndir(c, si);
if(tstate == tsAdjusting) return;
ld z = ctof(c) ? rhexf : hexvdist;
// int sym = si.symmetries;
for(int i=0; i<c->type; i++) {
hyperpoint h1 = spin(M_PI + M_PI * (2*i +1) / c->type) * xpush(z) * C0;
hyperpoint h2 = spin(M_PI + M_PI * (2*i -1) / c->type) * xpush(z) * C0;
hyperpoint hm1 = spin(M_PI + M_PI * (2*i +1) / c->type) * xpush(z) * C0;
hyperpoint hm2 = spin(M_PI + M_PI * (2*i -1) / c->type) * xpush(z) * C0;
mapTextureTriangle(mi, {C0, h1, h2}, {C0, hm1, hm2});
}
}
int recolor(int col) {
if(color_alpha == 0) return col;
if(color_alpha == 255) return col | 0xFFFFFF00;
for(int i=1; i<4; i++)
part(col, i) = color_alpha + ((255-color_alpha) * part(col,i) + 127) / 255;
return col;
}
bool apply(cell *c, const transmatrix &V, int col) {
if(tstate == tsOff) return false;
using namespace patterns;
auto si = getpatterninfo0(c);
if(tstate == tsAdjusting) {
queuepolyat(V, shFullCross[ctof(c)], 0, PPR_LINE);
lastptd().u.poly.outline = models.count(c) ? master_color : slave_color;
queuepolyat(V, shFullFloor[ctof(c)], 0, PPR_LINE);
lastptd().u.poly.outline = models.count(c) ? master_color : slave_color;
return false;
}
try {
auto& mi = texture_map.at(si.id);
qfi.spin = applyPatterndir(c, si);
int n = mi.vertices.size() / 3;
if(geometry != mi.current_geometry || nontruncated != mi.current_trunc) {
// we can easily make it more symmetric
mi.symmetries = gcd(mi.symmetries, si.symmetries);
printf("Redrawing tile #%d from %d to %d\n", si.id, mi.current_type, c->type);
int nbase = n * mi.symmetries / mi.current_type;
int ntarget = nbase * c->type / mi.symmetries;
printf("n = %d nbase = %d ntarget = %d\n", n, nbase, ntarget);
vector<GLfloat> new_tvertices = move(mi.tvertices);
new_tvertices.resize(3*ntarget);
for(int i=3*nbase; i<3*ntarget; i++) {
new_tvertices[i] = new_tvertices[i - 3*nbase];
}
mapTexture(c, mi, si, Id);
mi.tvertices = move(new_tvertices);
n = mi.vertices.size() / 3;
printf("new n = %d\n", n);
}
qfi.special = false;
qfi.shape = &shFullFloor[ctof(c)];
qfi.tinf = &mi;
if(chasmg == 2) return false;
else if(chasmg && wmspatial) {
if(detaillevel == 0) return false;
queuetable(V * qfi.spin, &mi.vertices[0], n, mesh_color, recolor(c->land == laCocytus ? 0x080808FF : 0x101010FF), PPR_LAKEBOTTOM);
}
else {
queuetable(V * qfi.spin, &mi.vertices[0], n, mesh_color, recolor(col), PPR_FLOOR);
}
lastptd().u.poly.tinf = &mi;
if(grid_color) {
queuepolyat(V, shFullFloor[ctof(c)], 0, PPR_FLOOR);
lastptd().u.poly.outline = grid_color;
}
return true;
}
catch(out_of_range) {
// printf("Ignoring tile #%d : not mapped\n", si.id);
return false;
}
}
void perform_mapping() {
if(gsplits < 0) gsplits = 0;
if(gsplits > 4) gsplits = 4;
using namespace patterns;
texture_map.clear();
for(auto p: gmatrix) {
cell *c = p.first;
auto si = getpatterninfo0(c);
bool replace = false;
// int sgn = sphere ? -1 : 1;
if(!texture_map.count(si.id))
replace = true;
else if(hdist0(p.second*sphereflip * C0) < hdist0(texture_map[si.id].M * sphereflip * C0))
replace = true;
if(replace) {
auto& mi = texture_map[si.id];
mapTexture(c, mi, si, p.second);
mi.texture_id = textureid;
}
texture_map[si.id].matrices.push_back(p.second);
}
models.clear();
for(auto& t: texture_map) models.insert(t.second.c);
}
int forgeArgs() {
using namespace arg;
if(0) ;
else if(argis("-txpic")) {
shift(); texturename = args();
}
else if(argis("-fsp")) {
shift(); gsplits = argf();
}
else if(argis("-txc")) {
shift(); configname = args();
}
else return 1;
return 0;
}
bool newmove = false;
auto texture_hook =
addHook(hooks_args, 100, forgeArgs);
void drawRawTexture() {
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glMatrixMode(GL_MODELVIEW);
glcolor2(0xFFFFFF20);
glPushMatrix();
glTranslatef(0, 0, vid.scrdist);
glBindTexture(GL_TEXTURE_2D, textureid);
vector<GLfloat> tver, sver;
for(int i=0; i<4; i++) {
int cx[4] = {1, -1, -1, 1};
int cy[4] = {1, 1, -1, -1};
int x = cx[i];
int y = cy[i];
hyperpoint inmodel = hpxyz(x, y, 1);
inmodel = itt * inmodel;
tver.push_back((inmodel[0]+1)/2);
tver.push_back((inmodel[1]+1)/2);
tver.push_back(0);
sver.push_back(x * vid.scrsize);
sver.push_back(y * vid.scrsize);
sver.push_back(0);
}
activateVertexArray(&sver[0], 4);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, 0, &tver[0]);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
}
struct magicmapper_point {
cell *c;
hyperpoint cell_relative;
hyperpoint texture_coords;
};
vector<magicmapper_point> amp;
struct magic_param {
bool do_spin;
ld spinangle, scale, proj, moveangle, shift;
void shuffle() {
do_spin = hrand(2);
spinangle = hrandf() - hrandf();
moveangle = hrandf() * 2 * M_PI;
shift = hrandf() - hrandf();
scale = hrandf() - hrandf();
proj = hrandf() - hrandf();
}
void apply(ld delta) {
vid.alpha *= exp(delta * proj);
vid.scale *= exp(delta * scale);
if(do_spin)
View = spin(delta * spinangle) * View;
else
View = spin(moveangle) * xpush(delta*shift) * spin(-moveangle) * View;
fixmatrix(View);
}
};
ld magic_quality() {
gmatrix.clear();
calcparam();
ld q = 0;
for(auto& p: amp) {
hyperpoint inmodel;
applymodel(shmup::ggmatrix(p.c) * p.cell_relative, inmodel);
inmodel[0] *= vid.radius * 1. / vid.scrsize;
inmodel[1] *= vid.radius * 1. / vid.scrsize;
q += intvalxy(inmodel, p.texture_coords);
}
return q;
}
void applyMagic() {
ld cq = magic_quality();
int last_success = 0;
for(int s=0; s<50000 && s<last_success + 1000; s++) {
magic_param p;
p.shuffle();
bool failed = false;
for(ld delta = 1; delta > 1e-9; delta *= (failed ? -.7 : 1.2)) {
p.apply(delta);
ld nq = magic_quality();
if(nq < cq) {
cq = nq;
last_success = s;
}
else {
p.apply(-delta);
failed = true;
}
}
}
}
enum eTexturePanstate {tpsModel, tpsMove, tpsScale, tpsAffine, tpsZoom, tpsProjection, tpsMagic};
eTexturePanstate panstate;
void mousemovement() {
static hyperpoint lastmouse;
hyperpoint mouseeu = hpxyz((mousex - vid.xcenter + .0) / vid.scrsize, (mousey - vid.ycenter + .0) / vid.scrsize, 1);
bool nonzero = mouseeu[0] || mouseeu[1];
switch(panstate) {
case tpsModel:
if(!newmove && mouseh[2] < 50 && lastmouse[2] < 50) {
panning(lastmouse, mouseh);
perform_mapping();
}
lastmouse = mouseh; newmove = false;
break;
case tpsMove: {
if(!newmove)
itt = itt * inverse(eupush(mouseeu)) * eupush(lastmouse);
lastmouse = mouseeu; newmove = false;
break;
}
case tpsScale: {
if(nonzero && !newmove)
itt = itt * inverse(euscalezoom(mouseeu)) * euscalezoom(lastmouse);
if(nonzero) lastmouse = mouseeu;
newmove = false;
break;
}
case tpsAffine: {
if(!newmove)
itt = itt * inverse(euaffine(mouseeu)) * euaffine(lastmouse);
lastmouse = mouseeu; newmove = false;
break;
}
case tpsZoom: {
// do not zoom in portrait!
if(nonzero && !newmove) {
View = inverse(spintox(mouseeu)) * spintox(lastmouse) * View;
vid.scale = vid.scale * sqrt(intvalxy(C0, mouseeu)) / sqrt(intvalxy(C0, lastmouse));
}
if(nonzero) lastmouse = mouseeu;
newmove = false;
break;
}
case tpsProjection: {
if(nonzero && !newmove) {
vid.alpha = vid.alpha * sqrt(intvalxy(C0, mouseeu)) / sqrt(intvalxy(C0, lastmouse));
}
if(nonzero) lastmouse = mouseeu;
newmove = false;
}
case tpsMagic: {
if(!mouseover) return;
if(newmove) {
magicmapper_point newpoint;
newpoint.c = mouseover;
newpoint.cell_relative = inverse(gmatrix[mouseover]) * mouseh;
amp.push_back(newpoint);
newmove = false;
}
amp.back().texture_coords = mouseeu;
}
default: break;
}
}
patterns::patterninfo si_save;
saverlist texturesavers;
bool target_nontrunc;
void init_textureconfig() {
texturesavers = move(savers);
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
addsaver(itt[i][j], "texturematrix_" + its(i) + its(j), i==j ? 1 : 0);
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
addsaver(View[i][j], "viewmatrix_" + its(i) + its(j), i==j ? 1 : 0);
addsaverenum(targetgeometry, "geometry", gNormal);
addsaverenum(target_nontrunc, "chamfering", false);
// ... geometry parameters
addsaver(patterns::whichPattern, "pattern", 0);
addsaver(patterns::subpattern_flags, "pattern flags", 0);
cell *ctr = euclid ? centerover : viewctr.h->c7;
si_save = patterns::getpatterninfo0(ctr);
addsaver(si_save.id, "center type", 1);
addsaver(si_save.dir, "center direction", 0);
addsaver(si_save.reflect, "center reflection", false);
addsaver(twidth, "texture resolution", 2048);
addsaver(gsplits, "precision", 1);
addsaver(grid_color, "grid color", 0);
addsaver(color_alpha, "alpha color", 0);
addsaver(mesh_color, "mesh color", 0);
addsaver(vid.alpha, "projection", 1);
addsaver(vid.scale, "scale", 1);
addsaver(texturename, "texture filename", "");
swap(texturesavers, savers);
}
bool save_textureconfig() {
init_textureconfig();
FILE *f = fopen(configname.c_str(), "wt");
if(!f) return false;
targetgeometry = geometry;
target_nontrunc = nontruncated;
for(auto s: texturesavers) if(s->dosave())
fprintf(f, "%s=%s\n", s->name.c_str(), s->save().c_str());
fclose(f);
return true;
}
bool load_textureconfig() {
init_textureconfig();
FILE *f = fopen(configname.c_str(), "rt");
if(!f) return false;
swap(texturesavers, savers);
for(auto s: savers) s->reset();
loadNewConfig(f);
swap(texturesavers, savers);
fclose(f);
if(1) {
dynamicval<char> d1(patterns::whichPattern, patterns::whichPattern);
dynamicval<int> d2(patterns::subpattern_flags, patterns::subpattern_flags);
if(targetgeometry != geometry) {
restartGame('g');
return load_textureconfig();
}
if(nontruncated != target_nontrunc) {
restartGame('7');
}
}
if(!readtexture()) return false;
if(!loadTextureGL()) return false;
calcparam();
drawthemap();
perform_mapping();
tstate = tstate_max = tsActive;
return true;
}
void showMenu() {
cmode = sm::SIDE | sm::MAYDARK | sm::DIALOG_STRICT_X;
gamescreen(0);
if(tstate == tsAdjusting)
drawRawTexture();
dialog::init(XLAT("texture mode"));
if(tstate == tsOff) {
dialog::addSelItem(XLAT("select the texture's pattern"), XLAT("..."), 'r');
if(tstate_max == tsAdjusting)
dialog::addSelItem(XLAT("readjust the texture"), texturename, 't');
if(tstate_max == tsActive)
dialog::addSelItem(XLAT("reactivate the texture"), texturename, 't');
dialog::addSelItem(XLAT("open texture file"), texturename, 'o');
dialog::addSelItem(XLAT("load texture config"), "...", 'l');
}
if(tstate == tsAdjusting) {
dialog::addSelItem(XLAT("enable the texture"), texturename, 't');
dialog::addBoolItem(XLAT("move the model"), panstate == tpsModel, 'm');
dialog::addBoolItem(XLAT("move the texture"), panstate == tpsMove, 'a');
dialog::addBoolItem(XLAT("zoom/scale the texture"), panstate == tpsScale, 'x');
dialog::addBoolItem(XLAT("zoom/scale the model"), panstate == tpsZoom, 'z');
dialog::addBoolItem(XLAT("projection"), panstate == tpsProjection, 'p');
dialog::addBoolItem(XLAT("affine transformations"), panstate == tpsAffine, 'y');
dialog::addBoolItem(XLAT("magic"), panstate == tpsMagic, 'A');
dialog::addBoolItem(XLAT("grid color (master)"), "...", 'M');
dialog::addBoolItem(XLAT("grid color (copy)"), "...", 'C');
if(panstate == tpsMagic) {
dialog::addSelItem(XLAT("delete markers"), its(size(amp)), 'D');
dialog::addSelItem(XLAT("perform auto-adjustment"), "...", 'R');
}
dialog::addSelItem(XLAT("precision"), its(gsplits), 'p');
}
if(tstate == tsActive) {
/* dialog::addSelItem(XLAT("texture scale"), fts(iscale), 's');
dialog::addSelItem(XLAT("texture angle"), fts(irotate), 'a');
dialog::addSelItem(XLAT("texture position X"), fts(ix), 'x');
dialog::addSelItem(XLAT("texture position Y"), fts(iy), 'y'); */
dialog::addBoolItem(XLAT("deactivate the texture"), true, 't');
dialog::addBoolItem(XLAT("readjust the texture"), true, 'r');
dialog::addSelItem(XLAT("grid alpha"), "...", 'g');
dialog::addSelItem(XLAT("mesh alpha"), "...", 'm');
dialog::addSelItem(XLAT("color alpha"), its(color_alpha), 'c');
dialog::addSelItem(XLAT("save the texture config"), "...", 's');
}
dialog::addItem(XLAT("help"), SDLK_F1);
dialog::addItem(XLAT("back"), '0');
getcstat = '-';
dialog::display();
if(tstate == tsAdjusting) {
initquickqueue();
char letter = 'A';
for(auto& am: amp) {
hyperpoint h = shmup::ggmatrix(am.c) * am.cell_relative;
display(h);
queuechr(h, vid.fsize, letter, 0xC00000, 1);
hyperpoint inmodel;
applymodel(h, inmodel);
inmodel[0] *= vid.radius * 1. / vid.scrsize;
inmodel[1] *= vid.radius * 1. / vid.scrsize;
queuechr(
vid.xcenter + vid.scrsize * inmodel[0],
vid.ycenter + vid.scrsize * inmodel[1],
0, vid.fsize/2, letter, 0xC0C0C0, 1);
queuechr(
vid.xcenter + vid.scrsize * am.texture_coords[0],
vid.ycenter + vid.scrsize * am.texture_coords[1],
0, vid.fsize, letter, 0x00C000, 1);
letter++;
}
quickqueue();
}
if(holdmouse) mousemovement();
keyhandler = [] (int sym, int uni) {
// handlePanning(sym, uni);
dialog::handleNavigation(sym, uni);
if(uni == '-' && tstate == tsAdjusting) {
if(!holdmouse) {
holdmouse = true;
newmove = true;
}
}
else if(uni == 'm' && tstate == tsAdjusting) panstate = tpsModel;
else if(uni == 'a' && tstate == tsAdjusting) panstate = tpsMove;
else if(uni == 'x' && tstate == tsAdjusting) panstate = tpsScale;
else if(uni == 'y' && tstate == tsAdjusting) panstate = tpsAffine;
else if(uni == 'z' && tstate == tsAdjusting) panstate = tpsZoom;
else if(uni == 'p' && tstate == tsAdjusting) panstate = tpsProjection;
else if(uni == 'A' && tstate == tsAdjusting) panstate = tpsMagic;
else if(uni == 'D' && tstate == tsAdjusting) amp.clear();
else if(uni == 'R' && tstate == tsAdjusting) applyMagic();
else if(uni == 's' && tstate == tsActive)
dialog::openFileDialog(configname, XLAT("texture config to save:"), ".txc",
[] () {
return save_textureconfig();
});
else if(uni == 'l' && tstate == tsOff)
dialog::openFileDialog(configname, XLAT("texture config to load:"), ".txc",
[] () {
return load_textureconfig();
});
else if(uni == 'r' && tstate == tsOff)
pushScreen(patterns::showPattern);
else if(uni == 'o' && tstate == tsOff)
dialog::openFileDialog(texturename, XLAT("texture to load:"), ".png",
[] () {
if(readtexture() && loadTextureGL()) {
if(tstate_max == tsOff) tstate_max = tsAdjusting;
tstate = tstate_max;
return true;
}
else return false;
});
else if(uni == 'n' && tstate == tsOff) {
addMessage("white");
if(whitetexture() && loadTextureGL()) {
tstate = tstate_max = tsActive;
perform_mapping();
mapeditor::colortouse = 0xFFFF00FF;
mapeditor::initdraw(cwt.c);
pushScreen(mapeditor::showDrawEditor);
}
}
else if(uni == 't' && tstate == tsOff)
tstate = tstate_max;
else if((uni == 't' || uni == 'r') && tstate == tsAdjusting) {
tstate = tstate_max = tsActive;
perform_mapping();
}
else if(uni == 't' && tstate == tsActive)
tstate = tsOff;
else if(uni == 'r' && tstate == tsActive) {
tstate = tsAdjusting;
texture_map.clear();
}
else if(uni == 'g' && tstate == tsActive)
dialog::openColorDialog(grid_color, NULL);
else if(uni == 'm' && tstate == tsActive)
dialog::openColorDialog(mesh_color, NULL);
else if(uni == 'M' && tstate == tsAdjusting)
dialog::openColorDialog(master_color, NULL);
else if(uni == 'C' && tstate == tsActive)
dialog::openColorDialog(slave_color, NULL);
else if(uni == 'c' && tstate == tsActive) {
dialog::editNumber(color_alpha, 0, 255, 15, 0, XLAT("color alpha"),
XLAT("The higher the value, the less important the color of underlying terrain is."));
}
else if(uni == 'p' && tstate == tsAdjusting) {
dialog::editNumber(gsplits, 0, 4, 1, 1, XLAT("precision"),
XLAT("precision"));
dialog::reaction = perform_mapping;
}
else if(doexiton(sym, uni))
popScreen();
};
}
int lastupdate;
void update() {
if(lastupdate && ticks > lastupdate + 100) {
loadTextureGL();
lastupdate = 0;
}
}
pair<int,int> ptc(hyperpoint h) {
hyperpoint inmodel;
applymodel(h, inmodel);
inmodel = itt * inmodel;
inmodel[0] *= vid.radius * 1. / vid.scrsize;
inmodel[1] *= vid.radius * 1. / vid.scrsize;
int x = (1 + inmodel[0]) * twidth / 2;
int y = (1 + inmodel[1]) * twidth / 2;
return make_pair(x,y);
}
int near(pair<int, int> p1, pair<int, int> p2) {
return max(abs(p1.first-p2.first), abs(p1.second - p2.second));
}
void filltriangle(array<hyperpoint, 3> v, int col, int lev) {
pair<int,int> p[3] = {ptc(v[0]), ptc(v[1]), ptc(v[2])};
if(0) for(int i=0; i<3; i++)
printf("#%d fillt #%d %s -> %d,%d\n", lev, i, display(v[i]), p[i].first, p[i].second);
int d2 = near(p[0], p[1]), d1 = near(p[0], p[2]), d0 = near(p[1], p[2]);
if((d0 <= 1 && d1 <= 1 && d2 <= 1) || lev >= 5) {
for(int i=0; i<3; i++)
expanded_data[((p[i].first) & (twidth-1)) + (p[i].second & (twidth-1)) * twidth] = col;
return;
}
else if(d1 >= d0 && d1 >= d2)
swap(v[0], v[1]);
else if(d2 >= d0 && d2 >= d1)
swap(v[0], v[2]);
hyperpoint v3 = mid(v[1], v[2]);
filltriangle({v[0], v[1], v3}, col, lev+1);
filltriangle({v[0], v[2], v3}, col, lev+1);
}
void fillcircle(hyperpoint h, int col) {
transmatrix A = rgpushxto0(h);
ld rad = .02;
filltriangle({A * xpush(rad) * C0, A * spin(M_PI * 2/3) * C0, A * spin(-M_PI * 2/3) * C0}, col, 0);
}
void drawPixel(cell *c, hyperpoint h, int col) {
printf("s = %d\n", size(gmatrix));
try {
transmatrix M = gmatrix.at(c);
auto si = patterns::getpatterninfo0(c);
h = inverse(M * applyPatterndir(c, si)) * h;
auto& tinf = texture_map[si.id];
for(auto& M2: tinf.matrices) for(int i = 0; i<c->type; i += si.symmetries) {
hyperpoint inmodel;
fillcircle(M2 * spin(2 * M_PI * i / c->type) * h, col);
lastupdate = ticks;
}
}
catch(out_of_range) {}
}
}
// todo texture editor
// todo `three octagons` with two colors
Reference in New Issue View Git Blame Copy Permalink