render.d

   1 /* DooM2D: Midnight on the Firing Line
   2  * coded by Ketmar // Invisible Vector <ketmar@ketmar.no-ip.org>
   3  * Understanding is not required. Only obedience.
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 module render is aliced;
  19
  20 //version = dont_use_vsync;
  21
  22 private:
  23 import core.atomic;
  24 import core.thread;
  25 import core.time;
  26
  27 import std.concurrency;
  28
  29 import iv.glbinds;
  30 import glutils;
  31 import console;
  32 import wadarc;
  33
  34 import iv.stream;
  35
  36 import d2dmap;
  37 import d2dadefs;
  38 //import d2dactors;
  39 import d2dgfx;
  40 import d2dfont;
  41 import dacs;
  42
  43 import d2dunigrid;
  44
  45 // `map` is there
  46 import dengapi;
  47
  48 import d2dparts;
  49
  50
  51 // ////////////////////////////////////////////////////////////////////////// //
  52 import arsd.color;
  53 import arsd.png;
  54
  55
  56 // ////////////////////////////////////////////////////////////////////////// //
  57 public __gshared bool cheatNoDoors = false;
  58 public __gshared bool cheatNoWallClip = false;
  59
  60
  61 // ////////////////////////////////////////////////////////////////////////// //
  62 public __gshared SimpleWindow sdwindow;
  63
  64
  65 public enum vlWidth = 800;
  66 public enum vlHeight = 800;
  67 __gshared int scale = 2;
  68
  69 public int getScale () nothrow @trusted @nogc { pragma(inline, true); return scale; }
  70
  71
  72 // ////////////////////////////////////////////////////////////////////////// //
  73 __gshared bool levelLoaded = false;
  74
  75
  76 // ////////////////////////////////////////////////////////////////////////// //
  77 __gshared bool scanlines = false;
  78 __gshared bool doLighting = true;
  79 __gshared bool gamePaused = false;
  80 shared bool editMode = false;
  81
  82 public @property bool inEditMode () nothrow @trusted @nogc { import core.atomic; return atomicLoad(editMode); }
  83 @property void inEditMode (bool v) nothrow @trusted @nogc { import core.atomic; atomicStore(editMode, v); }
  84
  85
  86 // ////////////////////////////////////////////////////////////////////////// //
  87 // interpolation
  88 __gshared ubyte[] prevFrameActorsData;
  89 __gshared uint[65536] prevFrameActorOfs; // uint.max-1: dead; uint.max: last
  90 __gshared MonoTime lastthink = MonoTime.zero; // for interpolator
  91 __gshared MonoTime nextthink = MonoTime.zero;
  92 __gshared bool frameInterpolation = true;
  93
  94
  95 // ////////////////////////////////////////////////////////////////////////// //
  96 // attached lights
  97 struct AttachedLightInfo {
  98   enum Type {
  99     Point,
 100     Ambient,
 101   }
 102   Type type;
 103   int x, y;
 104   int w, h; // for ambient lights
 105   float r, g, b;
 106   bool uncolored;
 107   int radius;
 108 }
 109
 110 __gshared AttachedLightInfo[65536] attachedLights;
 111 __gshared uint attachedLightCount = 0;
 112
 113
 114 // ////////////////////////////////////////////////////////////////////////// //
 115 enum MaxLightRadius = 255;
 116
 117
 118 // ////////////////////////////////////////////////////////////////////////// //
 119 // for light
 120 __gshared FBO[MaxLightRadius+1] fboDistMap;
 121 __gshared FBO fboOccluders;
 122 __gshared Shader shadToPolar, shadBlur, shadBlurOcc, shadAmbient;
 123 __gshared TrueColorImage editorImg;
 124 __gshared FBO fboEditor;
 125
 126 __gshared FBO fboLevel, fboLevelLight, fboOrigBack, fboLMaskSmall;
 127 __gshared Shader shadScanlines;
 128 __gshared Shader shadLiquidDistort;
 129
 130
 131 // ////////////////////////////////////////////////////////////////////////// //
 132 // call once!
 133 public void initOpenGL () {
 134   gloStackClear();
 135
 136   glEnable(GL_TEXTURE_2D);
 137   glDisable(GL_LIGHTING);
 138   glDisable(GL_DITHER);
 139   glDisable(GL_BLEND);
 140   glDisable(GL_DEPTH_TEST);
 141
 142   // create shaders
 143   shadScanlines = new Shader("scanlines", loadTextFile("shaders/srscanlines.frag"));
 144
 145   shadLiquidDistort = new Shader("liquid_distort", loadTextFile("shaders/srliquid_distort.frag"));
 146   shadLiquidDistort.exec((Shader shad) {
 147     shad["texLqMap"] = 0;
 148   });
 149
 150   // lights
 151   shadToPolar = new Shader("light_trace", loadTextFile("shaders/srlight_trace.frag"));
 152   shadToPolar.exec((Shader shad) {
 153     shad["texOcc"] = 0;
 154     shad["texOccFull"] = 2;
 155     shad["texOccSmall"] = 3;
 156   });
 157
 158   shadBlur = new Shader("light_blur", loadTextFile("shaders/srlight_blur.frag"));
 159   shadBlur.exec((Shader shad) {
 160     shad["texDist"] = 0;
 161     shad["texBg"] = 1;
 162     shad["texOcc"] = 2;
 163     shad["texOccSmall"] = 3;
 164   });
 165
 166   shadBlurOcc = new Shader("light_blur_occ", loadTextFile("shaders/srlight_blur_occ.frag"));
 167   shadBlurOcc.exec((Shader shad) {
 168     shad["texLMap"] = 0;
 169     shad["texBg"] = 1;
 170     shad["texOcc"] = 2;
 171     shad["texOccSmall"] = 3;
 172   });
 173
 174   shadAmbient = new Shader("light_ambient", loadTextFile("shaders/srlight_ambient.frag"));
 175   shadAmbient.exec((Shader shad) {
 176     shad["texBg"] = 1;
 177     shad["texOcc"] = 2;
 178     shad["texOccSmall"] = 3;
 179   });
 180
 181   fboOccluders = new FBO(MaxLightRadius*2, MaxLightRadius*2, Texture.Option.Clamp, Texture.Option.Linear);
 182   //TODO: this sux!
 183   foreach (int sz; 2..MaxLightRadius+1) {
 184     fboDistMap[sz] = new FBO(sz*2, 1, Texture.Option.Clamp, Texture.Option.Linear); // create 1d distance map FBO
 185   }
 186
 187   editorImg = new TrueColorImage(vlWidth, vlHeight);
 188   editorImg.imageData.colors[] = Color(0, 0, 0, 0);
 189   fboEditor = new FBO(vlWidth, vlHeight, Texture.Option.Nearest);
 190
 191   // setup matrices
 192   glMatrixMode(GL_MODELVIEW);
 193   glLoadIdentity();
 194
 195   loadSmFont();
 196   loadBfFont();
 197   loadAllMonsterGraphics();
 198 }
 199
 200
 201 // ////////////////////////////////////////////////////////////////////////// //
 202 // should be called when OpenGL is initialized
 203 void loadMap (string mapname) {
 204   mapscripts.runUnloading(); // "map unloading" script
 205   clearMapScripts();
 206
 207   if (map !is null) map.clear();
 208   map = new LevelMap(mapname);
 209   curmapname = mapname;
 210
 211   ugInit(map.width*TileSize, map.height*TileSize);
 212
 213   map.oglBuildMega();
 214   mapTilesChanged = 0;
 215
 216   if (fboLevel !is null) fboLevel.clear();
 217   if (fboLevelLight !is null) fboLevelLight.clear();
 218   if (fboOrigBack !is null) fboOrigBack.clear();
 219   if (fboLMaskSmall !is null) fboLMaskSmall.clear();
 220
 221   fboLevel = new FBO(map.width*TileSize, map.height*TileSize, Texture.Option.Nearest); // final level render will be here
 222   fboLevelLight = new FBO(map.width*TileSize, map.height*TileSize, Texture.Option.Nearest); // level lights will be rendered here
 223   fboOrigBack = new FBO(map.width*TileSize, map.height*TileSize, Texture.Option.Nearest/*, Texture.Option.Depth*/); // background+foreground
 224   fboLMaskSmall = new FBO(map.width, map.height, Texture.Option.Nearest); // small lightmask
 225
 226   shadToPolar.exec((Shader shad) { shad["mapPixSize"] = SVec2F(map.width*TileSize-1, map.height*TileSize-1); });
 227   shadBlur.exec((Shader shad) { shad["mapPixSize"] = SVec2F(map.width*TileSize, map.height*TileSize); });
 228   shadBlurOcc.exec((Shader shad) { shad["mapPixSize"] = SVec2F(map.width*TileSize, map.height*TileSize); });
 229   shadAmbient.exec((Shader shad) { shad["mapPixSize"] = SVec2F(map.width*TileSize, map.height*TileSize); });
 230
 231   glActiveTexture(GL_TEXTURE0+0);
 232   glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 233   orthoCamera(vlWidth, vlHeight);
 234
 235   Actor.resetStorage();
 236
 237   setupMapScripts();
 238   mapscripts.runInit();
 239   loadMapMonsters();
 240   dotInit();
 241   mapscripts.runLoaded();
 242
 243   // save first snapshot
 244   if (prevFrameActorsData.length == 0) prevFrameActorsData = new ubyte[](Actor.actorSize*65536); // ~15-20 megabytes
 245   prevFrameActorOfs[] = uint.max; // just for fun
 246   Actor.saveSnapshot(prevFrameActorsData[], prevFrameActorOfs.ptr);
 247
 248   levelLoaded = true;
 249
 250   { import core.memory : GC; GC.collect(); }
 251 }
 252
 253
 254 // ////////////////////////////////////////////////////////////////////////// //
 255 //FIXME: optimize!
 256 __gshared uint mapTilesChanged = 0;
 257
 258
 259 //WARNING! this can be called only from DACS, so we don't have to sync it!
 260 public void mapDirty (uint layermask) { mapTilesChanged |= layermask; }
 261
 262
 263 void rebuildMapMegaTextures () {
 264   //fbo.replaceTexture
 265   //mapTilesChanged = false;
 266   //map.clearMegaTextures();
 267   map.oglBuildMega(mapTilesChanged);
 268   mapTilesChanged = 0;
 269   dotsAwake(); // let dormant dots fall
 270 }
 271
 272
 273 // ////////////////////////////////////////////////////////////////////////// //
 274 // messages
 275 struct Message {
 276   enum Phase { FadeIn, Stay, FadeOut }
 277   Phase phase;
 278   int alpha;
 279   int pauseMsecs;
 280   MonoTime removeTime;
 281   char[256] text;
 282   usize textlen;
 283 }
 284
 285 private import core.sync.mutex : Mutex;
 286
 287 __gshared Message[128] messages;
 288 __gshared uint messagesUsed = 0;
 289
 290 //__gshared Mutex messageLock;
 291 //shared static this () { messageLock = new Mutex(); }
 292
 293
 294 void addMessage (const(char)[] msgtext, int pauseMsecs=3000, bool noreplace=false) {
 295   //messageLock.lock();
 296   //scope(exit) messageLock.unlock();
 297   if (msgtext.length == 0) return;
 298   conwriteln(msgtext);
 299   if (pauseMsecs <= 50) return;
 300   if (messagesUsed == messages.length) {
 301     // remove top message
 302     foreach (immutable cidx; 1..messagesUsed) messages.ptr[cidx-1] = messages.ptr[cidx];
 303     messages.ptr[0].alpha = 255;
 304     --messagesUsed;
 305   }
 306   // quick replace
 307   if (!noreplace && messagesUsed == 1) {
 308     switch (messages.ptr[0].phase) {
 309       case Message.Phase.FadeIn:
 310         messages.ptr[0].phase = Message.Phase.FadeOut;
 311         break;
 312       case Message.Phase.Stay:
 313         messages.ptr[0].phase = Message.Phase.FadeOut;
 314         messages.ptr[0].alpha = 255;
 315         break;
 316       default:
 317     }
 318   }
 319   auto msg = messages.ptr+messagesUsed;
 320   ++messagesUsed;
 321   msg.phase = Message.Phase.FadeIn;
 322   msg.alpha = 0;
 323   msg.pauseMsecs = pauseMsecs;
 324   // copy text
 325   if (msgtext.length > msg.text.length) {
 326     msg.text = msgtext[0..msg.text.length];
 327     msg.textlen = msg.text.length;
 328   } else {
 329     msg.text[0..msgtext.length] = msgtext[];
 330     msg.textlen = msgtext.length;
 331   }
 332 }
 333
 334
 335 void doMessages (MonoTime curtime) {
 336   //messageLock.lock();
 337   //scope(exit) messageLock.unlock();
 338
 339   if (messagesUsed == 0) return;
 340   glEnable(GL_BLEND);
 341   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 342
 343   Message* msg;
 344
 345  again:
 346   msg = messages.ptr;
 347   final switch (msg.phase) {
 348     case Message.Phase.FadeIn:
 349       if ((msg.alpha += 10) >= 255) {
 350         msg.phase = Message.Phase.Stay;
 351         msg.removeTime = curtime+dur!"msecs"(msg.pauseMsecs);
 352         goto case; // to stay
 353       }
 354       glColor4f(1.0f, 1.0f, 1.0f, msg.alpha/255.0f);
 355       break;
 356     case Message.Phase.Stay:
 357       if (msg.removeTime <= curtime) {
 358         msg.alpha = 255;
 359         msg.phase = Message.Phase.FadeOut;
 360         goto case; // to fade
 361       }
 362       glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 363       break;
 364     case Message.Phase.FadeOut:
 365       if ((msg.alpha -= 10) <= 0) {
 366         if (--messagesUsed == 0) return;
 367         // remove this message
 368         foreach (immutable cidx; 1..messagesUsed+1) messages.ptr[cidx-1] = messages.ptr[cidx];
 369         goto again;
 370       }
 371       glColor4f(1.0f, 1.0f, 1.0f, msg.alpha/255.0f);
 372       break;
 373   }
 374
 375   smDrawText(10, 10, msg.text[0..msg.textlen]);
 376 }
 377
 378
 379 // ////////////////////////////////////////////////////////////////////////// //
 380 //mixin(Actor.FieldPropMixin!("0drawlistpos", uint));
 381
 382 mixin(Actor.FieldGetMixin!("classtype", StrId)); // fget_classtype
 383 mixin(Actor.FieldGetMixin!("classname", StrId)); // fget_classname
 384 mixin(Actor.FieldGetMixin!("x", int));
 385 mixin(Actor.FieldGetMixin!("y", int));
 386 mixin(Actor.FieldGetMixin!("s", int));
 387 mixin(Actor.FieldGetMixin!("radius", int));
 388 mixin(Actor.FieldGetMixin!("height", int));
 389 mixin(Actor.FieldGetMixin!("flags", uint));
 390 mixin(Actor.FieldGetMixin!("zAnimstate", StrId));
 391 mixin(Actor.FieldGetMixin!("zAnimidx", int));
 392 mixin(Actor.FieldGetMixin!("dir", uint));
 393 mixin(Actor.FieldGetMixin!("attLightXOfs", int));
 394 mixin(Actor.FieldGetMixin!("attLightYOfs", int));
 395 mixin(Actor.FieldGetMixin!("attLightRGBX", uint));
 396
 397 //mixin(Actor.FieldGetPtrMixin!("classtype", StrId)); // fget_classtype
 398 //mixin(Actor.FieldGetPtrMixin!("classname", StrId)); // fget_classname
 399 mixin(Actor.FieldGetPtrMixin!("x", int));
 400 mixin(Actor.FieldGetPtrMixin!("y", int));
 401 //mixin(Actor.FieldGetPtrMixin!("flags", uint));
 402 //mixin(Actor.FieldGetPtrMixin!("zAnimstate", StrId));
 403 //mixin(Actor.FieldGetPtrMixin!("zAnimidx", int));
 404 //mixin(Actor.FieldGetPtrMixin!("dir", uint));
 405 //mixin(Actor.FieldGetPtrMixin!("attLightXOfs", int));
 406 //mixin(Actor.FieldGetPtrMixin!("attLightYOfs", int));
 407 //mixin(Actor.FieldGetPtrMixin!("attLightRGBX", uint));
 408
 409
 410 // ////////////////////////////////////////////////////////////////////////// //
 411 __gshared int vportX0, vportY0, vportX1, vportY1;
 412
 413
 414 // ////////////////////////////////////////////////////////////////////////// //
 415 void renderLightAmbient() (int lightX, int lightY, int lightW, int lightH, in auto ref SVec4F lcol) {
 416   //conwriteln("!!!000: (", lightX, ",", lightY, ")-(", lightW, ",", lightH, "): r=", cast(uint)(255.0f*lcol.r), "; g=", cast(uint)(255.0f*lcol.g), "; b=", cast(uint)(255.0f*lcol.b), "; a=", cast(uint)(255.0f*lcol.a));
 417   if (lightW < 1 || lightH < 1) return;
 418   int lightX1 = lightX+lightW-1;
 419   int lightY1 = lightY+lightH-1;
 420   // clip light to viewport
 421   if (lightX < vportX0) lightX = vportX0;
 422   if (lightY < vportY0) lightY = vportY0;
 423   if (lightX1 > vportX1) lightX1 = vportX1;
 424   if (lightY1 > vportY1) lightY1 = vportY1;
 425   // is this light visible?
 426   //conwriteln("!!!001: (", lightX, ",", lightY, ")-(", lightX1, ",", lightY1, "): r=", cast(uint)(255.0f*lcol.r), "; g=", cast(uint)(255.0f*lcol.g), "; b=", cast(uint)(255.0f*lcol.b), "; a=", cast(uint)(255.0f*lcol.a));
 427   if (lightX1 < lightX || lightY1 < lightY || lightX > vportX1 || lightY > vportY1 || lightX1 < vportX0 || lightY1 < vportY0) return;
 428   //conwriteln("!!!002: (", lightX, ",", lightY, ")-(", lightX1, ",", lightY1, "): r=", cast(uint)(255.0f*lcol.r), "; g=", cast(uint)(255.0f*lcol.g), "; b=", cast(uint)(255.0f*lcol.b), "; a=", cast(uint)(255.0f*lcol.a));
 429
 430   fboLevelLight.exec({
 431     glEnable(GL_BLEND);
 432     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 433     //glDisable(GL_BLEND);
 434     orthoCamera(map.width*TileSize, map.height*TileSize);
 435     glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 436     shadAmbient.exec((Shader shad) {
 437       shad["lightColor"] = SVec4F(lcol.x, lcol.y, lcol.z, lcol.w);
 438       //shad["lightPos"] = SVec2F(lightX, lightY);
 439       glRectf(lightX, lightY, lightX1, lightY1);
 440     });
 441   });
 442 }
 443
 444
 445 // ////////////////////////////////////////////////////////////////////////// //
 446 void renderLight() (int lightX, int lightY, in auto ref SVec4F lcol, int lightRadius) {
 447   if (lightRadius < 2) return;
 448   if (lightRadius > MaxLightRadius) lightRadius = MaxLightRadius;
 449   int lightSize = lightRadius*2;
 450   // is this light visible?
 451   if (lightX <= -lightRadius || lightY <= -lightRadius || lightX-lightRadius >= map.width*TileSize || lightY-lightRadius >= map.height*TileSize) return;
 452
 453   // out of viewport -- do nothing
 454   if (lightX+lightRadius < vportX0 || lightY+lightRadius < vportY0) return;
 455   if (lightX-lightRadius > vportX1 || lightY-lightRadius > vportY1) return;
 456
 457   if (lightX >= 0 && lightY >= 0 && lightX < map.width*TileSize && lightY < map.height*TileSize &&
 458       map.teximgs[map.LightMask].imageData.colors.ptr[lightY*(map.width*TileSize)+lightX].a > 190) return;
 459
 460   // common color for all the following
 461   glDisable(GL_BLEND);
 462   glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 463
 464   // build 1d distance map to fboShadowMapId
 465   fboDistMap.ptr[lightRadius].exec({
 466     // no need to clear it, shader will take care of that
 467     shadToPolar.exec((Shader shad) {
 468       shad["lightTexSize"] = SVec2F(lightSize, lightSize);
 469       shad["lightPos"] = SVec2F(lightX, lightY);
 470       orthoCamera(lightSize, 1);
 471       // it doesn't matter what we will draw here, so just draw filled rect
 472       glRectf(0, 0, lightSize, 1);
 473     });
 474   });
 475
 476   // build light texture for blending
 477   fboOccluders.exec({
 478     // no need to clear it, shader will take care of that
 479     // debug
 480     //glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 481     //glClear(GL_COLOR_BUFFER_BIT);
 482     shadBlur.exec((Shader shad) {
 483       shad["lightTexSize"] = SVec2F(lightSize, MaxLightRadius*2); // x: size of distmap; y: size of this texture
 484       shad["lightColor"] = SVec4F(lcol.x, lcol.y, lcol.z, lcol.w);
 485       shad["lightPos"] = SVec2F(lightX-lightRadius, lightY-lightRadius);
 486       orthoCamera(fboOccluders.tex.width, fboOccluders.tex.height);
 487       //drawAtXY(fboDistMap[lightRadius].tex.tid, 0, 0, lightSize, lightSize);
 488       bindTexture(fboDistMap.ptr[lightRadius].tex.tid);
 489       glBegin(GL_QUADS);
 490         glTexCoord2f(0.0f, 0.0f); glVertex2i(0, 0); // top-left
 491         glTexCoord2f(1.0f, 0.0f); glVertex2i(lightSize, 0); // top-right
 492         glTexCoord2f(1.0f, 1.0f); glVertex2i(lightSize, lightSize); // bottom-right
 493         glTexCoord2f(0.0f, 1.0f); glVertex2i(0, lightSize); // bottom-left
 494       glEnd();
 495     });
 496   });
 497
 498   // blend light texture
 499   fboLevelLight.exec({
 500     glEnable(GL_BLEND);
 501     //glDisable(GL_BLEND);
 502     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 503     orthoCamera(fboLevelLight.tex.width, fboLevelLight.tex.height);
 504     //drawAtXY(fboOccluders.tex, lightX-lightRadius, lightY-lightRadius, mirrorY:true);
 505     float occe = 1.0f*lightSize/(MaxLightRadius*2);
 506     float occs = 1.0f-occe;
 507     int x0 = lightX-lightRadius+0;
 508     int y1 = lightY-lightRadius+0;
 509     int x1 = lightX+lightRadius-1+1;
 510     int y0 = lightY+lightRadius-1+1;
 511     bindTexture(fboOccluders.tex.tid);
 512     glBegin(GL_QUADS);
 513       /*
 514       glTexCoord2f(0.0f, 0.0f); glVertex2i(x0, y0); // top-left
 515       glTexCoord2f(occe, 0.0f); glVertex2i(x1, y0); // top-right
 516       glTexCoord2f(occe, occe); glVertex2i(x1, y1); // bottom-right
 517       glTexCoord2f(0.0f, occe); glVertex2i(x0, y1); // bottom-left
 518       */
 519       glTexCoord2f(0.0f, occs); glVertex2i(x0, y0); // top-left
 520       glTexCoord2f(occe, occs); glVertex2i(x1, y0); // top-right
 521       glTexCoord2f(occe, 1.0f); glVertex2i(x1, y1); // bottom-right
 522       glTexCoord2f(0.0f, 1.0f); glVertex2i(x0, y1); // bottom-left
 523     glEnd();
 524     /*
 525     bindTexture(0);
 526     glRectf(x0, y0, x1, y1);
 527     */
 528     // and blend it again, with the shader that will touch only occluders
 529     shadBlurOcc.exec((Shader shad) {
 530       //shad["lightTexSize"] = SVec2F(lightSize, lightSize);
 531       shad["lightTexSize"] = SVec2F(lightSize, fboOccluders.tex.height);
 532       shad["lightColor"] = SVec4F(lcol.x, lcol.y, lcol.z, lcol.w);
 533       shad["lightPos"] = SVec2F(lightX, lightY);
 534       //shad["lightPos"] = SVec2F(lightX-lightRadius, lightY-lightRadius);
 535       bindTexture(fboOccluders.tex.tid);
 536       glBegin(GL_QUADS);
 537         glTexCoord2f(0.0f, occs); glVertex2i(x0, y0); // top-left
 538         glTexCoord2f(occe, occs); glVertex2i(x1, y0); // top-right
 539         glTexCoord2f(occe, 1.0f); glVertex2i(x1, y1); // bottom-right
 540         glTexCoord2f(0.0f, 1.0f); glVertex2i(x0, y1); // bottom-left
 541       glEnd();
 542       //drawAtXY(fboOccluders.tex.tid, lightX-lightRadius, lightY-lightRadius, lightSize, lightSize, mirrorY:true);
 543     });
 544   });
 545 }
 546
 547
 548 // ////////////////////////////////////////////////////////////////////////// //
 549 __gshared int testLightX = vlWidth/2, testLightY = vlHeight/2;
 550 __gshared bool testLightMoved = false;
 551 //__gshared int mapOfsX, mapOfsY;
 552 //__gshared bool movement = false;
 553 __gshared float iLiquidTime = 0.0;
 554 //__gshared bool altMove = false;
 555
 556
 557 void renderScene (MonoTime curtime) {
 558   //enum BackIntens = 0.05f;
 559   enum BackIntens = 0.0f;
 560
 561   gloStackClear();
 562   float atob = (curtime > lastthink ? cast(float)((curtime-lastthink).total!"msecs")/cast(float)((nextthink-lastthink).total!"msecs") : 1.0f);
 563   if (gamePaused || inEditMode) atob = 1.0f;
 564   //{ import core.stdc.stdio; printf("atob=%f\n", cast(double)atob); }
 565   /*
 566   {
 567     int framelen = cast(int)((nextthink-lastthink).total!"msecs");
 568     int curfp = cast(int)((curtime-lastthink).total!"msecs");
 569     { import core.stdc.stdio; printf("framelen=%d; curfp=%d\n", framelen, curfp); }
 570   }
 571   */
 572
 573   int mofsx, mofsy; // camera offset, will be set in background layer builder
 574
 575   if (mapTilesChanged != 0) rebuildMapMegaTextures();
 576
 577   // build background layer
 578   fboOrigBack.exec({
 579     //glDisable(GL_BLEND);
 580     //glClearDepth(1.0f);
 581     //glDepthFunc(GL_LESS);
 582     //glDepthFunc(GL_NEVER);
 583     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 584     glClear(GL_COLOR_BUFFER_BIT/*|GL_DEPTH_BUFFER_BIT*/);
 585     glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 586     orthoCamera(map.width*TileSize, map.height*TileSize);
 587
 588     glEnable(GL_BLEND);
 589     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 590     // draw sky
 591     /*
 592     drawAtXY(map.skytexgl.tid, mapOfsX/2-map.MapSize*TileSize, mapOfsY/2-map.MapSize*TileSize, map.MapSize*TileSize, map.MapSize*TileSize);
 593     drawAtXY(map.skytexgl.tid, mapOfsX/2-map.MapSize*TileSize, mapOfsY/2, map.MapSize*TileSize, map.MapSize*TileSize);
 594     drawAtXY(map.skytexgl.tid, mapOfsX/2, mapOfsY/2-map.MapSize*TileSize, map.MapSize*TileSize, map.MapSize*TileSize);
 595     drawAtXY(map.skytexgl.tid, mapOfsX/2, mapOfsY/2, map.MapSize*TileSize, map.MapSize*TileSize);
 596     */
 597     drawAtXY(map.skytexgl.tid, 0, 0, map.MapSize*TileSize, map.MapSize*TileSize);
 598     // draw background
 599     drawAtXY(map.texgl.ptr[map.Back], 0, 0);
 600     // draw distorted liquid areas
 601     shadLiquidDistort.exec((Shader shad) {
 602       shad["iDistortTime"] = iLiquidTime;
 603       drawAtXY(map.texgl.ptr[map.AllLiquids], 0, 0);
 604     });
 605     // monsters, items; we'll do linear interpolation here
 606     glColor3f(1.0f, 1.0f, 1.0f);
 607     //glEnable(GL_DEPTH_TEST);
 608     attachedLightCount = 0;
 609
 610     // who cares about memory?!
 611     // draw order: players, items, monsters, other
 612     static struct DrawInfo {
 613       ActorDef adef;
 614       ActorId aid;
 615       int actorX, actorY;
 616       @disable this (this); // no copies
 617     }
 618     enum { Pixels, Players, Items, Monsters, Other }
 619     __gshared DrawInfo[65536][4] drawlists;
 620     __gshared uint[4] dlpos;
 621     DrawInfo camchickdi;
 622
 623     dlpos[] = 0;
 624
 625     Actor.forEach((ActorId me) {
 626       //me.fprop_0drawlistpos = 0;
 627       if (auto adef = findActorDef(me)) {
 628         uint dlnum = Other;
 629         switch (adef.classtype.get) {
 630           case "monster": dlnum = (adef.classname.get != "Player" ? Monsters : Players); break;
 631           case "item": dlnum = Items; break;
 632           default: dlnum = Other; break;
 633         }
 634         if (me.fget_flags&AF_PIXEL) dlnum = Pixels;
 635         int actorX, actorY; // current actor position
 636         {
 637           auto ofs = prevFrameActorOfs.ptr[me.id&0xffff];
 638           if (frameInterpolation && ofs < uint.max-1 && Actor.isSameSavedActor(me.id, prevFrameActorsData.ptr, ofs)) {
 639             import core.stdc.math : roundf;
 640             auto xptr = prevFrameActorsData.ptr+ofs;
 641             int ox = xptr.fgetp_x;
 642             int nx = me.fget_x;
 643             int oy = xptr.fgetp_y;
 644             int ny = me.fget_y;
 645             actorX = cast(int)(ox+roundf((nx-ox)*atob));
 646             actorY = cast(int)(oy+roundf((ny-oy)*atob));
 647             //conwriteln("actor ", me.id, "; o=(", ox, ",", oy, "); n=(", nx, ",", ny, "); p=(", x, ",", y, ")");
 648           } else {
 649             actorX = me.fget_x;
 650             actorY = me.fget_y;
 651           }
 652         }
 653         if (me.id == cameraChick.id) {
 654           camchickdi.adef = adef;
 655           camchickdi.aid = me;
 656           camchickdi.actorX = actorX;
 657           camchickdi.actorY = actorY;
 658         }
 659         // draw sprite
 660         if ((me.fget_flags&AF_NODRAW) == 0) {
 661           //auto dl = &drawlists[dlnum][dlpos.ptr[dlnum]];
 662           //me.fprop_0drawlistpos = (dlpos.ptr[dlnum]&0xffff)|((dlnum&0xff)<<16);
 663           auto dl = drawlists.ptr[dlnum].ptr+dlpos.ptr[dlnum];
 664           ++dlpos.ptr[dlnum];
 665           dl.adef = adef;
 666           dl.aid = me;
 667           dl.actorX = actorX;
 668           dl.actorY = actorY;
 669         }
 670         // process attached lights
 671         if ((me.fget_flags&AF_NOLIGHT) == 0) {
 672           uint alr = me.fget_attLightRGBX;
 673           bool isambient = (me.fget_classtype.get == "light" && me.fget_classname.get == "Ambient");
 674           if ((alr&0xff) >= 4 || (isambient && me.fget_radius >= 1 && me.fget_height >= 1)) {
 675             //if (isambient) conwriteln("isambient: ", isambient, "; x=", me.fget_x, "; y=", me.fget_y, "; w=", me.fget_radius, "; h=", me.fget_height);
 676             // yep, add it
 677             auto li = attachedLights.ptr+attachedLightCount;
 678             ++attachedLightCount;
 679             li.type = (!isambient ? AttachedLightInfo.Type.Point : AttachedLightInfo.Type.Ambient);
 680             li.x = actorX+me.fget_attLightXOfs;
 681             li.y = actorY+me.fget_attLightYOfs;
 682             li.r = ((alr>>24)&0xff)/255.0f; // red or intensity
 683             if ((alr&0x00_ff_ff_00U) == 0x00_00_01_00U) {
 684               li.uncolored = true;
 685             } else {
 686               li.g = ((alr>>16)&0xff)/255.0f;
 687               li.b = ((alr>>8)&0xff)/255.0f;
 688               li.uncolored = false;
 689             }
 690             li.radius = (alr&0xff);
 691             if (li.radius > MaxLightRadius) li.radius = MaxLightRadius;
 692             if (isambient) {
 693               li.w = me.fget_radius;
 694               li.h = me.fget_height;
 695             }
 696           }
 697         }
 698       } else {
 699         conwriteln("not found actor ", me.id, " (", me.classtype!string, ":", me.classname!string, ")");
 700       }
 701     });
 702
 703     // draw actor lists
 704     foreach_reverse (uint dlnum; 0..drawlists.length) {
 705       if (dlnum == Pixels) continue;
 706       auto dl = drawlists.ptr[dlnum].ptr;
 707       if (dlnum == Players) dl += dlpos.ptr[dlnum]-1;
 708       foreach (uint idx; 0..dlpos.ptr[dlnum]) {
 709         auto me = dl.aid;
 710         if (auto isp = dl.adef.animSpr(me.fget_zAnimstate, me.fget_dir, me.fget_zAnimidx)) {
 711           //drawAtXY(isp.tex, dl.actorX-isp.vga.sx, dl.actorY-isp.vga.sy);
 712           isp.drawAtXY(dl.actorX, dl.actorY);
 713         }
 714         if (dlnum != Players) ++dl; else --dl;
 715       }
 716     }
 717     // draw pixels
 718     if (dlpos[Pixels]) {
 719       bindTexture(0);
 720       bool pointsStarted = false;
 721       Color lastColor = Color(0, 0, 0, 0);
 722       auto dl = drawlists.ptr[Pixels].ptr;
 723       foreach (uint idx; 0..dlpos.ptr[Pixels]) {
 724         auto me = dl.aid;
 725         auto s = me.fget_s;
 726         if (s < 0 || s > 255) continue; //FIXME
 727         Color clr = d2dpal.ptr[s&0xff];
 728         if (clr.a == 0) continue;
 729         if (clr != lastColor) {
 730           if (pointsStarted) glEnd();
 731           glColor4f(clr.r/255.0f, clr.g/255.0f, clr.b/255.0f, clr.a/255.0f);
 732           lastColor = clr;
 733           pointsStarted = false;
 734         }
 735         if (!pointsStarted) {
 736           glBegin(GL_POINTS);
 737           pointsStarted = true;
 738         }
 739         glVertex2i(dl.actorX, dl.actorY);
 740         ++dl;
 741       }
 742       if (pointsStarted) {
 743         glEnd();
 744         glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 745       }
 746     }
 747
 748     // camera movement
 749     if (/*altMove || movement ||*/ scale == 1 || !cameraChick.valid) {
 750       mofsx = 0;
 751       mofsy = 0;
 752       vportX0 = 0;
 753       vportY0 = 0;
 754       vportX1 = map.width*TileSize;
 755       vportY1 = map.height*TileSize;
 756     } else {
 757       int tiltHeight = /*getMapViewHeight()*/(vlHeight/scale)/4;
 758       int vy = cameraChick.looky!int;
 759       if (vy < -tiltHeight) vy = -tiltHeight; else if (vy > tiltHeight) vy = tiltHeight;
 760       int swdt = vlWidth/scale;
 761       int shgt = vlHeight/scale;
 762       int x = camchickdi.actorX-swdt/2;
 763       int y = (camchickdi.actorY+vy)-shgt/2;
 764       if (x < 0) x = 0; else if (x >= map.width*TileSize-swdt) x = map.width*TileSize-swdt-1;
 765       if (y < 0) y = 0; else if (y >= map.height*TileSize-shgt) y = map.height*TileSize-shgt-1;
 766       mofsx = x*2;
 767       mofsy = y*2;
 768       vportX0 = mofsx/scale;
 769       vportY0 = mofsy/scale;
 770       vportX1 = vportX0+vlWidth/scale;
 771       vportY1 = vportY0+vlHeight/scale;
 772     }
 773
 774     //glDisable(GL_DEPTH_TEST);
 775     // draw dots
 776     dotDraw(atob);
 777     // do liquid coloring
 778     drawAtXY(map.texgl.ptr[map.LiquidMask], 0, 0);
 779     // foreground -- hide secrets, draw lifts and such
 780     drawAtXY(map.texgl.ptr[map.Front], 0, 0);
 781     /+
 782     {
 783       enum r = 255;
 784       enum g = 0;
 785       enum b = 0;
 786       enum a = 255;
 787       bindTexture(0);
 788       glColor4f(r/255.0f, g/255.0f, b/255.0f, a/255.0f);
 789       glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
 790       if (cameraChick.valid) {
 791         glBegin(GL_POINTS);
 792         glVertex2i(camchickdi.actorX, camchickdi.actorY-70);
 793         glEnd();
 794         //glRectf(camchickdi.actorX, camchickdi.actorY-70, camchickdi.actorX+4, camchickdi.actorY-70+4);
 795       }
 796       //glRectf(0, 0, 300, 300);
 797       glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 798     }
 799     +/
 800   });
 801
 802
 803   if (doLighting) {
 804     glDisable(GL_BLEND);
 805     glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 806
 807     // make smaller occluder texture, so we can trace faster
 808     //assert(fboLMaskSmall.tex.width == map.width);
 809     //assert(fboLMaskSmall.tex.height == map.height);
 810     fboLMaskSmall.exec({
 811       orthoCamera(map.width, map.height);
 812       drawAtXY(map.texgl.ptr[map.LightMask].tid, 0, 0, map.width, map.height, mirrorY:true);
 813     });
 814
 815     // clear light layer
 816     fboLevelLight.exec({
 817       glClearColor(BackIntens, BackIntens, BackIntens, 1.0f);
 818       //glClearColor(0.15f, 0.15f, 0.15f, 1.0f);
 819       ////glColor4f(1.0f, 1.0f, 1.0f, 0.0f);
 820       glClear(GL_COLOR_BUFFER_BIT);
 821     });
 822
 823     // texture 1 is background
 824     glActiveTexture(GL_TEXTURE0+1);
 825     glBindTexture(GL_TEXTURE_2D, fboOrigBack.tex.tid);
 826     // texture 2 is occluders
 827     glActiveTexture(GL_TEXTURE0+2);
 828     glBindTexture(GL_TEXTURE_2D, map.texgl.ptr[map.LightMask].tid);
 829     // texture 3 is small occluder map
 830     glActiveTexture(GL_TEXTURE0+3);
 831     glBindTexture(GL_TEXTURE_2D, fboLMaskSmall.tex.tid);
 832     // done texture assign
 833     glActiveTexture(GL_TEXTURE0+0);
 834
 835     /*
 836     enum LYOfs = 1;
 837
 838     renderLight( 27, 391-0+LYOfs, SVec4F(0.0f, 0.0f, 0.0f, 1.0f), 100);
 839     renderLight(542, 424-0+LYOfs, SVec4F(0.0f, 0.0f, 0.0f, 1.0f), 100);
 840     renderLight(377, 368-0+LYOfs, SVec4F(0.0f, 0.0f, 0.0f, 1.0f),  32);
 841     renderLight(147, 288-0+LYOfs, SVec4F(0.0f, 0.0f, 0.0f, 1.0f),  64);
 842     renderLight( 71, 200-0+LYOfs, SVec4F(0.0f, 0.0f, 0.0f, 1.0f), 128);
 843     renderLight(249, 200-0+LYOfs, SVec4F(0.0f, 0.0f, 0.0f, 1.0f), 128);
 844     renderLight(426, 200-0+LYOfs, SVec4F(0.0f, 0.0f, 0.0f, 1.0f), 128);
 845     renderLight(624, 200-0+LYOfs, SVec4F(0.0f, 0.0f, 0.0f, 1.0f), 128);
 846     renderLight(549, 298-0+LYOfs, SVec4F(0.0f, 0.0f, 0.0f, 1.0f),  64);
 847     renderLight( 74, 304-0+LYOfs, SVec4F(0.0f, 0.0f, 0.0f, 1.0f),  32);
 848
 849     renderLight(24*TileSize+4, (24+18)*TileSize-2+LYOfs, SVec4F(0.6f, 0.0f, 0.0f, 1.0f), 128);
 850
 851     renderLight(280, 330, SVec4F(0.0f, 0.0f, 0.0f, 1.0f), 64);
 852     */
 853
 854     // attached lights
 855     foreach (ref li; attachedLights[0..attachedLightCount]) {
 856       if (li.type == AttachedLightInfo.Type.Ambient) {
 857         //conwriteln("ambient: x=", li.x, "; y=", li.y, "; w=", li.w, "; h=", li.h);
 858         // ambient light
 859         if (li.uncolored) {
 860           renderLightAmbient(li.x, li.y, li.w, li.h, SVec4F(0.0f, 0.0f, 0.0f, li.r));
 861         } else {
 862           renderLightAmbient(li.x, li.y, li.w, li.h, SVec4F(li.r, li.g, li.b, 1.0f));
 863         }
 864       } else if (li.type == AttachedLightInfo.Type.Point) {
 865         // point light
 866         if (li.uncolored) {
 867           renderLight(li.x, li.y, SVec4F(0.0f, 0.0f, 0.0f, li.r), li.radius);
 868         } else {
 869           renderLight(li.x, li.y, SVec4F(li.r, li.g, li.b, 1.0f), li.radius);
 870         }
 871       }
 872     }
 873
 874     {
 875       if (testLightMoved) {
 876         testLightX = testLightX/scale+mofsx/scale;
 877         testLightY = testLightY/scale+mofsy/scale;
 878         testLightMoved = false;
 879       }
 880       foreach (immutable _; 0..1) {
 881         renderLight(testLightX, testLightY, SVec4F(0.3f, 0.3f, 0.0f, 1.0f), 96);
 882       }
 883     }
 884
 885     glActiveTexture(GL_TEXTURE0+1);
 886     glBindTexture(GL_TEXTURE_2D, 0);
 887     glActiveTexture(GL_TEXTURE0+2);
 888     glBindTexture(GL_TEXTURE_2D, 0);
 889     glActiveTexture(GL_TEXTURE0+3);
 890     glBindTexture(GL_TEXTURE_2D, 0);
 891     glActiveTexture(GL_TEXTURE0+0);
 892
 893
 894     // draw scaled level
 895     /+
 896     shadScanlines.exec((Shader shad) {
 897       shad["scanlines"] = scanlines;
 898       glClearColor(BackIntens, BackIntens, BackIntens, 1.0f);
 899       glClear(GL_COLOR_BUFFER_BIT);
 900       orthoCamera(vlWidth, vlHeight);
 901       //orthoCamera(map.width*TileSize*scale, map.height*TileSize*scale);
 902       //glMatrixMode(GL_MODELVIEW);
 903       //glLoadIdentity();
 904       //glTranslatef(0.375, 0.375, 0); // to be pixel-perfect
 905       // somehow, FBO objects are mirrored; wtf?!
 906       drawAtXY(fboLevel.tex.tid, -mapOfsX, -mapOfsY, map.width*TileSize*scale, map.height*TileSize*scale, mirrorY:true);
 907       //glLoadIdentity();
 908     });
 909     +/
 910
 911     /*
 912     fboLevelLight.exec({
 913       smDrawText(map.width*TileSize/2, map.height*TileSize/2, "Testing...");
 914     });
 915     */
 916   }
 917
 918   glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 919
 920   glDisable(GL_BLEND);
 921
 922   /*
 923   fboOrigBack.exec({
 924     //auto img = smfont.ptr[0x39];
 925     auto img = fftest;
 926     if (img !is null) {
 927       //conwriteln("img.sx=", img.sx, "; img.sy=", img.sy, "; ", img.width, "x", img.height);
 928       drawAtXY(img.tex, 10-img.sx, 10-img.sy);
 929     }
 930   });
 931   */
 932
 933
 934   /+
 935   { // http://stackoverflow.com/questions/7207422/setting-up-opengl-multiple-render-targets
 936     GLenum[1] buffers = [ GL_BACK_LEFT, /*GL_COLOR_ATTACHMENT0_EXT*/ ];
 937     //GLenum[1] buffers = [ GL_NONE, /*GL_COLOR_ATTACHMENT0_EXT*/ ];
 938     glDrawBuffers(1, buffers.ptr);
 939   }
 940   +/
 941
 942
 943   orthoCamera(vlWidth, vlHeight);
 944   auto tex = (doLighting ? fboLevelLight.tex.tid : fboOrigBack.tex.tid);
 945   drawAtXY(tex, -mofsx, -mofsy, map.width*TileSize*scale, map.height*TileSize*scale, mirrorY:true);
 946
 947   if (levelLoaded) {
 948     glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 949     //orthoCamera(map.width*TileSize, map.height*TileSize);
 950     glEnable(GL_BLEND);
 951     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 952     hudScripts.runDraw();
 953   }
 954
 955   //drawAtXY(map.texgl.ptr[map.LightMask].tid, -mofsx, -mofsy, map.width*TileSize*scale, map.height*TileSize*scale, mirrorY:true);
 956   //drawAtXY(fboLMaskSmall.tex.tid, 0, 0, map.width*TileSize, map.height*TileSize);
 957
 958   if (inEditMode) {
 959     glEnable(GL_BLEND);
 960     //glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 961     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 962     glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 963     editorUpdateImage();
 964     fboEditor.tex.setFromImage(editorImg);
 965     drawAtXY(fboEditor.tex, 0, 0);
 966     glDisable(GL_BLEND);
 967   }
 968
 969   doMessages(curtime);
 970 }
 971
 972
 973 // ////////////////////////////////////////////////////////////////////////// //
 974 // returns time slept
 975 int sleepAtMaxMsecs (int msecs) {
 976   if (msecs > 0) {
 977     import core.sys.posix.signal : timespec;
 978     import core.sys.posix.time : nanosleep;
 979     timespec ts = void, tpassed = void;
 980     ts.tv_sec = 0;
 981     ts.tv_nsec = msecs*1000*1000+(500*1000); // milli to nano
 982     nanosleep(&ts, &tpassed);
 983     return (ts.tv_nsec-tpassed.tv_nsec)/(1000*1000);
 984   } else {
 985     return 0;
 986   }
 987 }
 988
 989
 990 // ////////////////////////////////////////////////////////////////////////// //
 991 mixin(import("editor.d"));
 992
 993
 994 // ////////////////////////////////////////////////////////////////////////// //
 995 // rendering thread
 996 shared int diedie = 0;
 997
 998 enum D2DFrameTime = 55; // milliseconds
 999 enum MinFrameTime = 1000/60; // ~60 FPS
1000
1001 public void renderThread (Tid starterTid) {
1002   enum BoolOptVarMsgMixin(string varname) =
1003     "if (msg.toggle) msg.value = !"~varname~";\n"~
1004     "if ("~varname~" != msg.value) "~varname~" = msg.value; else msg.showMessage = false;\n";
1005
1006   send(starterTid, 42);
1007   try {
1008     MonoTime curtime = MonoTime.currTime;
1009
1010     lastthink = curtime; // for interpolator
1011     nextthink = curtime+dur!"msecs"(D2DFrameTime);
1012     MonoTime nextvframe = curtime;
1013
1014     enum MaxFPSFrames = 16;
1015     float frtimes = 0.0f;
1016     int framenum = 0;
1017     int prevFPS = -1;
1018     int hushFrames = 6; // ignore first `hushFrames` frames overtime
1019     MonoTime prevFrameStartTime = curtime;
1020
1021     bool vframeWasLost = false;
1022
1023     void resetFrameTimers () {
1024       MonoTime curtime = MonoTime.currTime;
1025       lastthink = curtime; // for interpolator
1026       nextthink = curtime+dur!"msecs"(D2DFrameTime);
1027       nextvframe = curtime;
1028     }
1029
1030     void loadNewLevel (string name) {
1031       /*
1032       if (levelLoaded) {
1033         conwriteln("ERROR: can't load new levels yet");
1034         return;
1035       }
1036       */
1037       if (name.length == 0) {
1038         conwriteln("ERROR: can't load empty level!");
1039       }
1040       conwriteln("loading map '", name, "'");
1041       loadMap(name);
1042       resetFrameTimers();
1043     }
1044
1045     void receiveMessages () {
1046       for (;;) {
1047         import core.time : Duration;
1048         //conwriteln("rendering thread: waiting for messages...");
1049         auto got = receiveTimeout(
1050           Duration.zero, // don't wait
1051           (TMsgMessage msg) {
1052             addMessage(msg.text[0..msg.textlen], msg.pauseMsecs, msg.noreplace);
1053           },
1054           (TMsgLoadLevel msg) {
1055             nextmapname = null; // clear "exit" flag
1056             loadNewLevel(msg.mapfile[0..msg.textlen].idup);
1057           },
1058           (TMsgSkipLevel msg) {
1059             string mn = genNextMapName(0);
1060             if (mn.length) {
1061               nextmapname = null; // clear "exit" flag
1062               loadNewLevel(mn);
1063             }
1064           },
1065           (TMsgIntOption msg) {
1066             final switch (msg.type) with (TMsgIntOption.Type) {
1067               case Scale:
1068                 if (msg.value >= 1 && msg.value <= 2) scale = msg.value;
1069                 break;
1070             }
1071           },
1072           (TMsgBoolOption msg) {
1073             final switch (msg.type) with (TMsgBoolOption.Type) {
1074               case Interpolation: mixin(BoolOptVarMsgMixin!"frameInterpolation"); break;
1075               case Lighting: mixin(BoolOptVarMsgMixin!"doLighting"); break;
1076               case Pause: mixin(BoolOptVarMsgMixin!"gamePaused"); break;
1077               case EditMode:
1078                 if (msg.toggle) msg.value = !inEditMode;
1079                 if (inEditMode != msg.value) {
1080                   inEditMode = msg.value;
1081                   if (msg.value) sdwindow.hideCursor(); else sdwindow.showCursor();
1082                 } else {
1083                   msg.showMessage = false;
1084                 }
1085                 break;
1086               mixin(BoolOptVarMsgMixin!"inEditMode"); break;
1087               case CheatNoDoors: mixin(BoolOptVarMsgMixin!"cheatNoDoors"); break;
1088               case CheatNoWallClip: mixin(BoolOptVarMsgMixin!"cheatNoWallClip"); break;
1089             }
1090             if (msg.showMessage) {
1091               char[128] mbuf;
1092               uint msgpos;
1093               void putStr(T) (T s) if (is(T : const(char)[])) {
1094                 foreach (char ch; s) {
1095                   if (msgpos >= mbuf.length) break;
1096                   mbuf.ptr[msgpos++] = ch;
1097                 }
1098               }
1099               putStr("Option \"");
1100               { import std.conv : to; putStr(to!string(msg.type)); }
1101               putStr("\": O");
1102               if (msg.value) putStr("N"); else putStr("FF");
1103               addMessage(mbuf[0..msgpos]);
1104             }
1105           },
1106           (TMsgTestLightMove msg) {
1107             testLightX = msg.x;
1108             testLightY = msg.y;
1109             testLightMoved = true;
1110           },
1111           (TMsgMouseEvent msg) { editorMouseEvent(msg); },
1112           (TMsgKeyEvent msg) { editorKeyEvent(msg); },
1113           (Variant v) {
1114             conwriteln("WARNING: unknown thread message received and ignored");
1115           },
1116         );
1117         if (!got) {
1118           // no more messages
1119           //conwriteln("rendering thread: no more messages");
1120           break;
1121         }
1122       }
1123       if (nextmapname.length) {
1124         string mn = nextmapname;
1125         nextmapname = null; // clear "exit" flag
1126         loadNewLevel(mn);
1127       }
1128     }
1129
1130     // "D2D frames"; curtime should be set; return `true` if frame was processed; will fix `curtime`
1131     bool doThinkFrame () {
1132       if (curtime >= nextthink) {
1133         lastthink = curtime;
1134         while (nextthink <= curtime) nextthink += dur!"msecs"(D2DFrameTime);
1135         if (levelLoaded) {
1136           // save snapshot and other data for interpolator
1137           Actor.saveSnapshot(prevFrameActorsData[], prevFrameActorOfs.ptr);
1138           if (!gamePaused && !inEditMode) {
1139             // process actors
1140             doActorsThink();
1141             dotThink();
1142           }
1143         }
1144         // some timing
1145         auto tm = MonoTime.currTime;
1146         int thinkTime = cast(int)((tm-curtime).total!"msecs");
1147         if (thinkTime > 9) { import core.stdc.stdio; printf("spent on thinking: %d msecs\n", thinkTime); }
1148         curtime = tm;
1149         return true;
1150       } else {
1151         return false;
1152       }
1153     }
1154
1155     // "video frames"; curtime should be set; return `true` if frame was processed; will fix `curtime`
1156     bool doVFrame () {
1157       version(dont_use_vsync) {
1158         // timer
1159         enum doCheckTime = true;
1160       } else {
1161         // vsync
1162         __gshared bool prevLost = false;
1163         bool doCheckTime = vframeWasLost;
1164         if (vframeWasLost) {
1165           if (!prevLost) {
1166             { import core.stdc.stdio; printf("frame was lost!\n"); }
1167           }
1168           prevLost = true;
1169         } else {
1170           prevLost = false;
1171         }
1172       }
1173       if (doCheckTime) {
1174         if (curtime < nextvframe) return false;
1175         version(dont_use_vsync) {
1176           if (curtime > nextvframe) {
1177             auto overtime = cast(int)((curtime-nextvframe).total!"msecs");
1178             if (overtime > 2500) {
1179               if (hushFrames) {
1180                 --hushFrames;
1181               } else {
1182                 { import core.stdc.stdio; printf("  spent whole %d msecs\n", overtime); }
1183               }
1184             }
1185           }
1186         }
1187       }
1188       while (nextvframe <= curtime) nextvframe += dur!"msecs"(MinFrameTime);
1189       bool ctset = false;
1190       {
1191         sdwindow.mtLock();
1192         scope(exit) sdwindow.mtUnlock();
1193         ctset = sdwindow.setAsCurrentOpenGlContextNT;
1194       }
1195       // if we can't set context, pretend that videoframe was processed; this should solve problem with vsync and invisible window
1196       if (ctset) {
1197         // render scene
1198         iLiquidTime = cast(float)((curtime-MonoTime.zero).total!"msecs"%10000000)/18.0f*0.04f;
1199         receiveMessages(); // here, 'cause we need active OpenGL context for some messages
1200         if (levelLoaded) {
1201           renderScene(curtime);
1202         } else {
1203           //renderLoading(curtime);
1204         }
1205         sdwindow.mtLock();
1206         scope(exit) sdwindow.mtUnlock();
1207         sdwindow.swapOpenGlBuffers();
1208         glFinish();
1209         sdwindow.releaseCurrentOpenGlContext();
1210         vframeWasLost = false;
1211       } else {
1212         vframeWasLost = true;
1213         { import core.stdc.stdio; printf("xframe was lost!\n"); }
1214       }
1215       curtime = MonoTime.currTime;
1216       return true;
1217     }
1218
1219     for (;;) {
1220       if (sdwindow.closed) break;
1221       if (atomicLoad(diedie) > 0) break;
1222
1223       curtime = MonoTime.currTime;
1224       auto fstime = curtime;
1225
1226       doThinkFrame(); // this will fix curtime if necessary
1227       if (doVFrame()) {
1228         if (!vframeWasLost) {
1229           // fps
1230           auto frameTime = cast(float)(curtime-prevFrameStartTime).total!"msecs"/1000.0f;
1231           prevFrameStartTime = curtime;
1232           frtimes += frameTime;
1233           if (++framenum >= MaxFPSFrames || frtimes >= 3.0f) {
1234             import std.string : format;
1235             int newFPS = cast(int)(cast(float)MaxFPSFrames/frtimes+0.5);
1236             if (newFPS != prevFPS) {
1237               sdwindow.title = "%s / FPS:%s".format("D2D", newFPS);
1238               prevFPS = newFPS;
1239             }
1240             framenum = 0;
1241             frtimes = 0.0f;
1242           }
1243         }
1244       }
1245
1246       curtime = MonoTime.currTime;
1247
1248       // now sleep until next "video" or "think" frame
1249       if (nextthink > curtime && nextvframe > curtime) {
1250         // let's decide
1251         immutable nextVideoFrameSleep = cast(int)((nextvframe-curtime).total!"msecs");
1252         immutable nextThinkFrameSleep = cast(int)((nextthink-curtime).total!"msecs");
1253         immutable sleepTime = (nextVideoFrameSleep < nextThinkFrameSleep ? nextVideoFrameSleep : nextThinkFrameSleep);
1254         sleepAtMaxMsecs(sleepTime);
1255         //curtime = MonoTime.currTime;
1256       }
1257     }
1258   } catch (Throwable e) {
1259     // here, we are dead and fucked (the exact order doesn't matter)
1260     import core.stdc.stdlib : abort;
1261     import core.stdc.stdio : fprintf, stderr;
1262     import core.memory : GC;
1263     GC.disable(); // yeah
1264     thread_suspendAll(); // stop right here, you criminal scum!
1265     auto s = e.toString();
1266     fprintf(stderr, "\n=== FATAL ===\n%.*s\n", cast(uint)s.length, s.ptr);
1267     abort(); // die, you bitch!
1268     /*
1269     import core.stdc.stdio;
1270     fprintf(stderr, "FUUUUUUUUUUUUUUUUUUUUUUUUUU\n");
1271     import std.stdio : stderr;
1272     writeln(
1273     for (;;) {
1274       if (sdwindow.closed) break;
1275       if (atomicLoad(diedie) > 0) break;
1276       sleepAtMaxMsecs(100);
1277     }
1278     */
1279   }
1280   atomicStore(diedie, 2);
1281 }
1282
1283
1284 // ////////////////////////////////////////////////////////////////////////// //
1285 __gshared Tid renderTid;
1286 shared bool renderThreadStarted = false;
1287
1288
1289 public void startRenderThread () {
1290   if (!cas(&renderThreadStarted, false, true)) {
1291     assert(0, "render thread already started!");
1292   }
1293   renderTid = spawn(&renderThread, thisTid);
1294   setMaxMailboxSize(renderTid, 1024, OnCrowding.throwException); //FIXME
1295   // wait for "i'm ready" signal
1296   receive(
1297     (int ok) {
1298       if (ok != 42) assert(0, "wtf?!");
1299     },
1300   );
1301   conwriteln("rendering thread started");
1302 }
1303
1304
1305 // ////////////////////////////////////////////////////////////////////////// //
1306 public void closeWindow () {
1307   if (atomicLoad(diedie) != 2) {
1308     atomicStore(diedie, 1);
1309     while (atomicLoad(diedie) != 2) {}
1310   }
1311   if (!sdwindow.closed) {
1312     flushGui();
1313     sdwindow.close();
1314   }
1315 }
1316
1317
1318 // ////////////////////////////////////////////////////////////////////////// //
1319 // thread messages
1320
1321
1322 // ////////////////////////////////////////////////////////////////////////// //
1323 struct TMsgMouseEvent {
1324   MouseEventType type;
1325   int x, y;
1326   int dx, dy;
1327   MouseButton button; /// See $(LREF MouseButton)
1328   int modifierState; /// See $(LREF ModifierState)
1329 }
1330
1331 public void postMouseEvent() (in auto ref MouseEvent evt) {
1332   if (!atomicLoad(renderThreadStarted)) return;
1333   TMsgMouseEvent msg;
1334   msg.type = evt.type;
1335   msg.x = evt.x;
1336   msg.y = evt.y;
1337   msg.dx = evt.dx;
1338   msg.dy = evt.dy;
1339   msg.button = evt.button;
1340   msg.modifierState = evt.modifierState;
1341   send(renderTid, msg);
1342 }
1343
1344
1345 // ////////////////////////////////////////////////////////////////////////// //
1346 struct TMsgKeyEvent {
1347   Key key;
1348   uint hardwareCode;
1349   bool pressed;
1350   dchar character;
1351   uint modifierState;
1352 }
1353
1354 public void postKeyEvent() (in auto ref KeyEvent evt) {
1355   if (!atomicLoad(renderThreadStarted)) return;
1356   TMsgKeyEvent msg;
1357   msg.key = evt.key;
1358   msg.pressed = evt.pressed;
1359   msg.character = evt.character;
1360   msg.modifierState = evt.modifierState;
1361   send(renderTid, msg);
1362 }
1363
1364
1365 // ////////////////////////////////////////////////////////////////////////// //
1366 struct TMsgTestLightMove {
1367   int x, y;
1368 }
1369
1370 public void postTestLightMove (int x, int y) {
1371   if (!atomicLoad(renderThreadStarted)) return;
1372   auto msg = TMsgTestLightMove(x, y);
1373   send(renderTid, msg);
1374 }
1375
1376
1377 // ////////////////////////////////////////////////////////////////////////// //
1378 struct TMsgMessage {
1379   char[256] text;
1380   uint textlen;
1381   int pauseMsecs;
1382   bool noreplace;
1383 }
1384
1385 public void postAddMessage (const(char)[] msgtext, int pauseMsecs=3000, bool noreplace=false) {
1386   if (!atomicLoad(renderThreadStarted)) return;
1387   if (msgtext.length > TMsgMessage.text.length) msgtext = msgtext[0..TMsgMessage.text.length];
1388   TMsgMessage msg;
1389   msg.textlen = cast(uint)msgtext.length;
1390   if (msg.textlen) msg.text[0..msg.textlen] = msgtext[0..msg.textlen];
1391   msg.pauseMsecs = pauseMsecs;
1392   msg.noreplace = noreplace;
1393   send(renderTid, msg);
1394 }
1395
1396
1397 // ////////////////////////////////////////////////////////////////////////// //
1398 struct TMsgLoadLevel {
1399   char[1024] mapfile;
1400   uint textlen;
1401 }
1402
1403 public void postLoadLevel (const(char)[] mapfile) {
1404   if (!atomicLoad(renderThreadStarted)) return;
1405   if (mapfile.length > TMsgLoadLevel.mapfile.length) mapfile = mapfile[0..TMsgLoadLevel.mapfile.length];
1406   TMsgLoadLevel msg;
1407   msg.textlen = cast(uint)mapfile.length;
1408   if (msg.textlen) msg.mapfile[0..msg.textlen] = mapfile[0..msg.textlen];
1409   send(renderTid, msg);
1410 }
1411
1412
1413 // ////////////////////////////////////////////////////////////////////////// //
1414 struct TMsgSkipLevel {
1415 }
1416
1417 public void postSkipLevel () {
1418   if (!atomicLoad(renderThreadStarted)) return;
1419   TMsgSkipLevel msg;
1420   send(renderTid, msg);
1421 }
1422
1423
1424 // ////////////////////////////////////////////////////////////////////////// //
1425 struct TMsgIntOption {
1426   enum Type {
1427     Scale,
1428   }
1429   Type type;
1430   int value;
1431   bool showMessage;
1432 }
1433
1434
1435 struct TMsgBoolOption {
1436   enum Type {
1437     Interpolation,
1438     Lighting,
1439     Pause,
1440     EditMode,
1441     CheatNoDoors,
1442     CheatNoWallClip,
1443   }
1444   Type type;
1445   bool value;
1446   bool toggle;
1447   bool showMessage;
1448 }
1449
1450
1451 bool strCaseEqu (const(char)[] s0, const(char)[] s1) {
1452   if (s0.length != s1.length) return false;
1453   foreach (immutable idx, char ch; s0) {
1454     if (ch >= 'A' && ch <= 'Z') ch += 32;
1455     char c1 = s1.ptr[idx];
1456     if (c1 >= 'A' && c1 <= 'Z') c1 += 32;
1457     if (ch != c1) return false;
1458   }
1459   return true;
1460 }
1461
1462
1463 public bool postToggleOption (const(char)[] name, bool showMessage=false) { /*pragma(inline, true);*/ return postSetOption(name, true, showMessage:showMessage, toggle:true); }
1464
1465 public bool postSetOption(T) (const(char)[] name, T value, bool showMessage=false, bool toggle=false) if ((is(T == int) || is(T == bool))) {
1466   if (!atomicLoad(renderThreadStarted)) return false;
1467   if (name.length == 0 || name.length > 127) return false;
1468   static if (is(T == int)) {
1469     TMsgIntOption msg;
1470     foreach (string oname; __traits(allMembers, TMsgIntOption.Type)) {
1471       if (strCaseEqu(oname, name)) {
1472         msg.type = __traits(getMember, TMsgIntOption.Type, oname);
1473         msg.value = value;
1474         msg.showMessage = showMessage;
1475         send(renderTid, msg);
1476         return true;
1477       }
1478     }
1479   } else static if (is(T == bool)) {
1480     TMsgBoolOption msg;
1481     foreach (string oname; __traits(allMembers, TMsgBoolOption.Type)) {
1482       if (strCaseEqu(oname, name)) {
1483         msg.type = __traits(getMember, TMsgBoolOption.Type, oname);
1484         msg.value = value;
1485         msg.toggle = toggle;
1486         msg.showMessage = showMessage;
1487         send(renderTid, msg);
1488         return true;
1489       }
1490     }
1491   } else {
1492     static assert(0, "invalid option type '"~T.stringof~"'");
1493   }
1494   return false;
1495 }