nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "stdmisc.h"
+00027 
+00028 #include "nel/misc/plane.h"
+00029 
+00030 
+00031 namespace       NLMISC
+00032 {
+00033 
+00034 
+00035 //============================================================
+00036 void    CPlane::make(const CVector &normal, const CVector &p)
+00037 {
+00038         CVector v= normal.normed();
+00039         a= v.x;
+00040         b= v.y;
+00041         c= v.z;
+00042         d=-(v*p);               // d=- (ax+by+cz).
+00043 }
+00044 void    CPlane::make(const CVector &p0, const CVector &p1, const CVector &p2)
+00045 {
+00046         CVector v;
+00047 
+00048         v=(p1-p0)^(p2-p1);
+00049         make(v,p1);
+00050 }
+00051 
+00052 
+00053 //============================================================
+00054 bool    CPlane::clipSegmentBack(CVector &p0, CVector &p1) const
+00055 {
+00056         float   d0,d1,decal;
+00057         CVector proj;
+00058 
+00059         d0= (*this)*p0;
+00060         d1= (*this)*p1;
+00061         if(d0<0 && d1<0)
+00062                 return true;
+00063         if(d0>=0 && d1>=0)
+00064                 return false;
+00065         // Clip line.
+00066         decal= (0-d0) / (d1-d0);
+00067         proj= p0+ (p1-p0)*decal;
+00068         if(d0>=0)
+00069                 p0=proj;
+00070         else
+00071                 p1=proj;
+00072         return true;
+00073 }
+00074 bool    CPlane::clipSegmentFront(CVector &p0, CVector &p1) const
+00075 {
+00076         float   d0,d1,decal;
+00077         CVector proj;
+00078 
+00079         d0= (*this)*p0;
+00080         d1= (*this)*p1;
+00081         if(d0>=0 && d1>=0)
+00082                 return true;
+00083         if(d0<0 && d1<0)
+00084                 return false;
+00085         // Clip line.
+00086         decal= (0-d0) / (d1-d0);
+00087         proj= p0+ (p1-p0)*decal;
+00088         if(d0<0)
+00089                 p0=proj;
+00090         else
+00091                 p1=proj;
+00092         return true;
+00093 }
+00094 
+00095 
+00096 //============================================================
+00097 sint    CPlane::clipPolygonBack(CVector in[], CVector out[], sint nIn) const
+00098 {
+00099         sint nOut=0,s,p,i;
+00100         if(nIn<=2) return 0;
+00101 
+00102         s=nIn-1;
+00103 
+00104         for (i=0;i<nIn;i++)
+00105         {
+00106                 p=i;
+00107                 if ( (*this)*in[p] < 0 )
+00108                 {
+00109                         if ( (*this)*in[s] > 0 ) 
+00110                                 out[nOut++]= intersect(in[s],in[p]);
+00111                         out[nOut++]=in[p];
+00112                 }
+00113                 else
+00114                 {
+00115                         if ( (*this)*in[s] < 0 ) 
+00116                                 out[nOut++]= intersect(in[s],in[p]);
+00117                 }
+00118                 s=p;
+00119         }
+00120 
+00121         return nOut;
+00122 }
+00123 
+00124 //============================================================
+00125 sint    CPlane::clipPolygonFront(CVector in[], CVector out[], sint nIn) const
+00126 {
+00127         sint nOut=0,s,p,i;
+00128         if(nIn<=2) return 0;
+00129 
+00130         s=nIn-1;
+00131 
+00132         for (i=0;i<nIn;i++)
+00133         {
+00134                 p=i;
+00135                 if ( (*this)*in[p] > 0 )
+00136                 {
+00137                         if ( (*this)*in[s] < 0 ) 
+00138                                 out[nOut++]= intersect(in[s],in[p]);
+00139                         out[nOut++]=in[p];
+00140                 }
+00141                 else
+00142                 {
+00143                         if ( (*this)*in[s] > 0 ) 
+00144                                 out[nOut++]= intersect(in[s],in[p]);
+00145                 }
+00146                 s=p;
+00147         }
+00148 
+00149         return nOut;
+00150 }
+00151 
+00152 
+00153 //============================================================
+00154 CPlane  CPlane::inverted() const
+00155 {
+00156         return CPlane(-a, -b, -c, -d);
+00157 }
+00158                 
+00159 //============================================================
+00160 void    CPlane::invert()
+00161 {
+00162         a = -a;
+00163         b = -b;
+00164         c = -c;
+00165         d = -d;
+00166 }
+00167 
+00168 
+00169 
+00170 
+00171 }
+00172 
+
plane.cpp
