FDH14.h

Go to the documentation of this file.

/* $Id: FDH14.h,v 1.5 2002/12/05 19:30:18 cvs Exp $ */

#ifndef __FDH_14_H
#define __FDH_14_H

#include <esg/geometry/FDH.h>

namespace esg {

class OGSCENE_EXPORT FDH14 : public FDH {
        friend class FDH14Tree;
        friend class FDH14DistRot;
  
private:
        static const double   SCALE; 
  
public:
        static const unsigned DIRS;          
        static const unsigned SIZE;          
        static const float    FDHMat[14][3]; 


        class RotInfo; 

protected:
        // Geometric transformations
        // ATTENTION: There is not real rotation but FDH recreated
        //            from rotated FDH
        virtual void _rotateX   (float /* angle */);
        virtual void _rotateY   (float /* angle */);
        virtual void _rotateZ   (float /* angle */);
        virtual void _rotate    (float /* angle */, const Vector3& /* axis */);
        virtual void _rotate    (const Matrix3&);
        virtual void _transform (const Matrix4&);

        virtual Mesh* _mesh                 (int /* not used */) const;
        virtual void  _duplicate_attributes (const Geometry&);

        FDH14 () : FDH(DIRS, FDHMat) {}
  
public:
        FDH14 (SceneGraphObject& object)
            : FDH(DIRS, FDHMat, object) {}

        FDH14 (List<SceneGraphObject>& list)
            : FDH(DIRS, FDHMat, list) {}

        FDH14(const Geometry& geom1, const Geometry& geom2)
            : FDH(DIRS, FDHMat, geom1, geom2) {}

        FDH14 (const Geometry& geom)
            : FDH(DIRS, FDHMat, geom) {}

        FDH14 (const float values[])
            : FDH(DIRS, FDHMat, values) {}

        virtual void rayIntersection (PointEnv*      pPE,
                                      int            mask,
                                      const Vector3& origin,
                                      const Vector3& direction,
                                      float          maxDist = MAXFLOAT);

        virtual Interval extent (const Vector3& direction) const;

        virtual Geometry* clone (const Matrix4* pTrMat) const;
};




//                         subclass FDH14::RotInfo                           //

class FDH14::RotInfo { 
        friend class FDH14;

private:
        static const double   ROT_EPS;   
        static const double   ROT_SCALE; 
  
public:
        struct FDH_Precomp { 
                int   p[4];
                float v1[3], v2[3];
                float tau; 
        };
  
protected:
        static const int _SgnCtrl[8][4];  

        FDH_Precomp* r;         
        float        mat[4][4]; 
        int          rotation;  
  
protected:
        inline void  fdh_precomp (FDH_Precomp *r, const float c[]);


  //---------------------------------------------------
public:
        RotInfo ();

        RotInfo (const float trMat[4][4]);

        RotInfo (const Matrix4f& trMat);

        RotInfo (const Vector3& direction);
        
        virtual ~RotInfo() { if (r) delete [] r; }

        static float fast_lp (const FDH_Precomp& r, // Precomp. values for FDH
                              const float        origFDH[]) { // Original FDH
            return (((origFDH[r.p[2]] + origFDH[r.p[3]]) * ROT_SCALE
                     -(origFDH[r.p[0]] + origFDH[r.p[1]]) < -ROT_EPS)
                    ?
                    origFDH[r.p[1]] * r.v2[0] +
                    origFDH[r.p[2]] * r.v2[1] +
                    origFDH[r.p[3]] * r.v2[2] + r.tau
                    :
                    origFDH[r.p[0]] * r.v1[0] +
                    origFDH[r.p[1]] * r.v1[1] +
                    origFDH[r.p[2]] * r.v1[2] + r.tau);
        }

        void recompute (const float trMat[4][4]);

        void recompute (const Matrix4f& trMat);

        void recompute (const Vector3& direction);

        FDH_Precomp get (int index) const { return r[index]; }

        RotInfo* clone (void) const;

        Matrix4 getMat (void) const;
}; //RotInfo

}; // namespace

#endif // __FDH_14_h

---