hyperpoint h;

char glyph;

color_t color;

color_t line;

/** The cell which is currently in the center. */

cell *precise_center;

/** The current rotation, relative to precise_center. */

transmatrix view_matrix;

/** Camera rotation, used in nonisotropic geometries. */

transmatrix local_perspective;

/** The view relative to the player character. */

shiftmatrix player_matrix;

/** On-screen coordinates for all the visible cells. */

map<cell*, shiftmatrix_or_null> cellmatrices, old_cellmatrices;

/** Position of the current map view, relative to the screen (0 to 1). */

ld xmin, ymin, xmax, ymax;

/** Position of the current map view, in pixels. */

ld xtop, ytop, xsize, ysize;

display_data() { xmin = ymin = 0; xmax = ymax = 1; }

/** Center of the current map view, in pixels. */

int xcenter, ycenter;

ld radius;

int scrsize;

bool sidescreen;

ld tanfov;

flagtype next_shader_flags;

vector<radarpoint> radarpoints;

vector<radarline> radarlines;

transmatrix radar_transform;

transmatrix radar_transform_post;

ld eyewidth();

bool separate_eyes();

bool in_anaglyph();

void set_viewport(int ed);

void set_projection(int ed, ld shift);

void set_mask(int ed);

void set_all(int ed, ld shift);

/** Which copy of the player cell? */

transmatrix which_copy;

/** On-screen coordinates for all the visible cells. */

map<cell*, vector<shiftmatrix>> all_drawn_copies;

unsigned char cu = c;

if(cu < 128) return 1;

if(cu < 224) return 2;

if(cu < 0xF0) return 3;

return 4;

if(!pos) return 0;

int npos = pos - 1;

while(npos && ((unsigned char)s[npos]) >= 128 && ((unsigned char)s[npos]) < 192) npos--;

return pos - npos;

#if CAP_COMPLEX2

return max(get_sightrange(), ambush::distance);

#else

return get_sightrange();

#endif

switch(vid.stereo_mode) {

case sAnaglyph:

return vid.anaglyph_eyewidth;

case sLR:

return vid.lr_eyewidth;

default:

return 0;

}

int siz = utfsize(s[i]);

if(siz == 1) return s[i++];

for(int k=0; k<NUMEXTRA; k++)

if(eqs(s.c_str()+i, natchars[k])) {

i += siz; return 128+k;

}

printf("Unknown character in: '%s' at position %d\n", s.c_str(), i);

i += siz; return '?';

if(size < 1) size = 1;

if(size > max_font_size) size = max_font_size;

if(size > 72) size &=~ 3;

if(size > 144) size &=~ 7;

#if SDLVER >= 2

SDL_UpdateTexture(s_texture, nullptr, s->pixels, s->w * sizeof (Uint32));

SDL_RenderClear(s_renderer);

#if SDLVER >= 3

SDL_RenderTexture(s_renderer, s_texture, nullptr, nullptr);

#else

SDL_RenderCopy(s_renderer, s_texture, nullptr, nullptr);

#endif

SDL_RenderPresent(s_renderer);

#else

SDL_UpdateRect(s, 0, 0, 0, 0);

#endif

#if CAP_GL

if(vid.usingGL) {

#if SDLVER >= 2

SDL_GL_SwapWindow(s_window);

#else

SDL_GL_SwapBuffers();

#endif

return;

}

#endif

present_surface();

fix_font_size(siz);

auto& cf = cfont->font[siz];

if(!cf) {

if(cf == NULL) cf = TTF_OpenFont(find_file(cfont->filename).c_str(), siz);

#ifdef FONTCONFIG

if(cf == NULL && cfont->use_fontconfig)

cf = findfont(siz);

#endif

if(cf == NULL) {

printf("error: Font file not found: %s\n", cfont->filename.c_str());

if(font_id == 0) throw hr_exception("font file not found");

font_id = 0; set_cfont(); loadfont(siz);

}

}

if(isize(str) == 0) return 0;

#if CAP_SDLTTF

fix_font_size(siz);

loadfont(siz);

int w, h;

TTF_SizeUTF8(cfont->font[siz], str.c_str(), &w, &h);

// printf("width = %d [%d]\n", w, isize(str));

return w;

#elif CAP_GL

return gl_width(siz, str.c_str());

#else

return 0;

#endif

if(!vid.usingGL) return;

auto t = this;

auto current_projection = tie(ed, pmodel, t, current_rbuffer);

if(new_projection_needed || !glhr::current_glprogram || (next_shader_flags & GF_which) != (glhr::current_glprogram->shader_flags & GF_which) || current_projection != last_projection || shift != lband_shift) {

last_projection = current_projection;

lband_shift = shift;

set_projection(ed, shift);

set_mask(ed);

set_viewport(ed);

new_projection_needed = false;

}

if(ed == 0 || vid.stereo_mode != sAnaglyph) {

glColorMask( GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE );

}

else if(ed == 1) {

glColorMask( GL_TRUE,GL_FALSE,GL_FALSE,GL_TRUE );

}

else if(ed == -1) {

glColorMask( GL_FALSE,GL_TRUE,GL_TRUE,GL_TRUE );

}

ld xtop = current_display->xtop;

ld ytop = current_display->ytop;

ld xsize = current_display->xsize;

ld ysize = current_display->ysize;

if(ed == 0 || vid.stereo_mode != sLR) ;

else if(ed == 1) xsize /= 2;

else if(ed == -1) xsize /= 2, xtop += xsize;

glViewport(xtop, ytop, xsize, ysize);

DEBBI(debug_graph, ("setGLProjection"));

GLERR("pre_setGLProjection");

glClearColor(part(col, 2) / 255.0, part(col, 1) / 255.0, part(col, 0) / 255.0, 1);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

GLERR("setGLProjection #1");

glEnable(GL_BLEND);

#ifndef GLES_ONLY

if(vid.antialias & AA_LINES) {

glEnable(GL_LINE_SMOOTH);

glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);

}

else glDisable(GL_LINE_SMOOTH);

#endif

glLineWidth(vid.linewidth);

GLERR("setGLProjection #2");

#ifndef GLES_ONLY

if(vid.antialias & AA_POLY) {

glEnable(GL_POLYGON_SMOOTH);

glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);

}

else glDisable(GL_POLYGON_SMOOTH);

#endif

GLERR("setGLProjection #3");

//glLineWidth(1.0f);

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

#ifdef GL_ES

glClearDepthf(1.0f);

#else

glClearDepth(1.0f);

#endif

glDepthFunc(GL_LEQUAL);

GLERR("setGLProjection");

reset_projection();

glhr::set_depthwrite(true);

glClear(GL_DEPTH_BUFFER_BIT);

int rval=1;

// rval<<=1 Is A Prettier Way Of Writing rval*=2;

while(rval<a) rval<<=1;

return rval;

string filename;

#if FONTCONFIG

bool use_fontconfig;

#endif

struct glfont_t* glfont[max_glfont_size+1];

#if CAP_SDLTTF

TTF_Font* font[max_font_size+1];

#endif

struct basic_textureinfo *finf;

~fontdata();

GLuint texture; // Holds The Texture Id

vector<charinfo_t> chars;

vector<const char*> reps;

#if CAP_TABFONT

if(ch < 32) return;

int otwidth, otheight, tpixindex = 0;

unsigned char tpix[3000];

loadCompressedChar(otwidth, otheight, tpix);

#else

if(!txt) return;

int otwidth = txt->w;

int otheight = txt->h;

#endif

if(otwidth+curx+1 > FONTTEXTURESIZE) curx = 0, cury += theight+1, theight = 0;

theight = max(theight, otheight);

for(int j=0; j<otheight;j++) for(int i=0; i<otwidth; i++) {

fontpixels[j+cury][i+curx] =

#if CAP_TABFONT

(i>=otwidth || j>=otheight) ? 0 : (tpix[tpixindex++] * 0x100) | 0xFF;

#else

((i>=txt->w || j>=txt->h) ? 0 : ((qpixel(txt, i, j)>>24)&0xFF) * 0x100) | 0x00FF;

#endif

}

auto& c = f.chars[ch];

c.w = otwidth;

c.h = otheight;

c.tx0 = (float) curx / (float) FONTTEXTURESIZE;

c.tx1 = (float) (curx+otwidth) / (float) FONTTEXTURESIZE;

c.ty0 = (float) cury;

c.ty1 = (float) (cury+otheight);

curx += otwidth+1;

vector<int> res;

for(int i=0; s[i];) {

int tabid = getnext(s,i);

if(f.reps[tabid]) {

for(auto sub: get_tabids(f, f.reps[tabid])) res.push_back(sub);

continue;

}

res.push_back(tabid);

}

return res;

int gsiz = size;

if(size > vid.fsize || size > max_glfont_size) gsiz = max_glfont_size;

#if CAP_FIXEDSIZE

gsiz = CAP_FIXEDSIZE;

#endif

init_glfont(gsiz);

if(!cfont->glfont[gsiz]) return 0;

glfont_t& f(*cfont->glfont[gsiz]);

int x = 0;

for(int tabid: get_tabids(f, s)) x += f.chars[tabid].w * size/gsiz;

return x;

glhr::textured_vertex res;

res.coords[0] = x1;

res.coords[1] = y1;

res.coords[2] = 0;

res.coords[3] = 1;

res.texture[0] = tx;

res.texture[1] = ty;

return res;

int gsiz = size;

if(size > vid.fsize || size > max_glfont_size) gsiz = max_glfont_size;

#if CAP_FIXEDSIZE

gsiz = CAP_FIXEDSIZE;

#endif

init_glfont(gsiz);

if(!cfont->glfont[gsiz]) return false;

glfont_t& f(*cfont->glfont[gsiz]);

int tsize = 0;

auto tabids = get_tabids(f, s);

for(int tabid: tabids) {

tsize += f.chars[tabid].w * size/gsiz;

}

x -= tsize * align / 16;

y += f.chars[32].h * size / (gsiz*2);

int ysiz = f.chars[32].h * size / gsiz;

bool clicked = (mousex >= x && mousey <= y && mousex <= x+tsize && mousey >= y-ysiz);

color_t icolor = (color << 8) | 0xFF;

if(icolor != text_color || f.texture != text_texture || shift != text_shift || shapes_merged) {

glflush();

text_color = icolor;

text_texture = f.texture;

text_shift = shift;

}

texts_merged++;

auto& tver = text_vertices;

glBindTexture(GL_TEXTURE_2D, f.texture);

for(int tabid: tabids) {

auto& c = f.chars[tabid];

int wi = c.w * size/gsiz;

int hi = c.h * size/gsiz;

GLERR("pre-print");

glhr::textured_vertex t00 = charvertex(x, y-hi, c.tx0, c.ty0);

glhr::textured_vertex t01 = charvertex(x, y, c.tx0, c.ty1);

glhr::textured_vertex t11 = charvertex(x+wi, y, c.tx1, c.ty1);

glhr::textured_vertex t10 = charvertex(x+wi, y-hi, c.tx1, c.ty0);

tver.push_back(t00);

tver.push_back(t01);

tver.push_back(t10);

tver.push_back(t10);

tver.push_back(t01);

tver.push_back(t11);

x += wi;

}

return clicked;

DEBBI(debug_init_graph, ("reset GL"))

callhooks(hooks_resetGL);

#if CAP_GLFONT

for(auto& cf: fontdatas)

for(int i=0; i<=max_glfont_size; i++) if(cf.second.glfont[i]) {

delete cf.second.glfont[i];

cf.second.glfont[i] = NULL;

}

#endif

#if MAXMDIM >= 4

if(floor_textures) {

delete floor_textures;

floor_textures = NULL;

}

#endif

#if MAXMDIM >= 4 && CAP_GL

if(airbuf) {

delete airbuf;

airbuf = nullptr;

}

#endif

compiled_programs.clear();

matched_programs.clear();

glhr::current_glprogram = nullptr;

glhr::flags_become(0);

check_cgi();

if(currentmap) cgi.require_shapes();

for(auto& c: cgis) c.second.initPolyForGL();

#if MAXMDIM >= 4

if(GDIM == 3 && !floor_textures) make_floor_textures();

#endif

ray::reset_raycaster();

#if CAP_RUG

if(rug::glbuf) rug::close_glbuf();

#endif

gdpush(2); gdpush(x); gdpush(y); gdpush(8);

gdpush(col); gdpush(size); gdpush(0);

gdpush(1); gdpush(chr);

return false;

int g = (int) graphdata.size(), q = 0;

gdpush((int) s.size()); for(int i=0; i<isize(s); i++) {

int u;

tie(u, i) = unicode_value(s, i);

gdpush(u); q++;

}

graphdata[g] = q;

gdpush(2); gdpush(x); gdpush(y); gdpush(align);

gdpush(color); gdpush(size); gdpush(b);

gdpush_utf8(s);

int mx = mousex - x;

int my = mousey - y;

int len = textwidth(size, s);

return

mx >= -len*align/32 && mx <= +len*(16-align)/32 &&

my >= -size*3/4 && my <= +size*3/4;

if(strlen(str) == 0) return false;

if(size < 4 || size > 2000) {

return false;

}

#if CAP_GLFONT

if(vid.usingGL) return gl_print(x, y, shift, size, str, color, align);

#endif

#if !CAP_SDLTTF

static bool towarn = true;

if(towarn) towarn = false, printf("WARNING: NOTTF works only with OpenGL!\n");

return false;

#else

SDL_Color col;

col.r = (color >> 16) & 255;

col.g = (color >> 8 ) & 255;

col.b = (color >> 0 ) & 255;

col.r >>= darken; col.g >>= darken; col.b >>= darken;

fix_font_size(size);

loadfont(size);

SDL_Surface *txt = ((vid.antialias & AA_FONT)?TTF_RenderUTF8_Blended:TTF_RenderUTF8_Solid)(cfont->font[size], str, col);

if(txt == NULL) return false;

SDL_Rect rect;

rect.w = txt->w;

rect.h = txt->h;

rect.x = x - rect.w * align / 16;

rect.y = y - rect.h/2;

bool clicked = (mousex >= rect.x && mousey >= rect.y && mousex <= rect.x+rect.w && mousey <= rect.y+rect.h);

if(shift) {

#if SDLVER == 3

SDL_Surface* txt2 = SDL_ConvertSurface(txt, SDL_PIXELFORMAT_RGBA8888);

#elif SDLVER == 2

SDL_Surface* txt2 = SDL_ConvertSurfaceFormat(txt, SDL_PIXELFORMAT_RGBA8888, 0);

#else

SDL_Surface* txt2 = SDL_DisplayFormat(txt);

#endif

SDL_LockSurface(txt2);

SDL_LockSurface(s);

color_t c0 = qpixel(txt2, 0, 0);

for(int yy=0; yy<rect.h; yy++)

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 & 0x00FFFF;

SDL_UnlockSurface(s);

SDL_UnlockSurface(txt2);

SDL_DestroySurface(txt2);

}

else {

SDL_BlitSurface(txt, NULL, s,&rect);

}

SDL_DestroySurface(txt);

return clicked;

#endif

if(b) {

displaystr(x-b, y, 0, size, s, p, align);

displaystr(x+b, y, 0, size, s, p, align);

displaystr(x, y-b, 0, size, s, p, align);

displaystr(x, y+b, 0, size, s, p, align);

}

if(b >= 2) {

int b1 = b-1;

displaystr(x-b1, y-b1, 0, size, s, p, align);

displaystr(x-b1, y+b1, 0, size, s, p, align);

displaystr(x+b1, y-b1, 0, size, s, p, align);

displaystr(x+b1, y+b1, 0, size, s, p, align);

}

return displaystr(x, y, 0, size, s, color, align);

char buf[2];

buf[0] = chr; buf[1] = 0;

return displaystr(x, y, shift, size, buf, col, 8);