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

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

using namespace std;


namespace CHCDemoEngine
{


/*inline static bool CompDist(RenderQueueBucket *b1, RenderQueueBucket *b2)
{
        return (b1->mMinDistance < b2->mMinDistance);
}*/
RenderQueue::RenderQueue(): 
mState(NULL), 
mCamera(NULL),
mNumEntries(0)
{
}


RenderQueue::RenderQueue(RenderState *state, Camera *cam):
mState(state), 
mCamera(cam),
mNumEntries(0)
{
}


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


bool RenderQueue::FitsInBucket(Shape *shape, size_t idx) const
{
        Technique *tech = shape->GetMaterial()->GetTechnique(mState->GetRenderTechnique());

        // test if entity belongs to this bucket
        if (tech->IsAlphaTestEnabled() != mBuckets[idx]->mAlphaTestEnabled) { return false; }
        if (tech->IsCullFaceEnabled() != mBuckets[idx]->mCullFaceEnabled) { return false; }
        if (tech->IsColorWriteEnabled() != mBuckets[idx]->mColorWriteEnabled) { return false; }
        if (tech->IsLightingEnabled() != mBuckets[idx]->mLightingEnabled) { return false; }
        if (tech->IsDepthWriteEnabled() != mBuckets[idx]->mDepthWriteEnabled) { return false; }

        //if (tech->IsColorWriteEnabled()) cout << "x";

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

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

        if (hasTexture)
        {
                if (tech->GetTexture()->GetWidth() != mBuckets[idx]->mTexWidth) { return false; }
                if (tech->GetTexture()->GetHeight() != mBuckets[idx]->mTexHeight) {return false; }
                if (tech->GetTexture()->GetFormat() != mBuckets[idx]->mTexFormat) { return false; }
        }

        //if (!tech->GetFragmentProgram() && mBuckets[idx]->mHasFragmentProgram) { return false; }
        //if (!tech->GetVertexProgram() && mBuckets[idx]->mHasVertexProgram) { return false; }
        if (tech->GetFragmentProgram() != mBuckets[idx]->mFragmentProgram) { return false; }
        if (tech->GetVertexProgram() != mBuckets[idx]->mVertexProgram) { return false; }

        return true;
}


void RenderQueue::Enqueue(SceneEntity *entity)
{
        ShapeContainer::iterator sit, sit_end;

        entity->GetCurrentLODLevel(sit, sit_end);

        for (; sit != sit_end; ++ sit)
        {
                Enqueue(*sit);
        }
}


void RenderQueue::Enqueue(Shape *shape)
{
        Technique *tech = shape->GetMaterial()->GetTechnique(mState->GetRenderTechnique());
        RenderQueueBucket *bucket = tech->mRenderQueueBucket;

        ++ mNumEntries;
        
        if (!bucket)
        {
                bool bucketFound = false;

                size_t i = 0;

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

                // create new bucket
                if (!bucketFound)
                {
                        RenderQueueBucket *bucket = new RenderQueueBucket();
                        //bucket->mMinDistance = -1;

                        bucket->mAlphaTestEnabled = tech->IsAlphaTestEnabled();
                        bucket->mCullFaceEnabled = tech->IsCullFaceEnabled();

                        bucket->mColorWriteEnabled = tech->IsColorWriteEnabled();
                        bucket->mLightingEnabled = tech->IsLightingEnabled();
                        bucket->mDepthWriteEnabled = tech->IsDepthWriteEnabled();


                        Texture *tex = tech->GetTexture();

                        if (tex != NULL)
                        {
                                bucket->mHasTexture = true; 

                                bucket->mTexWidth = tex->GetWidth();
                                bucket->mTexHeight = tex->GetHeight();

                                bucket->mTexFormat = tex->GetFormat(); 
                        }
                        else
                        {
                                bucket->mHasTexture = false; 

                                bucket->mTexWidth = 0;
                                bucket->mTexHeight = 0;
                                bucket->mTexFormat = 0;
                        }

                        //      bucket->mHasVertexProgram = (tech->GetVertexProgram() != NULL);
                        //      bucket->mHasFragmentProgram = (tech->GetFragmentProgram() != NULL);
                        bucket->mVertexProgram = tech->GetVertexProgram();
                        bucket->mFragmentProgram = tech->GetFragmentProgram();

                        mBuckets.push_back(bucket);
                        //cout << "increased #buckets to " << (int)mBuckets.size() << endl;
                }

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

        if (bucket->IsEmpty())
        {
                // add to currently active buckets that will be rendered
                // assume that the incoming nodes are ordered by distance 
                // => active buckets are sorted by distance
                mActiveBuckets.push_back(bucket);
        
                // => set min dist on first incoming node
                //const Vector3 v = shape->GetCenter() - mCamera->GetPosition();
                //const float dist = SqrMagnitude(v);
                //bucket->mMinDistance = dist;

                }

        bucket->mShapes.push_back(shape);
}


void RenderQueue::Clear()
{
        for (size_t i = 0; i < mActiveBuckets.size(); ++ i)
        {
                //mBuckets[i]->mMinDistance = -1;
                mActiveBuckets[i]->mShapes.clear();
        }

        mNumEntries = 0;

        mActiveBuckets.clear();
}


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


void RenderQueue::Render()
{
        // sort the buckets
        //Sort();

        // render all buckets
        for (size_t i = 0; i < mBuckets.size(); ++ i)
        {
                ShapeContainer::const_iterator sit, sit_end = mBuckets[i]->mShapes.end();

                for (sit = mBuckets[i]->mShapes.begin(); sit != sit_end; ++ sit)
                {
                        Shape *shape = *sit;
                        shape->Render(mState);
                }
        }
        //Print();
}


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

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

                for (sit = mBuckets[i]->mShapes.begin(); sit != sit_end; ++ sit)
                {
                        Shape *shape = *sit;
                        
                        Technique *tech = shape->GetMaterial()->GetTechnique(mState->GetRenderTechnique());
                        int tsize = tech->GetTexture() ? tech->GetTexture()->GetByteSize() : 0;
                        
                        float dist = SqrMagnitude(shape->GetBoundingBox().Center() - mCamera->GetPosition());
                        
                        Debug << "e: " << shape << " a: " << tech->IsAlphaTestEnabled() << " s: " << tsize << " d: " << dist << " " << endl;
                }
        }
}


/*void RenderQueue::Sort()
{
        // sort buckets itself by distance
        sort(mBuckets.begin(), mBuckets.end(), CompDist);
}*/


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


}