Geometry.h

Go to the documentation of this file.

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

#ifndef __GEOMETRY_H
#define __GEOMETRY_H

#include <esg/Definitions.h>
#include <esg/ESGObject.h>
#include <esg/mesh/Mesh.h>
#include <esg/PointEnv.h>


namespace esg {

class OGSCENE_EXPORT Geometry : public ESGObject {
public:
        static const float EPS; 
        
protected:
        bool _insideOut; // whether to invert normals

protected:
    virtual Mesh* _mesh                 (int /*density*/) const = 0;
    virtual void  _duplicate_attributes (const Geometry& src);
    
    // Geometric transformations
    virtual void _rotateX   (float /* angle */)                            = 0;
    virtual void _rotateY   (float /* angle */)                            = 0;
    virtual void _rotateZ   (float /* angle */)                            = 0;
    virtual void _rotate    (float /* angle */, const Vector3& /* axis */) = 0;
    virtual void _rotate    (const Matrix3&)                               = 0;
    virtual void _translate (float /* x */, float /* y */, float /* z */)  = 0;
    virtual void _transform (const Matrix4&)                               = 0;
    virtual void _scale     (float /* scale */)                            = 0;
            void _translate (const Vector3& v) { _translate(v.x, v.y, v.z); }

public:
        Geometry() : _insideOut(false) {}

        virtual ~Geometry() {}

        void insideOut (bool b) { _insideOut = b; } // invert facet normals

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

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

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

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

        virtual Interval extent (const Vector3& direction) const = 0;

        Interval extent (float x, float y, float z) const {
            return extent(Vector3(x,y,z));
        }
        
        virtual Vector3 centroid (void) const = 0;

        virtual double radius (const Vector3& centroid) const = 0;

        virtual double radius (void) const { return radius(centroid()); }

        Geometry* clone (void) const { return clone(NULL);}

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

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

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

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

        Mesh* mesh (int density = 0) const;

        
        




    // debuging:
    virtual void __debug() {
        fprintf(stderr,"Geometry: No debug info\n");
    }
};

}; // namespace

#endif // __GEOMETRY_H

---