source: trunk/BUTE/Ogre/EntityRenderingObject.cpp @ 124

#include "Ogre.h"
#include "RenderingType.h"
#include "OgreEffectWrapper.h"
#include "ManagedOgreRenderTexturePass.h"
#include "FinalRenderingRun.h"
#include "entityrenderingobject.h"

#include "LightMapFinalRenderingRun.h"

const long EntityRenderingObject::entityRenderingObjectTypeId(-2);
const String EntityRenderingObject::entityRenderingObjectTypeName("EntityRenderingObject");

EntityRenderingObject::EntityRenderingObject(Entity* owner, unsigned long startFrame, const RenderingType& renderingType )
{
        this->startFrame = startFrame;

        if(renderingType.diffuseShaded &&
                !renderingType.diffuseTextured )
                finalRenderingRun = new LightMapFinalRenderingRun(owner);

        //for all possible per entity preComputingRuns
        if(finalRenderingRun->getLightMapUpdateInterval() != 0)
        {
                lightMapRun = new LightMapRun(
                                renderingType.lightMapResolutionX,
                                renderingType.lightMapResolutionY,
                                renderingType.lightMapNumberOfMipmapLevels, 
                                renderingType.lightMapLOD,
                                owner);
                finalRenderingRun->setLightMapTexture(lightMapRun->getResultTextureName());
        }
        else
                lightMapRun = NULL;

        if(finalRenderingRun->getVRMUpdateInterval() != 0)
        {
                vrmRun = new VRMRun(
                        owner,
                        renderingType.vrmMapResolutionX,
                        renderingType.vrmMapResolutionY
                        );
                finalRenderingRun->setVRMTexture(vrmRun->getResultTextureName());
        }
        else
                vrmRun = NULL;

        if(finalRenderingRun->getCausticMapUpdateInterval() != 0)
        {
                causticMapRun = new CausticMapRun(owner, renderingType.causticMapResolutionX, renderingType.causticMapResolutionY);
                finalRenderingRun->setCausticMapTexture(causticMapRun->getResultTextureName());
        }
        else
                vrmRun = NULL;

        if(finalRenderingRun->getPRMUpdateInterval() != 0)
        {
                prmRun = new PRMRun(
                        owner,
                        renderingType.prmResolution,
                        renderingType.prmNEntryPoints,
                        renderingType.prmNClusters,
                        renderingType.prmTileSize
                        );
                finalRenderingRun->setPRMTexture(prmRun->getResultTextureName());
                finalRenderingRun->setEntryPointsTexture(prmRun->getEntryPointsTextureName());
                finalRenderingRun->setNEntryPoints(prmRun->getNEntryPoints());
                finalRenderingRun->setNClusters(prmRun->getNClusters());
                finalRenderingRun->setTileSize(prmRun->getTileSize());
        }
        else
                prmRun = NULL;

        if(finalRenderingRun->getDiffuseEnvironmentUpdateInterval() != 0)
        {
                diffuseEnvironmentRun = new DiffuseEnvironmentMapRun(owner, renderingType.diffuseEnvironmentMapResolution);
                finalRenderingRun->setDiffuseEnvironmentTextureCube(diffuseEnvironmentRun->getResultTextureName());
        }
        else
                diffuseEnvironmentRun = NULL;

        if(finalRenderingRun->getSpecularEnvironmentUpdateInterval() != 0)
        {
                specularEnvironmentRun = new SpecularEnvironmentMapRun(owner, renderingType.specularEnvironmentMapResolution);
                finalRenderingRun->setSpecularEnvironmentTextureCube(specularEnvironmentRun->getResultTextureName());
        }
        else
                specularEnvironmentRun = NULL;

        if(finalRenderingRun->getFresnelEnvironmentUpdateInterval() != 0)
        {
                fresnelEnvironmentRun = new FresnelEnvironmentMapRun(owner, renderingType.fresnelEnvironmentMapResolution);
                finalRenderingRun->setFresnelEnvironmentTextureCube(fresnelEnvironmentRun->getResultTextureName());
        }
        else
                fresnelEnvironmentRun = NULL;

}

/**
        perform preproc necessary in this frame
*/
void EntityRenderingObject::updateLightMap(long frameCount)
{
        if(finalRenderingRun->getLightMapUpdateInterval() != 0 &&
                ((frameCount - startFrame)  % finalRenderingRun->getLightMapUpdateInterval()) == 0 )
                lightMapRun->update();
}

void EntityRenderingObject::updateVRM(long frameCount)
{
        if(finalRenderingRun->getVRMUpdateInterval() != 0 &&
                ((frameCount - startFrame)  % finalRenderingRun->getVRMUpdateInterval()) == 0 )
                vrmRun->update();               
}

void EntityRenderingObject::updateCausticMap(long frameCount)
{
        if(finalRenderingRun->getCausticMapUpdateInterval() != 0 &&
                ((frameCount - startFrame)  % finalRenderingRun->getCausticMapUpdateInterval()) == 0 )
                causticMapRun->update();                
}

void EntityRenderingObject::updatePRM(long frameCount)
{
        if(finalRenderingRun->getPRMUpdateInterval() != 0 &&
                ((frameCount - startFrame)  % finalRenderingRun->getPRMUpdateInterval()) == 0 )
                prmRun->update();
}

void EntityRenderingObject::updateEnvironmentCubes(long frameCount)
{
        if(finalRenderingRun->getDiffuseEnvironmentUpdateInterval() != 0 &&
                ((frameCount - startFrame)  % finalRenderingRun->getDiffuseEnvironmentUpdateInterval()) == 0 )
                diffuseEnvironmentRun->update();
        if(finalRenderingRun->getSpecularEnvironmentUpdateInterval() != 0 &&
                ((frameCount - startFrame)  % finalRenderingRun->getSpecularEnvironmentUpdateInterval()) == 0 )
                specularEnvironmentRun->update();
        if(finalRenderingRun->getFresnelEnvironmentUpdateInterval() != 0 &&
                ((frameCount - startFrame)  % finalRenderingRun->getFresnelEnvironmentUpdateInterval()) == 0 )
                fresnelEnvironmentRun->update();
}

EntityRenderingObject::~EntityRenderingObject(void)
{
        delete finalRenderingRun;
}