Hemisphere.h

Go to the documentation of this file.

/* $Id:$ */

#ifndef __HEMISPHERE_H
#define __HEMISPHERE_H

#include <esg/geometry/Sphere.h>

namespace esg {

class Hemisphere : public Sphere {
protected:
        Vector3 _xAxis, _yAxis, _zAxis;
        bool    _backfaceCulling;

protected:
        virtual Mesh* _mesh      (int /* density */) const; 
        virtual void  _duplicate_attributes (const Geometry&);
        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&);
    
public:
        Hemisphere (const Vector3& c,
                    float          r,
                    const Vector3& z,
                    bool           bfc = false);

        Hemisphere (const Vector3& z, bool bfc = false);

        Hemisphere (bool bfc = false);

        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; // to change?

        virtual double radius (const Vector3& centroid) const;

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

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

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

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

        Vector3 getZenith(void) const { return _zAxis; }

        void setZenith(const Vector3& zenith);

    
        inline Vector3 world2local3D(const Vector3& dir) const {
            return Vector3(dir.x*_xAxis.x + dir.y*_xAxis.y + dir.z*_xAxis.z,
                           dir.x*_yAxis.x + dir.y*_yAxis.y + dir.z*_yAxis.z,
                           dir.x*_zAxis.x + dir.y*_zAxis.y + dir.z*_zAxis.z);
        }

        Vector2 world2local2D(const Vector3& dir) const;


        Vector3 sampleUniformly(double  elevationRand,
                                double  azimuthRand,
                                double* pPDFval) const;

        Vector2 sampleUniformly2D(double  elevationRand,
                                  double  azimuthRand,
                                  double* pPDFval) const;

        Vector2 dir2uvUniformly(const Vector3& dir) const;

        Vector3 samplePriorToZenith(double  elevationRand,
                                    double  azimuthRand,
                                    double* pPDFVal) const;

        Vector2 samplePriorToZenith2D(double  elevationRand,
                                      double  azimuthRand,
                                      double* pPDFVal) const;

        Vector2 dir2uvPriorToZenith(const Vector3& dir) const;

        Vector3 samplePriorToPoweredZenith(double  elevationRand,
                                           double  azimuthRand,
                                           int     power,
                                           double* pPDFVal) const;

        Vector2 samplePriorToPoweredZenith2D(double  elevationRand,
                                             double  azimuthRand,
                                             int     power,
                                             double* pPDFVal) const;

        Vector2 dir2uvPriorToPoweredZenith(const Vector3& dir,int power) const;
};

}; // namespace

#endif // __HEMISPHERE_H

---