FDH.h

Go to the documentation of this file.

/* $Id: FDH.h,v 1.4 2002/11/05 14:31:15 anonymous Exp $ */

#ifndef __FDH_H
#define __FDH_H

#include <esg/Definitions.h>
#include <esg/SceneGraphObject.h>
#include <esg/List.h>
#include <esg/geometry/Geometry.h>

namespace esg {

class OGSCENE_EXPORT FDH : public Geometry {
public:
        static const unsigned DIRS;        
        static const unsigned SIZE;        
        static const float    FDHMat[][3]; 

        struct FDHCache : public Cache {
                float * dval;
                float * oval;
        
                FDHCache(unsigned dirs) {
                    dval = new float[dirs];
                    oval = new float[dirs];
                }
        
                FDHCache(const float (*mat)[3], unsigned dirs,
                         const Vector3& o, const Vector3& d) {
                    dval = new float [dirs];
                    oval = new float [dirs];
                    for (register unsigned i = 0; i < dirs; i++) {
                        dval[i]=mat[i][0]*d.x + mat[i][1]*d.y + mat[i][2]*d.z;
                        oval[i]=mat[i][0]*o.x + mat[i][1]*o.y + mat[i][2]*o.z;
                    }
                }
        
                virtual ~FDHCache () { delete [] oval; delete [] dval; }
        };
    
protected:
        float*         _values;    
        const unsigned _dirs;      
        const float    (*_mat)[3]; 

protected:
        int _cut_line (Vector3d&,  // Point of line
                       Vector3d&   // Line's direction, second point in output
                       ) const; 
    
        virtual Vector3d* _get_corners(unsigned&  numCorners,
                                       unsigned (*facetVert)[100],
                                       unsigned   nFacetCert[]) const;
        virtual Mesh*     _mesh(int /* not used */) const;
        virtual void      _duplicate_attributes (const Geometry&);

        // 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 _translate (float /* x */, float /* y */, float /* z */);
        virtual void _transform (const Matrix4&);
        virtual void _scale     (float);
        
        FDH (unsigned d, const float(*m)[3]) : _dirs(d), _mat(m) {}
    
public:
        FDH (unsigned          dirs,
             const float     (*mat)[3],
             SceneGraphObject& object);

        FDH (unsigned                dirs,
             const float           (*mat)[3],
             List<SceneGraphObject>& list);

        FDH (unsigned          dirs,
             const float     (*mat)[3],
             const Geometry&   geom1,
             const Geometry&   geom2);

        FDH (unsigned          dirs,
             const float     (*mat)[3],
             const Geometry&   geom);

        FDH (unsigned      dirs,
             const float (*mat)[3],
             const float   values[]);

        virtual ~FDH ();

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

        virtual bool mapToUV (const Vector3& v, Vector2& uv);

        virtual void randomSample (int mask, PointEnv& pe, double* pdf);

        virtual bool randomDirection (const Vector3& pov,
                                      Vector3&       dir,
                                      double*        pdf);

        virtual Interval extent (const Vector3& direction) const;

        virtual Vector3 centroid (void) const;

        virtual double radius (const Vector3& centroid) const;

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

        virtual bool separation (Geometry& geom, Vector3*  pDir);

        virtual double distance (const Geometry& geom, Vector3* pDir);

        virtual void dump (const char* intent, const char* tab);


        virtual bool checkVolume (void) const;

        virtual void __debug() {
            fprintf(stderr,"FDH Values:\n");
            for(unsigned i=0;i<_dirs;i++) fprintf(stderr,"%f ",_values[i]);
            fprintf(stderr," - ");
            for(unsigned i=0;i<_dirs;i++) fprintf(stderr,"%f ",-_values[i+_dirs]);
            fprintf(stderr,"\n");
        }
    
};


    
    /**************************************************************
     * Macros for Liang-Barsky line clipping algorithm            *
     *                                                            *
     * t1 = -(N * P_0 + D_1) / (N * P_1)                          *
     * t2 = -(N * P_0 + D_2) / (N * P_1)                          *
     * where N is normal vector of half-space (FDH direction)     *
     *       P_0 is origin of ray                                 *
     *       P_1 is direction of ray                              *
     *       D_1, D_2 are plane distances (FDH values)            *
     **************************************************************/

#ifndef FDH_CLIP_LINE_INIT
#define FDH_CLIP_LINE_INIT(o, d, i1, i2) { \
   if (d != 0.0) { \
      if (d > 0.0) { \
          t_out = (_values[i1] - o) /  d; \
          if (t_out < Geometry::EPS) return; \
          t_in  = (_values[i2] + o) / -d; \
          if (t_in > maxDist)       return; \
      } else { \
          t_in  = (_values[i1] - o) /  d; \
          if (t_in > maxDist)       return; \
          t_out = (_values[i2] + o) / -d; \
          if (t_out < Geometry::EPS) return; \
      } \
  } else { \
      if ((o < -_values[i2]) || (o > _values[i1])) return; \
      t_in  =  -MAXFLOAT+1; \
      t_out =   MAXFLOAT; \
  } \
}
#endif

#ifndef FDH_CLIP_LINE_CONT
#define FDH_CLIP_LINE_CONT(o, d, i1, i2) { \
   if (d != 0.0) { \
      if (d > 0.0) { \
          t1 = (_values[i2] + o) / -d; \
          if (t1 > maxDist) return; \
          t2 = (_values[i1] - o) /  d;  \
      } else { \
          t1 = (_values[i1] - o) /  d; \
          if (t1 > maxDist) return; \
          t2 = (_values[i2] + o) / -d; \
      } \
      if (t2 < t_out) { /* optimized order of tests taken from POV-ray */ \
          if (t2 < Geometry::EPS) return; \
          if (t1 > t_in) { if (t1 > t2) return; t_in = t1; } \
          else if (t_in > t2) return; \
          t_out = t2; \
      } else if (t1 > t_in) { if (t1 > t_out) return; t_in = t1; } \
  } else  \
      if ((o < -_values[i2]) || (o > _values[i1])) return; \
}
#endif

#ifndef FDH_CLIP_LINE_INDEX_INIT
#define FDH_CLIP_LINE_INDEX_INIT(o, d, i1, i2) { \
   if (d != 0.0) { \
      if (d > 0.0) { \
          t_out = (_values[i1] - o) /  d; \
          if (t_out < Geometry::EPS) return; \
          t_in  = (_values[i2] + o) / -d; \
          if (t_in > maxDist)       return; \
          plane1 = i2; plane2 = i1; \
      } else { \
          t_in  = (_values[i1] - o) /  d; \
          if (t_in > maxDist)       return; \
          t_out = (_values[i2] + o) / -d; \
          if (t_out < Geometry::EPS) return; \
          plane1 = i1; plane2 = i2; \
      } \
  } else { \
      if ((o < -_values[i2]) || (o > _values[i1])) return; \
      t_in  = -MAXFLOAT+1; \
      t_out =  MAXFLOAT; \
  } \
}
#endif

#ifndef FDH_CLIP_LINE_INDEX_CONT
#define FDH_CLIP_LINE_INDEX_CONT(o, d, i1, i2) { \
   register int a1, a2; \
   if (d != 0.0) { \
      if (d > 0.0) { \
          t1 = (_values[i2] + o) / -d; \
          if (t1 > maxDist) return; \
          t2 = (_values[i1] - o) /  d; \
          a1 = i2; a2 = i1; \
      } else { \
          t1 = (_values[i1] - o) /  d; \
          if (t1 > maxDist) return; \
          t2 = (_values[i2] + o) / -d; \
          a1 = i1; a2 = i2; \
      } \
      if (t2 < t_out) { /* optimized order of tests taken from POV-ray */ \
          if (t2 < Geometry::EPS) return; \
          if (t1 > t_in) { if (t1 > t2) return; t_in = t1; } \
          else if (t_in > t2) return; \
          t_out = t2; plane2 = a2; \
      } else \
          if (t1 > t_in) { if (t1 > t_out) return; t_in = t1; plane1 = a1; }\
  } else  \
      if ((o < -_values[i2]) || (o > _values[i1])) return; \
}
#endif


}; // namespace

#endif // __FDH_H

---