OpenSceneGraph/include/osg/LOD

//C++ header - Open Scene Graph - Copyright (C) 1998-2001 Robert Osfield
//Distributed under the terms of the GNU Library General Public License (LGPL)
//as published by the Free Software Foundation.

#ifndef OSG_LOD
#define OSG_LOD 1

#include <osg/Group>

namespace osg {

/** LOD - Level Of Detail group node which allows switching between children
    depending on distance from eye point.
    Typical uses are for load balancing - objects further away from
    the eye point are rendered at a lower level of detail, and at times
    of high stress on the graphics pipeline lower levels of detail can
    also be chosen.
    The children are ordered from most detailed (for close up views) to the least 
    (see from a distance), and a set of ranges are used to decide which LOD is used 
    at different view distances, the criteria used is child 'i' is used when 
    range[i]<dist<range[i+1] is true. This requires there to be n+1 range values where the number of
    children is n, since no maximum distance of infinity is assumed.  If the number of range values (m)
    is insufficient then the children m through to n will be ignored, only 0..m-1 will be used
    during rendering.
*/
class SG_EXPORT LOD : public Group
{
    public :
    
        LOD() {}

        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/
        LOD(const LOD&,const CopyOp& copyop=CopyOp::SHALLOW_COPY);

        META_Node(LOD);

        virtual void traverse(NodeVisitor& nv);
        
        /** Sets the value of range list element index to range which
            is a floating point distance specified in world coordinates.
            Range list automatically expands to accommodate values beyond
            the current getNumRanges().*/
        void setRange(const unsigned int index, const float range);
        
        /** returns the range for specified index.*/
        inline const float getRange(const unsigned int index) const { return _rangeList[index]; }
        
        /** returns the number of ranges currently set.*/
        inline const int getNumRanges() const { return _rangeList.size(); }

        /** Sets the object-space point which defines the center of the osg::LOD.  
            center is affected by any transforms in the hierarchy above the osg::LOD.*/
        inline void setCenter(const Vec3 &center) { _center = center; }
        
        /** return the LOD center point. */
        inline const Vec3& getCenter() const { return _center; }


        /** Callback attached to an LOD which allows the users to customize the selection of LOD children.*/
        struct EvaluateLODCallback : public osg::Referenced
        {
            /** Compute the child to select.*/
            virtual const int evaluateLODChild(const osg::LOD* lod, const Vec3& eye_local, const float bias) const;
        };
        
        friend struct osg::LOD::EvaluateLODCallback;

        /** Set the EvaluateLODCallback which allows users to attach customize computation of the the selection of LOD children.*/
        void setEvaluateLODCallback(EvaluateLODCallback* cbc) { _evaluateLODCallback=cbc; }
        
        /** Get the non const ComputeBillboardCallback.*/
        EvaluateLODCallback* getEvaluateLODCallback() { return _evaluateLODCallback.get(); }
        
        /** Get the const ComputeBillboardCallback.*/
        const EvaluateLODCallback* getEvaluateLODCallback() const { return _evaluateLODCallback.get(); }        



        /** return the child to traverse.
            Selected by the distance between the eye point in local
            coordinates and the LOD center, multiplied by the bias.*/ 
        inline const int evaluate(const Vec3& eye_local,const float bias=1.0f) const
        {
            if (_evaluateLODCallback.valid())
                return _evaluateLODCallback->evaluateLODChild(this,eye_local,bias);
            else
                return evaluateLODChild(eye_local,bias);
        }


    protected :
        virtual ~LOD() {}

        virtual const int evaluateLODChild(const Vec3& eye_local,const float bias) const;

        typedef std::vector<float> RangeList;
        RangeList _rangeList;
        RangeList _rangeList2;
        
        ref_ptr<EvaluateLODCallback>   _evaluateLODCallback;

        Vec3 _center;


};

}

#endif