source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SceneEntity.cpp @ 2847

#include "SceneEntity.h"
#include "Geometry.h"
#include "Material.h"
#include "RenderState.h"
#include "Shape.h"
#include "Transform3.h"
#include "Camera.h"

#include "glInterface.h"
#include <Cg/cg.h>
#include <Cg/cgGL.h>


using namespace std;


namespace CHCDemoEngine 
{


SceneEntity::SceneEntity(Transform3 *trafo): 
mTransform(trafo), mCurrentLODLevel(0), mLODLastUpdated(-1)
{
        mBox.Initialize();
}


SceneEntity::~SceneEntity()
{
}


void SceneEntity::UpdateLODs(const Vector3 &viewPoint)
{
        const Vector3 pos = GetCenter();

        const float distance = SqrDistance(pos, viewPoint);

        mCurrentLODLevel = 0;

        const int l = (int)mLODLevels.size();

        for (int i = 0; i < l; ++ i)
        {
                LODLevel *lod = mLODLevels[i];

                if (lod->mSquaredDistance > distance)
                        break;

                mCurrentLODLevel = i;
        }

        /*if (mLODLevels.size() > 1)
        {
                Debug << "dist: " << distance << " numshapes: " << mLODLevels[mCurrentLODLevel]->mShapes.size() << " lod: " << mCurrentLODLevel << " of " << mLODLevels.size() << endl;
        }*/
}

void SceneEntity::GetCurrentLODLevel(ShapeContainer::iterator &start, 
                                                                         ShapeContainer::iterator &end)
{
        if (mLODLastUpdated != LODLevel::sFrameId)
        {
                mLODLastUpdated = LODLevel::sFrameId;
                UpdateLODs(LODLevel::sViewPoint);
        }

        start = mLODLevels[mCurrentLODLevel]->mShapes.begin(); 
        end = mLODLevels[mCurrentLODLevel]->mShapes.end();
}


void SceneEntity::GetLODLevel(int level, 
                                                          ShapeContainer::iterator &start, 
                                                          ShapeContainer::iterator &end)
{
        LODLevel *lod = mLODLevels[level];

        start = lod->mShapes.begin();
        end = lod->mShapes.end();
}


void SceneEntity::Render(RenderState *state)
{
        ShapeContainer::iterator sit, sit_end;

        GetCurrentLODLevel(sit, sit_end);

        for (; sit != sit_end; ++ sit)
        {
                (*sit)->Render(state);
        }
}


void SceneEntity::AddShape(Shape *shape)
{
        mShapes.push_back(shape);
        mBox.Include(shape->GetBoundingBox());

        mCenter = mBox.Center();
}


void SceneEntity::SetTransform(Transform3 *trafo)
{
        mTransform = trafo;
}


void SceneEntity::SetLastRendered(int lastRendered)
{
        mLastRendered = lastRendered;
}


int SceneEntity::GetLastRendered() const
{
        return mLastRendered;
}


int SceneEntity::CountNumTriangles(int lodLevel)
{
        int numTriangles = 0;
        
        ShapeContainer::iterator sit, sit_end;

        if (lodLevel == -1)
        {
                GetCurrentLODLevel(sit, sit_end);
        }
        else
        {
                GetLODLevel(lodLevel, sit, sit_end);
        }


        for (; sit != sit_end; ++ sit)
        {
                numTriangles += (*sit)->GetGeometry()->GetNumTriangles();
        }

        return numTriangles;
}


AxisAlignedBox3 SceneEntity::GetTransformedBoundingBox() const
{
        Matrix4x4 *mat = mTransform->GetMatrix();

        if (!mat)
                return mBox;

        return Transform(mBox, *mat);
}


AxisAlignedBox3 SceneEntity::GetBoundingBox() const
{
        return mBox;
}


Vector3 SceneEntity::GetCenter() const
{
        Matrix4x4 *mat = mTransform->GetMatrix();

        if (!mat)
                return mCenter;

        return (*mat) * mCenter;
}


}