source: GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderingRuns/OgreFocusingMapRenderingRun.cpp @ 1425

#include "OgreFocusingMapRenderingRun.h"


void OgreFocusingMapRenderingRun::getMinMax(Vector3& min, Vector3& max)
{       
        unsigned int buffersize = focusingMapSize * focusingMapSize * 4;
        float* floatbuffer = new float[buffersize];
        PixelBox lockBox(focusingMapSize, focusingMapSize, 1, PF_FLOAT32_RGBA, floatbuffer);
        focusingTexture->getBuffer()->blitToMemory(lockBox);
        
    float minX = 0;
        float minY = 0;
        float minZ = 0;
        float maxX = 0;
        float maxY = 0;
        float maxZ = 0;

        bool first = true;
        
        for(unsigned int i = 0; i < buffersize; i+= 4)
        {
                float x = floatbuffer[i];
                float y = floatbuffer[i + 1];
                float z = floatbuffer[i + 2];
                float valid = floatbuffer[i + 3];

                if(valid)
                {
                        if(first)
                        {
                                minX = x;
                                minY = y;
                                minZ = z;
                                maxX = x;
                                maxY = y;
                                maxZ = z;

                                first = false;
                        }
                        else
                        {
                                if(x < minX)minX = x;
                                if(y < minY)minY = y;
                                if(z < minZ)minZ = z;

                                if(x > maxX)maxX = x;
                                if(y > maxY)maxY = y;
                                if(z > maxZ)maxZ = z;
                        }
                }
        }

        min.x = minX; min.y = minY; min.z = minZ;
        max.x = maxX; max.y = maxY; max.z = maxZ;

        delete[] floatbuffer;
}

OgreFocusingMapRenderingRun::OgreFocusingMapRenderingRun(       String name,
                                                                                                                        Matrix4 lightMatrix,
                                                                                                                        unsigned int focusingMapSize
                                                                                                                   )
                                                                                                                   : OgreRenderingRun(1, 1)
                                                                                                                   , RenderingRun(1, 1)
{
        this->name = name;
        this->lightMatrix = lightMatrix;
        this->focusingMapSize = focusingMapSize;        
        
        createFocusingMap();    
}

void OgreFocusingMapRenderingRun::setCameraMatrices(const Matrix4 &view, const Matrix4 &projection)
{
        camera->setCustomViewMatrix(true, view);
        camera->setCustomProjectionMatrix(true, projection);
}

void OgreFocusingMapRenderingRun::createFocusingMap()
{
        int width = focusingMapSize;
        int height = focusingMapSize;
        TexturePtr texPtr = Ogre::TextureManager::getSingleton().createManual(name, 
                                                                                                                                                "default",
                                                                                                                                                TEX_TYPE_2D,
                                                                                                                                                width,
                                                                                                                                                height,
                                                                                                                                                0,
                                                                                                                                                0,
                                                                                                                                                PF_FLOAT32_RGBA,
                                                                                                                                                TU_RENDERTARGET);
        focusingTexture = texPtr.getPointer();
         //add viewport to rendertarget
         HardwarePixelBuffer* hpb = (focusingTexture->getBuffer()).getPointer();
         RenderTarget* rt = hpb->getRenderTarget();
         this->camera = Root::getSingleton()._getCurrentSceneManager()->createCamera(name + "_CAMERA"); 
         Viewport* v = rt->addViewport(camera);
         v->setOverlaysEnabled(false);
         rt->setAutoUpdated(false);
}



void OgreFocusingMapRenderingRun::updateFrame(unsigned long frameNum)
{
        
        
        MaterialPtr mat = MaterialManager::getSingleton().getByName("GameTools/FocusingShader");
        GpuProgramParameters* Vparams = mat->getTechnique(0)->getPass(0)->getVertexProgramParameters().getPointer();
        Vparams->setNamedConstant("lightTransform", lightMatrix);
                
        setMaterialForVisibles(String("GameTools/FocusingShader"), camera);

        RenderTarget* rt = focusingTexture->getBuffer().getPointer()->getRenderTarget();

        ColourValue backColor(0,0,0,0); 
        rt->getViewport(0)->setBackgroundColour(backColor);
                
        rt->update();   

        //rt->writeContentsToFile("focusingmap.dds");
        
        restoreMaterials();     
}