source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderQueue.h @ 3110

#ifndef __RENDERQUEUE_H
#define __RENDERQUEUE_H

#include "common.h"


namespace CHCDemoEngine 
{

class RenderState;
class Camera;

typedef std::pair<Shape *, SceneEntity *> ShapePair;
typedef std::vector<ShapePair> ShapePairArray;

/** Defines a bucket for scene entities that have the same properties.
*/
struct RenderQueueBucket
{
        inline bool IsEmpty() const { return mShapes.empty();}


        ////////
        //-- the attributes used to sort the materials
        
        // texture related parameters
        int mTexHeight;
        int mTexWidth;
        int mTexFormat;

        bool mHasTexture;

        bool mColorWriteEnabled;
        bool mDepthWriteEnabled;
        bool mLightingEnabled;

        bool mAlphaTestEnabled;
        bool mCullFaceEnabled;

        //bool mHasVertexProgram;
        //bool mHasFragmentProgram;
        ShaderProgram *mVertexProgram;
        ShaderProgram *mFragmentProgram;
        /// the shapes that belong to a bucket
        ShapePairArray mShapes;
        /// minimal distance to the camera
        //float mMinDistance;
};


/** This class implements a render queue that sorts renderable geometry in order
        to minimize state changes while approximately keeping front-to-back order
        The implementation roughly follows the suggested implementation in 
        Tom Forsyth's article on render state changes. It assumes that the incoming
        objecs are roughly front to back level and therefore does not require any sorting 
        and therefore has very  low overhead.
*/
class RenderQueue
{
public:

        /** Default constructor
        */
        RenderQueue();
        /** Constructor passing the current render state
        */
        RenderQueue(RenderState *state);

        ~RenderQueue();
        /** Enqueues all the shapes of an entity.
        */
        void Enqueue(SceneEntity *entity);
        /** Enqueues a single shape. We also have to pass the entity which contains the shape.
        */
        void Enqueue(Shape *shape, SceneEntity *containingEnt);
        /** Sets the current render state
        */
        void SetRenderState(RenderState *state);
        /** Returns the number of entries currently in the queue.
        */
        inline int GetSize() const { return (int)mNumEntries; }
        /** Renders and clears the queue.
        */
        void Apply();
        /** Clears the render queue
        */
        void Clear();


protected:

        //void Sort();

        inline bool FitsInBucket(Shape *shape, size_t idx) const;
        /** Renders the contents of the render queue.
        */
        void Render();


        ///////////
        //-- members

        // the current render state
        RenderState *mState;
        /// each bucket contains objects with similar materials that don't cause a hard state change
        std::vector<RenderQueueBucket *> mBuckets;
        /// this are the buckets that where touched until the last clear. They are sorted by distance
        std::vector<RenderQueueBucket *> mActiveBuckets;

        int mNumEntries;
};


}

#endif