source: GTP/branches/IllumWPdeliver2008dec/IlluminationWP/source/OgreIllumModule/src/RenderingRuns/OgreCausticCubeMapRenderingRun.cpp @ 3255

#include "OgreCausticCubeMapRenderingRun.h"
//#include "OgreIlluminationManager.h"
#include "OgrePhotonMapRenderingRun.h"



OgreCausticCubeMapRenderingRun::OgreCausticCubeMapRenderingRun(OgreSharedRuns* sharedRuns,
                                                                                                                   String name,
                                                                                                                   unsigned long startFrame,
                                                                                                                        unsigned long updateInterval,
                                                                                                                        unsigned int resolution,
                                                                                                                   String materialName,
                                                                                                                   unsigned char photonMapTexId,
                                                                                                                   bool updateAllFace,
                                                                                                                   float attenuation,
                                                                                                                   bool useTriangles,
                                                                                                                   bool blurMap)
                :CausticCubeMapRenderingRun(startFrame, updateInterval, resolution, updateAllFace)
                , OgreRenderingRun(startFrame, updateInterval)
                , RenderingRun(startFrame, updateInterval)
{
        this->attenuation = attenuation;
        this->useTriangles = useTriangles;
        this->sharedRuns = sharedRuns;
        this->name = name;
        this->materialName =  materialName;
        this->photonMapTexId = photonMapTexId;
        this->blurMap = blurMap;

        spriteSetName = name + String("_pixelSpriteSet");
        
        createCausticCubeMap();
}

void OgreCausticCubeMapRenderingRun::createCausticCubeMap()
{
        causticCubemapTexture = createCubeRenderTexture(name, 
                                                                                                Vector3(0,0,0),
                                                                                                resolution,
                                                                                                PF_FLOAT16_RGBA,
                                                                                                0);

        if(blurMap)
                bluredCausticCubemapTexture = createCubeRenderTexture(name + "_BLURED", 
                                                                                                Vector3(0,0,0),
                                                                                                resolution,
                                                                                                PF_FLOAT16_RGBA,
                                                                                                0);
        
}

void OgreCausticCubeMapRenderingRun::photonMapChanged(RenderingRun* run)
{
        Material* mat = (Material*) MaterialManager::getSingleton().getByName(materialName).getPointer();
        String photonMapName = ((OgrePhotonMapRenderingRun*) run->asOgreRenderingRun())->getPhotonMapTextureName();
        mat->getTechnique(0)->getPass(0)->getTextureUnitState(photonMapTexId)->setTextureName(photonMapName);

        //rt = TextureManager::getSingleton().getByName(photonMapName);
        LogManager::getSingleton().logMessage(LML_NORMAL, name + " map: " + photonMapName + " material: " + mat->getName());
}

void OgreCausticCubeMapRenderingRun::updateCubeFace(int facenum)
{       
        RenderTarget* rt = causticCubemapTexture->getBuffer(facenum, 0).getPointer()
                                                        ->getRenderTarget();
        
        Camera* cam = rt->getViewport(0)->getCamera();
        cam->setNearClipDistance(0.001);
        cam->setFarClipDistance(2.0);
        cam->setAspectRatio(1.0);
        Radian r(Degree(90));
        cam->setFOVy(r);

        RenderingRun* run = sharedRuns->getRun(ILLUMRUN_PHOTONMAP);
        String photonMapName = ((OgrePhotonMapRenderingRun*) run->asOgreRenderingRun())->getPhotonMapTextureName();
        TexturePtr tex = TextureManager::getSingleton().getByName(photonMapName);
        
        if(!useTriangles)
                renderPixelSprites(materialName, rt, tex->getWidth(), tex->getHeight());
        else
                renderFullscreenGrid(materialName, rt, tex->getWidth(), tex->getHeight());

        if(blurMap)
        {
                rt = bluredCausticCubemapTexture->getBuffer(facenum, 0).getPointer()->getRenderTarget();
                Material*  mat = (Material*) MaterialManager::getSingleton().getByName("GTP/Basic/FSQuadBlurCubeFace").getPointer();
                mat->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName(causticCubemapTexture->getName());
                mat->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("face", facenum);
                renderFullscreenQuad("GTP/Basic/FSQuadBlurCubeFace", rt);
        }

        //rt->writeContentsToFile("caucube" + this->name + StringConverter::toString(facenum) + ".dds");
}

bool OgreCausticCubeMapRenderingRun::faceNeedsUpdate(int facenum)
{       
        return true;
}

void OgreCausticCubeMapRenderingRun::freeAllResources()
{
        this->bluredCausticCubemapTexture = 0;  
        TextureManager::getSingleton().remove(name);
        TextureManager::getSingleton().remove(name + "_BLURED");
        Root::getSingleton()._getCurrentSceneManager()->destroyCamera(name + "_CAMERA");        
        Root::getSingleton()._getCurrentSceneManager()->destroyCamera(name + "_BLURED" + "_CAMERA");    
}