IrradianceCache.h

Go to the documentation of this file.

/* $Id:$ */

#ifndef __IRRADIANCE_CACHE_H
#define __IRRADIANCE_CACHE_H

#include <esg/Definitions.h>
#include <vector>
#include <stdexcept>

namespace esg {

    class OGSCENE_EXPORT IrradianceCache {
        public:
            class Value; 
        protected:
            class Node;  
            
        protected:
            const float maxError; 

            IrradianceCache::Node* root; 

            vector< vector<IrradianceCache::Value*>* > treeValuesBuffer;


        protected:

            bool isInside(const Vector3& position) const;


        public:
            IrradianceCache(float mError, float rootSize) throw (out_of_range);


            virtual ~IrradianceCache();


            void addValue(const Vector3& pos,
                          const Vector3& normal,
                          const Color3f& irrad,
                          float meanDistance) throw (out_of_range);


            void getValue(const Vector3&                   pos,
                          const Vector3&                   normal,
                          vector<IrradianceCache::Value*>& buffer)
                const throw (out_of_range);


            unsigned int getNumStoredValues() const;


            unsigned int getNumNodes() const;


            const IrradianceCache::Value* getNextValuePointer();


            inline void resetValuePointer() {
                treeValuesBuffer.clear();
            }

    }; // class




    /*******************************************************************
     * Irradiance value stored in the octree
     */

    class IrradianceCache::Value {
        private:
            Vector3 position;     
            Vector3 normal;       
            Color3f irradiance;   
            float   meanDistance; 
            float   weight;       

        public:
            Value();

            Value(const Vector3& pos,
                  const Vector3& normal,
                  const Color3f& irrad,
                  float          meanDistance);
            
            ~Value() {};


            bool checkDomain(const Vector3& position,
                             const Vector3& normal,
                             float          maxError);

            friend ostream& operator << (ostream&     out,
                                         const Value& irradValue) {
                out << "location: " << irradValue.position
                    << ", normal: " << irradValue.normal
                    << ", harmonic mean distance: " << irradValue.meanDistance
                    << ", irradiance: " << irradValue.irradiance
                    << ", weighta: " << irradValue.weight;
                return out;
            }

            inline float getWeight() const { return weight; }

            inline const Color3f& getIrradiance() const { return irradiance; }

            inline const Vector3& getPosition() const { return position; }

            inline const Vector3& getNormal() const { return normal; }

            inline const float getMeanDistance() const { return meanDistance; }     
    }; // class



    
        
    /*******************************************************************
     * Node of the irradiance cache octree
     */

    class IrradianceCache::Node {
        protected:
            vector<IrradianceCache::Value*> irradianceValues; 
            Node*         subnodes[8];   
            const Vector3 center;        
            const float   size;          

        protected:
            void allocate(unsigned int nodeIndex);


            inline bool isAllocated(unsigned int nodeIndex) const {
                return (subnodes[nodeIndex]);
            }


            unsigned int selectSubnode(const Vector3& position) const;


            bool necessaryToSearch(const Vector3& position) const;


        public:
            Node(float s, float cX, float cY, float cZ);


            virtual ~Node();

            void addValue(const Vector3& position,
                          const Vector3& normal,
                          const Vector3& color,
                          float          meanDistance,
                          float          minSize,
                          float          maxSize);


            void getValue(const Vector3&                   position,
                          const Vector3&                   normal,
                          vector<IrradianceCache::Value*>& buffer,
                          float                            maxError);


            unsigned int getNumStoredValues() const;


            unsigned int getNumNodes() const;

            
            inline float getSize() const  { return size; }


            void getNodeValues(vector<vector<IrradianceCache::Value*>*>& irValues);
    }; // class

};

#endif // __IRRADIANCE_CACHE_H

---