--- /dev/null
+/*
+BobToolz plugin for GtkRadiant
+Copyright (C) 2001 Gordon Biggans
+
+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
+*/
+
+// DPlane.cpp: implementation of the DPlane class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "DPlane.h"
+
+#include <list>
+
+#include "DPoint.h"
+#include "DWinding.h"
+
+#include "str.h"
+#include "misc.h"
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+DPlane::DPlane(const vec3_t va, const vec3_t vb, const vec3_t vc, const _QERFaceData* texData)
+{
+ MakeNormal( va, vb, vc, normal );
+ if(VectorNormalize(normal, normal) == 0) // normalizes and returns length
+ globalErrorStream() << "DPlane::DPlane: Bad Normal.\n";
+
+ _d = (normal[0]*va[0]) + (normal[1]*va[1]) + (normal[2]*va[2]);
+
+ VectorCopy(va, points[0]);
+ VectorCopy(vb, points[1]);
+ VectorCopy(vc, points[2]);
+
+ m_bChkOk = true;
+
+ if(texData)
+ memcpy(&texInfo, texData, sizeof(_QERFaceData));
+ else
+ FillDefaultTexture(&texInfo, points[0], points[1], points[2], "textures/common/caulk");
+}
+
+DPlane::~DPlane()
+{
+
+}
+
+//////////////////////////////////////////////////////////////////////
+// Implementation
+//////////////////////////////////////////////////////////////////////
+
+vec_t DPlane::DistanceToPoint(vec3_t pnt)
+{
+ vec3_t tmp;
+ VectorSubtract(pnt, points[0], tmp);
+ return DotProduct(tmp, normal);
+}
+
+bool DPlane::PlaneIntersection(DPlane *pl1, DPlane *pl2, vec3_t out)
+{
+ float a1, a2, a3;
+ float b1, b2, b3;
+ float c1, c2, c3;
+
+ a1 = normal[0]; a2 = normal[1]; a3 = normal[2];
+ b1 = pl1->normal[0]; b2 = pl1->normal[1]; b3 = pl1->normal[2];
+ c1 = pl2->normal[0]; c2 = pl2->normal[1]; c3 = pl2->normal[2];
+
+ float d = Determinant3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3);
+
+ if(d == 0)
+ return false;
+
+ float v1 = _d;
+ float v2 = pl1->_d;
+ float v3 = pl2->_d;
+
+ float d1 = Determinant3x3(v1, a2, a3, v2, b2, b3, v3, c2, c3);
+ float d2 = Determinant3x3(a1, v1, a3, b1, v2, b3, c1, v3, c3);
+ float d3 = Determinant3x3(a1, a2, v1, b1, b2, v2, c1, c2, v3);
+
+ out[0] = d1/d;
+ out[1] = d2/d;
+ out[2] = d3/d;
+
+ return true;
+}
+
+bool DPlane::IsRedundant(std::list<DPoint*>& pointList)
+{
+ int cnt = 0;
+
+ //std::list<DPoint *>::const_iterator point=pointList.begin();
+ for(std::list<DPoint *>::const_iterator point=pointList.begin(); point!=pointList.end(); point++)
+ {
+ if(fabs(DistanceToPoint((*point)->_pnt)) < MAX_ROUND_ERROR)
+ cnt++;
+
+ if(cnt == 3)
+ return false;
+ }
+ return true;
+}
+
+bool DPlane::operator == (DPlane& other)
+{
+ vec3_t chk;
+ VectorSubtract(other.normal, normal, chk);
+ if(fabs(VectorLength(chk)) > MAX_ROUND_ERROR)
+ return false;
+
+ if(fabs(other._d - _d) > MAX_ROUND_ERROR)
+ return false;
+
+ return true;
+}
+
+bool DPlane::operator != (DPlane& other)
+{
+ vec3_t chk;
+ VectorAdd(other.normal, normal, chk);
+ if(fabs(VectorLength(chk)) > MAX_ROUND_ERROR)
+ return false;
+
+ return true;
+}
+
+DWinding* DPlane::BaseWindingForPlane()
+{
+ int i, x;
+ vec_t max, v;
+ vec3_t org, vright, vup;
+
+// find the major axis
+
+ max = -131072;
+ x = -1;
+ for (i=0 ; i<3; i++)
+ {
+ v = (float)fabs(normal[i]);
+ if (v > max)
+ {
+ x = i;
+ max = v;
+ }
+ }
+ if (x==-1)
+ globalOutputStream() << "BaseWindingForPlane: no axis found";
+
+ 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, _d, org);
+
+ CrossProduct (vup, normal, vright);
+
+ VectorScale (vup, 131072, vup);
+ VectorScale (vright, 131072, vright);
+
+// project a really big axis aligned box onto the plane
+ DWinding* w = new DWinding;
+ 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]);
+
+ return w;
+}
+
+void DPlane::Rebuild()
+{
+ vec3_t v1, v2;
+ VectorSubtract(points[0], points[1], v1);
+ VectorSubtract(points[2], points[1], v2);
+ CrossProduct(v1, v2, normal);
+
+ if(VectorNormalize(normal, normal) == 0) // normalizes and returns length
+ globalErrorStream() << "DPlane::Rebuild: Bad Normal.\n";
+
+ _d = (normal[0]*points[0][0]) + (normal[1]*points[0][1]) + (normal[2]*points[0][2]);
+
+ VectorCopy(points[0], texInfo.m_p0);
+ VectorCopy(points[1], texInfo.m_p1);
+ VectorCopy(points[2], texInfo.m_p2);
+}
+
+bool DPlane::AddToBrush(scene::Node& brush)
+{
+ bool changed = false;
+ if(!(m_bChkOk || !strcmp(m_shader.c_str(), "textures/common/caulk")))
+ {
+ m_shader = "textures/common/caulk";
+ changed = true;
+ }
+
+ _QERFaceData faceData;
+ faceData.m_p0 = vector3_from_array(points[0]);
+ faceData.m_p1 = vector3_from_array(points[1]);
+ faceData.m_p2 = vector3_from_array(points[2]);
+ faceData.m_texdef = texInfo.m_texdef;
+ faceData.m_shader = m_shader.c_str();
+ GlobalBrushCreator().Brush_addFace(brush, faceData);
+
+ return changed;
+}
+
+void DPlane::ScaleTexture()
+{ }
+
+DPlane::DPlane(const vec3_t va, const vec3_t vb, const vec3_t vc, const char* textureName, bool bDetail)
+{
+ vec3_t v1, v2;
+ VectorSubtract(va, vb, v1);
+ VectorSubtract(vc, vb, v2);
+ CrossProduct(v1, v2, normal);
+
+ if(VectorNormalize(normal, normal) == 0) // normalizes and returns length
+ globalErrorStream() << "DPlane::DPlane: Bad Normal.\n";
+
+ _d = (normal[0]*va[0]) + (normal[1]*va[1]) + (normal[2]*va[2]);
+
+ VectorCopy(va, points[0]);
+ VectorCopy(vb, points[1]);
+ VectorCopy(vc, points[2]);
+
+ m_bChkOk = true;
+
+ FillDefaultTexture(&texInfo, points[0], points[1], points[2], textureName);
+ if(bDetail)
+ texInfo.contents |= FACE_DETAIL;
+}
projects / voretournament / voretournament.git / blobdiff