src/engine/material.cpp

   1 #include "pch.h"
   2 #include "engine.h"
   3
   4 struct QuadNode
   5 {
   6     int x, y, size;
   7     uint filled;
   8     QuadNode *child[4];
   9
  10     QuadNode(int x, int y, int size) : x(x), y(y), size(size), filled(0) { loopi(4) child[i] = 0; }
  11
  12     void clear()
  13     {
  14         loopi(4) DELETEP(child[i]);
  15     }
  16
  17     ~QuadNode()
  18     {
  19         clear();
  20     }
  21
  22     void insert(int mx, int my, int msize)
  23     {
  24         if(size == msize)
  25         {
  26             filled = 0xF;
  27             return;
  28         }
  29         int csize = size>>1, i = 0;
  30         if(mx >= x+csize) i |= 1;
  31         if(my >= y+csize) i |= 2;
  32         if(csize == msize)
  33         {
  34             filled |= (1 << i);
  35             return;
  36         }
  37         if(!child[i]) child[i] = new QuadNode(i&1 ? x+csize : x, i&2 ? y+csize : y, csize);
  38         child[i]->insert(mx, my, msize);
  39         loopj(4) if(child[j])
  40         {
  41             if(child[j]->filled == 0xF)
  42             {
  43                 DELETEP(child[j]);
  44                 filled |= (1 << j);
  45             }
  46         }
  47     }
  48
  49     void genmatsurf(uchar mat, uchar orient, int x, int y, int z, int size, materialsurface *&matbuf)
  50     {
  51         materialsurface &m = *matbuf++;
  52         m.material = mat;
  53         m.orient = orient;
  54         m.csize = size;
  55         m.rsize = size;
  56         int dim = dimension(orient);
  57         m.o[C[dim]] = x;
  58         m.o[R[dim]] = y;
  59         m.o[dim] = z;
  60     }
  61
  62     void genmatsurfs(uchar mat, uchar orient, int z, materialsurface *&matbuf)
  63     {
  64         if(filled == 0xF) genmatsurf(mat, orient, x, y, z, size, matbuf);
  65         else if(filled)
  66         {
  67             int csize = size>>1;
  68             loopi(4) if(filled & (1 << i))
  69                 genmatsurf(mat, orient, i&1 ? x+csize : x, i&2 ? y+csize : y, z, csize, matbuf);
  70         }
  71         loopi(4) if(child[i]) child[i]->genmatsurfs(mat, orient, z, matbuf);
  72     }
  73 };
  74
  75 void renderwaterfall(materialsurface &m, Texture *tex, float scale, float offset, uchar mat)
  76 {
  77     float xf = 8.0f/(tex->xs*scale);
  78     float yf = 8.0f/(tex->ys*scale);
  79     float d = 16.0f*lastmillis;
  80     int dim = dimension(m.orient),
  81         csize = C[dim]==2 ? m.rsize : m.csize,
  82         rsize = R[dim]==2 ? m.rsize : m.csize;
  83     float t = lastmillis;
  84     switch(mat)
  85     {
  86         case MAT_WATER:
  87             t /= renderpath!=R_FIXEDFUNCTION ? 600.0f : 300.0f;
  88             d /= 1000.0f;
  89             break;
  90         case MAT_LAVA:
  91             t /= 2000.0f;
  92             d /= 3000.0f;
  93             break;
  94     }
  95     float wave = m.ends&2 ? (vertwater ? WATER_AMPLITUDE*sinf(t)-WATER_OFFSET : -WATER_OFFSET) : 0;
  96     loopi(4)
  97     {
  98         vec v(m.o.tovec());
  99         v[dim] += dimcoord(m.orient) ? -offset : offset;
 100         if(i==1 || i==2) v[dim^1] += csize;
 101         if(i<=1) v.z += rsize;
 102         if(m.ends&(i<=1 ? 2 : 1)) v.z += i<=1 ? wave : -WATER_OFFSET-WATER_AMPLITUDE;
 103         glTexCoord2f(xf*v[dim^1], yf*(v.z+d));
 104         glVertex3fv(v.v);
 105     }
 106
 107     xtraverts += 4;
 108 }
 109
 110 void drawmaterial(int orient, int x, int y, int z, int csize, int rsize, float offset)
 111 {
 112     int dim = dimension(orient), c = C[dim], r = R[dim];
 113     loopi(4)
 114     {
 115         int coord = fv[orient][i];
 116         vec v(x, y, z);
 117         v[c] += cubecoords[coord][c]/8*csize;
 118         v[r] += cubecoords[coord][r]/8*rsize;
 119         v[dim] += dimcoord(orient) ? -offset : offset;
 120         glVertex3fv(v.v);
 121     }
 122     xtraverts += 4;
 123 }
 124
 125 struct material
 126 {
 127     const char *name;
 128     uchar id;
 129 } materials[] =
 130 {
 131     {"air", MAT_AIR},
 132     {"water", MAT_WATER},
 133     {"clip", MAT_CLIP},
 134     {"glass", MAT_GLASS},
 135     {"noclip", MAT_NOCLIP},
 136     {"lava", MAT_LAVA},
 137     {"aiclip", MAT_AICLIP}
 138 };
 139
 140 int findmaterial(const char *name)
 141 {
 142     loopi(sizeof(materials)/sizeof(material))
 143     {
 144         if(!strcmp(materials[i].name, name)) return materials[i].id;
 145     }
 146     return -1;
 147 }
 148
 149 int visiblematerial(cube &c, int orient, int x, int y, int z, int size)
 150 {
 151     if(c.ext) switch(c.ext->material)
 152     {
 153     case MAT_AIR:
 154          break;
 155
 156     case MAT_LAVA:
 157     case MAT_WATER:
 158         if(visibleface(c, orient, x, y, z, size, c.ext->material))
 159             return (orient != O_BOTTOM ? MATSURF_VISIBLE : MATSURF_EDIT_ONLY);
 160         break;
 161
 162     case MAT_GLASS:
 163         if(visibleface(c, orient, x, y, z, size, MAT_GLASS))
 164             return MATSURF_VISIBLE;
 165         break;
 166
 167     default:
 168         if(visibleface(c, orient, x, y, z, size, c.ext->material))
 169             return MATSURF_EDIT_ONLY;
 170         break;
 171     }
 172     return MATSURF_NOT_VISIBLE;
 173 }
 174
 175 void genmatsurfs(cube &c, int cx, int cy, int cz, int size, vector<materialsurface> &matsurfs)
 176 {
 177     loopi(6)
 178     {
 179         int vis = visiblematerial(c, i, cx, cy, cz, size);
 180         if(vis != MATSURF_NOT_VISIBLE)
 181         {
 182             materialsurface m;
 183             m.material = (vis == MATSURF_EDIT_ONLY ? c.ext->material+MAT_EDIT : c.ext->material);
 184             m.orient = i;
 185             m.o = ivec(cx, cy, cz);
 186             m.csize = m.rsize = size;
 187             if(dimcoord(i)) m.o[dimension(i)] += size;
 188             matsurfs.add(m);
 189         }
 190     }
 191 }
 192
 193 static int mergematcmp(const materialsurface *x, const materialsurface *y)
 194 {
 195     int dim = dimension(x->orient), c = C[dim], r = R[dim];
 196     if(x->o[r] + x->rsize < y->o[r] + y->rsize) return -1;
 197     if(x->o[r] + x->rsize > y->o[r] + y->rsize) return 1;
 198     if(x->o[c] < y->o[c]) return -1;
 199     if(x->o[c] > y->o[c]) return 1;
 200     return 0;
 201 }
 202
 203 static int mergematr(materialsurface *m, int sz, materialsurface &n)
 204 {
 205     int dim = dimension(n.orient), c = C[dim], r = R[dim];
 206     for(int i = sz-1; i >= 0; --i)
 207     {
 208         if(m[i].o[r] + m[i].rsize < n.o[r]) break;
 209         if(m[i].o[r] + m[i].rsize == n.o[r] && m[i].o[c] == n.o[c] && m[i].csize == n.csize)
 210         {
 211             n.o[r] = m[i].o[r];
 212             n.rsize += m[i].rsize;
 213             memmove(&m[i], &m[i+1], (sz - (i+1)) * sizeof(materialsurface));
 214             return 1;
 215         }
 216     }
 217     return 0;
 218 }
 219
 220 static int mergematc(materialsurface &m, materialsurface &n)
 221 {
 222     int dim = dimension(n.orient), c = C[dim], r = R[dim];
 223     if(m.o[r] == n.o[r] && m.rsize == n.rsize && m.o[c] + m.csize == n.o[c])
 224     {
 225         n.o[c] = m.o[c];
 226         n.csize += m.csize;
 227         return 1;
 228     }
 229     return 0;
 230 }
 231
 232 static int mergemat(materialsurface *m, int sz, materialsurface &n)
 233 {
 234     for(bool merged = false; sz; merged = true)
 235     {
 236         int rmerged = mergematr(m, sz, n);
 237         sz -= rmerged;
 238         if(!rmerged && merged) break;
 239         if(!sz) break;
 240         int cmerged = mergematc(m[sz-1], n);
 241         sz -= cmerged;
 242         if(!cmerged) break;
 243     }
 244     m[sz++] = n;
 245     return sz;
 246 }
 247
 248 static int mergemats(materialsurface *m, int sz)
 249 {
 250     qsort(m, sz, sizeof(materialsurface), (int (__cdecl *)(const void *, const void *))mergematcmp);
 251
 252     int nsz = 0;
 253     loopi(sz) nsz = mergemat(m, nsz, m[i]);
 254     return nsz;
 255 }
 256
 257 static int optmatcmp(const materialsurface *x, const materialsurface *y)
 258 {
 259     if(x->material < y->material) return -1;
 260     if(x->material > y->material) return 1;
 261     if(x->orient > y->orient) return -1;
 262     if(x->orient < y->orient) return 1;
 263     int dim = dimension(x->orient), xc = x->o[dim], yc = y->o[dim];
 264     if(xc < yc) return -1;
 265     if(xc > yc) return 1;
 266     return 0;
 267 }
 268
 269 VARF(optmats, 0, 1, 1, allchanged());
 270
 271 int optimizematsurfs(materialsurface *matbuf, int matsurfs)
 272 {
 273     qsort(matbuf, matsurfs, sizeof(materialsurface), (int (__cdecl *)(const void*, const void*))optmatcmp);
 274     if(!optmats) return matsurfs;
 275     materialsurface *cur = matbuf, *end = matbuf+matsurfs;
 276     while(cur < end)
 277     {
 278          materialsurface *start = cur++;
 279          int dim = dimension(start->orient);
 280          while(cur < end &&
 281                cur->material == start->material &&
 282                cur->orient == start->orient &&
 283                cur->o[dim] == start->o[dim])
 284             ++cur;
 285          if(!isliquid(start->material) || start->orient != O_TOP || !vertwater)
 286          {
 287             if(start!=matbuf) memmove(matbuf, start, (cur-start)*sizeof(materialsurface));
 288             matbuf += mergemats(matbuf, cur-start);
 289          }
 290          else if(cur-start>=4)
 291          {
 292             QuadNode vmats(0, 0, hdr.worldsize);
 293             loopi(cur-start) vmats.insert(start[i].o[C[dim]], start[i].o[R[dim]], start[i].csize);
 294             vmats.genmatsurfs(start->material, start->orient, start->o[dim], matbuf);
 295          }
 296          else
 297          {
 298             if(start!=matbuf) memmove(matbuf, start, (cur-start)*sizeof(materialsurface));
 299             matbuf += cur-start;
 300          }
 301     }
 302     return matsurfs - (end-matbuf);
 303 }
 304
 305 extern vector<vtxarray *> valist;
 306
 307 struct waterinfo
 308 {
 309     materialsurface *m;
 310     double depth, area;
 311 };
 312
 313 void setupmaterials()
 314 {
 315     int hasmat = 0;
 316     vector<waterinfo> water;
 317     hashtable<ivec, int> watersets;
 318     unionfind uf;
 319     loopv(valist)
 320     {
 321         vtxarray *va = valist[i];
 322         lodlevel &lod = va->l0;
 323         loopj(lod.matsurfs)
 324         {
 325             materialsurface &m = lod.matbuf[j];
 326             if(m.material==MAT_WATER && m.orient==O_TOP)
 327             {
 328                 m.index = water.length();
 329                 loopvk(water)
 330                 {
 331                     materialsurface &n = *water[k].m;
 332                     if(m.o.z!=n.o.z) continue;
 333                     if(n.o.x+n.rsize==m.o.x || m.o.x+m.rsize==n.o.x)
 334                     {
 335                         if(n.o.y+n.csize>m.o.y && n.o.y<m.o.y+m.csize) uf.unite(m.index, n.index);
 336                     }
 337                     else if(n.o.y+n.csize==m.o.y || m.o.y+m.csize==n.o.y)
 338                     {
 339                         if(n.o.x+n.rsize>m.o.x && n.o.x<m.o.x+m.rsize) uf.unite(m.index, n.index);
 340                     }
 341                 }
 342                 waterinfo &wi = water.add();
 343                 wi.m = &m;
 344                 vec center(m.o.x+m.rsize/2, m.o.y+m.csize/2, m.o.z-WATER_OFFSET);
 345                 m.light = brightestlight(center, vec(0, 0, 1));
 346                 float depth = raycube(center, vec(0, 0, -1), 10000);
 347                 wi.depth = double(depth)*m.rsize*m.csize;
 348                 wi.area = m.rsize*m.csize;
 349             }
 350             else if(isliquid(m.material) && m.orient!=O_BOTTOM && m.orient!=O_TOP)
 351             {
 352                 m.ends = 0;
 353                 int dim = dimension(m.orient), coord = dimcoord(m.orient);
 354                 ivec o(m.o);
 355                 o.z -= 1;
 356                 o[dim] += coord ? 1 : -1;
 357                 int minc = o[dim^1], maxc = minc + (C[dim]==2 ? m.rsize : m.csize);
 358                 while(o[dim^1] < maxc)
 359                 {
 360                     cube &c = lookupcube(o.x, o.y, o.z);
 361                     if(c.ext && isliquid(c.ext->material)) { m.ends |= 1; break; }
 362                     o[dim^1] += lusize;
 363                 }
 364                 o[dim^1] = minc;
 365                 o.z += R[dim]==2 ? m.rsize : m.csize;
 366                 o[dim] -= coord ? 2 : -2;
 367                 while(o[dim^1] < maxc)
 368                 {
 369                     cube &c = lookupcube(o.x, o.y, o.z);
 370                     if(visiblematerial(c, O_TOP, lu.x, lu.y, lu.z, lusize)) { m.ends |= 2; break; }
 371                     o[dim^1] += lusize;
 372                 }
 373             }
 374             else if(m.material==MAT_GLASS)
 375             {
 376                 if(!hasCM) m.envmap = EMID_NONE;
 377                 else
 378                 {
 379                     int dim = dimension(m.orient);
 380                     vec center(m.o.tovec());
 381                     center[R[dim]] += m.rsize/2;
 382                     center[C[dim]] += m.csize/2;
 383                     m.envmap = closestenvmap(center);
 384                 }
 385             }
 386             hasmat |= 1<<m.material;
 387         }
 388     }
 389     loopv(water)
 390     {
 391         int root = uf.find(i);
 392         if(i==root) continue;
 393         materialsurface &m = *water[i].m, &n = *water[root].m;
 394         if(m.light && (!m.light->attr1 || !n.light || (n.light->attr1 && m.light->attr1 > n.light->attr1))) n.light = m.light;
 395         water[root].depth += water[i].depth;
 396         water[root].area += water[i].area;
 397     }
 398     loopv(water)
 399     {
 400         int root = uf.find(i);
 401         water[i].m->light = water[root].m->light;
 402         water[i].m->depth = (short)(water[root].depth/water[root].area);
 403     }
 404     if(hasmat&(1<<MAT_WATER))
 405     {
 406         extern void loadcaustics();
 407         loadcaustics();
 408         lookuptexture(-MAT_WATER);
 409     }
 410     if(hasmat&(1<<MAT_LAVA)) lookuptexture(-MAT_LAVA);
 411 }
 412
 413 VARP(showmat, 0, 1, 1);
 414
 415 static int sortdim[3];
 416 static ivec sortorigin;
 417
 418 static int vismatcmp(const materialsurface ** xm, const materialsurface ** ym)
 419 {
 420     const materialsurface &x = **xm, &y = **ym;
 421     int xdim = dimension(x.orient), ydim = dimension(y.orient);
 422     loopi(3)
 423     {
 424         int dim = sortdim[i], xmin, xmax, ymin, ymax;
 425         xmin = xmax = x.o[dim];
 426         if(dim==C[xdim]) xmax += x.csize;
 427         else if(dim==R[xdim]) xmax += x.rsize;
 428         ymin = ymax = y.o[dim];
 429         if(dim==C[ydim]) ymax += y.csize;
 430         else if(dim==R[ydim]) ymax += y.rsize;
 431         if(xmax > ymin && ymax > xmin) continue;
 432         int c = sortorigin[dim];
 433         if(c > xmin && c < xmax) return 1;
 434         if(c > ymin && c < ymax) return -1;
 435         xmin = abs(xmin - c);
 436         xmax = abs(xmax - c);
 437         ymin = abs(ymin - c);
 438         ymax = abs(ymax - c);
 439         if(max(xmin, xmax) <= min(ymin, ymax)) return 1;
 440         else if(max(ymin, ymax) <= min(xmin, xmax)) return -1;
 441     }
 442     if(x.material < y.material) return 1;
 443     if(x.material > y.material) return -1;
 444     return 0;
 445 }
 446
 447 extern vtxarray *visibleva, *reflectedva;
 448
 449 void sortmaterials(vector<materialsurface *> &vismats, float zclip, bool refract)
 450 {
 451     bool reflected = zclip && !refract && camera1->o.z >= zclip;
 452     sortorigin = ivec(camera1->o);
 453     if(reflected) sortorigin.z = int(zclip - (camera1->o.z - zclip));
 454     vec dir;
 455     vecfromyawpitch(camera1->yaw, reflected ? -camera1->pitch : camera1->pitch, 1, 0, dir);
 456     loopi(3) { dir[i] = fabs(dir[i]); sortdim[i] = i; }
 457     if(dir[sortdim[2]] > dir[sortdim[1]]) swap(int, sortdim[2], sortdim[1]);
 458     if(dir[sortdim[1]] > dir[sortdim[0]]) swap(int, sortdim[1], sortdim[0]);
 459     if(dir[sortdim[2]] > dir[sortdim[1]]) swap(int, sortdim[2], sortdim[1]);
 460
 461     for(vtxarray *va = reflected ? reflectedva : visibleva; va; va = reflected ? va->rnext : va->next)
 462     {
 463         lodlevel &lod = va->l0;
 464         if(!lod.matsurfs || va->occluded >= OCCLUDE_BB) continue;
 465         if(zclip && (refract ? va->z >= zclip : va->z+va->size <= zclip)) continue;
 466         loopi(lod.matsurfs)
 467         {
 468             materialsurface &m = lod.matbuf[i];
 469             if(!editmode || !showmat)
 470             {
 471                 if(m.material==MAT_WATER && m.orient==O_TOP) continue;
 472                 if(m.material>=MAT_EDIT) continue;
 473             }
 474             vismats.add(&m);
 475         }
 476     }
 477     vismats.sort(vismatcmp);
 478 }
 479
 480 void rendermatgrid(vector<materialsurface *> &vismats)
 481 {
 482     glEnable(GL_POLYGON_OFFSET_LINE);
 483     glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 484     static uchar cols[MAT_EDIT][3] =
 485     {
 486         { 0, 0, 0 },   // MAT_AIR - no edit volume,
 487         { 0, 0, 85 },  // MAT_WATER - blue,
 488         { 85, 0, 0 },  // MAT_CLIP - red,
 489         { 0, 85, 85 }, // MAT_GLASS - cyan,
 490         { 0, 85, 0 },  // MAT_NOCLIP - green
 491         { 85, 40, 0 }, // MAT_LAVA - orange
 492         { 85, 85, 0 }, // MAT_AICLIP - yellow
 493     };
 494     int lastmat = -1;
 495     glBegin(GL_QUADS);
 496     loopv(vismats)
 497     {
 498         materialsurface &m = *vismats[i];
 499         int curmat = m.material >= MAT_EDIT ? m.material-MAT_EDIT : m.material;
 500         if(curmat != lastmat)
 501         {
 502             lastmat = curmat;
 503             glColor3ubv(cols[curmat]);
 504         }
 505         drawmaterial(m.orient, m.o.x, m.o.y, m.o.z, m.csize, m.rsize, -0.1f);
 506     }
 507     glEnd();
 508     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 509     glDisable(GL_POLYGON_OFFSET_LINE);
 510 }
 511
 512 VARP(glassenv, 0, 1, 1);
 513
 514 void drawglass(int orient, int x, int y, int z, int csize, int rsize, float offset)
 515 {
 516     int dim = dimension(orient), c = C[dim], r = R[dim];
 517     loopi(4)
 518     {
 519         int coord = fv[orient][i];
 520         vec v(x, y, z);
 521         v[c] += cubecoords[coord][c]/8*csize;
 522         v[r] += cubecoords[coord][r]/8*rsize;
 523         v[dim] += dimcoord(orient) ? -offset : offset;
 524
 525         vec reflect(v);
 526         reflect.sub(camera1->o);
 527         reflect[dim] = -reflect[dim];
 528
 529         glTexCoord3f(-reflect.y, reflect.z, reflect.x);
 530         glVertex3fv(v.v);
 531     }
 532     xtraverts += 4;
 533 }
 534
 535 void rendermaterials(float zclip, bool refract)
 536 {
 537     vector<materialsurface *> vismats;
 538     sortmaterials(vismats, zclip, refract);
 539     if(vismats.empty()) return;
 540
 541     glDisable(GL_CULL_FACE);
 542
 543     Slot &wslot = lookuptexture(-MAT_WATER), &lslot = lookuptexture(-MAT_LAVA);
 544     uchar wcol[4] = { 128, 128, 128, 192 };
 545     if(hdr.watercolour[0] || hdr.watercolour[1] || hdr.watercolour[2]) memcpy(wcol, hdr.watercolour, 3);
 546     int lastorient = -1, lastmat = -1;
 547     GLenum textured = GL_TEXTURE_2D;
 548     bool begin = false, depth = true, blended = false, overbright = false;
 549     ushort envmapped = EMID_NONE;
 550     vec normal(0, 0, 0);
 551
 552     static float zerofog[4] = { 0, 0, 0, 1 };
 553     float oldfogc[4];
 554     glGetFloatv(GL_FOG_COLOR, oldfogc);
 555     int lastfogtype = 1;
 556     loopv(vismats)
 557     {
 558         materialsurface &m = *vismats[editmode && showmat ? vismats.length()-1-i : i];
 559         int curmat = !editmode || !showmat || m.material>=MAT_EDIT ? m.material : m.material+MAT_EDIT;
 560         if(lastmat!=curmat || lastorient!=m.orient || (curmat==MAT_GLASS && envmapped && m.envmap != envmapped))
 561         {
 562             int fogtype = lastfogtype;
 563             switch(curmat)
 564             {
 565                 case MAT_WATER:
 566                     if(lastmat==MAT_WATER && lastorient!=O_TOP && m.orient!=O_TOP) break;
 567                     if(begin) { glEnd(); begin = false; }
 568                     if(lastmat!=MAT_WATER || (lastorient==O_TOP)!=(m.orient==O_TOP))
 569                     {
 570                         if(depth) { glDepthMask(GL_FALSE); depth = false; }
 571                         if(!blended) { glEnable(GL_BLEND); blended = true; }
 572                         if(overbright) { resettmu(0); overbright = false; }
 573                         if(m.orient==O_TOP)
 574                         {
 575                             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 576                             glColor4ubv(wcol);
 577                         }
 578                         else
 579                         {
 580                             glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
 581                             glColor3f(wcol[0]/255.0f, wcol[1]/255.0f, wcol[2]/255.0f);
 582                         }
 583                         foggedshader->set();
 584                         fogtype = 0;
 585                     }
 586                     if(textured!=GL_TEXTURE_2D)
 587                     {
 588                         if(textured) glDisable(textured);
 589                         glEnable(GL_TEXTURE_2D);
 590                         textured = GL_TEXTURE_2D;
 591                     }
 592                     glBindTexture(GL_TEXTURE_2D, wslot.sts[m.orient==O_TOP ? 0 : 1].t->gl);
 593                     break;
 594
 595                 case MAT_LAVA:
 596                     if(lastmat==MAT_LAVA && lastorient!=O_TOP && m.orient!=O_TOP) break;
 597                     if(begin) { glEnd(); begin = false; }
 598                     if(lastmat!=MAT_LAVA)
 599                     {
 600                         if(!depth) { glDepthMask(GL_TRUE); depth = true; }
 601                         if(blended) { glDisable(GL_BLEND); blended = false; }
 602                         if(renderpath==R_FIXEDFUNCTION && !overbright) { setuptmu(0, "C * T x 2"); overbright = true; }
 603                         float t = lastmillis/2000.0f;
 604                         t -= int(t);
 605                         t = 1.0f - fabs(t-0.5f);
 606                         glColor3f(t, t, t);
 607                         static Shader *lavashader = NULL;
 608                         if(!lavashader) lavashader = lookupshaderbyname("lava");
 609                         lavashader->set();
 610                         fogtype = 1;
 611                     }
 612                     if(textured!=GL_TEXTURE_2D)
 613                     {
 614                         if(textured) glDisable(textured);
 615                         glEnable(GL_TEXTURE_2D);
 616                         textured = GL_TEXTURE_2D;
 617                     }
 618                     glBindTexture(GL_TEXTURE_2D, lslot.sts[m.orient==O_TOP ? 0 : 1].t->gl);
 619                     break;
 620
 621                 case MAT_GLASS:
 622                     if(m.envmap!=EMID_NONE && glassenv && (lastmat!=MAT_GLASS || lastorient!=m.orient))
 623                         normal = vec(dimension(m.orient)==0 ? dimcoord(m.orient)*2-1 : 0,
 624                                      dimension(m.orient)==1 ? dimcoord(m.orient)*2-1 : 0,
 625                                      dimension(m.orient)==2 ? dimcoord(m.orient)*2-1 : 0);
 626                     if((m.envmap==EMID_NONE || !glassenv || (envmapped==m.envmap && textured==GL_TEXTURE_CUBE_MAP_ARB)) && lastmat==MAT_GLASS) break;
 627                     if(begin) { glEnd(); begin = false; }
 628                     if(m.envmap!=EMID_NONE && glassenv)
 629                     {
 630                         if(textured!=GL_TEXTURE_CUBE_MAP_ARB)
 631                         {
 632                             if(textured) glDisable(textured);
 633                             glEnable(GL_TEXTURE_CUBE_MAP_ARB);
 634                             textured = GL_TEXTURE_CUBE_MAP_ARB;
 635                         }
 636                         if(envmapped!=m.envmap)
 637                         {
 638                             glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, lookupenvmap(m.envmap));
 639                             if(envmapped==EMID_NONE && renderpath!=R_FIXEDFUNCTION)
 640                                 setenvparamf("camera", SHPARAM_VERTEX, 0, camera1->o.x, camera1->o.y, camera1->o.z);
 641                             envmapped = m.envmap;
 642                         }
 643                     }
 644                     if(lastmat!=MAT_GLASS)
 645                     {
 646                         if(!blended) { glEnable(GL_BLEND); blended = true; }
 647                         if(overbright) { resettmu(0); overbright = false; }
 648                         if(depth) { glDepthMask(GL_FALSE); depth = false; }
 649                         if(m.envmap!=EMID_NONE && glassenv)
 650                         {
 651                             if(renderpath==R_FIXEDFUNCTION)
 652                             {
 653                                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 654                                 glColor4f(0.8f, 0.9f, 1.0f, 0.25f);
 655                                 fogtype = 1;
 656                             }
 657                             else
 658                             {
 659                                 glBlendFunc(GL_ONE, GL_SRC_ALPHA);
 660                                 glColor3f(0, 0.5f, 1.0f);
 661                             }
 662                             static Shader *glassshader = NULL;
 663                             if(!glassshader) glassshader = lookupshaderbyname("glass");
 664                             glassshader->set();
 665                         }
 666                         else
 667                         {
 668                             if(textured)
 669                             {
 670                                 glDisable(textured);
 671                                 textured = 0;
 672                             }
 673                             glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
 674                             glColor3f(0.3f, 0.15f, 0.0f);
 675                             foggednotextureshader->set();
 676                             fogtype = 0;
 677                         }
 678                     }
 679                     break;
 680
 681                 default:
 682                 {
 683                     if(lastmat==curmat) break;
 684                     if(lastmat<MAT_EDIT)
 685                     {
 686                         if(begin) { glEnd(); begin = false; }
 687                         if(!depth) { glDepthMask(GL_TRUE); depth = true; }
 688                         if(!blended) { glEnable(GL_BLEND); blended = true; }
 689                         if(overbright) { resettmu(0); overbright = false; }
 690                         glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
 691                         if(textured) { glDisable(GL_TEXTURE_2D); textured = 0; }
 692                         foggednotextureshader->set();
 693                         fogtype = 0;
 694                     }
 695                     static uchar blendcols[MAT_EDIT][3] =
 696                     {
 697                         { 0,   0,   0   }, // MAT_AIR - no edit volume,
 698                         { 255, 128, 0   }, // MAT_WATER - blue,
 699                         { 0,   255, 255 }, // MAT_CLIP - red,
 700                         { 255, 0,   0   }, // MAT_GLASS - cyan,
 701                         { 255, 0,   255 }, // MAT_NOCLIP - green
 702                         { 0, 128,   255 }, // MAT_LAVA - orange
 703                         { 0,   0,   255 }, // MAT_AICLIP - yellow
 704                     };
 705                     glColor3ubv(blendcols[curmat >= MAT_EDIT ? curmat-MAT_EDIT : curmat]);
 706                     break;
 707                 }
 708             }
 709             lastmat = curmat;
 710             lastorient = m.orient;
 711             if(fogtype!=lastfogtype)
 712             {
 713                 glFogfv(GL_FOG_COLOR, fogtype ? oldfogc : zerofog);
 714                 lastfogtype = fogtype;
 715             }
 716         }
 717         switch(curmat)
 718         {
 719             case MAT_WATER:
 720                 if(m.orient!=O_TOP)
 721                 {
 722                     if(!begin) { glBegin(GL_QUADS); begin = true; }
 723                     renderwaterfall(m, wslot.sts[1].t, wslot.sts[1].scale ? wslot.sts[1].scale : 1, 0.1f, MAT_WATER);
 724                 }
 725                 break;
 726
 727             case MAT_LAVA:
 728                 if(m.orient==O_TOP)
 729                 {
 730                     if(!vertwater && !begin) { glBegin(GL_QUADS); begin = true; }
 731                     renderlava(m, lslot.sts[0].t, lslot.sts[0].scale ? lslot.sts[0].scale : 1);
 732                 }
 733                 else
 734                 {
 735                     if(!begin) { glBegin(GL_QUADS); begin = true; }
 736                     renderwaterfall(m, lslot.sts[1].t, lslot.sts[1].scale ? lslot.sts[1].scale : 1, 0.1f, MAT_LAVA);
 737                 }
 738                 break;
 739
 740             case MAT_GLASS:
 741                 if(!begin) { glBegin(GL_QUADS); begin = true; }
 742                 if(m.envmap!=EMID_NONE && glassenv)
 743                 {
 744                     if(renderpath!=R_FIXEDFUNCTION) glNormal3fv(normal.v);
 745                     drawglass(m.orient, m.o.x, m.o.y, m.o.z, m.csize, m.rsize, 0.1f);
 746                 }
 747                 else drawmaterial(m.orient, m.o.x, m.o.y, m.o.z, m.csize, m.rsize, 0.1f);
 748                 break;
 749
 750             default:
 751                 if(!begin) { glBegin(GL_QUADS); begin = true; }
 752                 drawmaterial(m.orient, m.o.x, m.o.y, m.o.z, m.csize, m.rsize, -0.1f);
 753                 break;
 754         }
 755     }
 756
 757     if(begin) glEnd();
 758     if(!depth) glDepthMask(GL_TRUE);
 759     if(blended) glDisable(GL_BLEND);
 760     if(overbright) resettmu(0);
 761     if(!lastfogtype) glFogfv(GL_FOG_COLOR, oldfogc);
 762     if(editmode && showmat)
 763     {
 764         foggednotextureshader->set();
 765         rendermatgrid(vismats);
 766     }
 767
 768     glEnable(GL_CULL_FACE);
 769     if(textured!=GL_TEXTURE_2D)
 770     {
 771         if(textured) glDisable(textured);
 772         glEnable(GL_TEXTURE_2D);
 773     }
 774 }
 775