fixed alot of warnings, and some bugs, so it can be compiled with the current vccrun

[k8vacspelynky.git] / packages / Sprites / SpriteStore.vc

/**************************************************************************
 *    This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 3
 *  of the License, or (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 **************************************************************************/
//#define PXCOLDET_TEST


// ////////////////////////////////////////////////////////////////////////// //
class CollisionMask : Object;

int width; // in ints
int height; // in pixels
array!int mask;
array!int maskHLine; // used for rect checks
int x0, y0, x1, y1; // bounding box; right-bottom inclusive
bool bbsolid;
#ifdef PXCOLDET_TEST
bool dumpCheck;
#endif


final bool isEmptyMask { get { return (mask.length == 0); } }


final bool isRectOverlaps (int rx, int ry, int rw, int rh) {
  //writeln("  me:(", x0, ",", y0, ")-(", x1, ",", y1, "); it:(", rx, ",", ry, ")-(", rx+rw-1, ",", ry+rh-1, ")");
  return
    rw > 0 && rh > 0 &&
    rx <= x1 && ry <= y1 &&
    rx+rw > x0 && ry+rh > y0;
}


final void setPixel (int x, int y, optional bool v) {
  if (!specified_v) v = true;
  if (x < 0 || y < 0 || x >= width*32 || y >= height) return;
  int ix = x/32;
  int dx = 31-x%32;
  if (v) {
    mask[ix, y] |= 1<<dx;
  } else {
    mask[ix, y] &= ~(1<<dx);
  }
}


final bool colCheck (CollisionMask m1, int dx, int dy) {
  if (!m1 || mask.length == 0 || m1.mask.length == 0) return false;
  // check for sane dimensions
  if (width < 1 || height < 1 || m1.width < 1 || m1.height < 1) return false;
  // check coords (use boundig boxes)
  if (dx+m1.x0 > x1 || dy+m1.y0 > y1 || dx+m1.x1 < x0 || dy+m1.y1 < y0) return false;
  // check if both bounding boxes are solid
  if (bbsolid && m1.bbsolid) return true; // yeah, we're done
  // intersecting rects
#ifdef PXCOLDET_TEST
  if (dumpCheck) writeln("ofs: (", dx, ",", dy, "); self: ", width, "x", height, "; m1: ", m1.width, "x", m1.height, "; dx/32=", dx/32, "; dxend=", (dx+m1.width*32-1)/32+1);
#endif
  // calculate x bounds on self
  int sx0 = max(0, dx/32);
  int sx1 = min(width, (dx+m1.width*32-1)/32+1);
  // calculate y bounds on self
  int sy0 = max(0, dy);
  int sy1 = min(height, dy+m1.height);
  // calculate x start on m1
  int mx0 = -min(0, dx/32);
  // calculate y start on m1
  int my0 = -min(0, dy);
  int dm32 = dx%32;
  // debug
#ifdef PXCOLDET_TEST
  if (dumpCheck) writeln(" srect:(", sx0, ",", sy0, ")-(", sx1, ",", sy1, "); mofs:(", mx0, ",", my0, "); dm32=", dm32);
#endif
  // compensate loops
  mx0 -= sx0;
  my0 -= sy0;
  int v;
  // do checks
  if (dm32 < 0) {
    // shift self to the right
    int ssr = -dm32;
    int ssl = 32-ssr;
#ifdef PXCOLDET_TEST
    if (dumpCheck) writeln(" SELFRIGHT: ssr=", ssr, "; ssl=", ssl);
#endif
    foreach (int sy; sy0..sy1) {
      foreach (int sx; sx0..sx1) {
        // get bits
        v = (m1.mask[sx+mx0, sy+my0]<<ssr)|(m1.mask[sx+mx0+1, sy+my0]>>>ssl);
#ifdef PXCOLDET_TEST
        if (dumpCheck) writeln("  ", va("v=%x  m1=%x  self=%x  (sx=%d; sy=%d) (mx=%d; my=%d)", v, m1.mask[sx+mx0, sy+my0], mask[sx, sy], sx, sy, sx+mx0, sy+my0));
#endif
        // do check
        if (mask[sx, sy]&v) return true;
      }
    }
  } else if (dm32 > 0) {
    // shift self to the left
    int ssl = dm32;
    int ssr = 32-ssl;
#ifdef PXCOLDET_TEST
    if (dumpCheck) writeln(" SELFLEFT: ssr=", ssr, "; ssl=", ssl);
#endif
    foreach (int sy; sy0..sy1) {
      foreach (int sx; sx0..sx1) {
        // get bits
        v = (mask[sx, sy]<<ssl)|(mask[sx+1, sy]>>>ssr); // sprite mask is one int wider, so it is ok
#ifdef PXCOLDET_TEST
        if (dumpCheck) writeln("  ", va("v=%x  m1=%x  self=%x  (sx=%d; sy=%d) (mx=%d; my=%d)", v, m1.mask[sx+mx0, sy+my0], mask[sx, sy], sx, sy, sx+mx0, sy+my0));
#endif
        // do check
        if (v&m1.mask[sx+mx0, sy+my0]) return true;
      }
    }
  } else /*if (dm32 == 0)*/ {
    foreach (int sy; sy0..sy1) {
      foreach (int sx; sx0..sx1) {
        // do check
        if (mask[sx, sy]&m1.mask[sx+mx0, sy+my0]) return true;
      }
    }
  }
  return false;
}


// m is inclusive
// d is offset for m
final bool colCheckRect (int dx, int dy, int m1x0, int m1y0, int m1x1, int m1y1/*, optional bool dbgdump*/) {
  if (mask.length == 0) return false;
  // check for sane dimensions
  if (width < 1 || height < 1 || m1x1 < m1x0 || m1y1 < m1y0) return false;
  //!if (dbgdump) writeln("0: dx=", dx, "; dy=", dy, "; m1x0=", m1x0, "; m1x1=", m1x1, "; x0=", x0, "; x1=", x1);
  m1x0 += dx; m1y0 += dy;
  m1x1 += dx; m1y1 += dy;
  // check coords (use bounding boxes)
  if (m1x0 > x1 || m1y0 > y1 || m1x1 < x0 || m1y1 < y0) return false;
  // check if both bounding boxes are solid
  if (bbsolid) return true; // yeah, we're done
  // intersecting rects
  //!if (dbgdump) writeln("1: dx=", dx, "; dy=", dy, "; m1x0=", m1x0, "; m1x1=", m1x1, "; x0=", x0, "; x1=", x1);
  m1x0 = max(m1x0, x0);
  m1x1 = min(m1x1, x1);
  // create hline
  //TODO: we can create partial hline here, but meh...
  int hlwdt = width;
  if (maskHLine.length < hlwdt) maskHLine.length = hlwdt;
  //!if (dbgdump) writeln("2: m1x0=", m1x0, "; m1x1=", m1x1, "; hlwdt=", hlwdt, "; x0=", x0, "; x1=", x1);
  // fill it
  foreach (int vidx; 0..hlwdt) { int vv = vidx*32; maskHLine[vidx] = (vv <= m1x1 && vv+32 > m1x0 ? -1 : 0); }
  // fix left part
  maskHLine[m1x0>>5] >>>= (m1x0&0x1f);
  //!if (dbgdump) writeln("  3: ", m1x0>>5, " : ", va("%x", maskHLine[m1x0>>5]));
  //writeln(m1x1&0x1f, " : ", m1x1&0x1f != 0x1f);
  //!if (dbgdump) writeln("  4: ", m1x1>>5, " : ", m1x1&0x1f, "; ", va("%x", -1<<(31-(m1x1&0x1f))), " : ", va("%x", maskHLine[m1x1>>5]), " : ", va("%x", maskHLine[m1x1>>5]&(-1<<(31-(m1x1&0x1f)))));
  maskHLine[m1x1>>5] &= -1<<(31-(m1x1&0x1f));
  //!if (dbgdump) writeln("    ** ", va("%x", 0x0fffffff&0xf8000000));
  //!if (dbgdump) foreach (int vidx; 0..hlwdt) write(" ", va("%x", maskHLine[vidx])); writeln;
  // calculate x bounds on self
  int sx1 = min(width, hlwdt);
  // calculate y bounds on self
  int sy0 = max(0, m1y0);
  int sy1 = min(height, m1y1+1);
  /*
  if (dbgdump) {
    writeln("  CR: me:(", x0, ",", y0, ")-(", x1, ",", y1, "); it:(", m1x0, ",", m1y0, ")-(", m1x1, ",", m1y1, ")");
    writeln("      dx=", dx, "; sy0=", sy0, "; sx1=", sx1, "; sy1=", sy1, "; hlwdt=", hlwdt, "; ", va("%x", maskHLine[hlwdt-1]));
  }
  */
  // skip zeroes at the left part
  int sx0 = 0;
  while (sx0 < sx1 && !maskHLine[sx0]) ++sx0;
  if (sx0 >= sx1) return false;
  // skip zeroes at the right part
  while (sx1 > 0 && !maskHLine[sx1-1]) --sx1;
  if (sx0 >= sx1) return false;
  foreach (int sy; sy0..sy1) {
    foreach (int sx; sx0..sx1) {
      // do check
      //!if (dbgdump) writeln("  sx=", sx, "; m=", va("%x", mask[sx, sy]), "; hm=", va("%x", maskHLine[sx]));
      if (mask[sx, sy]&maskHLine[sx]) return true;
    }
  }
  return false;
}


static final CollisionMask Create (SpriteFrame frm, bool mirrored, optional bool dumpCheck) {
  CollisionMask res = SpawnObject(CollisionMask);
#ifdef PXCOLDET_TEST
  res.dumpCheck = dumpCheck;
#endif
  if (!frm || frm.width < 1 || frm.height < 1) return res;
  int elw = (frm.width+31)/32;
  if (elw < 1) FatalError("WUTA...");
  res.width = elw;
  res.height = frm.height;
  res.x0 = 0;
  res.y0 = 0;
  res.x1 = frm.width-1;
  res.y1 = frm.height-1;
  res.mask.setSize(elw+1, frm.height); // +1 to avoid one check in coldet
  // fill mask
  // detect bounding box
  // detect empty mask
  bool hasPix = false;
  int xmin = int.max, xmax = int.min;
  int ymin = int.max, ymax = int.min;
  foreach (int y; 0..frm.height) {
    foreach (int x; 0..frm.width) {
      if (frm.getMaskPixelEx(x, y, mirrored)) {
        res.setPixel(x, y, true);
        hasPix = true;
        xmin = min(xmin, x);
        ymin = min(ymin, y);
        xmax = max(xmax, x);
        ymax = max(ymax, y);
      }
    }
  }
  // check if we have at least one set pixel
  if (!hasPix) {
    // clear mask and exit
    res.mask.length = 0;
    return res;
  }
  // set bounding box
  res.x0 = xmin; res.y0 = ymin;
  res.x1 = xmax; res.y1 = ymax;
  res.bbsolid = true;
  // detect solid bounding box
  foreach (int y; ymin..ymax+1) {
    foreach (int x; xmin..xmax+1) {
      if (!frm.getMaskPixelEx(x, y, mirrored)) {
        res.bbsolid = false;
        break;
      }
    }
  }
#ifdef PXCOLDET_TEST
  if (dumpCheck) writeln("size: ", frm.width, "x", frm.height, "; bbox:(", res.x0, ",", res.y0, ")-(", res.x1, ",", res.y1, "); solid:", (res.bbsolid ? "tan" : "ona"));
#endif
  return res;
}


// ////////////////////////////////////////////////////////////////////////// //
class SpriteFrame : Object transient;

GLTexture tex;
//name Name;
int index;
int xofs, yofs;
int wdt, hgt;
CollisionMask colmask, colmaskMirrored; // will be lazily created
string mask; // collision bitmask; can be empty
// bounding box
int bx, by, bw, bh;
bool maskEmpty;
bool precise; // use precise pixel-perfect collision detection?
bool goodSize;


final int width { get wdt; }
final int height { get hgt; }


override void Destroy () {
  delete tex;
  ::Destroy();
}


final void blitAt (int x, int y, int scale, optional float angle) {
  if (goodSize) {
    tex.blitAt(x, y, scale, angle:angle!optional);
  } else {
    int w = wdt, h = hgt;
    tex.blitExt(x, y, x+w*scale, y+h*scale, 0, 0, w, h, angle:angle!optional);
  }
}


final void processMask () {
  maskEmpty = true;
  if (!mask || bw < 1 || bh < 1) return;
  foreach (int idx; 0..mask.length) if (mask[idx]) { maskEmpty = false; return; }
}


final bool getMaskPixel (int x, int y) {
  if (maskEmpty) return false;
  if (x < bx || y < by || x >= bx+bw || y >= by+bh) return false;
  if (!mask) return true;
  int w = tex.width, h = tex.height;
  if (x < 0 || y < 0 || x >= w || y >= h) return false;
  return !!(mask[y*((w+7)/8)+x/8]&(0x80>>(x&7)));
}


final bool getMaskPixelEx (int x, int y, bool mirrored) {
  if (maskEmpty) return false;
  if (mirrored) x = tex.width-x-1;
  return getMaskPixel(x, y);
}


final bool isEmptyPixelMask { get maskEmpty; }


final CollisionMask getColMask (bool mirrored) {
  CollisionMask res = (mirrored ? colmaskMirrored : colmask);
  if (!res) {
    res = CollisionMask.Create(self, mirrored);
    if (mirrored) colmaskMirrored = res; else colmask = res;
  }
  return res;
}


// inclusive
final void getBBox (out int x0, out int y0, out int x1, out int y1, optional bool doMirror) {
  y0 = by;
  y1 = y0+bh-1;
  if (!doMirror) {
    x0 = bx;
    x1 = x0+bw-1;
  } else {
    x1 = width-bx-1;
    x0 = x1-bw+1;
  }
}


final bool checkPoint (int dx, int dy, bool doMirror) {
  return (precise ? getMaskPixelEx(dx, dy, doMirror) : dx >= bx && dy >= by && dx < bx+bw && dy < by+bh);
}


final bool checkRect (int rx, int ry, int rw, int rh, bool doMirror) {
  if (rw < 1 || rh < 1 || maskEmpty || bw < 1 || bh < 1) return false;
  if (rx+rw > bx && ry+rh > by && rx < bx+bw && ry < by+bh) {
    if (!precise) return true;
    auto cm = getColMask(doMirror);
    return (rx+rw > cm.x0 && ry+rh > cm.y0 && rx <= cm.x1 && ry <= cm.y1);
  }
  return false;
}


final bool checkRectFrm (SpriteFrame frm, int dx, int dy, optional bool mirrorSelf, optional bool mirrorFrm) {
  if (!frm || bw < 1 || bh < 1 || frm.bw < 1 || frm.bh < 1) return false;
  int selfx0, selfy0, selfx1, selfy1;
  getBBox(out selfx0, out selfy0, out selfx1, out selfy1, mirrorSelf);
  int frmx0, frmy0, frmx1, frmy1;
  frm.getBBox(out frmx0, out frmy0, out frmx1, out frmy1, mirrorFrm);
  if (dx+frmx0 > selfx1 || dy+frmy0 > selfy1 || dx+frmx1 < selfx0 || dy+frmy1 < selfy0) return false;
  return true;
}


final bool pixelCheck (SpriteFrame frm, int dx, int dy, optional bool mirrorSelf, optional bool mirrorFrm/*, optional bool dbgdump*/) {
  if (precise && maskEmpty) return false;
  if (!frm || bw < 1 || bh < 1 || frm.bw < 1 || frm.bh < 1) return false;
  if (frm.precise && frm.maskEmpty) return false;
  int selfx0, selfy0, selfx1, selfy1;
  getBBox(out selfx0, out selfy0, out selfx1, out selfy1, mirrorSelf);
  int frmx0, frmy0, frmx1, frmy1;
  frm.getBBox(out frmx0, out frmy0, out frmx1, out frmy1, mirrorFrm);
  if (dx+frmx0 > selfx1 || dy+frmy0 > selfy1 || dx+frmx1 < selfx0 || dy+frmy1 < selfy0) return false;
  if (!precise && !frm.precise) return true; // bboxes overlaps, it is enough
  //!if (dbgdump) writeln("!!! (precise=", precise, "; frm.precise=", frm.precise, "; myempty=", maskEmpty, "; frmempty=", frm.maskEmpty, ")");
  CollisionMask selfCM, frmCM;
  // if our mask is empty, it means "bbcheck with other mask"
  if (maskEmpty) {
    if (!frm.precise) return true;
    if (frm.maskEmpty) FatalError("WTF?! (0)");
    frmCM = frm.getColMask(mirrorFrm);
    //!if (dbgdump) writeln("0:!!! dx=", dx, "; dy=", dy, "; me:(", bx-dx, ",", by-dy, ")-(", bx-dx+bw-1, ",", by-dy+bh-1, "); it:(", frmCM.x0, ",", frmCM.y0, ")-(", frmCM.x1, ",", frmCM.y1, ")");
    //!if (dbgdump) writeln("0:!!! dx=", -(dx+frmx0), "; dy=", -(dy+frmy0), "; self=(", selfx0, ",", selfy0, ")-(", selfx1, ",", selfy1, ")");
    return frmCM.colCheckRect(-dx, -dy, selfx0, selfy0, selfx1, selfy1/*, dbgdump!optional*/);
  }
  // if their mask is empty, it means "bbcheck with other mask"
  if (frm.maskEmpty) {
    //writeln("!!! 1");
    if (!precise) return true;
    if (maskEmpty) FatalError("WTF?! (1)");
    selfCM = getColMask(mirrorSelf);
    return selfCM.colCheckRect(dx, dy, frmx0, frmy0, frmx1, frmy1/*, dbgdump!optional*/);
  }
  //if (maskEmpty || frm.maskEmpty) return false;
#ifdef PXCOLDET_TEST
  foreach (auto y; frm.by..frm.by+frm.bh) {
    foreach (auto x; frm.bx..frm.bx+frm.bw) {
      if (frm.getMaskPixelEx(x, y, mirrorFrm) && getMaskPixelEx(dx+x, dy+y, mirrorSelf)) return true;
    }
  }
  return false;
#else
  // lazy colmask creation
  selfCM = getColMask(mirrorSelf);
  frmCM = frm.getColMask(mirrorFrm);
  // check it
  return selfCM.colCheck(frmCM, dx, dy);
#endif
}


// ////////////////////////////////////////////////////////////////////////// //
class SpriteImage : Object transient;

name Name;
array!SpriteFrame frames;
bool precise; // use precise pixel-perfect collision detection?


override void Destroy () {
  foreach (ref auto fr; frames) delete fr;
  ::Destroy();
}


static final int roundToPOW (int n) {
  --n;
  n |= n>>1;
  n |= n>>2;
  n |= n>>4;
  n |= n>>8;
  n |= n>>16;
  ++n;
  return n;
}


static final SpriteImage Load (string fname, bool allowNPot) {
  auto fl = FileReader.Open(fname);
  if (!fl) return none;
  // signature
  string sign = fl.readBuf(4, true); // exact
  if (sign != "SPR0" || fl.error) { delete fl; return none; }
  // name
  int nlen = fl.readU8();
  if (fl.error) { delete fl; return none; }
  string sprName;
  if (nlen) {
    sprName = fl.readBuf(nlen, true); // exact
    if (fl.error) { delete fl; return none; }
  }
  // number of frames
  int frameCount = fl.readU8();
  // frame dimensions
  int frameW = fl.readU16();
  int frameH = fl.readU16();
  // frame offset
  int xofs = fl.readI16();
  int yofs = fl.readI16();
  // flags
  int flags = fl.readU8(); // bit 0: precise collision flag (disk shape is emulated with precise mask)
  if (fl.error) { delete fl; return none; }
  if (frameW < 1 || frameH < 1 || frameW > 8192 || frameH > 8192) { delete fl; return none; }

  int txw = (allowNPot ? frameW : roundToPOW(frameW));
  int txh = (allowNPot ? frameH : roundToPOW(frameH));

  auto spimg = SpawnObject(SpriteImage);
  spimg.Name = name(sprName);
  spimg.frames.length = frameCount;
  spimg.precise = ((flags&0x01) != 0);
  //writeln(fname, " : ", spimg.precise);
  // load frames
  foreach (auto fridx; 0..frameCount) {
    // read bounding box
    int x0 = fl.readI16();
    int y0 = fl.readI16();
    int x1 = fl.readI16();
    int y1 = fl.readI16();
    if (fl.error) { delete fl; delete spimg; return none; }
    // collision mask
    string cmask;
    if (flags&0x01) {
      int mwdt = (frameW+7)/8;
      cmask = fl.readBuf(mwdt*frameH, true); // exact
      if (fl.error) { delete fl; delete spimg; return none; }
    }
    // image
    //name frmName = name(va("%s_frame_%d", sprName, fridx));
    auto tex = GLTexture.CreateEmpty(txw, txh/*, frmName*/);
    foreach (int y; 0..frameH) {
      foreach (int x; 0..frameW) {
        ubyte r = fl.readU8();
        ubyte g = fl.readU8();
        ubyte b = fl.readU8();
        ubyte a = 255-fl.readU8();
        if (fl.error) {
          writeln("error loading sprite file '", fname, "' (x=", x, "; y=", y, ")");
          delete fl; delete spimg; delete tex;
          return none;
        }
        //write("(", a, ",", r, ",", g, ",", b, ") ");
        tex.setPixel(x, y, (a<<24)|(r<<16)|(g<<8)|b);
      }
      foreach (int x; frameW..txw) tex.setPixel(x, y, 0xff_00_00_00);
      //writeln();
    }
    foreach (int y; frameH..txh) foreach (int x; frameW..txw) tex.setPixel(x, y, 0xff_00_00_00);
    // update texture image
    tex.upload();
    // create sprite frame
    auto frm = SpawnObject(SpriteFrame);
    //frm.Name = frmName;
    frm.index = fridx;
    frm.tex = tex;
    frm.xofs = xofs;
    frm.yofs = yofs;
    frm.wdt = frameW;
    frm.hgt = frameH;
    frm.goodSize = (txw == frameW && txh == frameH);
    frm.mask = cmask;
    frm.bx = x0;
    frm.by = y0;
    frm.bw = (x1 < x0 ? 0 : x1-x0+1);
    frm.bh = (y1 < y0 ? 0 : y1-y0+1);
    frm.precise = spimg.precise;
    frm.processMask();
    spimg.frames[fridx] = frm;
  }
  delete fl;
  return spimg;
}


// ////////////////////////////////////////////////////////////////////////// //
class SpriteStore : Object transient;

array!SpriteImage sprbyid;
string sprPath;
bool bDumpLoaded;
int allowNPot = -1;
SpriteImage fontImg;
name fontName;


private final void loadSprite (name Name) {
  if (!Name) FatalError("cannot load namelss sprite");

  if (allowNPot < 0) {
    if (!GLVideo.isInitialized) {
      writeln("preloading sprite '", Name, "'");
    } else {
      allowNPot = (GLVideo.glHasNPOT ? 1 : 0);
      if (allowNPot) writeln("*** NPOT textures allowed");
      //allowNPot = 0;
    }
  }

  auto spr = SpriteImage.Load(va("%s/%n.spr", sprPath, Name), (allowNPot > 0));
  if (!spr) FatalError("cannot load sprite '%n'", Name);

  sprbyid[NameToIIndex(/*spr.*/Name)] = spr;

  if (bDumpLoaded) {
    writeln("sprite: <", spr.Name, ">, ", spr.frames.length, " frames; id=", NameToIIndex(spr.Name));
    foreach (auto fidx, SpriteFrame frm; spr.frames) {
      writeln("  === FRAME #", fidx, " ===");
      //writeln("    name: <", frm.Name, ">");
      writeln("    index: <", frm.index, ">");
      writeln("    size: (", frm.tex.width, "x", frm.tex.height, ")");
      writeln("    offset: (", frm.xofs, ",", frm.yofs, ")");
      writeln("    bbox: (", frm.bx, ",", frm.by, ")x(", frm.bw, ",", frm.bh, ")");
      if (frm.mask) writeln("    has collision mask", (frm.maskEmpty ? " (empty)" : ""));
    }
  }
}


final void loadFont (name Name) {
  if (fontName != Name) {
    fontName = Name;
    fontImg = opIndex(Name);
  }
}


final int getFontHeight (optional int scale) {
  if (!specified_scale) scale = 1;
  if (scale < 1 || !fontImg) return 0;
  return fontImg.frames[0].height*scale;
}


final int getCharWidth (int ch, optional int scale) {
  if (ch < 32) return 0;
  if (!specified_scale) scale = 1;
  if (scale < 1 || !fontImg) return 0;
  auto flen = fontImg.frames.length;
  if (flen < 1) return 0;
  if (ch < 32) ch = 32;
  if (ch >= "a" && ch <= "z" && ch-32 >= flen) ch -= 32;
  ch -= 32;
  if (ch < 0 || ch >= flen) ch = 0;
  return fontImg.frames[ch].width*scale;
}


final int getTextWidth (string str, optional int scale, optional bool processHighlights1, optional bool processHighlights2) {
  if (!specified_scale) scale = 1;
  int res = 0;
  int inHigh = 0;
  foreach (auto sidx; 0..str.length) {
    auto ch = str[sidx];
    if (processHighlights1) {
      if (ch == '~' && (!inHigh || inHigh == 1)) {
        inHigh = !inHigh;
        continue;
      }
    }
    if (processHighlights2) {
      if (ch == '|' && (!inHigh || inHigh == 2)) {
        inHigh = 2-inHigh;
        continue;
      }
    }
    res += getCharWidth(ch, scale);
  }
  return res;
}


// returns char width
final int renderChar (int x, int y, int ch, optional int scale) {
  if (ch < 32) return 0;
  if (!specified_scale) scale = 1;
  if (scale < 1 || !fontImg) return 0;
  auto flen = fontImg.frames.length;
  if (flen < 1) return 0;
  if (ch < 32) ch = 32;
  if (ch >= "a" && ch <= "z" && ch-32 >= flen) ch -= 32;
  ch -= 32;
  if (ch < 0 || ch >= flen) ch = 0;
  fontImg.frames[ch].blitAt(x, y, scale);
  return fontImg.frames[ch].width*scale;
}


final void renderText (int x, int y, string str, optional int scale) {
  if (!specified_scale) scale = 1;
  if (scale < 1 || !fontImg) return;
  auto flen = fontImg.frames.length;
  if (flen < 1) return;
  foreach (auto sidx; 0..str.length) {
    auto ch = str[sidx];
    if (ch >= "a" && ch <= "z" && ch-32 >= flen) ch -= 32;
    ch -= 32;
    if (ch >= 0 && ch < flen) {
      fontImg.frames[ch].blitAt(x, y, scale);
      x += fontImg.frames[ch].width*scale;
    } else {
      x += fontImg.frames[0].width*scale;
    }
  }
}


final void renderTextHiChar (int x, int y, string str, optional int scale, optional int hotCharOfs, optional int hotCharColor) {
  if (!specified_scale) scale = 1;
  if (scale < 1 || !fontImg) return;
  auto flen = fontImg.frames.length;
  if (flen < 1) return;
  auto oclr = GLVideo.color;
  foreach (auto sidx; 0..str.length) {
    auto ch = str[sidx];
    if (ch >= "a" && ch <= "z" && ch-32 >= flen) ch -= 32;
    ch -= 32;
    if (ch >= 0 && ch < flen) {
      if (specified_hotCharOfs && specified_hotCharColor) {
        if (hotCharOfs == sidx) GLVideo.color = hotCharColor;
      }
      fontImg.frames[ch].blitAt(x, y, scale);
      x += fontImg.frames[ch].width*scale;
      GLVideo.color = oclr;
    } else {
      x += fontImg.frames[0].width*scale;
    }
  }
  GLVideo.color = oclr;
}


final void renderTextWithHighlight (int x, int y, string str, optional int scale, int hiColor, optional int hiColor1) {
  if (!specified_scale) scale = 1;
  if (scale < 1 || !fontImg) return;
  auto flen = fontImg.frames.length;
  if (flen < 1) return;
  auto oclr = GLVideo.color;
  int inHigh = 0;
  foreach (auto sidx; 0..str.length) {
    auto ch = str[sidx];
    if (ch == '~' && (!inHigh || inHigh == 1)) {
      inHigh = !inHigh;
      GLVideo.color = (inHigh ? hiColor : oclr);
      continue;
    }
    if (specified_hiColor1 && ch == '|' && (!inHigh || inHigh == 2)) {
      inHigh = 2-inHigh;
      GLVideo.color = (inHigh ? hiColor1 : oclr);
      continue;
    }
    if (ch >= "a" && ch <= "z" && ch-32 >= flen) ch -= 32;
    ch -= 32;
    if (ch >= 0 && ch < flen) {
      fontImg.frames[ch].blitAt(x, y, scale);
      x += fontImg.frames[ch].width*scale;
    } else {
      x += fontImg.frames[0].width*scale;
    }
  }
  GLVideo.color = oclr;
}


// this knows about '\n' too
final void renderTextWrapped (int x, int y, int wdt, string str, optional int scale) {
  if (!specified_scale) scale = 1;
  if (scale < 1 || !fontImg || fontImg.frames.length < 1) return;
  //auto flen = fontImg.frames.length;
  int x0 = x;
  int sidx = 0;
  bool skipSpaces = false;
  while (sidx < str.length) {
    auto ch = str[sidx];
    if (ch == '\r') { ++sidx; continue; }
    if (ch == '\n') { x = x0; y += fontImg.frames[0].height*scale; ++sidx; skipSpaces = false; continue; }
    if (skipSpaces && ch <= 32) { ++sidx; continue; }
    // find end of the current word (and calculate word width)
    int epos = sidx;
    int wwdt = 0;
    if (!skipSpaces) {
      while (epos < str.length && str[epos] <= 32 && str[epos] != '\n') wwdt += getCharWidth(str[epos++], scale!optional);
    }
    while (epos < str.length && str[epos] > 32) wwdt += getCharWidth(str[epos++], scale!optional);
    // do we need to wrap here?
    if (x > x0 && x+wwdt-x0 > wdt) {
      // yes, do wrapping
      // skip spaces on wrapping, they aren't needed
      if (!skipSpaces) { while (sidx < str.length && str[sidx] <= 32 && str[sidx] != '\n') ++sidx; }
      // move to the next line
      x = x0;
      y += fontImg.frames[0].height*scale;
    }
    // print it
    while (sidx < epos) x += renderChar(x, y, str[sidx++], scale!optional);
    x += getCharWidth(32, scale!optional);
    // skip the following spaces
    skipSpaces = true;
  }
}


// splitted by "\n"
final int getMultilineTextWidth (string str, optional int scale, optional bool processHighlights1, optional bool processHighlights2) {
  if (!specified_scale) scale = 1;
  int curwdt = 0, maxwdt = 0;
  int inHigh = 0;
  foreach (auto sidx; 0..str.length) {
    auto ch = str[sidx];
    if (processHighlights1) {
      if (ch == '~' && (!inHigh || inHigh == 1)) {
        inHigh = !inHigh;
        continue;
      }
    }
    if (processHighlights2) {
      if (ch == '|' && (!inHigh || inHigh == 2)) {
        inHigh = 2-inHigh;
        continue;
      }
    }
    if (ch == '\n') {
      maxwdt = max(maxwdt, curwdt);
      curwdt = 0;
    } else {
      curwdt += getCharWidth(str[sidx], scale);
    }
  }
  return max(curwdt, maxwdt);
}


// splitted by "\n"
final int getMultilineTextHeight (string str, optional int scale) {
  if (!specified_scale) scale = 1;
  int lineCount = 1;
  int lend = str.length;
  while (lend > 0 && str[lend-1] == '\n') --lend;
  foreach (auto sidx; 0..lend) if (str[sidx] == '\n') ++lineCount;
  return lineCount*getFontHeight(scale);
}


// `x` is a center point; `y` is a starting line
final void renderMultilineTextCentered (int x, int y, string str, optional int scale, optional int highColor1, optional int highColor2) {
  if (!specified_scale) scale = 1;
  if (scale < 1 || !fontImg) return;
  auto flen = fontImg.frames.length;
  if (flen < 1) return;
  highColor1 = (highColor1&0xff_ff_ff)|(GLVideo.color&0xff_00_00_00);
  highColor2 = (highColor2&0xff_ff_ff)|(GLVideo.color&0xff_00_00_00);
  int pos = 0;
  int endpos = str.length;
  while (endpos > 0 && str[endpos] == '\n') --endpos;
  if (y < 0) {
    int lc = 1;
    foreach (auto sidx; pos..endpos) if (str[sidx] == '\n') ++lc;
    if (y == int.min) {
      y = (GLVideo.screenHeight-lc*getFontHeight(scale!optional))/2;
    } else {
      y = (-y-lc*getFontHeight(scale!optional))/2;
    }
  }
  while (pos < endpos) {
    int epos = pos;
    while (epos < str.length && str[epos] != '\n') ++epos;
    string s = str[pos..epos];
    pos = epos+1;
    if (specified_highColor1 || specified_highColor2) {
      renderTextWithHighlight(x-getTextWidth(s, scale, specified_highColor1, specified_highColor2)/2, y, s, scale, highColor1!optional, highColor2!optional);
    } else {
      renderText(x-getTextWidth(s, scale)/2, y, s, scale);
    }
    y += fontImg.frames[0].height*scale;
  }
}


final void renderMultilineText (int x, int y, string str, optional int scale, optional int highColor1, optional int highColor2) {
  if (!specified_scale) scale = 1;
  if (scale < 1 || !fontImg) return;
  auto flen = fontImg.frames.length;
  if (flen < 1) return;
  highColor1 = (highColor1&0xff_ff_ff)|(GLVideo.color&0xff_00_00_00);
  highColor2 = (highColor2&0xff_ff_ff)|(GLVideo.color&0xff_00_00_00);
  int pos = 0;
  int endpos = str.length;
  while (endpos > 0 && str[endpos] == '\n') --endpos;
  if (y < 0) {
    int lc = 1;
    foreach (auto sidx; pos..endpos) if (str[sidx] == '\n') ++lc;
    if (y == int.min) {
      y = (GLVideo.screenHeight-lc*getFontHeight(scale!optional))/2;
    } else {
      y = (-y-lc*getFontHeight(scale!optional))/2;
    }
  }
  while (pos < endpos) {
    int epos = pos;
    while (epos < str.length && str[epos] != '\n') ++epos;
    string s = str[pos..epos];
    pos = epos+1;
    if (specified_highColor1 || specified_highColor2) {
      renderTextWithHighlight(x, y, s, scale, highColor1!optional, highColor2!optional);
    } else {
      renderText(x, y, s, scale);
    }
    y += fontImg.frames[0].height*scale;
  }
}


final SpriteImage opIndex (name Name) {
  int id = NameToIIndex(Name);
  if (id <= 0) return none; // just in case
  if (id >= sprbyid.length || !sprbyid[id]) loadSprite(Name);
  return (id >= 0 && id < sprbyid.length ? sprbyid[id] : none);
}


defaultproperties {
  //sprPath = "data/gfx/sprites";
  sprPath = "sprites";
}