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

#ifndef __RENDERQUEUE_H
#define __RENDERQUEUE_H

#include "common.h"
#include "Timer/PerfTimer.h"


namespace CHCDemoEngine 
{

class RenderState;
class Camera;


/** Defines a bucket for scene entities that have the same properties.
*/
struct RenderQueueBucket
{
        ////////
        //-- the attributes used to sort the materials
        /// texture 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;

        /// minimal distance to the camera
        float mMinDistance;

        /// the shapes that belong to a bucket
        ShapeContainer mShapes;
};


/** 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 requires sorting only on 
        bucket level and therefore has very     low overhead.
*/
class RenderQueue
{
public:

        /** Default constructor
        */
        RenderQueue();
        /** Constructor taking a render queue
        */
        RenderQueue(RenderState *state, Camera *cam);

        ~RenderQueue();
        /** Enqueues an entity.
        */
        void Enqueue(SceneEntity *entity);
        /** Enqueues a single shape.
        */
        void Enqueue(Shape *shape);
        /** Sets the current render state
        */
        void SetRenderState(RenderState *state);
        /** Sets the current render state
        */
        void SetCamera(Camera *cam);
        /** 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();
        /** Prints the current state of the render queue.
        */
        void Print();


        ///////////

        RenderState *mState;
        
        Camera *mCamera;
        //SceneEntityContainer mEntities;
        int mMinSizeForSorting;
        /// each bucket contains objects with similar materials that don't cause a hard state change
        std::vector<RenderQueueBucket *> mBuckets;

        int mNumEntries;
};


}

#endif