source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderQueue.cpp @ 2819

#include "RenderQueue.h"
#include "SceneEntity.h"
#include "Geometry.h"
#include "Texture.h"
#include "Material.h"
#include "Camera.h"


using namespace std;


namespace CHCDemoEngine
{

static Camera *sCam = NULL;


inline static bool CompDist(SceneEntity *e1, SceneEntity *e2)
{
        return 
                (SqrMagnitude(e1->GetBoundingBox().Center() - sCam->GetPosition()) <
                 SqrMagnitude(e2->GetBoundingBox().Center() - sCam->GetPosition()));
}


inline static bool CompDist2(RenderQueueBucket *b1, RenderQueueBucket *b2)
{
        return (b1->mMinDistance < b2->mMinDistance);
}


RenderQueue::RenderQueue(): 
mState(NULL), 
mMinSizeForSorting(3),
mCamera(NULL),
mSize(0)
{
}


RenderQueue::RenderQueue(RenderState *state, Camera *cam):
mState(state), 
mMinSizeForSorting(3),
mCamera(cam),
mSize(0)
{
        sCam = cam;
}


RenderQueue::~RenderQueue()
{
        for (size_t i = 0; i < mBuckets.size(); ++ i)
        {
                DEL_PTR(mBuckets[i]);
        }
}


bool RenderQueue::FitsInBucket(SceneEntity *ent, size_t idx) const
{
        Material *mat = ent->GetMaterial();

        // test if entity 
        //if (mat->IsAlphaTestEnabled() != mBuckets[idx]->mAlphaTestEnabled) return false;

        const bool hasTexture = (mat->GetTexture() != NULL);

        if (hasTexture != mBuckets[idx]->mHasTexture)
                return false;

        if (hasTexture)
        {
                if (mat->GetTexture()->GetWidth() != mBuckets[idx]->mTexWidth)
                        return false;

                if (mat->GetTexture()->GetHeight() != mBuckets[idx]->mTexHeight)
                        return false;
        }

        return true;
}


void RenderQueue::Enqueue(SceneEntity *entity)
{
        RenderQueueBucket *bucket;
        ++ mSize;

        if (entity->mRenderQueueBucket)
        {
                bucket = entity->mRenderQueueBucket;
        }
        else
        {
                bool bucketFound = false;

                size_t i = 0;

                for (; i < mBuckets.size(); ++ i)
                {
                        if (bucketFound = FitsInBucket(entity, i))
                                break;
                }

                // create new bucket
                if (!bucketFound)
                {
                        RenderQueueBucket *bucket = new RenderQueueBucket();

                        Material *mat = entity->GetMaterial();

                        bucket->mAlphaTestEnabled = mat->IsAlphaTestEnabled();

                        const bool hasTexture = (mat->GetTexture() != NULL);

                        bucket->mHasTexture = hasTexture; 

                        bucket->mTexWidth = hasTexture ? mat->GetTexture()->GetWidth() : 0;
                        bucket->mTexHeight = hasTexture ? mat->GetTexture()->GetHeight() : 0;

                        mBuckets.push_back(bucket);

                        // assume that the incoming nodes are ordered by distance => set min dist
                        // on first incoming node
                        float dist = SqrMagnitude(entity->GetBoundingBox().Center() - mCamera->GetPosition());
                        mBuckets[i]->mMinDistance = dist;

                        //cout << "num buckets: " << (int)mBuckets.size() << endl;
                }

                bucket = mBuckets[i];
                entity->mRenderQueueBucket = bucket;
        }

        bucket->mEntities.push_back(entity);
}


void RenderQueue::Clear()
{
        for (size_t i = 0; i < mBuckets.size(); ++ i)
                mBuckets[i]->mEntities.clear();

        mSize = 0;
}


void RenderQueue::SetRenderState(RenderState *state)
{
        mState = state;
}


void RenderQueue::Render()
{
        Sort();
        
        // render all buckets
        for (size_t i = 0; i < mBuckets.size(); ++ i)
        {
                SceneEntityContainer::const_iterator sit, sit_end = mBuckets[i]->mEntities.end();
                for (sit = mBuckets[i]->mEntities.begin(); sit != sit_end; ++ sit)
                {
                        SceneEntity *ent = *sit;
                        ent->Render(mState);
                }
        }

        //Print();
}


void RenderQueue::Print()
{
        for (size_t i = 0; i < mBuckets.size(); ++ i)
        {
                Debug << "\n******\nbucket " << (int)i << endl;

                SceneEntityContainer::const_iterator sit, sit_end = mBuckets[i]->mEntities.end();

                for (sit = mBuckets[i]->mEntities.begin(); sit != sit_end; ++ sit)
                {
                        SceneEntity *ent = *sit;
        
                        Material *mat = ent->GetMaterial();
                        int tsize = mat->GetTexture() ? mat->GetTexture()->GetByteSize() : 0;
                        float dist = SqrMagnitude(ent->GetBoundingBox().Center() - mCamera->GetPosition());
                        Debug << "e: " << ent << " a: " << mat->IsAlphaTestEnabled() << " s: " << tsize << " d: " << dist << " " << endl;
                }
        }
}


void RenderQueue::Apply()
{
        Render();
        Clear();
}


void RenderQueue::Sort()
{
        // sort buckets itself
        sort(mBuckets.begin(), mBuckets.end(), CompDist2);
}


}