--- /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 <stdlib.h>
+#include <math.h>
+#include "gensurf.h"
+
+#define MAX_FACES 128 // Maximum number of faces on a brush
+#define MAX_POINTS_ON_WINDING 64
+#define SIDE_FRONT 0
+#define SIDE_ON 2
+#define SIDE_BACK 1
+#define SIDE_CROSS -2
+
+//vec3 vec3_origin = {0,0,0};
+
+void PlaneFromPoints (float *p0, float *p1, float *p2, PLANE *plane)
+{
+ vec3 t1, t2;
+ vec length;
+
+ VectorSubtract (p0, p1, t1);
+ VectorSubtract (p2, p1, t2);
+ plane->normal[0] = t1[1]*t2[2] - t1[2]*t2[1];
+ plane->normal[1] = t1[2]*t2[0] - t1[0]*t2[2];
+ plane->normal[2] = t1[0]*t2[1] - t1[1]*t2[0];
+
+ length = (vec)(sqrt(plane->normal[0]*plane->normal[0] +
+ plane->normal[1]*plane->normal[1] +
+ plane->normal[2]*plane->normal[2] ));
+ if (length == 0)
+ {
+ VectorClear(plane->normal);
+ }
+ else
+ {
+ plane->normal[0] /= length;
+ plane->normal[1] /= length;
+ plane->normal[2] /= length;
+ }
+ plane->dist = DotProduct (p0, plane->normal);
+}
+/*
+void VectorMA (vec3 va, vec scale, vec3 vb, vec3 vc)
+{
+ vc[0] = va[0] + scale*vb[0];
+ vc[1] = va[1] + scale*vb[1];
+ vc[2] = va[2] + scale*vb[2];
+}
+
+void CrossProduct (vec3 v1, vec3 v2, vec3 cross)
+{
+ cross[0] = v1[1]*v2[2] - v1[2]*v2[1];
+ cross[1] = v1[2]*v2[0] - v1[0]*v2[2];
+ cross[2] = v1[0]*v2[1] - v1[1]*v2[0];
+}
+*/
+/*
+=============
+AllocWinding
+=============
+*/
+MY_WINDING *AllocWinding (int points)
+{
+ MY_WINDING *w;
+ int s;
+
+ s = sizeof(vec)*3*points + sizeof(int);
+ w = (MY_WINDING*)malloc (s);
+ memset (w, 0, s);
+ return w;
+}
+/*
+vec VectorNormalize (vec3 in, vec3 out)
+{
+ vec length, ilength;
+
+ length = (vec)(sqrt (in[0]*in[0] + in[1]*in[1] + in[2]*in[2]));
+ if (length == 0)
+ {
+ VectorClear (out);
+ return 0;
+ }
+
+ ilength = (vec)1.0/length;
+ out[0] = in[0]*ilength;
+ out[1] = in[1]*ilength;
+ out[2] = in[2]*ilength;
+
+ return length;
+}
+*/
+
+/*
+=================
+BaseWindingForPlane
+=================
+*/
+MY_WINDING *BaseWindingForPlane (vec3 normal, vec dist)
+{
+ int i, x;
+ vec max, v;
+ vec3 org, vright, vup;
+ MY_WINDING *w;
+
+// find the major axis
+
+ max = -BOGUS_RANGE;
+ x = -1;
+ for (i=0 ; i<3; i++)
+ {
+ v = (vec)(fabs(normal[i]));
+ if (v > max)
+ {
+ x = i;
+ max = v;
+ }
+ }
+ if (x==-1) x = 2;
+
+ VectorCopy(vec3_origin,vup);
+ switch (x)
+ {
+ case 0:
+ case 1:
+ vup[2] = 1;
+ break;
+ case 2:
+ vup[0] = 1;
+ break;
+ }
+
+ v = DotProduct (vup, normal);
+ VectorMA (vup, -v, normal, vup);
+ VectorNormalize (vup, vup);
+
+ VectorScale (normal, dist, org);
+
+ CrossProduct (vup, normal, vright);
+
+ VectorScale (vup, 65536, vup);
+ VectorScale (vright, 65536, vright);
+
+// project a really big axis aligned box onto the plane
+ w = AllocWinding (4);
+
+ VectorSubtract (org, vright, w->p[0]);
+ VectorAdd (w->p[0], vup, w->p[0]);
+
+ VectorAdd (org, vright, w->p[1]);
+ VectorAdd (w->p[1], vup, w->p[1]);
+
+ VectorAdd (org, vright, w->p[2]);
+ VectorSubtract (w->p[2], vup, w->p[2]);
+
+ VectorSubtract (org, vright, w->p[3]);
+ VectorSubtract (w->p[3], vup, w->p[3]);
+
+ w->numpoints = 4;
+
+ return w;
+}
+
+void FreeWinding (MY_WINDING *w)
+{
+ if (*(unsigned *)w == 0xdeaddead)
+// Error ("FreeWinding: freed a freed winding");
+ return;
+ *(unsigned *)w = 0xdeaddead;
+
+ free (w);
+}
+
+/*
+=============
+ChopWindingInPlace
+=============
+*/
+void ChopWindingInPlace (MY_WINDING **inout, vec3 normal, vec dist, vec epsilon)
+{
+ MY_WINDING *in;
+ vec dists[MAX_POINTS_ON_WINDING+4];
+ int sides[MAX_POINTS_ON_WINDING+4];
+ int counts[3];
+ static vec dot; // VC 4.2 optimizer bug if not static
+ int i, j;
+ vec *p1, *p2;
+ vec3 mid;
+ MY_WINDING *f;
+ int maxpts;
+
+ in = *inout;
+ counts[0] = counts[1] = counts[2] = 0;
+
+// determine sides for each point
+ for (i=0 ; i<in->numpoints ; i++)
+ {
+ dot = DotProduct (in->p[i], normal);
+ dot -= dist;
+ dists[i] = dot;
+ if (dot > epsilon)
+ sides[i] = SIDE_FRONT;
+ else if (dot < -epsilon)
+ sides[i] = SIDE_BACK;
+ else
+ {
+ sides[i] = SIDE_ON;
+ }
+ counts[sides[i]]++;
+ }
+ sides[i] = sides[0];
+ dists[i] = dists[0];
+
+ if (!counts[0])
+ {
+ FreeWinding(in);
+ *inout = NULL;
+ return;
+ }
+ if (!counts[1])
+ return; // inout stays the same
+
+ maxpts = in->numpoints+4; // cant use counts[0]+2 because
+ // of fp grouping errors
+
+ f = AllocWinding (maxpts);
+
+ for (i=0 ; i<in->numpoints ; i++)
+ {
+ p1 = in->p[i];
+
+ if (sides[i] == SIDE_ON)
+ {
+ VectorCopy (p1, f->p[f->numpoints]);
+ f->numpoints++;
+ continue;
+ }
+
+ if (sides[i] == SIDE_FRONT)
+ {
+ VectorCopy (p1, f->p[f->numpoints]);
+ f->numpoints++;
+ }
+
+ if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
+ continue;
+
+ // generate a split point
+ p2 = in->p[(i+1)%in->numpoints];
+
+ dot = dists[i] / (dists[i]-dists[i+1]);
+ for (j=0 ; j<3 ; j++)
+ { // avoid round off error when possible
+ if (normal[j] == 1)
+ mid[j] = dist;
+ else if (normal[j] == -1)
+ mid[j] = -dist;
+ else
+ mid[j] = p1[j] + dot*(p2[j]-p1[j]);
+ }
+
+ VectorCopy (mid, f->p[f->numpoints]);
+ f->numpoints++;
+ }
+
+// if (f->numpoints > maxpts)
+// Error ("ClipWinding: points exceeded estimate");
+// if (f->numpoints > MAX_POINTS_ON_WINDING)
+// Error ("ClipWinding: MAX_POINTS_ON_WINDING");
+
+ FreeWinding(in);
+ *inout = f;
+}
+
+void UseFaceBounds()
+{
+ LPVOID vp;
+ float Dot, BestDot;
+ float planepts[3][3];
+ int BestFace;
+ int i, j;
+ int NumFaces;
+ vec3 SurfNormal;
+ vec3 vmin,vmax;
+ PLANE plane[MAX_FACES*2];
+ PLANE pface;
+ MY_WINDING *w;
+
+ switch(Plane)
+ {
+ case PLANE_XY1:
+ SurfNormal[0] = 0.0;
+ SurfNormal[1] = 0.0;
+ SurfNormal[2] =-1.0;
+ break;
+ case PLANE_XZ0:
+ SurfNormal[0] = 0.0;
+ SurfNormal[1] = 1.0;
+ SurfNormal[2] = 0.0;
+ break;
+ case PLANE_XZ1:
+ SurfNormal[0] = 0.0;
+ SurfNormal[1] =-1.0;
+ SurfNormal[2] = 0.0;
+ break;
+ case PLANE_YZ0:
+ SurfNormal[0] = 1.0;
+ SurfNormal[1] = 0.0;
+ SurfNormal[2] = 0.0;
+ break;
+ case PLANE_YZ1:
+ SurfNormal[0] =-1.0;
+ SurfNormal[1] = 0.0;
+ SurfNormal[2] = 0.0;
+ break;
+ default:
+ SurfNormal[0] = 0.0;
+ SurfNormal[1] = 0.0;
+ SurfNormal[2] = 1.0;
+ }
+
+#if 0
+ i = g_FuncTable.m_pfnAllocateSelectedBrushHandles();
+ vp = g_FuncTable.m_pfnGetSelectedBrushHandle(0);
+ NumFaces = g_FuncTable.m_pfnGetFaceCount(vp);
+
+ BestFace = -1;
+ BestDot = 0.0;
+
+ for(i=0; i<NumFaces; i++)
+ {
+ _QERFaceData* QERFaceData = g_FuncTable.m_pfnGetFaceData(vp,i);
+ planepts[0][0] = QERFaceData->m_v1[0];
+ planepts[0][1] = QERFaceData->m_v1[1];
+ planepts[0][2] = QERFaceData->m_v1[2];
+ planepts[1][0] = QERFaceData->m_v2[0];
+ planepts[1][1] = QERFaceData->m_v2[1];
+ planepts[1][2] = QERFaceData->m_v2[2];
+ planepts[2][0] = QERFaceData->m_v3[0];
+ planepts[2][1] = QERFaceData->m_v3[1];
+ planepts[2][2] = QERFaceData->m_v3[2];
+
+ PlaneFromPoints (planepts[0], planepts[1], planepts[2], &plane[2*i]);
+ VectorSubtract (vec3_origin, plane[2*i].normal, plane[2*i+1].normal);
+ plane[2*i+1].dist = -plane[2*i].dist;
+
+ Dot = DotProduct(plane[2*i].normal,SurfNormal);
+ if(Dot > BestDot)
+ {
+ BestDot = Dot;
+ BestFace = i;
+ if(strlen(QERFaceData->m_TextureName))
+ strcpy(Texture[Game][0],QERFaceData->m_TextureName);
+ }
+ }
+ for(i=0; i<NumFaces; i++)
+ {
+ if(i==BestFace) continue;
+ _QERFaceData* QERFaceData = g_FuncTable.m_pfnGetFaceData(vp,i);
+ if(strlen(QERFaceData->m_TextureName))
+ {
+ if(strcmp(Texture[Game][0],QERFaceData->m_TextureName))
+ strcpy(Texture[Game][1],QERFaceData->m_TextureName);
+ }
+ }
+
+
+ g_FuncTable.m_pfnReleaseSelectedBrushHandles();
+
+ w = BaseWindingForPlane (plane[BestFace*2].normal, plane[BestFace*2].dist);
+
+ for (i=0 ; i<NumFaces && w; i++)
+ {
+ if (BestFace == i)
+ continue;
+ ChopWindingInPlace (&w, plane[i*2+1].normal, plane[i*2+1].dist, 0);
+ }
+ if(!w) return;
+
+ // Get bounding box for this face
+ vmin[0] = vmax[0] = w->p[0][0];
+ vmin[1] = vmax[1] = w->p[0][1];
+ vmin[2] = vmax[2] = w->p[0][2];
+ for(j=1; j<w->numpoints; j++)
+ {
+ vmin[0] = min(vmin[0],w->p[j][0]);
+ vmin[1] = min(vmin[1],w->p[j][1]);
+ vmin[2] = min(vmin[2],w->p[j][2]);
+ vmax[0] = max(vmax[0],w->p[j][0]);
+ vmax[1] = max(vmax[1],w->p[j][1]);
+ vmax[2] = max(vmax[2],w->p[j][2]);
+ }
+
+ FreeWinding(w);
+
+ VectorCopy(plane[BestFace*2].normal,pface.normal);
+ pface.dist = plane[BestFace*2].dist;
+ switch(Plane)
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ if(pface.normal[1] == 0.) return;
+ Hll = vmin[0];
+ Hur = vmax[0];
+ Vll = vmin[2];
+ Vur = vmax[2];
+ Z00 = (pface.dist - pface.normal[0]*Hll - pface.normal[2]*Vll)/pface.normal[1];
+ Z01 = (pface.dist - pface.normal[0]*Hll - pface.normal[2]*Vur)/pface.normal[1];
+ Z10 = (pface.dist - pface.normal[0]*Hur - pface.normal[2]*Vll)/pface.normal[1];
+ Z11 = (pface.dist - pface.normal[0]*Hur - pface.normal[2]*Vur)/pface.normal[1];
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ if(pface.normal[0] == 0.) return;
+ Hll = vmin[1];
+ Hur = vmax[1];
+ Vll = vmin[2];
+ Vur = vmax[2];
+ Z00 = (pface.dist - pface.normal[1]*Hll - pface.normal[2]*Vll)/pface.normal[0];
+ Z01 = (pface.dist - pface.normal[1]*Hll - pface.normal[2]*Vur)/pface.normal[0];
+ Z10 = (pface.dist - pface.normal[1]*Hur - pface.normal[2]*Vll)/pface.normal[0];
+ Z11 = (pface.dist - pface.normal[1]*Hur - pface.normal[2]*Vur)/pface.normal[0];
+ break;
+ default:
+ if(pface.normal[2] == 0.) return;
+ Hll = vmin[0];
+ Hur = vmax[0];
+ Vll = vmin[1];
+ Vur = vmax[1];
+ Z00 = (pface.dist - pface.normal[0]*Hll - pface.normal[1]*Vll)/pface.normal[2];
+ Z01 = (pface.dist - pface.normal[0]*Hll - pface.normal[1]*Vur)/pface.normal[2];
+ Z10 = (pface.dist - pface.normal[0]*Hur - pface.normal[1]*Vll)/pface.normal[2];
+ Z11 = (pface.dist - pface.normal[0]*Hur - pface.normal[1]*Vur)/pface.normal[2];
+ }
+#endif
+}
projects / voretournament / voretournament.git / blobdiff