contrib/gtkgensurf/genmap.cpp

   1 /*
   2 GenSurf plugin for GtkRadiant
   3 Copyright (C) 2001 David Hyde, Loki software and qeradiant.com
   4
   5 This library is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU Lesser General Public
   7 License as published by the Free Software Foundation; either
   8 version 2.1 of the License, or (at your option) any later version.
   9
  10 This library 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 GNU
  13 Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public
  16 License along with this library; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19
  20 #include <math.h>
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include "gensurf.h"
  24
  25 double  xmin,xmax,ymin,ymax,zmin,zmax;
  26 double  backface;
  27 extern double dh, dv;
  28 FILE  *fmap;
  29 XYZ     xyz[MAX_ROWS+1][MAX_ROWS+1];
  30 int     contents;
  31 int     surface[3];
  32
  33 #include "iundo.h"
  34
  35 #include "refcounted_ptr.h"
  36
  37 #include <vector>
  38 #include <list>
  39 #include <map>
  40 #include <algorithm>
  41
  42 #include "scenelib.h"
  43
  44 scene::Node* h_func_group;
  45 scene::Node* h_worldspawn;
  46
  47
  48 //=============================================================
  49 // Hydra : snap-to-grid begin
  50 double CalculateSnapValue(double value)
  51 {
  52         long                snapvalue;
  53
  54   // simple uncomplicated snapping, rounding both UP and DOWN to the nearest
  55         // grid unit.
  56         if (SnapToGrid >0)
  57         {
  58                 snapvalue = (int)value / SnapToGrid;
  59                 if ((long)value % SnapToGrid < (SnapToGrid / 2)) // Snap Downwards if less than halfway between to grid units
  60                         value = snapvalue * SnapToGrid;
  61                 else // Snap Upwards if more than halfway between to grid units
  62                         value = (snapvalue+1) * SnapToGrid;
  63         }
  64   return value;
  65 }
  66 // Hydra : snap-to-grid end
  67
  68 //=============================================================
  69 bool ValidSurface()
  70 {
  71   if(WaveType == WAVE_BITMAP && !gbmp.colors) return FALSE;
  72   if(NH  < 1)        return FALSE;
  73   if(NH  > MAX_ROWS) return FALSE;
  74   if(NV  < 1)        return FALSE;
  75   if(NV  > MAX_ROWS) return FALSE;
  76   if(Hll >= Hur)     return FALSE;
  77   if(Vll >= Vur)     return FALSE;
  78   return TRUE;
  79 }
  80
  81 //=============================================================
  82 int MapPatches()
  83 {
  84   int     NH_remain;
  85   int     NV_remain;
  86   int     NH_patch;
  87   int     NV_patch;
  88   int     BrushNum = 0;
  89   int     i, j, k1, k2, k3;
  90   int     i0, j0, ii;
  91   char    szOops[128];
  92
  93   dh = (Hur-Hll)/NH;
  94   dv = (Vur-Vll)/NV;
  95
  96   // Generate control points in pp array to give desired values currently
  97   // in p array.
  98   switch(Plane)
  99   {
 100   case PLANE_XY0:
 101   case PLANE_XY1:
 102     k1 = 0;
 103     k2 = 1;
 104     k3 = 2;
 105     break;
 106   case PLANE_XZ0:
 107   case PLANE_XZ1:
 108     k1 = 0;
 109     k2 = 2;
 110     k3 = 1;
 111     break;
 112   case PLANE_YZ0:
 113   case PLANE_YZ1:
 114     k1 = 1;
 115     k2 = 2;
 116     k3 = 0;
 117     break;
 118   }
 119   for(i=0; i<=NH; i++)
 120   {
 121     for(j=0; j<=NV; j++)
 122     {
 123       xyz[i][j].pp[k1] = xyz[i][j].p[k1];
 124       xyz[i][j].pp[k2] = xyz[i][j].p[k2];
 125     }
 126   }
 127   for(i=0; i<=NH; i+=2)
 128   {
 129     for(j=0; j<=NV; j+=2)
 130       xyz[i][j].pp[k3] = xyz[i][j].p[k3];
 131   }
 132   for(i=1; i<NH; i+=2)
 133   {
 134     for(j=0; j<=NV; j+=2)
 135     {
 136       xyz[i][j].pp[k3] = (4*xyz[i][j].p[k3] - xyz[i-1][j].p[k3] - xyz[i+1][j].p[k3])/2;
 137     }
 138   }
 139   for(j=1; j<NV; j+=2)
 140   {
 141     for(i=0; i<=NH; i+=2)
 142     {
 143       xyz[i][j].pp[k3] = (4*xyz[i][j].p[k3] - xyz[i][j-1].p[k3] - xyz[i][j+1].p[k3])/2;
 144     }
 145   }
 146   for(i=1; i<NH; i+=2)
 147   {
 148     for(j=1; j<NV; j+=2)
 149     {
 150       xyz[i][j].pp[k3] = (16*xyz[i][j].p[k3] - xyz[i-1][j-1].p[k3] - 2*xyz[i][j-1].p[k3]
 151         - xyz[i+1][j-1].p[k3] - 2*xyz[i-1][j].p[k3] - 2*xyz[i+1][j].p[k3]
 152         - xyz[i-1][j+1].p[k3] - 2*xyz[i][j+1].p[k3] - xyz[i+1][j+1].p[k3])/4;
 153     }
 154   }
 155
 156   NH_remain = NH+1;
 157   i0 = 0;
 158   while(NH_remain > 1)
 159   {
 160     if(( (NH_remain-1) % 14) == 0)
 161       NH_patch = 15;
 162     else if(( (NH_remain-1) % 12) == 0)
 163       NH_patch = 13;
 164     else if(( (NH_remain-1) % 10) == 0)
 165       NH_patch = 11;
 166     else if(( (NH_remain-1) % 8) == 0)
 167       NH_patch = 9;
 168     else if(( (NH_remain-1) % 6) == 0)
 169       NH_patch = 7;
 170     else if(( (NH_remain-1) % 4) == 0)
 171       NH_patch = 5;
 172     else if(( (NH_remain-1) % 2) == 0)
 173       NH_patch = 3;
 174     else if(NH_remain > 16)
 175       NH_patch = 7;
 176     else if(NH_remain > 4)
 177       NH_patch = 5;
 178     else
 179       NH_patch = 3;
 180     while( NH_patch > 3 && (NH_patch-1)*dh > 512 )
 181       NH_patch -= 2;
 182     NH_remain -= (NH_patch-1);
 183     if(NH_remain < 0)
 184     {
 185       sprintf(szOops,"Oops... screwed up with NH=%d",NH);
 186       g_FuncTable.m_pfnMessageBox(NULL,szOops,"Uh oh");
 187     }
 188     NV_remain = NV+1;
 189     j0 = 0;
 190     while(NV_remain > 1)
 191     {
 192       if(( (NV_remain-1) % 14) == 0)
 193         NV_patch = 15;
 194       else if(( (NV_remain-1) % 12) == 0)
 195         NV_patch = 13;
 196       else if(( (NV_remain-1) % 10) == 0)
 197         NV_patch = 11;
 198       else if(( (NV_remain-1) % 8) == 0)
 199         NV_patch = 9;
 200       else if(( (NV_remain-1) % 6) == 0)
 201         NV_patch = 7;
 202       else if(( (NV_remain-1) % 4) == 0)
 203         NV_patch = 5;
 204       else if(( (NV_remain-1) % 2) == 0)
 205         NV_patch = 3;
 206       else if(NV_remain > 16)
 207         NV_patch = 7;
 208       else if(NV_remain > 4)
 209         NV_patch = 5;
 210       else
 211         NV_patch = 3;
 212       while( NV_patch > 3 && (NV_patch-1)*dh > 512 )
 213         NV_patch -= 2;
 214       NV_remain -= (NV_patch-1);
 215       if(NV_remain < 0)
 216       {
 217         sprintf(szOops,"Oops... screwed up with NV=%d",NV);
 218         g_FuncTable.m_pfnMessageBox(NULL,szOops,"Uh oh");
 219       }
 220
 221       scene::Node* patch = MakePatch();
 222 #if 0
 223       b->pPatch->setDims(NH_patch, NV_patch);
 224       for(i=0; i<NH_patch; i++)
 225       {
 226         switch(Plane)
 227         {
 228         case PLANE_XY1:
 229         case PLANE_XZ0:
 230         case PLANE_YZ1:
 231           ii = i0 + NH_patch - 1 - i;
 232           break;
 233         default:
 234           ii = i0+i;
 235         }
 236         for(j=0; j<NV_patch; j++)
 237         {
 238           b->pPatch->ctrlAt(COL,i,j)[0] = (float)xyz[ii][j0+j].pp[0];
 239           b->pPatch->ctrlAt(COL,i,j)[1] = (float)xyz[ii][j0+j].pp[1];
 240           b->pPatch->ctrlAt(COL,i,j)[2] = (float)xyz[ii][j0+j].pp[2];
 241           b->pPatch->ctrlAt(COL,i,j)[3] = (float)i;
 242           b->pPatch->ctrlAt(COL,i,j)[4] = (float)j;
 243         }
 244       }
 245       b->pPatch->UpdateCachedData();
 246 #endif
 247       BrushNum++;
 248       j0 += NV_patch-1;
 249     }
 250     i0 += NH_patch-1;
 251   }
 252   return BrushNum;
 253 }
 254
 255 //=============================================================
 256 void MapBrushes()
 257 {
 258   char  hint[128];
 259   char  skip[128];
 260   char  sidetext[64];
 261   char  surftext[64];
 262   char  surftext2[64];
 263   char  surft[64];
 264   float Steep;
 265   vec3_t  PlaneNormal,SurfNormal;
 266   vec3_t  t[2];
 267   int   i, j, k;
 268   int   surf;
 269   bool  CheckAngle;
 270   BRUSH brush;
 271   XYZ   v[8];
 272
 273   strcpy(surftext,Texture[Game][0]);
 274   strcpy(sidetext,(strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
 275   strcpy(surftext2,(strlen(Texture[Game][2]) ? Texture[Game][2] : Texture[Game][0]));
 276
 277   // if surftext2 is identical to surftext, there's no need to
 278   // check surface angle
 279   if(!g_strcasecmp(surftext,surftext2))
 280     CheckAngle = FALSE;
 281   else
 282   {
 283     CheckAngle = TRUE;
 284     Steep = (float)cos((double)SlantAngle/57.2957795);
 285     switch(Plane)
 286     {
 287     case PLANE_XY0: PlaneNormal[0]= 0.;PlaneNormal[1]= 0.;PlaneNormal[2]= 1.;break;
 288     case PLANE_XY1: PlaneNormal[0]= 0.;PlaneNormal[1]= 0.;PlaneNormal[2]=-1.;break;
 289     case PLANE_XZ0: PlaneNormal[0]= 0.;PlaneNormal[1]= 1.;PlaneNormal[2]= 1.;break;
 290     case PLANE_XZ1: PlaneNormal[0]= 0.;PlaneNormal[1]=-1.;PlaneNormal[2]= 1.;break;
 291     case PLANE_YZ0: PlaneNormal[0]= 1.;PlaneNormal[1]= 0.;PlaneNormal[2]= 1.;break;
 292     case PLANE_YZ1: PlaneNormal[0]=-1.;PlaneNormal[1]= 0.;PlaneNormal[2]= 1.;break;
 293     }
 294   }
 295
 296   OpenFuncGroup();
 297
 298   for(i=0; i<NH; i++)
 299   {
 300     for(j=0; j<NV; j++)
 301     {
 302       if( (i+j) % 2 )
 303       {
 304         VectorCopy(xyz[i  ][j  ].p, v[0].p);
 305         switch(Plane)
 306         {
 307         case PLANE_XY1:
 308         case PLANE_XZ1:
 309         case PLANE_YZ1:
 310           VectorCopy(xyz[i+1][j  ].p, v[1].p);
 311           VectorCopy(xyz[i+1][j+1].p, v[2].p);
 312           break;
 313         default:
 314           VectorCopy(xyz[i+1][j+1].p, v[1].p);
 315           VectorCopy(xyz[i+1][j  ].p, v[2].p);
 316         }
 317       }
 318       else
 319       {
 320         VectorCopy(xyz[i  ][j  ].p, v[0].p);
 321         switch(Plane)
 322         {
 323         case PLANE_XY1:
 324         case PLANE_XZ1:
 325         case PLANE_YZ1:
 326           VectorCopy(xyz[i+1][j  ].p, v[1].p);
 327           VectorCopy(xyz[i  ][j+1].p, v[2].p);
 328           break;
 329         default:
 330           VectorCopy(xyz[i  ][j+1].p, v[1].p);
 331           VectorCopy(xyz[i+1][j  ].p, v[2].p);
 332         }
 333       }
 334       VectorCopy(v[0].p,v[3].p);
 335       VectorCopy(v[1].p,v[4].p);
 336       VectorCopy(v[2].p,v[5].p);
 337       switch(Plane)
 338       {
 339       case PLANE_XZ0:
 340       case PLANE_XZ1:
 341         v[0].p[1] = backface;
 342         v[1].p[1] = backface;
 343         v[2].p[1] = backface;
 344         break;
 345       case PLANE_YZ0:
 346       case PLANE_YZ1:
 347         v[3].p[0] = backface;
 348         v[4].p[0] = backface;
 349         v[5].p[0] = backface;
 350         break;
 351       default:
 352         v[3].p[2] = backface;
 353         v[4].p[2] = backface;
 354         v[5].p[2] = backface;
 355       }
 356
 357       brush.Number   = i*NV*2+j*2;
 358       brush.NumFaces = 5;
 359       XYZtoV(&v[0],&brush.face[0].v[0]);
 360       XYZtoV(&v[3],&brush.face[0].v[1]);
 361       XYZtoV(&v[4],&brush.face[0].v[2]);
 362       strcpy(brush.face[0].texture,
 363         (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
 364       brush.face[0].Shift[0] = (float)TexOffset[0];
 365       brush.face[0].Shift[1] = (float)TexOffset[1];
 366       brush.face[0].Rotate   = 0.;
 367       brush.face[0].Scale[0] = (float)TexScale[0];
 368       brush.face[0].Scale[1] = (float)TexScale[1];
 369       brush.face[0].Contents = contents;
 370       brush.face[0].Surface  = surface[1];
 371       brush.face[0].Value    = 0;
 372
 373       XYZtoV(&v[1],&brush.face[1].v[0]);
 374       XYZtoV(&v[4],&brush.face[1].v[1]);
 375       XYZtoV(&v[5],&brush.face[1].v[2]);
 376       strcpy(brush.face[1].texture,
 377         (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
 378       brush.face[1].Shift[0] = (float)TexOffset[0];
 379       brush.face[1].Shift[1] = (float)TexOffset[1];
 380       brush.face[1].Rotate   = 0.;
 381       brush.face[1].Scale[0] = (float)TexScale[0];
 382       brush.face[1].Scale[1] = (float)TexScale[1];
 383       brush.face[1].Contents = contents;
 384       brush.face[1].Surface  = surface[1];
 385       brush.face[1].Value    = 0;
 386
 387       XYZtoV(&v[2],&brush.face[2].v[0]);
 388       XYZtoV(&v[5],&brush.face[2].v[1]);
 389       XYZtoV(&v[3],&brush.face[2].v[2]);
 390       strcpy(brush.face[2].texture,
 391         (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
 392       brush.face[2].Shift[0] = (float)TexOffset[0];
 393       brush.face[2].Shift[1] = (float)TexOffset[1];
 394       brush.face[2].Rotate   = 0.;
 395       brush.face[2].Scale[0] = (float)TexScale[0];
 396       brush.face[2].Scale[1] = (float)TexScale[1];
 397       brush.face[2].Contents = contents;
 398       brush.face[2].Surface  = surface[1];
 399       brush.face[2].Value    = 0;
 400
 401       if(CheckAngle && (Plane==PLANE_XZ0 || Plane==PLANE_XZ1))
 402       {
 403         XYZVectorSubtract(v[4].p,v[3].p,t[0]);
 404         XYZVectorSubtract(v[5].p,v[4].p,t[1]);
 405         CrossProduct(t[0],t[1],SurfNormal);
 406         VectorNormalize(SurfNormal,SurfNormal);
 407         if(DotProduct(SurfNormal,PlaneNormal) < Steep)
 408         {
 409           strcpy(surft,surftext2);
 410           surf = surface[2];
 411         }
 412         else
 413         {
 414           strcpy(surft,surftext);
 415           surf = surface[0];
 416         }
 417       }
 418       else
 419       {
 420         strcpy(surft,surftext);
 421         surf = surface[0];
 422       }
 423
 424       XYZtoV(&v[3],&brush.face[3].v[0]);
 425       XYZtoV(&v[5],&brush.face[3].v[1]);
 426       XYZtoV(&v[4],&brush.face[3].v[2]);
 427       strcpy(brush.face[3].texture,
 428         (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surft : sidetext));
 429       brush.face[3].Shift[0] = (float)TexOffset[0];
 430       brush.face[3].Shift[1] = (float)TexOffset[1];
 431       brush.face[3].Rotate   = 0.;
 432       brush.face[3].Scale[0] = (float)TexScale[0];
 433       brush.face[3].Scale[1] = (float)TexScale[1];
 434       brush.face[3].Contents = contents;
 435       brush.face[3].Surface  = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surf : surface[1]);
 436       brush.face[3].Value    = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? ArghRad2 : 0);
 437
 438       if(CheckAngle && Plane!=PLANE_XZ0 && Plane!=PLANE_XZ1)
 439       {
 440         XYZVectorSubtract(v[2].p,v[0].p,t[0]);
 441         XYZVectorSubtract(v[1].p,v[2].p,t[1]);
 442         CrossProduct(t[0],t[1],SurfNormal);
 443         VectorNormalize(SurfNormal,SurfNormal);
 444         if(DotProduct(SurfNormal,PlaneNormal) < Steep)
 445         {
 446           strcpy(surft,surftext2);
 447           surf = surface[2];
 448         }
 449         else
 450         {
 451           strcpy(surft,surftext);
 452           surf = surface[0];
 453         }
 454       }
 455       else
 456       {
 457         strcpy(surft,surftext);
 458         surf = surface[0];
 459       }
 460
 461       XYZtoV(&v[0],&brush.face[4].v[0]);
 462       XYZtoV(&v[1],&brush.face[4].v[1]);
 463       XYZtoV(&v[2],&brush.face[4].v[2]);
 464       strcpy(brush.face[4].texture,
 465         (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? sidetext : surft));
 466       brush.face[4].Shift[0] = (float)TexOffset[0];
 467       brush.face[4].Shift[1] = (float)TexOffset[1];
 468       brush.face[4].Rotate   = 0.;
 469       brush.face[4].Scale[0] = (float)TexScale[0];
 470       brush.face[4].Scale[1] = (float)TexScale[1];
 471       brush.face[4].Contents = contents;
 472       brush.face[4].Surface  = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surface[1] : surf);
 473       brush.face[4].Value    = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? 0 : ArghRad2);
 474
 475       MakeBrush(&brush);
 476       if( (i+j) %2 )
 477       {
 478         VectorCopy(xyz[i  ][j+1].p,v[0].p);
 479         switch(Plane)
 480         {
 481         case PLANE_XY1:
 482         case PLANE_XZ1:
 483         case PLANE_YZ1:
 484           VectorCopy(xyz[i  ][j  ].p,v[1].p);
 485           VectorCopy(xyz[i+1][j+1].p,v[2].p);
 486           break;
 487         default:
 488           VectorCopy(xyz[i+1][j+1].p,v[1].p);
 489           VectorCopy(xyz[i  ][j  ].p,v[2].p);
 490         }
 491       }
 492       else
 493       {
 494         VectorCopy(xyz[i  ][j+1].p,v[0].p);
 495         switch(Plane)
 496         {
 497         case PLANE_XY1:
 498         case PLANE_XZ1:
 499         case PLANE_YZ1:
 500           VectorCopy(xyz[i+1][j  ].p,v[1].p);
 501           VectorCopy(xyz[i+1][j+1].p,v[2].p);
 502           break;
 503         default:
 504           VectorCopy(xyz[i+1][j+1].p,v[1].p);
 505           VectorCopy(xyz[i+1][j  ].p,v[2].p);
 506         }
 507       }
 508       VectorCopy(v[0].p,v[3].p);
 509       VectorCopy(v[1].p,v[4].p);
 510       VectorCopy(v[2].p,v[5].p);
 511       switch(Plane)
 512       {
 513       case PLANE_XZ0:
 514       case PLANE_XZ1:
 515         v[0].p[1] = backface;
 516         v[1].p[1] = backface;
 517         v[2].p[1] = backface;
 518         break;
 519       case PLANE_YZ0:
 520       case PLANE_YZ1:
 521         v[3].p[0] = backface;
 522         v[4].p[0] = backface;
 523         v[5].p[0] = backface;
 524         break;
 525       default:
 526         v[3].p[2] = backface;
 527         v[4].p[2] = backface;
 528         v[5].p[2] = backface;
 529       }
 530       brush.Number   = i*NV*2+j*2+1;
 531       brush.NumFaces = 5;
 532       XYZtoV(&v[0],&brush.face[0].v[0]);
 533       XYZtoV(&v[3],&brush.face[0].v[1]);
 534       XYZtoV(&v[4],&brush.face[0].v[2]);
 535       strcpy(brush.face[0].texture,
 536         (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
 537       brush.face[0].Shift[0] = (float)TexOffset[0];
 538       brush.face[0].Shift[1] = (float)TexOffset[1];
 539       brush.face[0].Rotate   = 0.;
 540       brush.face[0].Scale[0] = (float)TexScale[0];
 541       brush.face[0].Scale[1] = (float)TexScale[1];
 542       brush.face[0].Contents = contents;
 543       brush.face[0].Surface  = surface[1];
 544       brush.face[0].Value    = 0;
 545
 546       XYZtoV(&v[1],&brush.face[1].v[0]);
 547       XYZtoV(&v[4],&brush.face[1].v[1]);
 548       XYZtoV(&v[5],&brush.face[1].v[2]);
 549       strcpy(brush.face[1].texture,
 550         (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
 551       brush.face[1].Shift[0] = (float)TexOffset[0];
 552       brush.face[1].Shift[1] = (float)TexOffset[1];
 553       brush.face[1].Rotate   = 0.;
 554       brush.face[1].Scale[0] = (float)TexScale[0];
 555       brush.face[1].Scale[1] = (float)TexScale[1];
 556       brush.face[1].Contents = contents;
 557       brush.face[1].Surface  = surface[1];
 558       brush.face[1].Value    = 0;
 559
 560       XYZtoV(&v[2],&brush.face[2].v[0]);
 561       XYZtoV(&v[5],&brush.face[2].v[1]);
 562       XYZtoV(&v[3],&brush.face[2].v[2]);
 563       strcpy(brush.face[2].texture,
 564         (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
 565       brush.face[2].Shift[0] = (float)TexOffset[0];
 566       brush.face[2].Shift[1] = (float)TexOffset[1];
 567       brush.face[2].Rotate   = 0.;
 568       brush.face[2].Scale[0] = (float)TexScale[0];
 569       brush.face[2].Scale[1] = (float)TexScale[1];
 570       brush.face[2].Contents = contents;
 571       brush.face[2].Surface  = surface[1];
 572       brush.face[2].Value    = 0;
 573
 574       if(CheckAngle && (Plane==PLANE_XZ0 || Plane==PLANE_XZ1))
 575       {
 576         XYZVectorSubtract(v[4].p,v[3].p,t[0]);
 577         XYZVectorSubtract(v[5].p,v[4].p,t[1]);
 578         CrossProduct(t[0],t[1],SurfNormal);
 579         VectorNormalize(SurfNormal,SurfNormal);
 580         if(DotProduct(SurfNormal,PlaneNormal) < Steep)
 581         {
 582           strcpy(surft,surftext2);
 583           surf = surface[2];
 584         }
 585         else
 586         {
 587           strcpy(surft,surftext);
 588           surf = surface[0];
 589         }
 590       }
 591       else
 592       {
 593         strcpy(surft,surftext);
 594         surf = surface[0];
 595       }
 596       XYZtoV(&v[3],&brush.face[3].v[0]);
 597       XYZtoV(&v[5],&brush.face[3].v[1]);
 598       XYZtoV(&v[4],&brush.face[3].v[2]);
 599       strcpy(brush.face[3].texture,
 600         (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surft : sidetext));
 601       brush.face[3].Shift[0] = (float)TexOffset[0];
 602       brush.face[3].Shift[1] = (float)TexOffset[1];
 603       brush.face[3].Rotate   = 0.;
 604       brush.face[3].Scale[0] = (float)TexScale[0];
 605       brush.face[3].Scale[1] = (float)TexScale[1];
 606       brush.face[3].Contents = contents;
 607       brush.face[3].Surface  = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surf : surface[1]);
 608       brush.face[3].Value    = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? ArghRad2 : 0);
 609
 610       if(CheckAngle && Plane!=PLANE_XZ0 && Plane!=PLANE_XZ1)
 611       {
 612         XYZVectorSubtract(v[2].p,v[0].p,t[0]);
 613         XYZVectorSubtract(v[1].p,v[2].p,t[1]);
 614         CrossProduct(t[0],t[1],SurfNormal);
 615         VectorNormalize(SurfNormal,SurfNormal);
 616         if(DotProduct(SurfNormal,PlaneNormal) < Steep)
 617         {
 618           strcpy(surft,surftext2);
 619           surf = surface[2];
 620         }
 621         else
 622         {
 623           strcpy(surft,surftext);
 624           surf = surface[0];
 625         }
 626       }
 627       else
 628       {
 629         strcpy(surft,surftext);
 630         surf = surface[0];
 631       }
 632       XYZtoV(&v[0],&brush.face[4].v[0]);
 633       XYZtoV(&v[1],&brush.face[4].v[1]);
 634       XYZtoV(&v[2],&brush.face[4].v[2]);
 635       strcpy(brush.face[4].texture,
 636         (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? sidetext : surft));
 637       brush.face[4].Shift[0] = (float)TexOffset[0];
 638       brush.face[4].Shift[1] = (float)TexOffset[1];
 639       brush.face[4].Rotate   = 0.;
 640       brush.face[4].Scale[0] = (float)TexScale[0];
 641       brush.face[4].Scale[1] = (float)TexScale[1];
 642       brush.face[4].Contents = contents;
 643       brush.face[4].Surface  = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surface[1] : surf);
 644       brush.face[4].Value    = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? 0 : ArghRad2);
 645
 646       MakeBrush(&brush);
 647     }
 648   }
 649   CloseFuncGroup();
 650
 651   if( AddHints || GimpHints )
 652   {
 653     int detail, i1, j1, N;
 654     double front;
 655
 656     switch(Game)
 657     {
 658     case HALFLIFE:
 659       strcpy(hint,"HINT");
 660       strcpy(skip,"HINT");
 661       break;
 662     case SIN:
 663       strcpy(hint,"generic/misc/hint");
 664       strcpy(skip,"generic/misc/skip");
 665       break;
 666     case HERETIC2:
 667       strcpy(hint,"general/hint");
 668       strcpy(skip,"general/hint");   // Heretic2 doesn't have a skip texture
 669       break;
 670     case KINGPIN:
 671       strcpy(hint,"common/0_hint");
 672       strcpy(skip,"common/0_skip");
 673       break;
 674     case GENESIS3D:
 675       strcpy(hint,"hint");
 676       strcpy(skip,"hint");
 677       break;
 678     case QUAKE3:
 679       strcpy(hint,"textures/common/hint");
 680       strcpy(skip,"textures/common/skip");
 681       break;
 682     default:
 683       strcpy(hint,"e1u1/hint");
 684       strcpy(skip,"e1u1/skip");
 685     }
 686
 687     OpenFuncGroup();
 688
 689     if(AddHints==1)
 690     {
 691       detail = CONTENTS_DETAIL;
 692       N = 0;
 693       for(i=0; i<NH; i++)
 694       {
 695         i1 = i+1;
 696
 697         for(j=0; j<NV; j++)
 698         {
 699
 700           // For detail hint brushes, no need to use a hint brush over
 701           // EVERY grid square... it would be redundant. Instead use
 702           // a checkerboard pattern
 703           if((i+j)%2) continue;
 704
 705           j1 = j+1;
 706
 707           VectorCopy(xyz[i  ][j  ].p, v[0].p);
 708           switch(Plane)
 709           {
 710           case PLANE_XY1:
 711           case PLANE_XZ1:
 712           case PLANE_YZ1:
 713             VectorCopy(xyz[i1][j ].p, v[1].p);
 714             VectorCopy(xyz[i1][j1].p, v[2].p);
 715             VectorCopy(xyz[i ][j1].p, v[3].p);
 716             break;
 717           default:
 718             VectorCopy(xyz[i ][j1].p, v[1].p);
 719             VectorCopy(xyz[i1][j1].p, v[2].p);
 720             VectorCopy(xyz[i1][j ].p, v[3].p);
 721           }
 722
 723           VectorCopy(v[0].p,v[4].p);
 724           VectorCopy(v[1].p,v[5].p);
 725           VectorCopy(v[2].p,v[6].p);
 726           VectorCopy(v[3].p,v[7].p);
 727
 728           switch(Plane)
 729           {
 730           case PLANE_XY1:
 731             front  = LessThan(zmin,32.);
 732             v[4].p[2] = backface;
 733             v[5].p[2] = backface;
 734             v[6].p[2] = backface;
 735             v[7].p[2] = backface;
 736             break;
 737           case PLANE_XZ0:
 738             front  = MoreThan(ymax,32.);
 739             v[0].p[1] = backface;
 740             v[1].p[1] = backface;
 741             v[2].p[1] = backface;
 742             v[3].p[1] = backface;
 743             break;
 744           case PLANE_XZ1:
 745             front  = LessThan(ymin,32.);
 746             v[0].p[1] = backface;
 747             v[1].p[1] = backface;
 748             v[2].p[1] = backface;
 749             v[3].p[1] = backface;
 750             break;
 751           case PLANE_YZ0:
 752             front  = MoreThan(xmax,32.);
 753             v[4].p[0] = backface;
 754             v[5].p[0] = backface;
 755             v[6].p[0] = backface;
 756             v[7].p[0] = backface;
 757             break;
 758           case PLANE_YZ1:
 759             front  = LessThan(xmin,32.);
 760             v[4].p[0] = backface;
 761             v[5].p[0] = backface;
 762             v[6].p[0] = backface;
 763             v[7].p[0] = backface;
 764             break;
 765           default:
 766             front  = MoreThan(zmax,32.);
 767             v[4].p[2] = backface;
 768             v[5].p[2] = backface;
 769             v[6].p[2] = backface;
 770             v[7].p[2] = backface;
 771           }
 772
 773           switch(Plane)
 774           {
 775           case PLANE_XZ0:
 776           case PLANE_XZ1:
 777             v[4].p[1] = front;
 778             v[5].p[1] = v[4].p[1];
 779             v[6].p[1] = v[4].p[1];
 780             v[7].p[1] = v[4].p[1];
 781             break;
 782           case PLANE_YZ0:
 783           case PLANE_YZ1:
 784             v[0].p[0] = front;
 785             v[1].p[0] = v[0].p[0];
 786             v[2].p[0] = v[0].p[0];
 787             v[3].p[0] = v[0].p[0];
 788             break;
 789           default:
 790             v[0].p[2] = front;
 791             v[1].p[2] = v[0].p[2];
 792             v[2].p[2] = v[0].p[2];
 793             v[3].p[2] = v[0].p[2];
 794           }
 795
 796           brush.NumFaces = 6;
 797           brush.Number   = N;
 798           XYZtoV(&v[0],&brush.face[0].v[0]);
 799           XYZtoV(&v[1],&brush.face[0].v[1]);
 800           XYZtoV(&v[2],&brush.face[0].v[2]);
 801           strcpy(brush.face[0].texture,skip);
 802           brush.face[0].Shift[0] = 0.;
 803           brush.face[0].Shift[1] = 0.;
 804           brush.face[0].Rotate   = 0.;
 805           brush.face[0].Scale[0] = 1.;
 806           brush.face[0].Scale[1] = 1.;
 807           brush.face[0].Contents = detail;
 808           brush.face[0].Surface  = SURF_SKIP;
 809           brush.face[0].Value    = 0;
 810
 811           XYZtoV(&v[4],&brush.face[1].v[0]);
 812           XYZtoV(&v[7],&brush.face[1].v[1]);
 813           XYZtoV(&v[6],&brush.face[1].v[2]);
 814           strcpy(brush.face[1].texture,skip);
 815           brush.face[1].Shift[0] = 0.;
 816           brush.face[1].Shift[1] = 0.;
 817           brush.face[1].Rotate   = 0.;
 818           brush.face[1].Scale[0] = 1.;
 819           brush.face[1].Scale[1] = 1.;
 820           brush.face[1].Contents = detail;
 821           brush.face[1].Surface  = SURF_SKIP;
 822           brush.face[1].Value    = 0;
 823
 824           XYZtoV(&v[0],&brush.face[2].v[0]);
 825           XYZtoV(&v[4],&brush.face[2].v[1]);
 826           XYZtoV(&v[5],&brush.face[2].v[2]);
 827           strcpy(brush.face[2].texture,hint);
 828           brush.face[2].Shift[0] = 0.;
 829           brush.face[2].Shift[1] = 0.;
 830           brush.face[2].Rotate   = 0.;
 831           brush.face[2].Scale[0] = 1.;
 832           brush.face[2].Scale[1] = 1.;
 833           brush.face[2].Contents = detail;
 834           brush.face[2].Surface  = SURF_HINT;
 835           brush.face[2].Value    = 0;
 836
 837           XYZtoV(&v[1],&brush.face[3].v[0]);
 838           XYZtoV(&v[5],&brush.face[3].v[1]);
 839           XYZtoV(&v[6],&brush.face[3].v[2]);
 840           strcpy(brush.face[3].texture,hint);
 841           brush.face[3].Shift[0] = 0.;
 842           brush.face[3].Shift[1] = 0.;
 843           brush.face[3].Rotate   = 0.;
 844           brush.face[3].Scale[0] = 1.;
 845           brush.face[3].Scale[1] = 1.;
 846           brush.face[3].Contents = detail;
 847           brush.face[3].Surface  = SURF_HINT;
 848           brush.face[3].Value    = 0;
 849
 850           XYZtoV(&v[2],&brush.face[4].v[0]);
 851           XYZtoV(&v[6],&brush.face[4].v[1]);
 852           XYZtoV(&v[7],&brush.face[4].v[2]);
 853           strcpy(brush.face[4].texture,hint);
 854           brush.face[4].Shift[0] = 0.;
 855           brush.face[4].Shift[1] = 0.;
 856           brush.face[4].Rotate   = 0.;
 857           brush.face[4].Scale[0] = 1.;
 858           brush.face[4].Scale[1] = 1.;
 859           brush.face[4].Contents = detail;
 860           brush.face[4].Surface  = SURF_HINT;
 861           brush.face[4].Value    = 0;
 862
 863           XYZtoV(&v[3],&brush.face[5].v[0]);
 864           XYZtoV(&v[7],&brush.face[5].v[1]);
 865           XYZtoV(&v[4],&brush.face[5].v[2]);
 866           strcpy(brush.face[5].texture,hint);
 867           brush.face[5].Shift[0] = 0.;
 868           brush.face[5].Shift[1] = 0.;
 869           brush.face[5].Rotate   = 0.;
 870           brush.face[5].Scale[0] = 1.;
 871           brush.face[5].Scale[1] = 1.;
 872           brush.face[5].Contents = detail;
 873           brush.face[5].Surface  = SURF_HINT;
 874           brush.face[5].Value    = 0;
 875
 876           MakeBrush(&brush);
 877           N++;
 878         }
 879       }
 880     }
 881     if(GimpHints)
 882     {
 883       N = 0;
 884       // these brush parameters never change
 885       brush.NumFaces = 5;
 886       for(i=0; i<6; i++)
 887       {
 888         strcpy(brush.face[i].texture,hint);
 889         brush.face[i].Shift[0] = 0.;
 890         brush.face[i].Shift[1] = 0.;
 891         brush.face[i].Rotate   = 0.;
 892         brush.face[i].Scale[0] = 1.;
 893         brush.face[i].Scale[1] = 1.;
 894         brush.face[i].Contents = 0;
 895         brush.face[i].Surface  = SURF_HINT;
 896         brush.face[i].Value    = 0;
 897       }
 898       for(i=0; i<NH; i++)
 899       {
 900         for(j=0; j<NV; j++)
 901         {
 902           for(k=0; k<2; k++)
 903           {
 904             if(k==0)
 905             {
 906               if( (i+j) % 2 )
 907               {
 908                 VectorCopy(xyz[i  ][j  ].p, v[0].p);
 909                 switch(Plane)
 910                 {
 911                 case PLANE_XY1:
 912                 case PLANE_XZ1:
 913                 case PLANE_YZ1:
 914                   VectorCopy(xyz[i+1][j  ].p, v[1].p);
 915                   VectorCopy(xyz[i+1][j+1].p, v[2].p);
 916                   break;
 917                 default:
 918                   VectorCopy(xyz[i+1][j+1].p, v[1].p);
 919                   VectorCopy(xyz[i+1][j  ].p, v[2].p);
 920                 }
 921               }
 922               else
 923               {
 924                 VectorCopy(xyz[i  ][j  ].p, v[0].p);
 925                 switch(Plane)
 926                 {
 927                 case PLANE_XY1:
 928                 case PLANE_XZ1:
 929                 case PLANE_YZ1:
 930                   VectorCopy(xyz[i+1][j  ].p, v[1].p);
 931                   VectorCopy(xyz[i  ][j+1].p, v[2].p);
 932                   break;
 933                 default:
 934                   VectorCopy(xyz[i  ][j+1].p, v[1].p);
 935                   VectorCopy(xyz[i+1][j  ].p, v[2].p);
 936                 }
 937               }
 938             }
 939             else
 940             {
 941               if( (i+j) %2 )
 942               {
 943                 VectorCopy(xyz[i  ][j+1].p,v[0].p);
 944                 switch(Plane)
 945                 {
 946                 case PLANE_XY1:
 947                 case PLANE_XZ1:
 948                 case PLANE_YZ1:
 949                   VectorCopy(xyz[i  ][j  ].p,v[1].p);
 950                   VectorCopy(xyz[i+1][j+1].p,v[2].p);
 951                   break;
 952                 default:
 953                   VectorCopy(xyz[i+1][j+1].p,v[1].p);
 954                   VectorCopy(xyz[i  ][j  ].p,v[2].p);
 955                 }
 956               }
 957               else
 958               {
 959                 VectorCopy(xyz[i  ][j+1].p,v[0].p);
 960                 switch(Plane)
 961                 {
 962                 case PLANE_XY1:
 963                 case PLANE_XZ1:
 964                 case PLANE_YZ1:
 965                   VectorCopy(xyz[i+1][j  ].p,v[1].p);
 966                   VectorCopy(xyz[i+1][j+1].p,v[2].p);
 967                   break;
 968                 default:
 969                   VectorCopy(xyz[i+1][j+1].p,v[1].p);
 970                   VectorCopy(xyz[i+1][j  ].p,v[2].p);
 971                 }
 972               }
 973             }
 974             VectorCopy(v[0].p,v[3].p);
 975             VectorCopy(v[1].p,v[4].p);
 976             VectorCopy(v[2].p,v[5].p);
 977             switch(Plane)
 978             {
 979             case PLANE_XY0:
 980               v[0].p[2] += HINT_OFFSET;
 981               v[1].p[2] += HINT_OFFSET;
 982               v[2].p[2] += HINT_OFFSET;
 983 //              v[3].p[2] = backface;
 984 //              v[4].p[2] = backface;
 985 //              v[5].p[2] = backface;
 986               break;
 987             case PLANE_XY1:
 988               v[0].p[2] -= HINT_OFFSET;
 989               v[1].p[2] -= HINT_OFFSET;
 990               v[2].p[2] -= HINT_OFFSET;
 991 //              v[3].p[2] = backface;
 992 //              v[4].p[2] = backface;
 993 //              v[5].p[2] = backface;
 994               break;
 995             case PLANE_XZ0:
 996 //              v[0].p[1] = backface;
 997 //              v[1].p[1] = backface;
 998 //              v[2].p[1] = backface;
 999               v[3].p[1] += HINT_OFFSET;
1000               v[4].p[1] += HINT_OFFSET;
1001               v[5].p[1] += HINT_OFFSET;
1002               break;
1003             case PLANE_XZ1:
1004 //              v[0].p[1] = backface;
1005 //              v[1].p[1] = backface;
1006 //              v[2].p[1] = backface;
1007               v[3].p[1] -= HINT_OFFSET;
1008               v[4].p[1] -= HINT_OFFSET;
1009               v[5].p[1] -= HINT_OFFSET;
1010               break;
1011             case PLANE_YZ0:
1012               v[0].p[0] += HINT_OFFSET;
1013               v[1].p[0] += HINT_OFFSET;
1014               v[2].p[0] += HINT_OFFSET;
1015 //              v[3].p[0] = backface;
1016 //              v[4].p[0] = backface;
1017 //              v[5].p[0] = backface;
1018               break;
1019             case PLANE_YZ1:
1020               v[0].p[0] -= HINT_OFFSET;
1021               v[1].p[0] -= HINT_OFFSET;
1022               v[2].p[0] -= HINT_OFFSET;
1023 //              v[3].p[0] = backface;
1024 //              v[4].p[0] = backface;
1025 //              v[5].p[0] = backface;
1026               break;
1027             }
1028             brush.Number   = N;
1029             XYZtoV(&v[0],&brush.face[0].v[0]);
1030             XYZtoV(&v[3],&brush.face[0].v[1]);
1031             XYZtoV(&v[4],&brush.face[0].v[2]);
1032
1033             XYZtoV(&v[1],&brush.face[1].v[0]);
1034             XYZtoV(&v[4],&brush.face[1].v[1]);
1035             XYZtoV(&v[5],&brush.face[1].v[2]);
1036
1037             XYZtoV(&v[2],&brush.face[2].v[0]);
1038             XYZtoV(&v[5],&brush.face[2].v[1]);
1039             XYZtoV(&v[3],&brush.face[2].v[2]);
1040
1041             XYZtoV(&v[3],&brush.face[3].v[0]);
1042             XYZtoV(&v[5],&brush.face[3].v[1]);
1043             XYZtoV(&v[4],&brush.face[3].v[2]);
1044
1045             XYZtoV(&v[0],&brush.face[4].v[0]);
1046             XYZtoV(&v[1],&brush.face[4].v[1]);
1047             XYZtoV(&v[2],&brush.face[4].v[2]);
1048
1049             MakeBrush(&brush);
1050             N++;
1051           }
1052         }
1053       }
1054     } // endif AddHints==1
1055     CloseFuncGroup();
1056   }
1057
1058 } // end MapBrushes
1059
1060 //=============================================================
1061 void GenerateMap()
1062 {
1063   extern void MapOut(int,int,NODE *,TRI *);
1064   extern bool SingleBrushSelected;
1065   int  ntri;
1066
1067   if(!ValidSurface()) return;
1068         /*
1069   ghCursorCurrent = LoadCursor(NULL,IDC_WAIT);
1070   SetCursor(ghCursorCurrent);
1071         */
1072 #if 0
1073     if(SingleBrushSelected) g_FuncTable.m_pfnDeleteSelection();
1074 #endif
1075
1076   GenerateXYZ();
1077   ntri = NH*NV*2;
1078
1079   if(Game==QUAKE3 && UsePatches != 0)
1080     MapPatches();
1081
1082   if(Decimate > 0 && (Game != QUAKE3 || UsePatches==0) )
1083   {
1084     MapOut(gNumNodes,gNumTris,gNode,gTri);
1085                 /*
1086     ghCursorCurrent = ghCursorDefault;
1087     SetCursor(ghCursorCurrent);
1088                 */
1089     return;
1090   }
1091
1092   contents = 0;
1093   // HL doesn't have detail property
1094   if((Game != HALFLIFE) && UseDetail) contents += CONTENTS_DETAIL;
1095   // HL and Q3 don't have ladder property
1096   if((Game != HALFLIFE && Game != QUAKE3) && UseLadder) contents += CONTENTS_LADDER;
1097   // Genesis requires solid property to be set explicitly
1098   if(Game == GENESIS3D) contents |= CONTENTS_SOLID;
1099   // Heretic 2 uses different sounds (in surface props) for different texture types
1100   if(Game == HERETIC2)
1101   {
1102     surface[0] = GetDefSurfaceProps(Texture[Game][0]);
1103     surface[1] = GetDefSurfaceProps(Texture[Game][1]);
1104     surface[2] = GetDefSurfaceProps(Texture[Game][2]);
1105   }
1106   else
1107   {
1108     surface[0] = 0;
1109     surface[1] = 0;
1110     surface[2] = 0;
1111   }
1112   if(Game!=QUAKE3 || UsePatches == 0)
1113     MapBrushes();
1114
1115         /*
1116   ghCursorCurrent = ghCursorDefault;
1117   SetCursor(ghCursorCurrent);
1118         */
1119 }
1120
1121 //=============================================================
1122 void GenerateXYZ()
1123 {
1124   extern void MakeDecimatedMap(int *, int *, NODE **, TRI **);
1125   double zl, zu;
1126   double wh, wv;
1127   int NHalfcycles;
1128   double a,v,h,ha,va;
1129   double delta, dr, rate;
1130   double range, maxrange;
1131   double r;
1132   int i, j, k, N;
1133   int i0, i1, j0, j1;
1134   int ii, jj;
1135
1136 //  FILE *f;
1137 //  char CSV[64];
1138
1139   if(!ValidSurface()) return;
1140
1141   srand(1);
1142   srand(RandomSeed);
1143
1144   dh = (Hur-Hll)/NH;
1145   dv = (Vur-Vll)/NV;
1146
1147   // H & V
1148   for(i=0; i<=NH; i++)
1149   {
1150     for(j=0;j<=NV;j++)
1151     {
1152       switch(Plane)
1153       {
1154       case PLANE_XZ0:
1155       case PLANE_XZ1:
1156         xyz[i][j].p[0] = Hll + i*dh;
1157         xyz[i][j].p[2] = Vll + j*dv;
1158         break;
1159       case PLANE_YZ0:
1160       case PLANE_YZ1:
1161         xyz[i][j].p[1] = Hll + i*dh;
1162         xyz[i][j].p[2] = Vll + j*dv;
1163         break;
1164       default:
1165         xyz[i][j].p[0] = Hll + i*dh;
1166         xyz[i][j].p[1] = Vll + j*dv;
1167       }
1168     }
1169   }
1170
1171   if(WaveType == WAVE_BITMAP)
1172     GenerateBitmapMapping();
1173         /*
1174   else if(WaveType == WAVE_FORMULA)
1175     DoFormula();
1176         */
1177   else
1178   {
1179     // Initialize Z values using bilinear interpolation
1180     for(i=0; i<=NH; i++)
1181     {
1182       zl = Z00 + i*(Z10 - Z00)/NH;
1183       zu = Z01 + i*(Z11 - Z01)/NH;
1184       switch(Plane)
1185       {
1186       case PLANE_XZ0:
1187       case PLANE_XZ1:
1188         for(j=0; j<=NV; j++)
1189           xyz[i][j].p[1] = zl + j*(zu-zl)/NV;
1190         break;
1191       case PLANE_YZ0:
1192       case PLANE_YZ1:
1193         for(j=0; j<=NV; j++)
1194           xyz[i][j].p[0] = zl + j*(zu-zl)/NV;
1195         break;
1196       default:
1197         for(j=0; j<=NV; j++)
1198           xyz[i][j].p[2] = zl + j*(zu-zl)/NV;
1199       }
1200     }
1201   }
1202
1203   switch(WaveType)
1204   {
1205   case WAVE_COS_SIN:
1206     if(FixBorders)
1207     {
1208       NHalfcycles = (int)((Hur-Hll)/(WaveLength/2.));
1209       NHalfcycles = max(NHalfcycles,1);
1210       wh = 2.*(Hur-Hll)/NHalfcycles;
1211       NHalfcycles = (int)((Vur-Vll)/(WaveLength/2.));
1212       wv = 2.*(Vur-Vll)/NHalfcycles;
1213       NHalfcycles = max(NHalfcycles,1);
1214       i0 = 1;
1215       i1 = NH-1;
1216       j0 = 1;
1217       j1 = NV-1;
1218     }
1219     else
1220     {
1221       wh = WaveLength;
1222       wv = WaveLength;
1223       i0 = 0;
1224       i1 = NH;
1225       j0 = 0;
1226       j1 = NV;
1227     }
1228
1229     for(i=i0; i<=i1; i++)
1230     {
1231       h  = Hll + i*dh;
1232       ha = ((h-Hll)/wh)*2.*PI - PI/2.;
1233       for(j=j0; j<=j1; j++)
1234       {
1235         v  = Vll + j*dv;
1236         va = ((v-Vll)/wv)*2.*PI;
1237         a = Amplitude * cos( ha ) * sin( va );
1238         switch(Plane)
1239         {
1240         case PLANE_XY1:
1241           xyz[i][j].p[2] -= a;
1242           break;
1243         case PLANE_XZ0:
1244           xyz[i][j].p[1] += a;
1245           break;
1246         case PLANE_XZ1:
1247           xyz[i][j].p[1] -= a;
1248           break;
1249         case PLANE_YZ0:
1250           xyz[i][j].p[0] += a;
1251           break;
1252         case PLANE_YZ1:
1253           xyz[i][j].p[0] -= a;
1254           break;
1255         default:
1256           xyz[i][j].p[2] += a;
1257         }
1258       }
1259     }
1260     break;
1261   case WAVE_HCYLINDER:
1262     for(i=0; i<=NH; i++)
1263     {
1264       h  = Hll + i*dh;
1265       ha = ((h-Hll)/WaveLength)*2.*PI - PI/2.;
1266       for(j=0; j<=NV; j++)
1267       {
1268         a = Amplitude * cos( ha );
1269         switch(Plane)
1270         {
1271         case PLANE_XY1:
1272           xyz[i][j].p[2] -= a;
1273           break;
1274         case PLANE_XZ0:
1275           xyz[i][j].p[1] += a;
1276           break;
1277         case PLANE_XZ1:
1278           xyz[i][j].p[1] -= a;
1279           break;
1280         case PLANE_YZ0:
1281           xyz[i][j].p[0] += a;
1282           break;
1283         case PLANE_YZ1:
1284           xyz[i][j].p[0] -= a;
1285           break;
1286         default:
1287           xyz[i][j].p[2] += a;
1288         }
1289       }
1290     }
1291     break;
1292   case WAVE_VCYLINDER:
1293     for(i=0; i<=NH; i++)
1294     {
1295       h  = Hll + i*dh;
1296       for(j=0; j<=NV; j++)
1297       {
1298         v  = Vll + j*dv;
1299         va = ((v-Vll)/WaveLength)*2.*PI;
1300         a = Amplitude * sin( va );
1301         switch(Plane)
1302         {
1303         case PLANE_XY1:
1304           xyz[i][j].p[2] -= a;
1305           break;
1306         case PLANE_XZ0:
1307           xyz[i][j].p[1] += a;
1308           break;
1309         case PLANE_XZ1:
1310           xyz[i][j].p[1] -= a;
1311           break;
1312         case PLANE_YZ0:
1313           xyz[i][j].p[0] += a;
1314           break;
1315         case PLANE_YZ1:
1316           xyz[i][j].p[0] -= a;
1317           break;
1318         default:
1319           xyz[i][j].p[2] += a;
1320         }
1321       }
1322     }
1323     break;
1324   case WAVE_ROUGH_ONLY:
1325     PlasmaCloud();
1326     break;
1327   }
1328
1329   if(WaveType != WAVE_ROUGH_ONLY)
1330   {
1331     // Fixed values
1332     for(i=0; i<=NH; i++)
1333     {
1334       for(j=0; j<=NV; j++)
1335       {
1336         if(xyz[i][j].fixed)
1337         {
1338           switch(Plane)
1339           {
1340           case PLANE_XZ0:
1341           case PLANE_XZ1:
1342             xyz[i][j].p[1] = xyz[i][j].fixed_value;
1343             break;
1344           case PLANE_YZ0:
1345           case PLANE_YZ1:
1346             xyz[i][j].p[0] = xyz[i][j].fixed_value;
1347             break;
1348           default:
1349             xyz[i][j].p[2] = xyz[i][j].fixed_value;
1350           }
1351
1352           if(xyz[i][j].range > 0)
1353           {
1354             maxrange = pow(xyz[i][j].range,2); // so we don't have to do sqrt's
1355             i0 = i - (int)( floor(xyz[i][j].range/dh - 0.5) + 1 );
1356             i1 = i + i - i0;
1357             j0 = j - (int)( floor(xyz[i][j].range/dv - 0.5) + 1 );
1358             j1 = j + j - j0;
1359             if(FixBorders)
1360             {
1361               i0 = max(i0,1);
1362               i1 = min(i1,NH-1);
1363               j0 = max(j0,1);
1364               j1 = min(j1,NV-1);
1365             }
1366             else
1367             {
1368               i0 = max(i0,0);
1369               i1 = min(i1,NH);
1370               j0 = max(j0,0);
1371               j1 = min(j1,NV);
1372             }
1373             for(ii=i0; ii<=i1; ii++)
1374             {
1375               for(jj=j0; jj<=j1; jj++)
1376               {
1377                 if(ii==i && jj==j) continue;
1378                 range = pow( dh*(i-ii), 2) + pow( dv*(j-jj), 2);
1379                 if(range > maxrange) continue;
1380                 dr = sqrt(range/maxrange);
1381                 rate = max(-30.,min(xyz[i][j].rate,30.));
1382                 if(rate < -1.)
1383                 {
1384                   delta = pow((1.-dr),-rate+1.);
1385                 }
1386                 else if(rate < 0.)
1387                 {
1388                   delta = (1+rate)*0.5*(cos(dr*PI)+1.0) -
1389                     rate*pow((1.-dr),2);
1390                 }
1391                 else if(rate == 0.)
1392                 {
1393                   delta = 0.5*(cos(dr*PI)+1.0);
1394                 }
1395                 else if(rate <= 1.)
1396                 {
1397                   delta = (1.-rate)*0.5*(cos(dr*PI)+1.0) +
1398                     rate*(1.-pow(dr,2));
1399                 }
1400                 else
1401                 {
1402                   delta = 1.-pow(dr,rate+1);
1403                 }
1404                 switch(Plane)
1405                 {
1406                 case PLANE_XZ0:
1407                 case PLANE_XZ1:
1408                   xyz[ii][jj].p[1] += (xyz[i][j].p[1] - xyz[ii][jj].p[1])*delta;
1409                   break;
1410                 case PLANE_YZ0:
1411                 case PLANE_YZ1:
1412                   xyz[ii][jj].p[0] += (xyz[i][j].p[0] - xyz[ii][jj].p[0])*delta;
1413                   break;
1414                 default:
1415                   xyz[ii][jj].p[2] += (xyz[i][j].p[2] - xyz[ii][jj].p[2])*delta;
1416                 }
1417               }
1418             }
1419           }
1420         }
1421       }
1422     }
1423   }
1424
1425   if((Roughness > 0.) && (WaveType != WAVE_ROUGH_ONLY) )
1426   {
1427     for(i=0; i<=NH; i++)
1428     {
1429       for(j=0; j<=NV; j++)
1430       {
1431         if(CanEdit(i,j) && !xyz[i][j].fixed)
1432         {
1433           switch(Plane)
1434           {
1435           case PLANE_XZ0:
1436           case PLANE_XZ1:
1437             xyz[i][j].p[1] += -Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX);
1438             break;
1439           case PLANE_YZ0:
1440           case PLANE_YZ1:
1441             xyz[i][j].p[0] += -Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX);
1442             break;
1443           default:
1444             xyz[i][j].p[2] += -Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX);
1445           }
1446         }
1447         else
1448           r = rand();    // We still get a random number, so that fixing points
1449                            // doesn't change the sequence.
1450
1451       }
1452     }
1453   }
1454
1455   for(i=0; i<=NH; i++)
1456   {
1457     for(j=0; j<=NV; j++)
1458     {
1459       for(k=0; k<3; k++)
1460       {
1461         xyz[i][j].p[k] = Nearest(xyz[i][j].p[k],2.0);
1462       }
1463     }
1464   }
1465
1466   // Find minima and maxima
1467   switch(Plane)
1468   {
1469   case PLANE_XZ0:
1470   case PLANE_XZ1:
1471     xmin = Hll;
1472     xmax = Hur;
1473     zmin = Vll;
1474     zmax = Vur;
1475     ymin = xyz[0][0].p[1];
1476     ymax = ymin;
1477     for(i=0; i<=NH; i++)
1478     {
1479       for(j=0; j<=NV; j++)
1480       {
1481         ymin = min(ymin,xyz[i][j].p[1]);
1482         ymax = max(ymax,xyz[i][j].p[1]);
1483       }
1484     }
1485     break;
1486   case PLANE_YZ0:
1487   case PLANE_YZ1:
1488     ymin = Hll;
1489     ymax = Hur;
1490     zmin = Vll;
1491     zmax = Vur;
1492     xmin = xyz[0][0].p[0];
1493     xmax = ymin;
1494     for(i=0; i<=NH; i++)
1495     {
1496       for(j=0; j<=NV; j++)
1497       {
1498         xmin = min(xmin,xyz[i][j].p[0]);
1499         xmax = max(xmax,xyz[i][j].p[0]);
1500       }
1501     }
1502     break;
1503     break;
1504   default:
1505     xmin = Hll;
1506     xmax = Hur;
1507     ymin = Vll;
1508     ymax = Vur;
1509     zmin = xyz[0][0].p[2];
1510     zmax = zmin;
1511     for(i=0; i<=NH; i++)
1512     {
1513       for(j=0; j<=NV; j++)
1514       {
1515         zmin = min(zmin,xyz[i][j].p[2]);
1516         zmax = max(zmax,xyz[i][j].p[2]);
1517       }
1518     }
1519   }
1520
1521   xmin = Nearest(xmin,2.);
1522   xmax = Nearest(xmax,2.);
1523   ymin = Nearest(ymin,2.);
1524   ymax = Nearest(ymax,2.);
1525   zmin = Nearest(zmin,2.);
1526   zmax = Nearest(zmax,2.);
1527
1528   switch(Plane)
1529   {
1530   case PLANE_XY1:
1531     backface = AtLeast(zmax+32.,32.);
1532     break;
1533   case PLANE_XZ0:
1534     backface = NoMoreThan(ymin-32.,32.);
1535     break;
1536   case PLANE_XZ1:
1537     backface = AtLeast(ymax+32.,32.);
1538     break;
1539   case PLANE_YZ0:
1540     backface = NoMoreThan(xmin-32.,32.);
1541     break;
1542   case PLANE_YZ1:
1543     backface = AtLeast(xmax+32.,32.);
1544     break;
1545   default:
1546     backface = NoMoreThan(zmin-32.,32.);
1547   }
1548
1549   if(gNode)
1550   {
1551     free(gNode);
1552     free(gTri);
1553     gNode = (NODE *)NULL;
1554     gTri  = (TRI *)NULL;
1555   }
1556   if(Decimate > 0 && (Game != QUAKE3 || UsePatches==0) )
1557   {
1558     MakeDecimatedMap(&gNumNodes,&gNumTris,&gNode,&gTri);
1559   }
1560   else
1561   {
1562     gNumNodes = (NH+1)*(NV+1);
1563     gNumTris  = NH*NV*2;
1564     gNode = (NODE *) malloc(gNumNodes * sizeof(NODE));
1565     gTri = (TRI *) malloc(gNumTris * sizeof(TRI));
1566
1567     for(i=0,N=0; i<=NH; i++)
1568     {
1569       for(j=0; j<=NV; j++, N++)
1570       {
1571         gNode[N].used = 1;
1572         gNode[N].p[0] = (float)xyz[i][j].p[0];
1573         gNode[N].p[1] = (float)xyz[i][j].p[1];
1574         gNode[N].p[2] = (float)xyz[i][j].p[2];
1575       }
1576     }
1577
1578     for(i=0; i<NH; i++)
1579     {
1580       for(j=0; j<NV; j++)
1581       {
1582         k = i*NV*2 + j*2;
1583         if( (i+j) % 2 )
1584         {
1585           switch(Plane)
1586           {
1587           case PLANE_XY1:
1588           case PLANE_XZ1:
1589           case PLANE_YZ1:
1590             gTri[k  ].v[0] = i*(NV+1)+j;
1591             gTri[k  ].v[1] = (i+1)*(NV+1)+j+1;
1592             gTri[k  ].v[2] = (i+1)*(NV+1)+j;
1593             gTri[k+1].v[0] = i*(NV+1)+j;
1594             gTri[k+1].v[1] = i*(NV+1)+j+1;
1595             gTri[k+1].v[2] = (i+1)*(NV+1)+j+1;
1596             break;
1597           default:
1598             gTri[k  ].v[0] = i*(NV+1)+j;
1599             gTri[k  ].v[1] = (i+1)*(NV+1)+j;
1600             gTri[k  ].v[2] = (i+1)*(NV+1)+j+1;
1601             gTri[k+1].v[0] = i*(NV+1)+j;
1602             gTri[k+1].v[1] = (i+1)*(NV+1)+j+1;
1603             gTri[k+1].v[2] = i*(NV+1)+j+1;
1604           }
1605         }
1606         else
1607         {
1608           switch(Plane)
1609           {
1610           case PLANE_XY1:
1611           case PLANE_XZ1:
1612           case PLANE_YZ1:
1613             gTri[k  ].v[0] = i*(NV+1)+j;
1614             gTri[k  ].v[1] = i*(NV+1)+j+1;
1615             gTri[k  ].v[2] = (i+1)*(NV+1)+j;
1616             gTri[k+1].v[0] = (i+1)*(NV+1)+j;
1617             gTri[k+1].v[1] = i*(NV+1)+j+1;
1618             gTri[k+1].v[2] = (i+1)*(NV+1)+j+1;
1619             break;
1620           default:
1621             gTri[k  ].v[0] = i*(NV+1)+j;
1622             gTri[k  ].v[1] = (i+1)*(NV+1)+j;
1623             gTri[k  ].v[2] = i*(NV+1)+j+1;
1624             gTri[k+1].v[0] = (i+1)*(NV+1)+j;
1625             gTri[k+1].v[1] = (i+1)*(NV+1)+j+1;
1626             gTri[k+1].v[2] = i*(NV+1)+j+1;
1627           }
1628         }
1629       }
1630     }
1631   }
1632 /*
1633   sprintf(CSV,"csv%03d.csv",Decimate);
1634   f = fopen(CSV,"w");
1635   for(i=0; i<gNumNodes; i++)
1636   {
1637     if(gNode[i].used)
1638       fprintf(f,"%g,%g,%g\n",gNode[i].p[0],gNode[i].p[1],gNode[i].p[2]);
1639   }
1640   fclose(f);
1641 */
1642   for(i=0; i<gNumTris; i++)
1643     PlaneFromPoints(gNode[gTri[i].v[0]].p,
1644                     gNode[gTri[i].v[1]].p,
1645                     gNode[gTri[i].v[2]].p,
1646                     &gTri[i].plane);
1647
1648   // Hydra: snap-to-grid begin
1649   if (SnapToGrid > 0)
1650   {
1651     for(i=0; i<NH; i++)
1652     {
1653       for(j=0; j<NV; j++)
1654       {
1655         switch(Plane)
1656         {
1657         case PLANE_XZ0:
1658         case PLANE_XZ1:
1659           xyz[i][j].p[1] = CalculateSnapValue(xyz[i][j].p[1]);
1660           break;
1661         case PLANE_YZ0:
1662         case PLANE_YZ1:
1663           xyz[i][j].p[0] = CalculateSnapValue(xyz[i][j].p[0]);
1664           break;
1665         default:
1666           xyz[i][j].p[2] = CalculateSnapValue(xyz[i][j].p[2]);
1667         }
1668       }
1669     }
1670   }
1671   // Hydra: snap-to-grid end
1672 }
1673 //=============================================================
1674 double Nearest(double x, double dx)
1675 {
1676   double xx;
1677
1678   xx = (double)(floor(x/dx - 0.5)+1.)*dx;
1679   if(fabs(xx) < dx/2) xx = 0.;
1680   return xx;
1681 }
1682 //=============================================================
1683 double NoMoreThan(double x, double dx)
1684 {
1685   double xx;
1686
1687   xx = (double)(floor(x/dx - 0.5)+1.)*dx;
1688   if(xx > x) xx -= dx;
1689   return xx;
1690 }
1691 //=============================================================
1692 double AtLeast(double x, double dx)
1693 {
1694   double xx;
1695
1696   xx = (double)(floor(x/dx - 0.5)+1.)*dx;
1697   if(xx < x) xx += dx;
1698   return xx;
1699 }
1700 //=============================================================
1701 double LessThan(double x,double dx)
1702 {
1703   double xx;
1704
1705   xx = (double)(floor(x/dx - 0.5)+1.)*dx;
1706   if(xx >= x) xx -= dx;
1707   return xx;
1708 }
1709 //=============================================================
1710 double MoreThan(double x,double dx)
1711 {
1712   double xx;
1713
1714   xx = (double)(floor(x/dx - 0.5)+1.)*dx;
1715   while(xx <= x)
1716     xx += dx;
1717   return xx;
1718 }
1719 //=============================================================
1720 void SubdividePlasma(int i0,int j0,int i1,int j1)
1721 {
1722   int i, j;
1723   double z1, z2;
1724   double r;      // NOTE: This is used to keep the random number sequence the same
1725                  //       when we fix a point. If we did NOT do this, then simply
1726                  //       fixing a point at its current value would change the entire
1727                  //       surface.
1728
1729   i = (i0+i1)/2;
1730   j = (j0+j1)/2;
1731   if(i1 > i0+1)
1732   {
1733     if(!xyz[i][j0].done)
1734     {
1735       xyz[i][j0].pp[2] = xyz[i0][j0].pp[2] +
1736         (xyz[i1][j0].pp[2] - xyz[i0][j0].pp[2])*(double)(i-i0)/(double)(i1-i0) +
1737         ((double)(i-i0))*(-Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX));
1738       xyz[i][j0].done = 1;
1739     }
1740     else
1741       r = rand();
1742     if((j1 > j0) && (!xyz[i][j1].done) )
1743     {
1744       xyz[i][j1].pp[2] = xyz[i0][j1].pp[2] +
1745         (xyz[i1][j1].pp[2] - xyz[i0][j1].pp[2])*(double)(i-i0)/(double)(i1-i0) +
1746         ((double)(i-i0))*(-Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX));
1747       xyz[i][j1].done = 1;
1748     }
1749     else
1750       r = rand();
1751   }
1752   if(j1 > j0 + 1)
1753   {
1754     if(!xyz[i0][j].done)
1755     {
1756       xyz[i0][j].pp[2] = xyz[i0][j0].pp[2] +
1757         (xyz[i0][j1].pp[2] - xyz[i0][j0].pp[2])*(double)(j-j0)/(double)(j1-j0) +
1758         ((double)(j-j0))*(-Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX));
1759       xyz[i0][j].done = 1;
1760     }
1761     else
1762       r = rand();
1763     if((i1 > i0) && (!xyz[i1][j].done))
1764     {
1765       xyz[i1][j].pp[2] = xyz[i1][j0].pp[2] +
1766         (xyz[i1][j1].pp[2] - xyz[i1][j0].pp[2])*(double)(j-j0)/(double)(j1-j0) +
1767         ((double)(j-j0))*(-Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX));
1768       xyz[i1][j].done = 1;
1769     }
1770     else
1771       r = rand();
1772   }
1773   if((i1 > i0+1) && (j1 > j0+1))
1774   {
1775     if(!xyz[i][j].done)
1776     {
1777       z1 = xyz[i0][j].pp[2] +
1778         (xyz[i1][j].pp[2] - xyz[i0][j].pp[2])*(double)(i-i0)/(double)(i1-i0);
1779       z2 = xyz[i][j0].pp[2] +
1780         (xyz[i][j1].pp[2] - xyz[i][j0].pp[2])*(double)(j-j0)/(double)(j1-j0);
1781       xyz[i][j].pp[2] = (z1+z2)/2. +
1782         ((double)(i-i0))*(-Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX));
1783       xyz[i][j].done = 1;
1784     }
1785     else
1786       r = rand();
1787   }
1788   if(i > i0+1 || j > j0+1)
1789     SubdividePlasma(i0,j0,i,j);
1790   if(i1 > i+1 || j > j0+1)
1791     SubdividePlasma(i,j0,i1,j);
1792   if(i > i0+1 || j1 > j0+1)
1793     SubdividePlasma(i0,j,i,j1);
1794   if(i1 > i+1 || j1 > j0+1)
1795     SubdividePlasma(i,j,i1,j1);
1796 }
1797 //==================================================================================
1798 void PlasmaCloud()
1799 {
1800   int i, j;
1801   /* use pp[2] values until done to avoid messing with a bunch of
1802      switch statements */
1803
1804   for(i=0; i<=NH; i++)
1805   {
1806     for(j=0; j<=NV; j++)
1807     {
1808       if(FixedPoint(i,j))
1809         xyz[i][j].done = 1;
1810       else
1811         xyz[i][j].done = 0;
1812     }
1813   }
1814
1815   switch(Plane)
1816   {
1817   case PLANE_XZ0:
1818   case PLANE_XZ1:
1819     for(i=0; i<=NH; i++)
1820     {
1821       for(j=0; j<=NV; j++)
1822       {
1823         if(xyz[i][j].fixed)
1824           xyz[i][j].pp[2] = xyz[i][j].fixed_value;
1825         else
1826           xyz[i][j].pp[2] = xyz[i][j].p[1];
1827       }
1828     }
1829     break;
1830   case PLANE_YZ0:
1831   case PLANE_YZ1:
1832     for(i=0; i<=NH; i++)
1833     {
1834       for(j=0; j<=NV; j++)
1835       {
1836         if(xyz[i][j].fixed)
1837           xyz[i][j].pp[2] = xyz[i][j].fixed_value;
1838         else
1839           xyz[i][j].pp[2] = xyz[i][j].p[0];
1840       }
1841     }
1842     break;
1843   default:
1844     for(i=0; i<=NH; i++)
1845     {
1846       for(j=0; j<=NV; j++)
1847       {
1848         if(xyz[i][j].fixed)
1849           xyz[i][j].pp[2] = xyz[i][j].fixed_value;
1850         else
1851           xyz[i][j].pp[2] = xyz[i][j].p[2];
1852       }
1853     }
1854     break;
1855   }
1856   SubdividePlasma(0,0,NH,NV);
1857   switch(Plane)
1858   {
1859   case PLANE_XZ0:
1860   case PLANE_XZ1:
1861     for(i=0; i<=NH; i++)
1862     {
1863       for(j=0; j<=NV; j++)
1864       {
1865         xyz[i][j].p[1] = xyz[i][j].pp[2];
1866       }
1867     }
1868     break;
1869   case PLANE_YZ0:
1870   case PLANE_YZ1:
1871     for(i=0; i<=NH; i++)
1872     {
1873       for(j=0; j<=NV; j++)
1874       {
1875         xyz[i][j].p[0] = xyz[i][j].pp[2];
1876       }
1877     }
1878     break;
1879   default:
1880     for(i=0; i<=NH; i++)
1881     {
1882       for(j=0; j<=NV; j++)
1883       {
1884         xyz[i][j].p[2] = xyz[i][j].pp[2];
1885       }
1886     }
1887     break;
1888   }
1889 }
1890 //===========================================================================
1891 bool FixedPoint(int i, int j)
1892 {
1893   if(xyz[i][j].fixed) return TRUE;
1894   return !CanEdit(i,j);
1895 }
1896 //===========================================================================
1897 bool CanEdit(int i, int j)
1898 {
1899   if(FixBorders && ( (WaveType==WAVE_COS_SIN) || (WaveType==WAVE_ROUGH_ONLY) ) )
1900   {
1901     if(i== 0) return FALSE;
1902     if(i==NH) return FALSE;
1903     if(j== 0) return FALSE;
1904     if(j==NV) return FALSE;
1905   }
1906   if(i== 0 && j== 0) return FALSE;
1907   if(i==NH && j== 0) return FALSE;
1908   if(i== 0 && j==NV) return FALSE;
1909   if(i==NH && j==NV) return FALSE;
1910   return TRUE;
1911 }
1912 /*============================================================================
1913   TriangleFromPoint
1914   Determines which triangle in the gTri array bounds the input point. Doesn't
1915   do anything special with border points.
1916 */
1917 int TriangleFromPoint(double x, double y)
1918 {
1919   int j, tri;
1920
1921   if(!gTri) return -1;
1922
1923   for(j=0, tri=-1; j<gNumTris && tri==-1; j++)
1924   {
1925     if( side(x,y,
1926       gNode[gTri[j].v[0]].p[0],gNode[gTri[j].v[0]].p[1],
1927       gNode[gTri[j].v[1]].p[0],gNode[gTri[j].v[1]].p[1]) < 0. ) continue;
1928     if( side(x,y,
1929       gNode[gTri[j].v[1]].p[0],gNode[gTri[j].v[1]].p[1],
1930       gNode[gTri[j].v[2]].p[0],gNode[gTri[j].v[2]].p[1]) < 0. ) continue;
1931     if( side(x,y,
1932       gNode[gTri[j].v[2]].p[0],gNode[gTri[j].v[2]].p[1],
1933       gNode[gTri[j].v[0]].p[0],gNode[gTri[j].v[0]].p[1]) < 0. ) continue;
1934     tri = j;
1935   }
1936
1937   return tri;
1938 }
1939 /*============================================================================
1940   PlayerStartZ
1941   Determines minimum height to place the player start such that he doesn't
1942   intersect any surface brushes.
1943 */
1944 int PlayerStartZ(double x, double y)
1945 {
1946   int k,t[5];
1947   double z, zt;
1948
1949   if(!gTri) return (int)zmax;
1950
1951   t[0] = TriangleFromPoint(x,y);
1952   t[1] = TriangleFromPoint(x+PlayerBox[Game].x[0],y+PlayerBox[Game].y[0]);
1953   t[2] = TriangleFromPoint(x+PlayerBox[Game].x[0],y+PlayerBox[Game].y[1]);
1954   t[3] = TriangleFromPoint(x+PlayerBox[Game].x[1],y+PlayerBox[Game].y[0]);
1955   t[4] = TriangleFromPoint(x+PlayerBox[Game].x[1],y+PlayerBox[Game].y[1]);
1956   z = zmin;
1957   for(k=0; k<5; k++)
1958   {
1959     zt = (gTri[t[k]].plane.dist -
1960           gTri[t[k]].plane.normal[0]*x -
1961           gTri[t[k]].plane.normal[1]*y   )/
1962           gTri[t[k]].plane.normal[2];
1963     z = max(z,zt);
1964   }
1965   return (int)(AtLeast(z,2.) - PlayerBox[Game].z[0]);
1966 }
1967 //=============================================================
1968 void XYZtoV(XYZ *xyz, vec3 *v)
1969 {
1970   v[0][0] = (vec)Nearest(xyz->p[0],2.);
1971   v[0][1] = (vec)Nearest(xyz->p[1],2.);
1972   v[0][2] = (vec)Nearest(xyz->p[2],2.);
1973 }
1974
1975 //=============================================================
1976 scene::Node* MakePatch(void)
1977 {
1978   scene::Node* patch = Patch_AllocNode();
1979 #if 0
1980   patch->m_patch->SetShader(Texture[Game][0]);
1981 #endif
1982   Node_getTraversable(h_worldspawn)->insert(patch);
1983   return patch;
1984 }
1985
1986 //=============================================================
1987 void MakeBrush(BRUSH *brush)
1988 {
1989   NodePtr node(Brush_AllocNode());
1990
1991 #if 0
1992   for(int i=0; i<brush->NumFaces; i++)
1993   {
1994     _QERFaceData QERFaceData;
1995     if(!strncmp(brush->face[i].texture, "textures/", 9))
1996       strcpy(QERFaceData.m_TextureName,brush->face[i].texture);
1997     else
1998     {
1999       strcpy(QERFaceData.m_TextureName,"textures/");
2000       strcpy(QERFaceData.m_TextureName+9,brush->face[i].texture);
2001     }
2002     QERFaceData.m_nContents = brush->face[i].Contents;
2003     QERFaceData.m_nFlags    = brush->face[i].Surface;
2004     QERFaceData.m_nValue    = brush->face[i].Value;
2005     QERFaceData.m_fShift[0] = brush->face[i].Shift[0];
2006     QERFaceData.m_fShift[1] = brush->face[i].Shift[1];
2007     QERFaceData.m_fRotate   = brush->face[i].Rotate;
2008     QERFaceData.m_fScale[0] = brush->face[i].Scale[0];
2009     QERFaceData.m_fScale[1] = brush->face[i].Scale[1];
2010     QERFaceData.m_v1[0]     = brush->face[i].v[0][0];
2011     QERFaceData.m_v1[1]     = brush->face[i].v[0][1];
2012     QERFaceData.m_v1[2]     = brush->face[i].v[0][2];
2013     QERFaceData.m_v2[0]     = brush->face[i].v[1][0];
2014     QERFaceData.m_v2[1]     = brush->face[i].v[1][1];
2015     QERFaceData.m_v2[2]     = brush->face[i].v[1][2];
2016     QERFaceData.m_v3[0]     = brush->face[i].v[2][0];
2017     QERFaceData.m_v3[1]     = brush->face[i].v[2][1];
2018     QERFaceData.m_v3[2]     = brush->face[i].v[2][2];
2019     QERFaceData.m_bBPrimit  = false;
2020     (g_FuncTable.m_pfnAddFaceData)(vp,&QERFaceData);
2021   }
2022 #endif
2023
2024   Node_getTraversable(h_func_group)->insert(node);
2025 }
2026 //=============================================================
2027 void OpenFuncGroup()
2028 {
2029   h_func_group = GlobalEntityCreator().createEntity("func_group");
2030   h_func_group->IncRef();
2031   if(AddTerrainKey)
2032     h_func_group->m_entity->setkeyvalue("terrain", "1");
2033 }
2034 //=============================================================
2035 void CloseFuncGroup()
2036 {
2037   h_func_group->DecRef();
2038   if (g_FuncTable.m_pfnSysUpdateWindows != NULL)
2039     g_FuncTable.m_pfnSysUpdateWindows (W_ALL);
2040 }