LightArray.h

Go to the documentation of this file.

/* $Id:$ */

#ifndef __LIGHT_ARRAY_EXPLORER_H
#define __LIGHT_ARRAY_EXPLORER_H

#include <esg/explorer/Explorer.h>
#include <esg/Export>

namespace esg {

class OGSCENE_EXPORT LightArray {
        friend class LightsExplorer;
    
public:
        static const ESGint MAX_LIGHTS = 8; 
        static const ESGint LIGHT0;         
        static const ESGint LIGHT1;         
        static const ESGint LIGHT2;         
        static const ESGint LIGHT3;         
        static const ESGint LIGHT4;         
        static const ESGint LIGHT5;         
        static const ESGint LIGHT6;         
        static const ESGint LIGHT7;         

        struct Light {
                Emittance             * pEmittance;
                Matrix4               * pTrMat;
                Geometry              * pGeometry;
                SceneGraphObject::OID   oid;
                Light ()
                    : pEmittance(NULL),pTrMat(NULL),pGeometry(NULL),oid(0) {}
                ~Light () { if (pTrMat) delete pTrMat; }
                void clear () {
                    if (pTrMat) delete pTrMat;
                    pTrMat     = NULL;
                    pEmittance = NULL;
                    pGeometry  = NULL;
                }
        };

        struct BlockingObj {
                SceneGraphObject * pObj;
                Matrix4            trMat;
                bool               transformed;
                BlockingObj () : pObj(NULL), transformed(false) {}
        };
        
protected:
        Light         _lightArray[MAX_LIGHTS]; 
        ESGbitmask    _set;                    
        ESGbitmask    _on;                     
        BlockingObj (*_blockingObjCache)[MAX_LIGHTS]; 
        unsigned      _numCaches;                     

public:
        LightArray (unsigned cache = 0) : _set(0), _on(0), _numCaches(cache){
            _blockingObjCache = new BlockingObj [_numCaches][MAX_LIGHTS];
            for (ESGint i = 0; i < MAX_LIGHTS; i++) 
                for (unsigned j = 0; j < _numCaches; j++) {
                    _blockingObjCache[j][i].pObj = NULL;
                    _blockingObjCache[j][i].transformed = false;
                }
        }

        virtual ~LightArray () {
            for (register ESGint i = 0; i < MAX_LIGHTS; i++)
                if (isSet(i)) _lightArray[i].clear();
            delete [] _blockingObjCache;
        }

        bool isSet (ESGint i) const { return (_set&(1<<i)); }

        bool isOn (ESGint i) const { return (_on&(1<<i)); }

        bool isAnyOn (void) const { return (_on != 0); }
        
        void turnLightOn (ESGint i) { _on |= (_set&(1<<i)); }
        
        void turnLightOff (ESGint i) { _on &= ~(_set&(1<<i)); }
        
        void turnAllOn (void) { _on  = _set; }
        
        void turnAllOff (void) { _on  = 0; }
        
        void turnOn (ESGbitmask m) { _on = (_set&m); }
        
        ESGbitmask getOnMask (void) const { return _on; }
        
        ESGbitmask getSetMask (void) const { return _set; }

        void clear (void) {
            for (register ESGint i = 0; i < MAX_LIGHTS; i++) 
                if (_set&(1<<i)) _lightArray[i].clear();
            _set = 0;
        }

        //Light& operator [] (ESGint i) { return _lightArray[i]; }

        Light& light (ESGint i) { return _lightArray[i]; }

        void setEmittance (ESGint i, Emittance* e) {
            _lightArray[i].pEmittance = e;
            if (e) { isSet(i); isOn(i); }
        }

        Emittance* getEmittance (ESGint i) { return _lightArray[i].pEmittance; }

        void setTransformation (ESGint i, const Matrix4& m) {
            if (_lightArray[i].pTrMat) delete _lightArray[i].pTrMat;
            _lightArray[i].pTrMat = new Matrix4(m);
        }

        Matrix4* getTransformation (ESGint i) { return _lightArray[i].pTrMat; }

        void setGeometry (ESGint i, Geometry* g) {
            _lightArray[i].pGeometry = g;
        }

        Geometry* getGeometry (ESGint i) { return _lightArray[i].pGeometry; }

        void setOID (ESGint i, SceneGraphObject::OID oid) {
            _lightArray[i].oid = oid;
        }

        SceneGraphObject::OID getOID(ESGint i) const {
            return _lightArray[i].oid;
        }

        bool emitPhoton (Vector3& o, Vector3& d, Color3f& p, ESGint i) const {
            const Light* l = &_lightArray[i];
            if (!l->pEmittance)                        return false;
            if (!l->pEmittance->stochasticEmission(d)) return false;
            if (!l->pEmittance->intensity(p))          return false;
            if (l->pEmittance->fitToGeometry() && l->pGeometry) {
                PointEnv pe;
                l->pGeometry->randomSample(ENV_WANT_SURFACE_POINT | (l->pEmittance->haveDirection() ? ENV_WANT_NORMAL : ENV_WANT_NOTHING), pe, NULL);
                if (pe.mask & ENV_HAVE_SURFACE_POINT) o.set(pe.intersection);
                if (l->pEmittance->haveDirection() && (pe.mask & ENV_HAVE_NORMAL))
                    l->pEmittance->setBeamDirection(pe.normal);
            } else {
                if (!l->pEmittance->haveLocation())    return false;
                if (!l->pEmittance->sourceLocation(o)) return false;
            }

            if (l->pTrMat) {
                Matrix3 rMat;
                l->pTrMat->get(rMat);
                l->pTrMat->transform(o);
                rMat.transform(d);
            }
            
            return true;
        }

        const BlockingObj* getBlockingObject (unsigned cache, ESGint light) const {
            return ((cache < _numCaches && light < MAX_LIGHTS && light >= 0) ?
                    &(_blockingObjCache[cache][light]) :
                    NULL);
        }

        bool setBlockingObj (unsigned          cache,
                             ESGint            light,
                             SceneGraphObject* pObj,
                             const Matrix4*    pMat) {
            if (cache>=_numCaches||light>=MAX_LIGHTS||light<0) return false;
            _blockingObjCache[cache][light].pObj = pObj;
            if (pMat) {
                _blockingObjCache[cache][light].trMat.set(*pMat);
                _blockingObjCache[cache][light].transformed = true;
            } else 
                _blockingObjCache[cache][light].transformed = false;
            return true;
        }
};
    
}; // namespace

#endif // __LIGHT_ARRAY_EXPLORER_H

---