source: obsolete/trunk/BUTE/Ogre/ManagedOgreRenderTexturePass.cpp @ 124

#include "Ogre.h"
#include <vector>
#include <cmath> 
#include "OgreEffectWrapper.h"
#include "ManagedOgreRenderTexturePass.h"


const char* ManagedOgreRenderTexturePass::noRenderTargetName="NO_RENDER_TEXTURE";
MovablePlane* ManagedOgreRenderTexturePass::fullScreenQuad=NULL;
Entity* ManagedOgreRenderTexturePass::fullScreenQuadEntity=NULL;
SceneNode* ManagedOgreRenderTexturePass::fullScreenQuadSceneNode=NULL;

ManagedOgreRenderTexturePass::ManagedOgreRenderTexturePass(
                        
                        Root* mRoot, const String& renderTextureName,unsigned int width,unsigned int height,
                        TextureType texType , PixelFormat internalFormat, 
                        const NameValuePairList *miscParams,bool fullScreenQuadRenderer
                        
                        ){
        
        this->mRoot=mRoot;
        renderSystem=mRoot->getRenderSystem();
        mSceneMgr=mRoot->getSceneManager(ST_GENERIC);
        if(renderTextureName!=noRenderTargetName){
                renderTexture=renderSystem->createRenderTexture(renderTextureName,width,height,texType,internalFormat,miscParams);
                this->addRenderTarget(renderTexture);
        }
        if(!fullScreenQuad){
                createFullScreenQuad();
        }
        this->fullScreenQuadRenderer=fullScreenQuadRenderer;
        effectWrapper=new EffectWrapper();
}

void ManagedOgreRenderTexturePass::createFullScreenQuad(){
        fullScreenQuad=new MovablePlane(Vector3::UNIT_Y,0.0f);
        MeshManager::getSingleton().createPlane("FullScreenQuad", 
        ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 
        *fullScreenQuad, 1, 1, 
        1, 1, true, 1, 1, 1, Vector3::UNIT_Z);
        this->fullScreenQuadEntity=mSceneMgr->createEntity("FullScreenQuad","FullScreenQuadEntity");
        SceneNode* rootNode = mSceneMgr->getRootSceneNode();
        fullScreenQuadSceneNode=rootNode->createChildSceneNode();
        mPlaneNode->attachObject(fullScreenQuadEntity);
    mPlaneNode->attachObject(fullScreenQuad);
        //camera setup.
}

void ManagedOgreRenderTexturePass::entityMaterialSetup(){
        SceneManager::EntityIterator entityIterator=mSceneMgr->getEntityIterator();
        while(entityIterator.hasMoreElements()){
                Entity* entity=entityIterator.getNext();
                entity->setMaterialName(this->effectWrapper->getMaterial()->getName());
                if(fullScreenQuadRenderer){
                        entityVisibilityList.push_back(entity->isVisible());
                        entity->setVisible(false);
                }
        }
        if(fullScreenQuadRenderer){
                this->fullScreenQuadSceneNode->setVisible(true);
        }
}

void ManagedOgreRenderTexturePass::entityMaterialCleanup(){
        if(fullScreenQuadRenderer){
                SceneManager::EntityIterator entityIterator=mSceneMgr->getEntityIterator();
                int elementNumber=0;
                while(entityIterator.hasMoreElements()){
                        Entity* entity=entityIterator.getNext();
                        entity->setVisible(entityVisibilityList.at(elementNumber));
                        elementNumber++;
                }
                entityVisibilityList.clear();
                this->fullScreenQuadSceneNode->setVisible(false);
        }
}

void ManagedOgreRenderTexturePass::update(NameValuePairList* startParams,NameValuePairList* endParams){
        onRenderStart(startParams);
        entityMaterialSetup();
        RenderTarget* rt=renderTargets.at(0);
        Matrix4* worldMatrices=new Matrix4[rt->getViewport(0)->getCamera()->getNumWorldTransforms()];
        rt->getViewport(0)->getCamera()->getWorldTransforms(worldMatrices);
        Matrix4 viewMatrix=renderTexture->getViewport(0)->getCamera()->getViewMatrix();
        Matrix4 projMatrix=renderTexture->getViewport(0)->getCamera()->getProjectionMatrix();
        std::vector<Viewport*> viewports;
        std::vector<RenderTarget*>::iterator rtIterator;
        for(rtIterator=renderTargets.begin();rtIterator!=renderTargets.end();rtIterator++){
                viewports.push_back((*rtIterator)->getViewport(0));
        }
        Matrix4 worldMatrix = Matrix4::IDENTITY;
        for(int i=0;i<rt->getViewport(0)->getCamera()->getNumWorldTransforms();i++){
                worldMatrix = worldMatrix * worldMatrices[i];
        }
        delete[] worldMatrices;
        mRoot->getSceneManager(ST_GENERIC)->manualRender(effectWrapper->getMaterial()->getTechnique(0)->getPass(0),viewports,this->cubeMapFaces,worldMatrix,viewMatrix,projMatrix,true);
        entityMaterialCleanup();
        onRenderEnd(endParams);
}

bool ManagedOgreRenderTexturePass::changeTexture(const String& textureName, unsigned short textureUnit){
        this->effectWrapper->SetTexture(textureUnit,textureName);
        return false;
}

bool ManagedOgreRenderTexturePass::changeMaterial(String& materialName, StringVector& newTextureNames,bool useOldTextureNames){
        effectWrapper->createMaterial(materialName);
        this->effectWrapper->getMaterial()->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
        std::vector<TextureUnitState*>::iterator iter;
        for(iter=usedTextureUnitStates.begin();iter<usedTextureUnitStates.end();iter++){
                usedTextureUnitStates.erase(iter);
        }
        if(!useOldTextureNames){
                textureNames=newTextureNames;
        }
        std::vector<String>::iterator iter2;
        int i=0;
        for(iter2=textureNames.begin();iter2<textureNames.end();iter2++){
                TextureUnitState* t = this->effectWrapper->getMaterial()->getTechnique(0)->getPass(0)->createTextureUnitState((*iter2),i);
                i++;
                usedTextureUnitStates.push_back(t);
        }
        return true;
}

void ManagedOgreRenderTexturePass::oneTimeRenderToTextureSetup(String& materialName,StringVector& textureNames){
        std::vector<String>::iterator iter;
        this->effectWrapper->getMaterial()->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
        int i=0;
        for(iter=textureNames.begin();iter<textureNames.end();iter++){
                TextureUnitState* t = this->effectWrapper->getMaterial()->getTechnique(0)->getPass(0)->createTextureUnitState((*iter),i);
                i++;
                usedTextureUnitStates.push_back(t);
        }
        effectWrapper->createMaterial(materialName);
}