--- /dev/null
+/*
+GenSurf plugin for GtkRadiant
+Copyright (C) 2001 David Hyde, Loki software and qeradiant.com
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "gensurf.h"
+
+double xmin,xmax,ymin,ymax,zmin,zmax;
+double backface;
+extern double dh, dv;
+FILE *fmap;
+XYZ xyz[MAX_ROWS+1][MAX_ROWS+1];
+int contents;
+int surface[3];
+
+#include "iundo.h"
+
+#include "refcounted_ptr.h"
+
+#include <vector>
+#include <list>
+#include <map>
+#include <algorithm>
+
+#include "scenelib.h"
+
+scene::Node* h_func_group;
+scene::Node* h_worldspawn;
+
+
+//=============================================================
+// Hydra : snap-to-grid begin
+double CalculateSnapValue(double value)
+{
+ long snapvalue;
+
+ // simple uncomplicated snapping, rounding both UP and DOWN to the nearest
+ // grid unit.
+ if (SnapToGrid >0)
+ {
+ snapvalue = (int)value / SnapToGrid;
+ if ((long)value % SnapToGrid < (SnapToGrid / 2)) // Snap Downwards if less than halfway between to grid units
+ value = snapvalue * SnapToGrid;
+ else // Snap Upwards if more than halfway between to grid units
+ value = (snapvalue+1) * SnapToGrid;
+ }
+ return value;
+}
+// Hydra : snap-to-grid end
+
+//=============================================================
+bool ValidSurface()
+{
+ if(WaveType == WAVE_BITMAP && !gbmp.colors) return FALSE;
+ if(NH < 1) return FALSE;
+ if(NH > MAX_ROWS) return FALSE;
+ if(NV < 1) return FALSE;
+ if(NV > MAX_ROWS) return FALSE;
+ if(Hll >= Hur) return FALSE;
+ if(Vll >= Vur) return FALSE;
+ return TRUE;
+}
+
+//=============================================================
+int MapPatches()
+{
+ int NH_remain;
+ int NV_remain;
+ int NH_patch;
+ int NV_patch;
+ int BrushNum = 0;
+ int i, j, k1, k2, k3;
+ int i0, j0, ii;
+ char szOops[128];
+
+ dh = (Hur-Hll)/NH;
+ dv = (Vur-Vll)/NV;
+
+ // Generate control points in pp array to give desired values currently
+ // in p array.
+ switch(Plane)
+ {
+ case PLANE_XY0:
+ case PLANE_XY1:
+ k1 = 0;
+ k2 = 1;
+ k3 = 2;
+ break;
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ k1 = 0;
+ k2 = 2;
+ k3 = 1;
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ k1 = 1;
+ k2 = 2;
+ k3 = 0;
+ break;
+ }
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ xyz[i][j].pp[k1] = xyz[i][j].p[k1];
+ xyz[i][j].pp[k2] = xyz[i][j].p[k2];
+ }
+ }
+ for(i=0; i<=NH; i+=2)
+ {
+ for(j=0; j<=NV; j+=2)
+ xyz[i][j].pp[k3] = xyz[i][j].p[k3];
+ }
+ for(i=1; i<NH; i+=2)
+ {
+ for(j=0; j<=NV; j+=2)
+ {
+ xyz[i][j].pp[k3] = (4*xyz[i][j].p[k3] - xyz[i-1][j].p[k3] - xyz[i+1][j].p[k3])/2;
+ }
+ }
+ for(j=1; j<NV; j+=2)
+ {
+ for(i=0; i<=NH; i+=2)
+ {
+ xyz[i][j].pp[k3] = (4*xyz[i][j].p[k3] - xyz[i][j-1].p[k3] - xyz[i][j+1].p[k3])/2;
+ }
+ }
+ for(i=1; i<NH; i+=2)
+ {
+ for(j=1; j<NV; j+=2)
+ {
+ 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]
+ - xyz[i+1][j-1].p[k3] - 2*xyz[i-1][j].p[k3] - 2*xyz[i+1][j].p[k3]
+ - xyz[i-1][j+1].p[k3] - 2*xyz[i][j+1].p[k3] - xyz[i+1][j+1].p[k3])/4;
+ }
+ }
+
+ NH_remain = NH+1;
+ i0 = 0;
+ while(NH_remain > 1)
+ {
+ if(( (NH_remain-1) % 14) == 0)
+ NH_patch = 15;
+ else if(( (NH_remain-1) % 12) == 0)
+ NH_patch = 13;
+ else if(( (NH_remain-1) % 10) == 0)
+ NH_patch = 11;
+ else if(( (NH_remain-1) % 8) == 0)
+ NH_patch = 9;
+ else if(( (NH_remain-1) % 6) == 0)
+ NH_patch = 7;
+ else if(( (NH_remain-1) % 4) == 0)
+ NH_patch = 5;
+ else if(( (NH_remain-1) % 2) == 0)
+ NH_patch = 3;
+ else if(NH_remain > 16)
+ NH_patch = 7;
+ else if(NH_remain > 4)
+ NH_patch = 5;
+ else
+ NH_patch = 3;
+ while( NH_patch > 3 && (NH_patch-1)*dh > 512 )
+ NH_patch -= 2;
+ NH_remain -= (NH_patch-1);
+ if(NH_remain < 0)
+ {
+ sprintf(szOops,"Oops... screwed up with NH=%d",NH);
+ g_FuncTable.m_pfnMessageBox(NULL,szOops,"Uh oh");
+ }
+ NV_remain = NV+1;
+ j0 = 0;
+ while(NV_remain > 1)
+ {
+ if(( (NV_remain-1) % 14) == 0)
+ NV_patch = 15;
+ else if(( (NV_remain-1) % 12) == 0)
+ NV_patch = 13;
+ else if(( (NV_remain-1) % 10) == 0)
+ NV_patch = 11;
+ else if(( (NV_remain-1) % 8) == 0)
+ NV_patch = 9;
+ else if(( (NV_remain-1) % 6) == 0)
+ NV_patch = 7;
+ else if(( (NV_remain-1) % 4) == 0)
+ NV_patch = 5;
+ else if(( (NV_remain-1) % 2) == 0)
+ NV_patch = 3;
+ else if(NV_remain > 16)
+ NV_patch = 7;
+ else if(NV_remain > 4)
+ NV_patch = 5;
+ else
+ NV_patch = 3;
+ while( NV_patch > 3 && (NV_patch-1)*dh > 512 )
+ NV_patch -= 2;
+ NV_remain -= (NV_patch-1);
+ if(NV_remain < 0)
+ {
+ sprintf(szOops,"Oops... screwed up with NV=%d",NV);
+ g_FuncTable.m_pfnMessageBox(NULL,szOops,"Uh oh");
+ }
+
+ scene::Node* patch = MakePatch();
+#if 0
+ b->pPatch->setDims(NH_patch, NV_patch);
+ for(i=0; i<NH_patch; i++)
+ {
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ0:
+ case PLANE_YZ1:
+ ii = i0 + NH_patch - 1 - i;
+ break;
+ default:
+ ii = i0+i;
+ }
+ for(j=0; j<NV_patch; j++)
+ {
+ b->pPatch->ctrlAt(COL,i,j)[0] = (float)xyz[ii][j0+j].pp[0];
+ b->pPatch->ctrlAt(COL,i,j)[1] = (float)xyz[ii][j0+j].pp[1];
+ b->pPatch->ctrlAt(COL,i,j)[2] = (float)xyz[ii][j0+j].pp[2];
+ b->pPatch->ctrlAt(COL,i,j)[3] = (float)i;
+ b->pPatch->ctrlAt(COL,i,j)[4] = (float)j;
+ }
+ }
+ b->pPatch->UpdateCachedData();
+#endif
+ BrushNum++;
+ j0 += NV_patch-1;
+ }
+ i0 += NH_patch-1;
+ }
+ return BrushNum;
+}
+
+//=============================================================
+void MapBrushes()
+{
+ char hint[128];
+ char skip[128];
+ char sidetext[64];
+ char surftext[64];
+ char surftext2[64];
+ char surft[64];
+ float Steep;
+ vec3_t PlaneNormal,SurfNormal;
+ vec3_t t[2];
+ int i, j, k;
+ int surf;
+ bool CheckAngle;
+ BRUSH brush;
+ XYZ v[8];
+
+ strcpy(surftext,Texture[Game][0]);
+ strcpy(sidetext,(strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
+ strcpy(surftext2,(strlen(Texture[Game][2]) ? Texture[Game][2] : Texture[Game][0]));
+
+ // if surftext2 is identical to surftext, there's no need to
+ // check surface angle
+ if(!g_strcasecmp(surftext,surftext2))
+ CheckAngle = FALSE;
+ else
+ {
+ CheckAngle = TRUE;
+ Steep = (float)cos((double)SlantAngle/57.2957795);
+ switch(Plane)
+ {
+ case PLANE_XY0: PlaneNormal[0]= 0.;PlaneNormal[1]= 0.;PlaneNormal[2]= 1.;break;
+ case PLANE_XY1: PlaneNormal[0]= 0.;PlaneNormal[1]= 0.;PlaneNormal[2]=-1.;break;
+ case PLANE_XZ0: PlaneNormal[0]= 0.;PlaneNormal[1]= 1.;PlaneNormal[2]= 1.;break;
+ case PLANE_XZ1: PlaneNormal[0]= 0.;PlaneNormal[1]=-1.;PlaneNormal[2]= 1.;break;
+ case PLANE_YZ0: PlaneNormal[0]= 1.;PlaneNormal[1]= 0.;PlaneNormal[2]= 1.;break;
+ case PLANE_YZ1: PlaneNormal[0]=-1.;PlaneNormal[1]= 0.;PlaneNormal[2]= 1.;break;
+ }
+ }
+
+ OpenFuncGroup();
+
+ for(i=0; i<NH; i++)
+ {
+ for(j=0; j<NV; j++)
+ {
+ if( (i+j) % 2 )
+ {
+ VectorCopy(xyz[i ][j ].p, v[0].p);
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ1:
+ case PLANE_YZ1:
+ VectorCopy(xyz[i+1][j ].p, v[1].p);
+ VectorCopy(xyz[i+1][j+1].p, v[2].p);
+ break;
+ default:
+ VectorCopy(xyz[i+1][j+1].p, v[1].p);
+ VectorCopy(xyz[i+1][j ].p, v[2].p);
+ }
+ }
+ else
+ {
+ VectorCopy(xyz[i ][j ].p, v[0].p);
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ1:
+ case PLANE_YZ1:
+ VectorCopy(xyz[i+1][j ].p, v[1].p);
+ VectorCopy(xyz[i ][j+1].p, v[2].p);
+ break;
+ default:
+ VectorCopy(xyz[i ][j+1].p, v[1].p);
+ VectorCopy(xyz[i+1][j ].p, v[2].p);
+ }
+ }
+ VectorCopy(v[0].p,v[3].p);
+ VectorCopy(v[1].p,v[4].p);
+ VectorCopy(v[2].p,v[5].p);
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ v[0].p[1] = backface;
+ v[1].p[1] = backface;
+ v[2].p[1] = backface;
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ v[3].p[0] = backface;
+ v[4].p[0] = backface;
+ v[5].p[0] = backface;
+ break;
+ default:
+ v[3].p[2] = backface;
+ v[4].p[2] = backface;
+ v[5].p[2] = backface;
+ }
+
+ brush.Number = i*NV*2+j*2;
+ brush.NumFaces = 5;
+ XYZtoV(&v[0],&brush.face[0].v[0]);
+ XYZtoV(&v[3],&brush.face[0].v[1]);
+ XYZtoV(&v[4],&brush.face[0].v[2]);
+ strcpy(brush.face[0].texture,
+ (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
+ brush.face[0].Shift[0] = (float)TexOffset[0];
+ brush.face[0].Shift[1] = (float)TexOffset[1];
+ brush.face[0].Rotate = 0.;
+ brush.face[0].Scale[0] = (float)TexScale[0];
+ brush.face[0].Scale[1] = (float)TexScale[1];
+ brush.face[0].Contents = contents;
+ brush.face[0].Surface = surface[1];
+ brush.face[0].Value = 0;
+
+ XYZtoV(&v[1],&brush.face[1].v[0]);
+ XYZtoV(&v[4],&brush.face[1].v[1]);
+ XYZtoV(&v[5],&brush.face[1].v[2]);
+ strcpy(brush.face[1].texture,
+ (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
+ brush.face[1].Shift[0] = (float)TexOffset[0];
+ brush.face[1].Shift[1] = (float)TexOffset[1];
+ brush.face[1].Rotate = 0.;
+ brush.face[1].Scale[0] = (float)TexScale[0];
+ brush.face[1].Scale[1] = (float)TexScale[1];
+ brush.face[1].Contents = contents;
+ brush.face[1].Surface = surface[1];
+ brush.face[1].Value = 0;
+
+ XYZtoV(&v[2],&brush.face[2].v[0]);
+ XYZtoV(&v[5],&brush.face[2].v[1]);
+ XYZtoV(&v[3],&brush.face[2].v[2]);
+ strcpy(brush.face[2].texture,
+ (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
+ brush.face[2].Shift[0] = (float)TexOffset[0];
+ brush.face[2].Shift[1] = (float)TexOffset[1];
+ brush.face[2].Rotate = 0.;
+ brush.face[2].Scale[0] = (float)TexScale[0];
+ brush.face[2].Scale[1] = (float)TexScale[1];
+ brush.face[2].Contents = contents;
+ brush.face[2].Surface = surface[1];
+ brush.face[2].Value = 0;
+
+ if(CheckAngle && (Plane==PLANE_XZ0 || Plane==PLANE_XZ1))
+ {
+ XYZVectorSubtract(v[4].p,v[3].p,t[0]);
+ XYZVectorSubtract(v[5].p,v[4].p,t[1]);
+ CrossProduct(t[0],t[1],SurfNormal);
+ VectorNormalize(SurfNormal,SurfNormal);
+ if(DotProduct(SurfNormal,PlaneNormal) < Steep)
+ {
+ strcpy(surft,surftext2);
+ surf = surface[2];
+ }
+ else
+ {
+ strcpy(surft,surftext);
+ surf = surface[0];
+ }
+ }
+ else
+ {
+ strcpy(surft,surftext);
+ surf = surface[0];
+ }
+
+ XYZtoV(&v[3],&brush.face[3].v[0]);
+ XYZtoV(&v[5],&brush.face[3].v[1]);
+ XYZtoV(&v[4],&brush.face[3].v[2]);
+ strcpy(brush.face[3].texture,
+ (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surft : sidetext));
+ brush.face[3].Shift[0] = (float)TexOffset[0];
+ brush.face[3].Shift[1] = (float)TexOffset[1];
+ brush.face[3].Rotate = 0.;
+ brush.face[3].Scale[0] = (float)TexScale[0];
+ brush.face[3].Scale[1] = (float)TexScale[1];
+ brush.face[3].Contents = contents;
+ brush.face[3].Surface = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surf : surface[1]);
+ brush.face[3].Value = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? ArghRad2 : 0);
+
+ if(CheckAngle && Plane!=PLANE_XZ0 && Plane!=PLANE_XZ1)
+ {
+ XYZVectorSubtract(v[2].p,v[0].p,t[0]);
+ XYZVectorSubtract(v[1].p,v[2].p,t[1]);
+ CrossProduct(t[0],t[1],SurfNormal);
+ VectorNormalize(SurfNormal,SurfNormal);
+ if(DotProduct(SurfNormal,PlaneNormal) < Steep)
+ {
+ strcpy(surft,surftext2);
+ surf = surface[2];
+ }
+ else
+ {
+ strcpy(surft,surftext);
+ surf = surface[0];
+ }
+ }
+ else
+ {
+ strcpy(surft,surftext);
+ surf = surface[0];
+ }
+
+ XYZtoV(&v[0],&brush.face[4].v[0]);
+ XYZtoV(&v[1],&brush.face[4].v[1]);
+ XYZtoV(&v[2],&brush.face[4].v[2]);
+ strcpy(brush.face[4].texture,
+ (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? sidetext : surft));
+ brush.face[4].Shift[0] = (float)TexOffset[0];
+ brush.face[4].Shift[1] = (float)TexOffset[1];
+ brush.face[4].Rotate = 0.;
+ brush.face[4].Scale[0] = (float)TexScale[0];
+ brush.face[4].Scale[1] = (float)TexScale[1];
+ brush.face[4].Contents = contents;
+ brush.face[4].Surface = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surface[1] : surf);
+ brush.face[4].Value = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? 0 : ArghRad2);
+
+ MakeBrush(&brush);
+ if( (i+j) %2 )
+ {
+ VectorCopy(xyz[i ][j+1].p,v[0].p);
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ1:
+ case PLANE_YZ1:
+ VectorCopy(xyz[i ][j ].p,v[1].p);
+ VectorCopy(xyz[i+1][j+1].p,v[2].p);
+ break;
+ default:
+ VectorCopy(xyz[i+1][j+1].p,v[1].p);
+ VectorCopy(xyz[i ][j ].p,v[2].p);
+ }
+ }
+ else
+ {
+ VectorCopy(xyz[i ][j+1].p,v[0].p);
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ1:
+ case PLANE_YZ1:
+ VectorCopy(xyz[i+1][j ].p,v[1].p);
+ VectorCopy(xyz[i+1][j+1].p,v[2].p);
+ break;
+ default:
+ VectorCopy(xyz[i+1][j+1].p,v[1].p);
+ VectorCopy(xyz[i+1][j ].p,v[2].p);
+ }
+ }
+ VectorCopy(v[0].p,v[3].p);
+ VectorCopy(v[1].p,v[4].p);
+ VectorCopy(v[2].p,v[5].p);
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ v[0].p[1] = backface;
+ v[1].p[1] = backface;
+ v[2].p[1] = backface;
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ v[3].p[0] = backface;
+ v[4].p[0] = backface;
+ v[5].p[0] = backface;
+ break;
+ default:
+ v[3].p[2] = backface;
+ v[4].p[2] = backface;
+ v[5].p[2] = backface;
+ }
+ brush.Number = i*NV*2+j*2+1;
+ brush.NumFaces = 5;
+ XYZtoV(&v[0],&brush.face[0].v[0]);
+ XYZtoV(&v[3],&brush.face[0].v[1]);
+ XYZtoV(&v[4],&brush.face[0].v[2]);
+ strcpy(brush.face[0].texture,
+ (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
+ brush.face[0].Shift[0] = (float)TexOffset[0];
+ brush.face[0].Shift[1] = (float)TexOffset[1];
+ brush.face[0].Rotate = 0.;
+ brush.face[0].Scale[0] = (float)TexScale[0];
+ brush.face[0].Scale[1] = (float)TexScale[1];
+ brush.face[0].Contents = contents;
+ brush.face[0].Surface = surface[1];
+ brush.face[0].Value = 0;
+
+ XYZtoV(&v[1],&brush.face[1].v[0]);
+ XYZtoV(&v[4],&brush.face[1].v[1]);
+ XYZtoV(&v[5],&brush.face[1].v[2]);
+ strcpy(brush.face[1].texture,
+ (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
+ brush.face[1].Shift[0] = (float)TexOffset[0];
+ brush.face[1].Shift[1] = (float)TexOffset[1];
+ brush.face[1].Rotate = 0.;
+ brush.face[1].Scale[0] = (float)TexScale[0];
+ brush.face[1].Scale[1] = (float)TexScale[1];
+ brush.face[1].Contents = contents;
+ brush.face[1].Surface = surface[1];
+ brush.face[1].Value = 0;
+
+ XYZtoV(&v[2],&brush.face[2].v[0]);
+ XYZtoV(&v[5],&brush.face[2].v[1]);
+ XYZtoV(&v[3],&brush.face[2].v[2]);
+ strcpy(brush.face[2].texture,
+ (strlen(Texture[Game][1]) ? Texture[Game][1] : Texture[Game][0]));
+ brush.face[2].Shift[0] = (float)TexOffset[0];
+ brush.face[2].Shift[1] = (float)TexOffset[1];
+ brush.face[2].Rotate = 0.;
+ brush.face[2].Scale[0] = (float)TexScale[0];
+ brush.face[2].Scale[1] = (float)TexScale[1];
+ brush.face[2].Contents = contents;
+ brush.face[2].Surface = surface[1];
+ brush.face[2].Value = 0;
+
+ if(CheckAngle && (Plane==PLANE_XZ0 || Plane==PLANE_XZ1))
+ {
+ XYZVectorSubtract(v[4].p,v[3].p,t[0]);
+ XYZVectorSubtract(v[5].p,v[4].p,t[1]);
+ CrossProduct(t[0],t[1],SurfNormal);
+ VectorNormalize(SurfNormal,SurfNormal);
+ if(DotProduct(SurfNormal,PlaneNormal) < Steep)
+ {
+ strcpy(surft,surftext2);
+ surf = surface[2];
+ }
+ else
+ {
+ strcpy(surft,surftext);
+ surf = surface[0];
+ }
+ }
+ else
+ {
+ strcpy(surft,surftext);
+ surf = surface[0];
+ }
+ XYZtoV(&v[3],&brush.face[3].v[0]);
+ XYZtoV(&v[5],&brush.face[3].v[1]);
+ XYZtoV(&v[4],&brush.face[3].v[2]);
+ strcpy(brush.face[3].texture,
+ (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surft : sidetext));
+ brush.face[3].Shift[0] = (float)TexOffset[0];
+ brush.face[3].Shift[1] = (float)TexOffset[1];
+ brush.face[3].Rotate = 0.;
+ brush.face[3].Scale[0] = (float)TexScale[0];
+ brush.face[3].Scale[1] = (float)TexScale[1];
+ brush.face[3].Contents = contents;
+ brush.face[3].Surface = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surf : surface[1]);
+ brush.face[3].Value = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? ArghRad2 : 0);
+
+ if(CheckAngle && Plane!=PLANE_XZ0 && Plane!=PLANE_XZ1)
+ {
+ XYZVectorSubtract(v[2].p,v[0].p,t[0]);
+ XYZVectorSubtract(v[1].p,v[2].p,t[1]);
+ CrossProduct(t[0],t[1],SurfNormal);
+ VectorNormalize(SurfNormal,SurfNormal);
+ if(DotProduct(SurfNormal,PlaneNormal) < Steep)
+ {
+ strcpy(surft,surftext2);
+ surf = surface[2];
+ }
+ else
+ {
+ strcpy(surft,surftext);
+ surf = surface[0];
+ }
+ }
+ else
+ {
+ strcpy(surft,surftext);
+ surf = surface[0];
+ }
+ XYZtoV(&v[0],&brush.face[4].v[0]);
+ XYZtoV(&v[1],&brush.face[4].v[1]);
+ XYZtoV(&v[2],&brush.face[4].v[2]);
+ strcpy(brush.face[4].texture,
+ (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? sidetext : surft));
+ brush.face[4].Shift[0] = (float)TexOffset[0];
+ brush.face[4].Shift[1] = (float)TexOffset[1];
+ brush.face[4].Rotate = 0.;
+ brush.face[4].Scale[0] = (float)TexScale[0];
+ brush.face[4].Scale[1] = (float)TexScale[1];
+ brush.face[4].Contents = contents;
+ brush.face[4].Surface = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? surface[1] : surf);
+ brush.face[4].Value = (Plane==PLANE_XZ0 || Plane==PLANE_XZ1 ? 0 : ArghRad2);
+
+ MakeBrush(&brush);
+ }
+ }
+ CloseFuncGroup();
+
+ if( AddHints || GimpHints )
+ {
+ int detail, i1, j1, N;
+ double front;
+
+ switch(Game)
+ {
+ case HALFLIFE:
+ strcpy(hint,"HINT");
+ strcpy(skip,"HINT");
+ break;
+ case SIN:
+ strcpy(hint,"generic/misc/hint");
+ strcpy(skip,"generic/misc/skip");
+ break;
+ case HERETIC2:
+ strcpy(hint,"general/hint");
+ strcpy(skip,"general/hint"); // Heretic2 doesn't have a skip texture
+ break;
+ case KINGPIN:
+ strcpy(hint,"common/0_hint");
+ strcpy(skip,"common/0_skip");
+ break;
+ case GENESIS3D:
+ strcpy(hint,"hint");
+ strcpy(skip,"hint");
+ break;
+ case QUAKE3:
+ strcpy(hint,"textures/common/hint");
+ strcpy(skip,"textures/common/skip");
+ break;
+ default:
+ strcpy(hint,"e1u1/hint");
+ strcpy(skip,"e1u1/skip");
+ }
+
+ OpenFuncGroup();
+
+ if(AddHints==1)
+ {
+ detail = CONTENTS_DETAIL;
+ N = 0;
+ for(i=0; i<NH; i++)
+ {
+ i1 = i+1;
+
+ for(j=0; j<NV; j++)
+ {
+
+ // For detail hint brushes, no need to use a hint brush over
+ // EVERY grid square... it would be redundant. Instead use
+ // a checkerboard pattern
+ if((i+j)%2) continue;
+
+ j1 = j+1;
+
+ VectorCopy(xyz[i ][j ].p, v[0].p);
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ1:
+ case PLANE_YZ1:
+ VectorCopy(xyz[i1][j ].p, v[1].p);
+ VectorCopy(xyz[i1][j1].p, v[2].p);
+ VectorCopy(xyz[i ][j1].p, v[3].p);
+ break;
+ default:
+ VectorCopy(xyz[i ][j1].p, v[1].p);
+ VectorCopy(xyz[i1][j1].p, v[2].p);
+ VectorCopy(xyz[i1][j ].p, v[3].p);
+ }
+
+ VectorCopy(v[0].p,v[4].p);
+ VectorCopy(v[1].p,v[5].p);
+ VectorCopy(v[2].p,v[6].p);
+ VectorCopy(v[3].p,v[7].p);
+
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ front = LessThan(zmin,32.);
+ v[4].p[2] = backface;
+ v[5].p[2] = backface;
+ v[6].p[2] = backface;
+ v[7].p[2] = backface;
+ break;
+ case PLANE_XZ0:
+ front = MoreThan(ymax,32.);
+ v[0].p[1] = backface;
+ v[1].p[1] = backface;
+ v[2].p[1] = backface;
+ v[3].p[1] = backface;
+ break;
+ case PLANE_XZ1:
+ front = LessThan(ymin,32.);
+ v[0].p[1] = backface;
+ v[1].p[1] = backface;
+ v[2].p[1] = backface;
+ v[3].p[1] = backface;
+ break;
+ case PLANE_YZ0:
+ front = MoreThan(xmax,32.);
+ v[4].p[0] = backface;
+ v[5].p[0] = backface;
+ v[6].p[0] = backface;
+ v[7].p[0] = backface;
+ break;
+ case PLANE_YZ1:
+ front = LessThan(xmin,32.);
+ v[4].p[0] = backface;
+ v[5].p[0] = backface;
+ v[6].p[0] = backface;
+ v[7].p[0] = backface;
+ break;
+ default:
+ front = MoreThan(zmax,32.);
+ v[4].p[2] = backface;
+ v[5].p[2] = backface;
+ v[6].p[2] = backface;
+ v[7].p[2] = backface;
+ }
+
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ v[4].p[1] = front;
+ v[5].p[1] = v[4].p[1];
+ v[6].p[1] = v[4].p[1];
+ v[7].p[1] = v[4].p[1];
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ v[0].p[0] = front;
+ v[1].p[0] = v[0].p[0];
+ v[2].p[0] = v[0].p[0];
+ v[3].p[0] = v[0].p[0];
+ break;
+ default:
+ v[0].p[2] = front;
+ v[1].p[2] = v[0].p[2];
+ v[2].p[2] = v[0].p[2];
+ v[3].p[2] = v[0].p[2];
+ }
+
+ brush.NumFaces = 6;
+ brush.Number = N;
+ XYZtoV(&v[0],&brush.face[0].v[0]);
+ XYZtoV(&v[1],&brush.face[0].v[1]);
+ XYZtoV(&v[2],&brush.face[0].v[2]);
+ strcpy(brush.face[0].texture,skip);
+ brush.face[0].Shift[0] = 0.;
+ brush.face[0].Shift[1] = 0.;
+ brush.face[0].Rotate = 0.;
+ brush.face[0].Scale[0] = 1.;
+ brush.face[0].Scale[1] = 1.;
+ brush.face[0].Contents = detail;
+ brush.face[0].Surface = SURF_SKIP;
+ brush.face[0].Value = 0;
+
+ XYZtoV(&v[4],&brush.face[1].v[0]);
+ XYZtoV(&v[7],&brush.face[1].v[1]);
+ XYZtoV(&v[6],&brush.face[1].v[2]);
+ strcpy(brush.face[1].texture,skip);
+ brush.face[1].Shift[0] = 0.;
+ brush.face[1].Shift[1] = 0.;
+ brush.face[1].Rotate = 0.;
+ brush.face[1].Scale[0] = 1.;
+ brush.face[1].Scale[1] = 1.;
+ brush.face[1].Contents = detail;
+ brush.face[1].Surface = SURF_SKIP;
+ brush.face[1].Value = 0;
+
+ XYZtoV(&v[0],&brush.face[2].v[0]);
+ XYZtoV(&v[4],&brush.face[2].v[1]);
+ XYZtoV(&v[5],&brush.face[2].v[2]);
+ strcpy(brush.face[2].texture,hint);
+ brush.face[2].Shift[0] = 0.;
+ brush.face[2].Shift[1] = 0.;
+ brush.face[2].Rotate = 0.;
+ brush.face[2].Scale[0] = 1.;
+ brush.face[2].Scale[1] = 1.;
+ brush.face[2].Contents = detail;
+ brush.face[2].Surface = SURF_HINT;
+ brush.face[2].Value = 0;
+
+ XYZtoV(&v[1],&brush.face[3].v[0]);
+ XYZtoV(&v[5],&brush.face[3].v[1]);
+ XYZtoV(&v[6],&brush.face[3].v[2]);
+ strcpy(brush.face[3].texture,hint);
+ brush.face[3].Shift[0] = 0.;
+ brush.face[3].Shift[1] = 0.;
+ brush.face[3].Rotate = 0.;
+ brush.face[3].Scale[0] = 1.;
+ brush.face[3].Scale[1] = 1.;
+ brush.face[3].Contents = detail;
+ brush.face[3].Surface = SURF_HINT;
+ brush.face[3].Value = 0;
+
+ XYZtoV(&v[2],&brush.face[4].v[0]);
+ XYZtoV(&v[6],&brush.face[4].v[1]);
+ XYZtoV(&v[7],&brush.face[4].v[2]);
+ strcpy(brush.face[4].texture,hint);
+ brush.face[4].Shift[0] = 0.;
+ brush.face[4].Shift[1] = 0.;
+ brush.face[4].Rotate = 0.;
+ brush.face[4].Scale[0] = 1.;
+ brush.face[4].Scale[1] = 1.;
+ brush.face[4].Contents = detail;
+ brush.face[4].Surface = SURF_HINT;
+ brush.face[4].Value = 0;
+
+ XYZtoV(&v[3],&brush.face[5].v[0]);
+ XYZtoV(&v[7],&brush.face[5].v[1]);
+ XYZtoV(&v[4],&brush.face[5].v[2]);
+ strcpy(brush.face[5].texture,hint);
+ brush.face[5].Shift[0] = 0.;
+ brush.face[5].Shift[1] = 0.;
+ brush.face[5].Rotate = 0.;
+ brush.face[5].Scale[0] = 1.;
+ brush.face[5].Scale[1] = 1.;
+ brush.face[5].Contents = detail;
+ brush.face[5].Surface = SURF_HINT;
+ brush.face[5].Value = 0;
+
+ MakeBrush(&brush);
+ N++;
+ }
+ }
+ }
+ if(GimpHints)
+ {
+ N = 0;
+ // these brush parameters never change
+ brush.NumFaces = 5;
+ for(i=0; i<6; i++)
+ {
+ strcpy(brush.face[i].texture,hint);
+ brush.face[i].Shift[0] = 0.;
+ brush.face[i].Shift[1] = 0.;
+ brush.face[i].Rotate = 0.;
+ brush.face[i].Scale[0] = 1.;
+ brush.face[i].Scale[1] = 1.;
+ brush.face[i].Contents = 0;
+ brush.face[i].Surface = SURF_HINT;
+ brush.face[i].Value = 0;
+ }
+ for(i=0; i<NH; i++)
+ {
+ for(j=0; j<NV; j++)
+ {
+ for(k=0; k<2; k++)
+ {
+ if(k==0)
+ {
+ if( (i+j) % 2 )
+ {
+ VectorCopy(xyz[i ][j ].p, v[0].p);
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ1:
+ case PLANE_YZ1:
+ VectorCopy(xyz[i+1][j ].p, v[1].p);
+ VectorCopy(xyz[i+1][j+1].p, v[2].p);
+ break;
+ default:
+ VectorCopy(xyz[i+1][j+1].p, v[1].p);
+ VectorCopy(xyz[i+1][j ].p, v[2].p);
+ }
+ }
+ else
+ {
+ VectorCopy(xyz[i ][j ].p, v[0].p);
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ1:
+ case PLANE_YZ1:
+ VectorCopy(xyz[i+1][j ].p, v[1].p);
+ VectorCopy(xyz[i ][j+1].p, v[2].p);
+ break;
+ default:
+ VectorCopy(xyz[i ][j+1].p, v[1].p);
+ VectorCopy(xyz[i+1][j ].p, v[2].p);
+ }
+ }
+ }
+ else
+ {
+ if( (i+j) %2 )
+ {
+ VectorCopy(xyz[i ][j+1].p,v[0].p);
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ1:
+ case PLANE_YZ1:
+ VectorCopy(xyz[i ][j ].p,v[1].p);
+ VectorCopy(xyz[i+1][j+1].p,v[2].p);
+ break;
+ default:
+ VectorCopy(xyz[i+1][j+1].p,v[1].p);
+ VectorCopy(xyz[i ][j ].p,v[2].p);
+ }
+ }
+ else
+ {
+ VectorCopy(xyz[i ][j+1].p,v[0].p);
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ1:
+ case PLANE_YZ1:
+ VectorCopy(xyz[i+1][j ].p,v[1].p);
+ VectorCopy(xyz[i+1][j+1].p,v[2].p);
+ break;
+ default:
+ VectorCopy(xyz[i+1][j+1].p,v[1].p);
+ VectorCopy(xyz[i+1][j ].p,v[2].p);
+ }
+ }
+ }
+ VectorCopy(v[0].p,v[3].p);
+ VectorCopy(v[1].p,v[4].p);
+ VectorCopy(v[2].p,v[5].p);
+ switch(Plane)
+ {
+ case PLANE_XY0:
+ v[0].p[2] += HINT_OFFSET;
+ v[1].p[2] += HINT_OFFSET;
+ v[2].p[2] += HINT_OFFSET;
+// v[3].p[2] = backface;
+// v[4].p[2] = backface;
+// v[5].p[2] = backface;
+ break;
+ case PLANE_XY1:
+ v[0].p[2] -= HINT_OFFSET;
+ v[1].p[2] -= HINT_OFFSET;
+ v[2].p[2] -= HINT_OFFSET;
+// v[3].p[2] = backface;
+// v[4].p[2] = backface;
+// v[5].p[2] = backface;
+ break;
+ case PLANE_XZ0:
+// v[0].p[1] = backface;
+// v[1].p[1] = backface;
+// v[2].p[1] = backface;
+ v[3].p[1] += HINT_OFFSET;
+ v[4].p[1] += HINT_OFFSET;
+ v[5].p[1] += HINT_OFFSET;
+ break;
+ case PLANE_XZ1:
+// v[0].p[1] = backface;
+// v[1].p[1] = backface;
+// v[2].p[1] = backface;
+ v[3].p[1] -= HINT_OFFSET;
+ v[4].p[1] -= HINT_OFFSET;
+ v[5].p[1] -= HINT_OFFSET;
+ break;
+ case PLANE_YZ0:
+ v[0].p[0] += HINT_OFFSET;
+ v[1].p[0] += HINT_OFFSET;
+ v[2].p[0] += HINT_OFFSET;
+// v[3].p[0] = backface;
+// v[4].p[0] = backface;
+// v[5].p[0] = backface;
+ break;
+ case PLANE_YZ1:
+ v[0].p[0] -= HINT_OFFSET;
+ v[1].p[0] -= HINT_OFFSET;
+ v[2].p[0] -= HINT_OFFSET;
+// v[3].p[0] = backface;
+// v[4].p[0] = backface;
+// v[5].p[0] = backface;
+ break;
+ }
+ brush.Number = N;
+ XYZtoV(&v[0],&brush.face[0].v[0]);
+ XYZtoV(&v[3],&brush.face[0].v[1]);
+ XYZtoV(&v[4],&brush.face[0].v[2]);
+
+ XYZtoV(&v[1],&brush.face[1].v[0]);
+ XYZtoV(&v[4],&brush.face[1].v[1]);
+ XYZtoV(&v[5],&brush.face[1].v[2]);
+
+ XYZtoV(&v[2],&brush.face[2].v[0]);
+ XYZtoV(&v[5],&brush.face[2].v[1]);
+ XYZtoV(&v[3],&brush.face[2].v[2]);
+
+ XYZtoV(&v[3],&brush.face[3].v[0]);
+ XYZtoV(&v[5],&brush.face[3].v[1]);
+ XYZtoV(&v[4],&brush.face[3].v[2]);
+
+ XYZtoV(&v[0],&brush.face[4].v[0]);
+ XYZtoV(&v[1],&brush.face[4].v[1]);
+ XYZtoV(&v[2],&brush.face[4].v[2]);
+
+ MakeBrush(&brush);
+ N++;
+ }
+ }
+ }
+ } // endif AddHints==1
+ CloseFuncGroup();
+ }
+
+} // end MapBrushes
+
+//=============================================================
+void GenerateMap()
+{
+ extern void MapOut(int,int,NODE *,TRI *);
+ extern bool SingleBrushSelected;
+ int ntri;
+
+ if(!ValidSurface()) return;
+ /*
+ ghCursorCurrent = LoadCursor(NULL,IDC_WAIT);
+ SetCursor(ghCursorCurrent);
+ */
+#if 0
+ if(SingleBrushSelected) g_FuncTable.m_pfnDeleteSelection();
+#endif
+
+ GenerateXYZ();
+ ntri = NH*NV*2;
+
+ if(Game==QUAKE3 && UsePatches != 0)
+ MapPatches();
+
+ if(Decimate > 0 && (Game != QUAKE3 || UsePatches==0) )
+ {
+ MapOut(gNumNodes,gNumTris,gNode,gTri);
+ /*
+ ghCursorCurrent = ghCursorDefault;
+ SetCursor(ghCursorCurrent);
+ */
+ return;
+ }
+
+ contents = 0;
+ // HL doesn't have detail property
+ if((Game != HALFLIFE) && UseDetail) contents += CONTENTS_DETAIL;
+ // HL and Q3 don't have ladder property
+ if((Game != HALFLIFE && Game != QUAKE3) && UseLadder) contents += CONTENTS_LADDER;
+ // Genesis requires solid property to be set explicitly
+ if(Game == GENESIS3D) contents |= CONTENTS_SOLID;
+ // Heretic 2 uses different sounds (in surface props) for different texture types
+ if(Game == HERETIC2)
+ {
+ surface[0] = GetDefSurfaceProps(Texture[Game][0]);
+ surface[1] = GetDefSurfaceProps(Texture[Game][1]);
+ surface[2] = GetDefSurfaceProps(Texture[Game][2]);
+ }
+ else
+ {
+ surface[0] = 0;
+ surface[1] = 0;
+ surface[2] = 0;
+ }
+ if(Game!=QUAKE3 || UsePatches == 0)
+ MapBrushes();
+
+ /*
+ ghCursorCurrent = ghCursorDefault;
+ SetCursor(ghCursorCurrent);
+ */
+}
+
+//=============================================================
+void GenerateXYZ()
+{
+ extern void MakeDecimatedMap(int *, int *, NODE **, TRI **);
+ double zl, zu;
+ double wh, wv;
+ int NHalfcycles;
+ double a,v,h,ha,va;
+ double delta, dr, rate;
+ double range, maxrange;
+ double r;
+ int i, j, k, N;
+ int i0, i1, j0, j1;
+ int ii, jj;
+
+// FILE *f;
+// char CSV[64];
+
+ if(!ValidSurface()) return;
+
+ srand(1);
+ srand(RandomSeed);
+
+ dh = (Hur-Hll)/NH;
+ dv = (Vur-Vll)/NV;
+
+ // H & V
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0;j<=NV;j++)
+ {
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ xyz[i][j].p[0] = Hll + i*dh;
+ xyz[i][j].p[2] = Vll + j*dv;
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ xyz[i][j].p[1] = Hll + i*dh;
+ xyz[i][j].p[2] = Vll + j*dv;
+ break;
+ default:
+ xyz[i][j].p[0] = Hll + i*dh;
+ xyz[i][j].p[1] = Vll + j*dv;
+ }
+ }
+ }
+
+ if(WaveType == WAVE_BITMAP)
+ GenerateBitmapMapping();
+ /*
+ else if(WaveType == WAVE_FORMULA)
+ DoFormula();
+ */
+ else
+ {
+ // Initialize Z values using bilinear interpolation
+ for(i=0; i<=NH; i++)
+ {
+ zl = Z00 + i*(Z10 - Z00)/NH;
+ zu = Z01 + i*(Z11 - Z01)/NH;
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ for(j=0; j<=NV; j++)
+ xyz[i][j].p[1] = zl + j*(zu-zl)/NV;
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ for(j=0; j<=NV; j++)
+ xyz[i][j].p[0] = zl + j*(zu-zl)/NV;
+ break;
+ default:
+ for(j=0; j<=NV; j++)
+ xyz[i][j].p[2] = zl + j*(zu-zl)/NV;
+ }
+ }
+ }
+
+ switch(WaveType)
+ {
+ case WAVE_COS_SIN:
+ if(FixBorders)
+ {
+ NHalfcycles = (int)((Hur-Hll)/(WaveLength/2.));
+ NHalfcycles = max(NHalfcycles,1);
+ wh = 2.*(Hur-Hll)/NHalfcycles;
+ NHalfcycles = (int)((Vur-Vll)/(WaveLength/2.));
+ wv = 2.*(Vur-Vll)/NHalfcycles;
+ NHalfcycles = max(NHalfcycles,1);
+ i0 = 1;
+ i1 = NH-1;
+ j0 = 1;
+ j1 = NV-1;
+ }
+ else
+ {
+ wh = WaveLength;
+ wv = WaveLength;
+ i0 = 0;
+ i1 = NH;
+ j0 = 0;
+ j1 = NV;
+ }
+
+ for(i=i0; i<=i1; i++)
+ {
+ h = Hll + i*dh;
+ ha = ((h-Hll)/wh)*2.*PI - PI/2.;
+ for(j=j0; j<=j1; j++)
+ {
+ v = Vll + j*dv;
+ va = ((v-Vll)/wv)*2.*PI;
+ a = Amplitude * cos( ha ) * sin( va );
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ xyz[i][j].p[2] -= a;
+ break;
+ case PLANE_XZ0:
+ xyz[i][j].p[1] += a;
+ break;
+ case PLANE_XZ1:
+ xyz[i][j].p[1] -= a;
+ break;
+ case PLANE_YZ0:
+ xyz[i][j].p[0] += a;
+ break;
+ case PLANE_YZ1:
+ xyz[i][j].p[0] -= a;
+ break;
+ default:
+ xyz[i][j].p[2] += a;
+ }
+ }
+ }
+ break;
+ case WAVE_HCYLINDER:
+ for(i=0; i<=NH; i++)
+ {
+ h = Hll + i*dh;
+ ha = ((h-Hll)/WaveLength)*2.*PI - PI/2.;
+ for(j=0; j<=NV; j++)
+ {
+ a = Amplitude * cos( ha );
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ xyz[i][j].p[2] -= a;
+ break;
+ case PLANE_XZ0:
+ xyz[i][j].p[1] += a;
+ break;
+ case PLANE_XZ1:
+ xyz[i][j].p[1] -= a;
+ break;
+ case PLANE_YZ0:
+ xyz[i][j].p[0] += a;
+ break;
+ case PLANE_YZ1:
+ xyz[i][j].p[0] -= a;
+ break;
+ default:
+ xyz[i][j].p[2] += a;
+ }
+ }
+ }
+ break;
+ case WAVE_VCYLINDER:
+ for(i=0; i<=NH; i++)
+ {
+ h = Hll + i*dh;
+ for(j=0; j<=NV; j++)
+ {
+ v = Vll + j*dv;
+ va = ((v-Vll)/WaveLength)*2.*PI;
+ a = Amplitude * sin( va );
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ xyz[i][j].p[2] -= a;
+ break;
+ case PLANE_XZ0:
+ xyz[i][j].p[1] += a;
+ break;
+ case PLANE_XZ1:
+ xyz[i][j].p[1] -= a;
+ break;
+ case PLANE_YZ0:
+ xyz[i][j].p[0] += a;
+ break;
+ case PLANE_YZ1:
+ xyz[i][j].p[0] -= a;
+ break;
+ default:
+ xyz[i][j].p[2] += a;
+ }
+ }
+ }
+ break;
+ case WAVE_ROUGH_ONLY:
+ PlasmaCloud();
+ break;
+ }
+
+ if(WaveType != WAVE_ROUGH_ONLY)
+ {
+ // Fixed values
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ if(xyz[i][j].fixed)
+ {
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ xyz[i][j].p[1] = xyz[i][j].fixed_value;
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ xyz[i][j].p[0] = xyz[i][j].fixed_value;
+ break;
+ default:
+ xyz[i][j].p[2] = xyz[i][j].fixed_value;
+ }
+
+ if(xyz[i][j].range > 0)
+ {
+ maxrange = pow(xyz[i][j].range,2); // so we don't have to do sqrt's
+ i0 = i - (int)( floor(xyz[i][j].range/dh - 0.5) + 1 );
+ i1 = i + i - i0;
+ j0 = j - (int)( floor(xyz[i][j].range/dv - 0.5) + 1 );
+ j1 = j + j - j0;
+ if(FixBorders)
+ {
+ i0 = max(i0,1);
+ i1 = min(i1,NH-1);
+ j0 = max(j0,1);
+ j1 = min(j1,NV-1);
+ }
+ else
+ {
+ i0 = max(i0,0);
+ i1 = min(i1,NH);
+ j0 = max(j0,0);
+ j1 = min(j1,NV);
+ }
+ for(ii=i0; ii<=i1; ii++)
+ {
+ for(jj=j0; jj<=j1; jj++)
+ {
+ if(ii==i && jj==j) continue;
+ range = pow( dh*(i-ii), 2) + pow( dv*(j-jj), 2);
+ if(range > maxrange) continue;
+ dr = sqrt(range/maxrange);
+ rate = max(-30.,min(xyz[i][j].rate,30.));
+ if(rate < -1.)
+ {
+ delta = pow((1.-dr),-rate+1.);
+ }
+ else if(rate < 0.)
+ {
+ delta = (1+rate)*0.5*(cos(dr*PI)+1.0) -
+ rate*pow((1.-dr),2);
+ }
+ else if(rate == 0.)
+ {
+ delta = 0.5*(cos(dr*PI)+1.0);
+ }
+ else if(rate <= 1.)
+ {
+ delta = (1.-rate)*0.5*(cos(dr*PI)+1.0) +
+ rate*(1.-pow(dr,2));
+ }
+ else
+ {
+ delta = 1.-pow(dr,rate+1);
+ }
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ xyz[ii][jj].p[1] += (xyz[i][j].p[1] - xyz[ii][jj].p[1])*delta;
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ xyz[ii][jj].p[0] += (xyz[i][j].p[0] - xyz[ii][jj].p[0])*delta;
+ break;
+ default:
+ xyz[ii][jj].p[2] += (xyz[i][j].p[2] - xyz[ii][jj].p[2])*delta;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if((Roughness > 0.) && (WaveType != WAVE_ROUGH_ONLY) )
+ {
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ if(CanEdit(i,j) && !xyz[i][j].fixed)
+ {
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ xyz[i][j].p[1] += -Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX);
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ xyz[i][j].p[0] += -Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX);
+ break;
+ default:
+ xyz[i][j].p[2] += -Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX);
+ }
+ }
+ else
+ r = rand(); // We still get a random number, so that fixing points
+ // doesn't change the sequence.
+
+ }
+ }
+ }
+
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ for(k=0; k<3; k++)
+ {
+ xyz[i][j].p[k] = Nearest(xyz[i][j].p[k],2.0);
+ }
+ }
+ }
+
+ // Find minima and maxima
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ xmin = Hll;
+ xmax = Hur;
+ zmin = Vll;
+ zmax = Vur;
+ ymin = xyz[0][0].p[1];
+ ymax = ymin;
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ ymin = min(ymin,xyz[i][j].p[1]);
+ ymax = max(ymax,xyz[i][j].p[1]);
+ }
+ }
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ ymin = Hll;
+ ymax = Hur;
+ zmin = Vll;
+ zmax = Vur;
+ xmin = xyz[0][0].p[0];
+ xmax = ymin;
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ xmin = min(xmin,xyz[i][j].p[0]);
+ xmax = max(xmax,xyz[i][j].p[0]);
+ }
+ }
+ break;
+ break;
+ default:
+ xmin = Hll;
+ xmax = Hur;
+ ymin = Vll;
+ ymax = Vur;
+ zmin = xyz[0][0].p[2];
+ zmax = zmin;
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ zmin = min(zmin,xyz[i][j].p[2]);
+ zmax = max(zmax,xyz[i][j].p[2]);
+ }
+ }
+ }
+
+ xmin = Nearest(xmin,2.);
+ xmax = Nearest(xmax,2.);
+ ymin = Nearest(ymin,2.);
+ ymax = Nearest(ymax,2.);
+ zmin = Nearest(zmin,2.);
+ zmax = Nearest(zmax,2.);
+
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ backface = AtLeast(zmax+32.,32.);
+ break;
+ case PLANE_XZ0:
+ backface = NoMoreThan(ymin-32.,32.);
+ break;
+ case PLANE_XZ1:
+ backface = AtLeast(ymax+32.,32.);
+ break;
+ case PLANE_YZ0:
+ backface = NoMoreThan(xmin-32.,32.);
+ break;
+ case PLANE_YZ1:
+ backface = AtLeast(xmax+32.,32.);
+ break;
+ default:
+ backface = NoMoreThan(zmin-32.,32.);
+ }
+
+ if(gNode)
+ {
+ free(gNode);
+ free(gTri);
+ gNode = (NODE *)NULL;
+ gTri = (TRI *)NULL;
+ }
+ if(Decimate > 0 && (Game != QUAKE3 || UsePatches==0) )
+ {
+ MakeDecimatedMap(&gNumNodes,&gNumTris,&gNode,&gTri);
+ }
+ else
+ {
+ gNumNodes = (NH+1)*(NV+1);
+ gNumTris = NH*NV*2;
+ gNode = (NODE *) malloc(gNumNodes * sizeof(NODE));
+ gTri = (TRI *) malloc(gNumTris * sizeof(TRI));
+
+ for(i=0,N=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++, N++)
+ {
+ gNode[N].used = 1;
+ gNode[N].p[0] = (float)xyz[i][j].p[0];
+ gNode[N].p[1] = (float)xyz[i][j].p[1];
+ gNode[N].p[2] = (float)xyz[i][j].p[2];
+ }
+ }
+
+ for(i=0; i<NH; i++)
+ {
+ for(j=0; j<NV; j++)
+ {
+ k = i*NV*2 + j*2;
+ if( (i+j) % 2 )
+ {
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ1:
+ case PLANE_YZ1:
+ gTri[k ].v[0] = i*(NV+1)+j;
+ gTri[k ].v[1] = (i+1)*(NV+1)+j+1;
+ gTri[k ].v[2] = (i+1)*(NV+1)+j;
+ gTri[k+1].v[0] = i*(NV+1)+j;
+ gTri[k+1].v[1] = i*(NV+1)+j+1;
+ gTri[k+1].v[2] = (i+1)*(NV+1)+j+1;
+ break;
+ default:
+ gTri[k ].v[0] = i*(NV+1)+j;
+ gTri[k ].v[1] = (i+1)*(NV+1)+j;
+ gTri[k ].v[2] = (i+1)*(NV+1)+j+1;
+ gTri[k+1].v[0] = i*(NV+1)+j;
+ gTri[k+1].v[1] = (i+1)*(NV+1)+j+1;
+ gTri[k+1].v[2] = i*(NV+1)+j+1;
+ }
+ }
+ else
+ {
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ case PLANE_XZ1:
+ case PLANE_YZ1:
+ gTri[k ].v[0] = i*(NV+1)+j;
+ gTri[k ].v[1] = i*(NV+1)+j+1;
+ gTri[k ].v[2] = (i+1)*(NV+1)+j;
+ gTri[k+1].v[0] = (i+1)*(NV+1)+j;
+ gTri[k+1].v[1] = i*(NV+1)+j+1;
+ gTri[k+1].v[2] = (i+1)*(NV+1)+j+1;
+ break;
+ default:
+ gTri[k ].v[0] = i*(NV+1)+j;
+ gTri[k ].v[1] = (i+1)*(NV+1)+j;
+ gTri[k ].v[2] = i*(NV+1)+j+1;
+ gTri[k+1].v[0] = (i+1)*(NV+1)+j;
+ gTri[k+1].v[1] = (i+1)*(NV+1)+j+1;
+ gTri[k+1].v[2] = i*(NV+1)+j+1;
+ }
+ }
+ }
+ }
+ }
+/*
+ sprintf(CSV,"csv%03d.csv",Decimate);
+ f = fopen(CSV,"w");
+ for(i=0; i<gNumNodes; i++)
+ {
+ if(gNode[i].used)
+ fprintf(f,"%g,%g,%g\n",gNode[i].p[0],gNode[i].p[1],gNode[i].p[2]);
+ }
+ fclose(f);
+*/
+ for(i=0; i<gNumTris; i++)
+ PlaneFromPoints(gNode[gTri[i].v[0]].p,
+ gNode[gTri[i].v[1]].p,
+ gNode[gTri[i].v[2]].p,
+ &gTri[i].plane);
+
+ // Hydra: snap-to-grid begin
+ if (SnapToGrid > 0)
+ {
+ for(i=0; i<NH; i++)
+ {
+ for(j=0; j<NV; j++)
+ {
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ xyz[i][j].p[1] = CalculateSnapValue(xyz[i][j].p[1]);
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ xyz[i][j].p[0] = CalculateSnapValue(xyz[i][j].p[0]);
+ break;
+ default:
+ xyz[i][j].p[2] = CalculateSnapValue(xyz[i][j].p[2]);
+ }
+ }
+ }
+ }
+ // Hydra: snap-to-grid end
+}
+//=============================================================
+double Nearest(double x, double dx)
+{
+ double xx;
+
+ xx = (double)(floor(x/dx - 0.5)+1.)*dx;
+ if(fabs(xx) < dx/2) xx = 0.;
+ return xx;
+}
+//=============================================================
+double NoMoreThan(double x, double dx)
+{
+ double xx;
+
+ xx = (double)(floor(x/dx - 0.5)+1.)*dx;
+ if(xx > x) xx -= dx;
+ return xx;
+}
+//=============================================================
+double AtLeast(double x, double dx)
+{
+ double xx;
+
+ xx = (double)(floor(x/dx - 0.5)+1.)*dx;
+ if(xx < x) xx += dx;
+ return xx;
+}
+//=============================================================
+double LessThan(double x,double dx)
+{
+ double xx;
+
+ xx = (double)(floor(x/dx - 0.5)+1.)*dx;
+ if(xx >= x) xx -= dx;
+ return xx;
+}
+//=============================================================
+double MoreThan(double x,double dx)
+{
+ double xx;
+
+ xx = (double)(floor(x/dx - 0.5)+1.)*dx;
+ while(xx <= x)
+ xx += dx;
+ return xx;
+}
+//=============================================================
+void SubdividePlasma(int i0,int j0,int i1,int j1)
+{
+ int i, j;
+ double z1, z2;
+ double r; // NOTE: This is used to keep the random number sequence the same
+ // when we fix a point. If we did NOT do this, then simply
+ // fixing a point at its current value would change the entire
+ // surface.
+
+ i = (i0+i1)/2;
+ j = (j0+j1)/2;
+ if(i1 > i0+1)
+ {
+ if(!xyz[i][j0].done)
+ {
+ xyz[i][j0].pp[2] = xyz[i0][j0].pp[2] +
+ (xyz[i1][j0].pp[2] - xyz[i0][j0].pp[2])*(double)(i-i0)/(double)(i1-i0) +
+ ((double)(i-i0))*(-Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX));
+ xyz[i][j0].done = 1;
+ }
+ else
+ r = rand();
+ if((j1 > j0) && (!xyz[i][j1].done) )
+ {
+ xyz[i][j1].pp[2] = xyz[i0][j1].pp[2] +
+ (xyz[i1][j1].pp[2] - xyz[i0][j1].pp[2])*(double)(i-i0)/(double)(i1-i0) +
+ ((double)(i-i0))*(-Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX));
+ xyz[i][j1].done = 1;
+ }
+ else
+ r = rand();
+ }
+ if(j1 > j0 + 1)
+ {
+ if(!xyz[i0][j].done)
+ {
+ xyz[i0][j].pp[2] = xyz[i0][j0].pp[2] +
+ (xyz[i0][j1].pp[2] - xyz[i0][j0].pp[2])*(double)(j-j0)/(double)(j1-j0) +
+ ((double)(j-j0))*(-Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX));
+ xyz[i0][j].done = 1;
+ }
+ else
+ r = rand();
+ if((i1 > i0) && (!xyz[i1][j].done))
+ {
+ xyz[i1][j].pp[2] = xyz[i1][j0].pp[2] +
+ (xyz[i1][j1].pp[2] - xyz[i1][j0].pp[2])*(double)(j-j0)/(double)(j1-j0) +
+ ((double)(j-j0))*(-Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX));
+ xyz[i1][j].done = 1;
+ }
+ else
+ r = rand();
+ }
+ if((i1 > i0+1) && (j1 > j0+1))
+ {
+ if(!xyz[i][j].done)
+ {
+ z1 = xyz[i0][j].pp[2] +
+ (xyz[i1][j].pp[2] - xyz[i0][j].pp[2])*(double)(i-i0)/(double)(i1-i0);
+ z2 = xyz[i][j0].pp[2] +
+ (xyz[i][j1].pp[2] - xyz[i][j0].pp[2])*(double)(j-j0)/(double)(j1-j0);
+ xyz[i][j].pp[2] = (z1+z2)/2. +
+ ((double)(i-i0))*(-Roughness/2. + Roughness*((double)rand()/(double)RAND_MAX));
+ xyz[i][j].done = 1;
+ }
+ else
+ r = rand();
+ }
+ if(i > i0+1 || j > j0+1)
+ SubdividePlasma(i0,j0,i,j);
+ if(i1 > i+1 || j > j0+1)
+ SubdividePlasma(i,j0,i1,j);
+ if(i > i0+1 || j1 > j0+1)
+ SubdividePlasma(i0,j,i,j1);
+ if(i1 > i+1 || j1 > j0+1)
+ SubdividePlasma(i,j,i1,j1);
+}
+//==================================================================================
+void PlasmaCloud()
+{
+ int i, j;
+ /* use pp[2] values until done to avoid messing with a bunch of
+ switch statements */
+
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ if(FixedPoint(i,j))
+ xyz[i][j].done = 1;
+ else
+ xyz[i][j].done = 0;
+ }
+ }
+
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ if(xyz[i][j].fixed)
+ xyz[i][j].pp[2] = xyz[i][j].fixed_value;
+ else
+ xyz[i][j].pp[2] = xyz[i][j].p[1];
+ }
+ }
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ if(xyz[i][j].fixed)
+ xyz[i][j].pp[2] = xyz[i][j].fixed_value;
+ else
+ xyz[i][j].pp[2] = xyz[i][j].p[0];
+ }
+ }
+ break;
+ default:
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ if(xyz[i][j].fixed)
+ xyz[i][j].pp[2] = xyz[i][j].fixed_value;
+ else
+ xyz[i][j].pp[2] = xyz[i][j].p[2];
+ }
+ }
+ break;
+ }
+ SubdividePlasma(0,0,NH,NV);
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ xyz[i][j].p[1] = xyz[i][j].pp[2];
+ }
+ }
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ xyz[i][j].p[0] = xyz[i][j].pp[2];
+ }
+ }
+ break;
+ default:
+ for(i=0; i<=NH; i++)
+ {
+ for(j=0; j<=NV; j++)
+ {
+ xyz[i][j].p[2] = xyz[i][j].pp[2];
+ }
+ }
+ break;
+ }
+}
+//===========================================================================
+bool FixedPoint(int i, int j)
+{
+ if(xyz[i][j].fixed) return TRUE;
+ return !CanEdit(i,j);
+}
+//===========================================================================
+bool CanEdit(int i, int j)
+{
+ if(FixBorders && ( (WaveType==WAVE_COS_SIN) || (WaveType==WAVE_ROUGH_ONLY) ) )
+ {
+ if(i== 0) return FALSE;
+ if(i==NH) return FALSE;
+ if(j== 0) return FALSE;
+ if(j==NV) return FALSE;
+ }
+ if(i== 0 && j== 0) return FALSE;
+ if(i==NH && j== 0) return FALSE;
+ if(i== 0 && j==NV) return FALSE;
+ if(i==NH && j==NV) return FALSE;
+ return TRUE;
+}
+/*============================================================================
+ TriangleFromPoint
+ Determines which triangle in the gTri array bounds the input point. Doesn't
+ do anything special with border points.
+*/
+int TriangleFromPoint(double x, double y)
+{
+ int j, tri;
+
+ if(!gTri) return -1;
+
+ for(j=0, tri=-1; j<gNumTris && tri==-1; j++)
+ {
+ if( side(x,y,
+ gNode[gTri[j].v[0]].p[0],gNode[gTri[j].v[0]].p[1],
+ gNode[gTri[j].v[1]].p[0],gNode[gTri[j].v[1]].p[1]) < 0. ) continue;
+ if( side(x,y,
+ gNode[gTri[j].v[1]].p[0],gNode[gTri[j].v[1]].p[1],
+ gNode[gTri[j].v[2]].p[0],gNode[gTri[j].v[2]].p[1]) < 0. ) continue;
+ if( side(x,y,
+ gNode[gTri[j].v[2]].p[0],gNode[gTri[j].v[2]].p[1],
+ gNode[gTri[j].v[0]].p[0],gNode[gTri[j].v[0]].p[1]) < 0. ) continue;
+ tri = j;
+ }
+
+ return tri;
+}
+/*============================================================================
+ PlayerStartZ
+ Determines minimum height to place the player start such that he doesn't
+ intersect any surface brushes.
+*/
+int PlayerStartZ(double x, double y)
+{
+ int k,t[5];
+ double z, zt;
+
+ if(!gTri) return (int)zmax;
+
+ t[0] = TriangleFromPoint(x,y);
+ t[1] = TriangleFromPoint(x+PlayerBox[Game].x[0],y+PlayerBox[Game].y[0]);
+ t[2] = TriangleFromPoint(x+PlayerBox[Game].x[0],y+PlayerBox[Game].y[1]);
+ t[3] = TriangleFromPoint(x+PlayerBox[Game].x[1],y+PlayerBox[Game].y[0]);
+ t[4] = TriangleFromPoint(x+PlayerBox[Game].x[1],y+PlayerBox[Game].y[1]);
+ z = zmin;
+ for(k=0; k<5; k++)
+ {
+ zt = (gTri[t[k]].plane.dist -
+ gTri[t[k]].plane.normal[0]*x -
+ gTri[t[k]].plane.normal[1]*y )/
+ gTri[t[k]].plane.normal[2];
+ z = max(z,zt);
+ }
+ return (int)(AtLeast(z,2.) - PlayerBox[Game].z[0]);
+}
+//=============================================================
+void XYZtoV(XYZ *xyz, vec3 *v)
+{
+ v[0][0] = (vec)Nearest(xyz->p[0],2.);
+ v[0][1] = (vec)Nearest(xyz->p[1],2.);
+ v[0][2] = (vec)Nearest(xyz->p[2],2.);
+}
+
+//=============================================================
+scene::Node* MakePatch(void)
+{
+ scene::Node* patch = Patch_AllocNode();
+#if 0
+ patch->m_patch->SetShader(Texture[Game][0]);
+#endif
+ Node_getTraversable(h_worldspawn)->insert(patch);
+ return patch;
+}
+
+//=============================================================
+void MakeBrush(BRUSH *brush)
+{
+ NodePtr node(Brush_AllocNode());
+
+#if 0
+ for(int i=0; i<brush->NumFaces; i++)
+ {
+ _QERFaceData QERFaceData;
+ if(!strncmp(brush->face[i].texture, "textures/", 9))
+ strcpy(QERFaceData.m_TextureName,brush->face[i].texture);
+ else
+ {
+ strcpy(QERFaceData.m_TextureName,"textures/");
+ strcpy(QERFaceData.m_TextureName+9,brush->face[i].texture);
+ }
+ QERFaceData.m_nContents = brush->face[i].Contents;
+ QERFaceData.m_nFlags = brush->face[i].Surface;
+ QERFaceData.m_nValue = brush->face[i].Value;
+ QERFaceData.m_fShift[0] = brush->face[i].Shift[0];
+ QERFaceData.m_fShift[1] = brush->face[i].Shift[1];
+ QERFaceData.m_fRotate = brush->face[i].Rotate;
+ QERFaceData.m_fScale[0] = brush->face[i].Scale[0];
+ QERFaceData.m_fScale[1] = brush->face[i].Scale[1];
+ QERFaceData.m_v1[0] = brush->face[i].v[0][0];
+ QERFaceData.m_v1[1] = brush->face[i].v[0][1];
+ QERFaceData.m_v1[2] = brush->face[i].v[0][2];
+ QERFaceData.m_v2[0] = brush->face[i].v[1][0];
+ QERFaceData.m_v2[1] = brush->face[i].v[1][1];
+ QERFaceData.m_v2[2] = brush->face[i].v[1][2];
+ QERFaceData.m_v3[0] = brush->face[i].v[2][0];
+ QERFaceData.m_v3[1] = brush->face[i].v[2][1];
+ QERFaceData.m_v3[2] = brush->face[i].v[2][2];
+ QERFaceData.m_bBPrimit = false;
+ (g_FuncTable.m_pfnAddFaceData)(vp,&QERFaceData);
+ }
+#endif
+
+ Node_getTraversable(h_func_group)->insert(node);
+}
+//=============================================================
+void OpenFuncGroup()
+{
+ h_func_group = GlobalEntityCreator().createEntity("func_group");
+ h_func_group->IncRef();
+ if(AddTerrainKey)
+ h_func_group->m_entity->setkeyvalue("terrain", "1");
+}
+//=============================================================
+void CloseFuncGroup()
+{
+ h_func_group->DecRef();
+ if (g_FuncTable.m_pfnSysUpdateWindows != NULL)
+ g_FuncTable.m_pfnSysUpdateWindows (W_ALL);
+}
projects / voretournament / voretournament.git / blobdiff