PointEnv.h

Go to the documentation of this file.

/* $Id:$ */

#ifndef __POINT_ENV_H
#define __POINT_ENV_H

#include <esg/Definitions.h>

namespace esg {

#define ENV_WANT_NOTHING        (0<<0)  
#define ENV_WANT_INTERFERENCE   (1<<0)  
#define ENV_WANT_INTERSECTION   (1<<1)  
#define ENV_WANT_SURFACE_POINT  (1<<1)  
#define ENV_WANT_NORMAL         (1<<2)  
#define ENV_WANT_ASOC_PRIMITIVE (1<<3)  
#define ENV_WANT_DISTANCE       (1<<4)  
#define ENV_WANT_TRANSFORMATION (1<<5)  
#define ENV_WANT_ENERGY         (1<<6)  
#define ENV_WANT_N_DOT_D        (1<<7)  
#define ENV_WANT_N_DOT_O        (1<<8)  
#define ENV_WANT_UV_COORD       (1<<9)  
#define ENV_WANT_VIEWER_DIR     (1<<10) 


#define ENV_USE_CACHE           (1<<11) 


#define ENV_HAVE_NOTHING        ENV_WANT_NOTHING        
#define ENV_HAVE_INTERFERENCE   ENV_WANT_INTERFERENCE   
#define ENV_HAVE_INTERSECTION   ENV_WANT_INTERSECTION   
#define ENV_HAVE_SURFACE_POINT  ENV_WANT_SURFACE_POINT  
#define ENV_HAVE_NORMAL         ENV_WANT_NORMAL         
#define ENV_HAVE_ASOC_PRIMITIVE ENV_WANT_ASOC_PRIMITIVE 
#define ENV_HAVE_DISTANCE       ENV_WANT_DISTANCE       
#define ENV_HAVE_TRANSFORMATION ENV_WANT_TRANSFORMATION 
#define ENV_HAVE_ENERGY         ENV_WANT_ENERGY         
#define ENV_HAVE_N_DOT_D        ENV_WANT_N_DOT_D        
#define ENV_HAVE_N_DOT_O        ENV_WANT_N_DOT_O        
#define ENV_HAVE_UV_COORD       ENV_WANT_UV_COORD       
#define ENV_HAVE_VIEWER_DIR     (1<<10)                 


// Visitable object means node of scene graph allowing its instection
// by VISITOR pattern, typically it is primitive or its specialization
class OGSCENE_EXPORT PointEnv {
public:
        /*
         * Normal at the PoI can be either oriented outwards the object,
         * inward the object or can be unknown (random)
         */
        enum NormalOrientation {
            OUTWARDS_NORMAL,
            INWARDS_NORMAL,
            RANDOM_NORMAL
        };
        
public:
        Color3f    energy;          
        Vector3    intersection;    
        Vector2    uvCoord;         
        Vector3    normal;          
        SceneGraphObject* pVisitableObj; 
        int        mask;            
        NormalOrientation normalOrientation; 
        Matrix4    trMat;           
        Vector3    viewerDir;       
        double     distance;        
        double     nd;              
        double     no;              
        Cache*     pCache;          

public:
        PointEnv ()
            : pVisitableObj(NULL),
              mask(ENV_HAVE_NOTHING),
              normalOrientation(RANDOM_NORMAL),
              pCache(NULL)
              {
                  trMat.setIdentity();
              }

        virtual ~PointEnv() { if (pCache)  delete pCache; }

        /*
    inline void init (void)
    {
        _mask = ENV_HAVE_NOTHING;
        _pVisitableObj = NULL;
        _pCache = NULL;
    }

    inline void setEnergy (const Color3f& c)
    {
        _energy.set(c);
        _mask |= ENV_HAVE_ENERGY;
    }
    
    inline void setIntersection (const Vector3& i)
    {
        _intersection.set(i);
        _mask |= ENV_HAVE_INTERSECTION|ENV_HAVE_INTERFERENCE;
    }

    inline void setUVCoord (const Vector2& c)
    {
        _uvCoord.set(c);
        _mask |= ENV_HAVE_UV_COORD;
    }

    inline void setUVCoord (float u, float v)
    {
        _uvCoord.set(u, v);
        _mask |= ENV_HAVE_UV_COORD;
    }

    inline void setUVCoord (double u, double v)
    {
        _uvCoord.set(u, v);
        _mask |= ENV_HAVE_UV_COORD;
    }

    inline void setNormal (const Vector3& n, NormalOrientation o)
    {
        _normal.set(n);
        _normalOrientation = o;
        _mask |= ENV_HAVE_NORMAL;
    }

    inline void setVisitableObject (SceneGraphObject* o)
    {
        _pVisitableObj = o;
        ((o)
         ? _mask |= ENV_HAVE_ASOC_PRIMITIVE
         : _mask &= ~ENV_HAVE_ASOC_PRIMITIVE);
    }

    inline void setTransform (const Matrix4& m)
    {
        _trMat.set(m);
        _mask |= ENV_HAVE_TRANSFORMATION;
    }

    inline void setDistance (double d)
    {
        _distance = d;
        _mask |= ENV_HAVE_DISTANCE;
    }

    inline void setAngleND (double a)
    {
        _nd = a;
        _mask |= ENV_HAVE_N_DOT_D;
    }

    inline void setAngleNO (double a)
    {
        _no = a;
        _mask |= ENV_HAVE_N_DOT_O;
    }

    inline void setInterference (void)
    {
        _mask |= ENV_HAVE_INTERFERENCE;
    }

    inline void setViewerDir (const Vector3& v)
    {
        _viewerDir.set(v);
        _mask |= ENV_HAVE_VIEWER_DIR;
    }

    inline void setCache (Cache* c)
    {
        _pCache = c;
    }

    inline const Color3f& energy       (void) const { return _energy;       }
    inline const Vector3& intersection (void) const { return _intersection; }
    inline const Vector2& uvCoord      (void) const { return _uvCoord;      }
    inline const Vector3& normal       (void) const { return _normal;       }
    inline const Matrix4& transform    (void) const { return _trMat;        }
    inline const Vector3& viewerDir    (void) const { return _viewerDir;    }
    inline const double   distance     (void) const { return _distance;     }
    inline const double   angleND      (void) const { return _nd;           }
    inline const double   angleNO      (void) const { return _no;           }
    inline const NormalOrientation normalOrientation (void) const {
        return _normalOrientation;
    }
    inline SceneGraphObject* visitableObject (void) { return _pVisitableObj; }
    inline Cache* cache (void) { return _pCache; }
    //inline int mask (void) const { return _mask; }
    */
    
};

}; // namespace

#endif // __POINT_ENV_H

---