source: GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderingRuns/OgreReducedCubeMapRenderingRun.cpp @ 2321

#include "OgreReducedCubeMapRenderingRun.h"
#include "OgreIlluminationManager.h"



OgreReducedCubeMapRenderingRun::OgreReducedCubeMapRenderingRun(OgreSharedRuns* sharedRuns,
                                                                                                                   String name,
                                                                                                                   unsigned long startFrame,
                                                                                                                        unsigned long updateInterval,
                                                                                                                        unsigned int resolution,
                                                                                                                   bool useDistCalc,
                                                                                                                   bool useFaceAngleCalc,
                                                                                                                   float distTolerance,
                                                                                                                   float angleTolerance,
                                                                                                                   bool updateAllFace)
                        :ReducedCubeMapRenderingRun(startFrame, updateInterval, resolution, useDistCalc, useFaceAngleCalc, distTolerance, angleTolerance, updateAllFace)
                        , OgreRenderingRun(startFrame, updateInterval)
                        , RenderingRun(startFrame, updateInterval)
{
        this->sharedRuns = sharedRuns;
        this->name = name;
        
        createReducedCubeMap();
}

void OgreReducedCubeMapRenderingRun::createReducedCubeMap()
{
        reducedCubemapTexture = createCubeRenderTexture(name, 
                                                                                                sharedRuns->getRootPosition(),
                                                                                                resolution,
                                                                                                PF_FLOAT16_RGBA);
}

void OgreReducedCubeMapRenderingRun::updateCubeFace(int facenum)
{
        RenderTarget* rt = reducedCubemapTexture->getBuffer(facenum, 0).getPointer()
                                                        ->getRenderTarget();
        
        Material*  mat = (Material*) MaterialManager::getSingleton().getByName("GTP/Diffuse/ReduceCubeMap").getPointer();
        GpuProgramParametersSharedPtr fpParams = mat->getTechnique(0)->getPass(0)->getFragmentProgramParameters(); 
        fpParams->setNamedConstant("nFace",facenum); 
//      mat->getTechnique(0)->getPass(0)->setFragmentProgramParameters(fpParams); 
        
        renderFullscreenQuad("GTP/Diffuse/ReduceCubeMap", rt);
        
        //rt->writeContentsToFile("cubbereduce" + StringConverter::toString(facenum) + ".dds");
}

bool OgreReducedCubeMapRenderingRun::faceNeedsUpdate(int facenum)
{       
        if(useDistCalc || useFaceAngleCalc)
        {
                float chance1 = 1.0;
                float chance2 = 1.0;
                
                Camera* mainCamera = OgreIlluminationManager::getSingleton().getMainCamera();

                if(useDistCalc)
                {
                        Vector3 cubemapPosition = sharedRuns->getRootPosition(ILLUMRUN_REDUCED_CUBEMAP);
                        float objradius = sharedRuns->getRootBoundingSphere(ILLUMRUN_REDUCED_CUBEMAP).getRadius();
                        float fov = mainCamera->getFOVy().valueRadians() / 2.0;
                        float dist = (cubemapPosition - mainCamera->getPosition()).length();
                        float vangle = Math::ASin( objradius / dist).valueRadians();
                        float angleratio = vangle / fov;
                        chance1 = Math::Pow(angleratio, 1.0 / distTolerance);
                }

                if(useFaceAngleCalc)
                {
                        Vector3 faceDir = getCubeMapFaceDirection(facenum);                     
                        Vector3 cameraDir = mainCamera->getDirection();
                        float angle = faceDir.dotProduct(-1 * cameraDir);
                        float facingforward = (angle + 1) / 2.0;
                        chance2 = Math::Pow(facingforward, 1.0 / angleTolerance);
                }
        
                float dice = Math::UnitRandom();
                float chance = chance1 * chance2;

                if(dice < chance)
                {       
                        return true;
                }
                else
                {
                        return false;
                }
        }

        return true;
}

void OgreReducedCubeMapRenderingRun::colorCubeMapChanged(String& newMapName)
{
        Material*  mat = (Material*) MaterialManager::getSingleton().getByName("GTP/Diffuse/ReduceCubeMap").getPointer();
        mat->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName(newMapName);
/*
        Texture* tex = (Texture*) TextureManager::getSingleton().getByName(newMapName).getPointer();
        int resolution = tex->getWidth();
        
        GpuProgramParametersSharedPtr fpParams = mat->getTechnique(0)->getPass(0)->getFragmentProgramParameters(); 
        fpParams->setNamedConstant("CUBEMAP_SIZE", resolution ); 
        mat->getTechnique(0)->getPass(0)->setFragmentProgramParameters(fpParams); */

}

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