---

CPlane.h

Go to the documentation of this file.

/*
        
        ZMACHINE 2.0 (SIGFRID)

        CPLANE.H

        author:                 Trombetta Roberto
        filename:               CPlane.h        
        description:    header file for plane class 
        date:                   10/02/2003

*/

#ifndef __CPLANE_H_
#define __CPLANE_H_

#define ZD_PLANE_INT_COINCIDENT 0
#define ZD_PLANE_INT_ALLIN              1
#define ZD_PLANE_INT_ALLOUT             2       
#define ZD_PLANE_INT_OK                 3

#define ZD_PLANE_MAX_COORD_X    0       
#define ZD_PLANE_MAX_COORD_Y    1
#define ZD_PLANE_MAX_COORD_Z    2


#include "CVector3.h"
#include "CMatrix.h"
#include "Zdef.h"
#include "Zmacro.h"


class CPlane {

public:
        
        zfloat fA,fB,fC,fD; 

        inline CPlane () {};

        inline CPlane (zfloat a, zfloat b, zfloat c, zfloat d) {fA=a; fB=b; fC=c; fD=d;};

        inline CPlane (const CVector3 &v1, const CVector3 &v2, const CVector3 &v3) {  
                
                CVector3 e;
                e.NormUnit(v1,v2,v3);

                fA = e.fCoord[0];
                fB = e.fCoord[1];
                fC = e.fCoord[2];
                fD = - (fA*v1.fCoord[0]+fB*v1.fCoord[1]+fC*v1.fCoord[2]);
        
        }


        inline CPlane (const CVector3 &v, const CVector3 &n) {
        
                fA = n.fCoord[0];
                fB = n.fCoord[1];
                fC = n.fCoord[2];               
                fD = - (fA*v.fCoord[0]+fB*v.fCoord[1]+fC*v.fCoord[2]);  
        
        }


        inline CPlane (const CPlane &p, zfloat dist) {
        
                fA = p.fA;
                fB = p.fB;
                fC = p.fC;              
                fD = p.fD+dist;
                        
        }

        inline CVector3 Norm () const { return CVector3 (fA,fB,fC);}

        inline CVector3 NormUnit () const { 
                
                zfloat module = (zfloat) sqrt (fA*fA+fB*fB+fC*fC);
                return CVector3 (fA/module, fB/module, fC/module);

        }

        inline zfloat Dist (const CVector3 &v) const { 
                
                return (fA*v.fCoord[0]+fB*v.fCoord[1]+fC*v.fCoord[2]+fD);
        
        } 


        inline bool IntersectPlanes (const CPlane &P2, const CPlane &P3, CVector3 &inter) const {

                CMatrix M  ((*this).fA, (*this).fB, (*this).fC, P2.fA, P2.fB, P2.fC, P3.fA, P3.fB, P3.fC); 
                CMatrix X  (-(*this).fD, (*this).fB, (*this).fC, -P2.fD, P2.fB, P2.fC, -P3.fD, P3.fB, P3.fC); 
                CMatrix Y  ((*this).fA, -(*this).fD, (*this).fC, P2.fA, -P2.fD, P2.fC, P3.fA, -P3.fD, P3.fC); 
                CMatrix Z  ((*this).fA, (*this).fB, -(*this).fD, P2.fA, P2.fB, -P2.fD, P3.fA, P3.fB, -P3.fD);
        
                zfloat det = M.determinant3();

                if ZM_FLOAT_EQ(det,0) return false;

                inter = CVector3 (X.determinant3()/det, Y.determinant3()/det, Z.determinant3()/det);

                return true;
        }


        inline zuint RayIntersection (const CVector3 &v1, const CVector3 &v2,CVector3 &result) const {
        
                zfloat fDist1 = Dist(v1);
                zfloat fDist2 = Dist(v2);

                if (ZM_FLOAT_EQ(fDist1,0)&&(ZM_FLOAT_EQ(fDist2,0))) {result = v1; return ZD_PLANE_INT_COINCIDENT;}
        
                if ((fDist1 > ZD_EPSILON) && (fDist2 > ZD_EPSILON)) return ZD_PLANE_INT_ALLIN;
                if ((fDist1 < -ZD_EPSILON) && (fDist2 < -ZD_EPSILON)) return ZD_PLANE_INT_ALLOUT;

                zfloat d = fDist1/(fDist1-fDist2);

                result = (v1 + ((v2-v1) * d));

                return ZD_PLANE_INT_OK;
        
        }


        inline zuint MaxNormCoord () const {
        
                if ((fabs(Norm().fCoord[0]) >= fabs(Norm().fCoord[1])) && 
                        (fabs(Norm().fCoord[0]) >= fabs(Norm().fCoord[2]))) 

                        return ZD_PLANE_MAX_COORD_X;

                if ((fabs(Norm().fCoord[1]) >= fabs(Norm().fCoord[0])) && 
                        (fabs(Norm().fCoord[1]) >= fabs(Norm().fCoord[2]))) 

                        return ZD_PLANE_MAX_COORD_Y;

                if ((fabs(Norm().fCoord[2]) >= fabs(Norm().fCoord[0])) && 
                        (fabs(Norm().fCoord[2]) >= fabs(Norm().fCoord[1]))) 

                        return ZD_PLANE_MAX_COORD_Z;

                return 0;       
        }


};

#endif

---