+++ /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