source: GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/OgreRenderingRun.cpp @ 1055

#include "OgreRenderingrun.h"

MovablePlane* OgreRenderingRun::fullScreenQuad = NULL;
Entity* OgreRenderingRun::fullScreenQuadEntity = NULL;
SceneNode* OgreRenderingRun::fullScreenQuadNode = NULL;

class MaterialSetVisitor : public QueuedRenderableVisitor
{
private:
        String materialName;
        std::map<Renderable*, String>* visibleObjects;
public:
    
        MaterialSetVisitor(String& materialName, std::map<Renderable*, String>* visibleObjects)
        {
                this->materialName = materialName;
                this->visibleObjects = visibleObjects;
        }

        void visit(const Renderable* r)
        {       
                Renderable* rend = (Renderable*) r; //sorry for removing the const
                
                if( visibleObjects->count(rend) == 0)
                {
                        (*visibleObjects)[rend] = rend->getMaterial().getPointer()->getName();
                        rend->setMaterialName(materialName);
                }
        }
        bool visit(const Pass* p){return true;}
        void visit(const RenderablePass* rp){}

};

Vector3 OgreRenderingRun::getCubeMapFaceDirection(unsigned char faceId)
{
        switch(faceId)
        {
                case 0: //positive X
                        return Vector3(1,0,0);
                case 1: //negative X
                        return Vector3(-1,0,0);
                case 2:  //positiove Y
                        return Vector3(0,1,0);
                case 3: //negative Y
                        return Vector3(0,-1,0);
                case 4:  //positiove Z
                        return Vector3(0,0,-1);
                case 5: //negative Z
                        return Vector3(0,0,1);
                default:
                        return Vector3(0,0,0);
        }
}

Texture* OgreRenderingRun::createCubeRenderTexture(String name,  const Vector3 position, unsigned int resolution, PixelFormat format, int numMips, ColourValue clearColor)
{
        //create texture
        TexturePtr texPtr = Ogre::TextureManager::getSingleton().createManual(  name, 
                                                                                                                                                        "default",
                                                                                                                                                        TEX_TYPE_CUBE_MAP,
                                                                                                                                                        resolution,
                                                                                                                                                        resolution,
                                                                                                                                                        0,
                                                                                                                                                        numMips,
                                                                                                                                                        format,
                                                                                                                                                        TU_RENDERTARGET);
        Texture* result = texPtr.getPointer();

        //add viewports to faces
        for(unsigned int i = 0; i < 6; i++)
        {
                Camera* cam = Root::getSingleton()._getCurrentSceneManager()
                        ->createCamera(name + "CUBEMAPFACE_" + StringConverter::toString(i) + "_CAMERA");
                
                cam->setPosition(position);
                cam->setAspectRatio(1);
                cam->setFOVy(Radian(Degree(90)));
                cam->setNearClipDistance(0.1);

                //set camera orientation
                switch(i)
                {
                        case 2:
                                cam->setOrientation(Quaternion(Radian(Degree(90)),Vector3(1,0,0)));
                                break;
                        case 3:
                                cam->setOrientation(Quaternion(Radian(Degree(90)),Vector3(-1,0,0)));
                                break;
                        default:
                                cam->setDirection(getCubeMapFaceDirection(i));
                                break;
                }

                HardwarePixelBuffer* hpb = (result->getBuffer(i, 0)).getPointer();
                RenderTarget* rt = hpb->getRenderTarget(0);
                Viewport* v = rt->addViewport(cam);
                v->setOverlaysEnabled(false);
                rt->setAutoUpdated(false);

                Root::getSingleton().getRenderSystem()->_setViewport(v);
                Root::getSingleton().getRenderSystem()->clearFrameBuffer( FBT_COLOUR, clearColor);
        }

        return result;

}

void OgreRenderingRun::setMaterialForRenderables(String& materialName, RenderQueue* rq)
{
        RenderQueue::QueueGroupIterator queueIt = rq->_getQueueGroupIterator();
   
    while (queueIt.hasMoreElements())
    {
        RenderQueueGroup* pGroup = queueIt.getNext();
                
        RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();

                while (groupIt.hasMoreElements())
                {
                        RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
                        const QueuedRenderableCollection& solids = pPriorityGrp->getSolidsBasic();
                        const QueuedRenderableCollection& transparents = pPriorityGrp->getTransparents();
                        MaterialSetVisitor visitor(materialName, &visibleObjects);      
                        solids.acceptVisitor(&visitor, QueuedRenderableCollection::OM_PASS_GROUP);
                        transparents.acceptVisitor(&visitor, QueuedRenderableCollection::OM_SORT_ASCENDING);            
                }                       
    }

        //refill renderqueue    
        rq->clear();

        std::map<Renderable*, String>::iterator it = visibleObjects.begin();
        std::map<Renderable*, String>::iterator itend = visibleObjects.end();

        while(it != itend)
        {
                rq->addRenderable((*it).first);
                it++;
        }

        SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
        sm->setFindVisibleObjects(false);       
}

void OgreRenderingRun::setMaterialForVisibles(String& materialName, Camera* cam, bool shadowcastersonly)
{
        SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
        
        RenderQueue* rq = sm->getRenderQueue();
        rq->clear();

        RenderQueue::QueueGroupIterator groupIter = rq->_getQueueGroupIterator();
        while (groupIter.hasMoreElements())
        {
                RenderQueueGroup* g = groupIter.getNext();
                g->defaultOrganisationMode();
        }

        sm->_findVisibleObjects (cam, shadowcastersonly);
        
        setMaterialForRenderables(materialName, rq);
}

void OgreRenderingRun::restoreMaterials()
{
        std::map<Renderable*, String>::iterator it = visibleObjects.begin();
        std::map<Renderable*, String>::iterator itend = visibleObjects.end();

        while(it != itend)
        {
                ((*it).first)->setMaterialName((*it).second);
                it++;
        }
        
        visibleObjects.clear();

        SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
        sm->setFindVisibleObjects(true);
}

void OgreRenderingRun::renderFullscreenQuad(String materialName, RenderTarget* target)
{
    SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
                        
        if(fullScreenQuad == NULL)
        {
                fullScreenQuad = new MovablePlane("PASS_FULLSCREENQUAD_PLANE");
                fullScreenQuad->d = 0;
        fullScreenQuad->normal = Vector3::UNIT_Z;
                MeshManager::getSingleton().createPlane("PASS_FULLSCREENQUAD_MESH", 
            ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 
            *fullScreenQuad, 2, 2, 
            1, 1, true, 1, 1, 1, Vector3::UNIT_Y);
                fullScreenQuadEntity = sm->createEntity( "PASS_FULLSCREENQUAD_ENTITY", "PASS_FULLSCREENQUAD_MESH" );
                sm->getRootSceneNode()->attachObject(fullScreenQuadEntity);
                fullScreenQuadEntity->setVisible(false);
        }

        fullScreenQuadEntity->setMaterialName(materialName);
        sm->getRenderQueue()->clear();
        sm->getRenderQueue()->addRenderable(fullScreenQuadEntity->getSubEntity(0));
        sm->setFindVisibleObjects(false);
        target->update();
        sm->setFindVisibleObjects(true);
}

void OgreRenderingRun::renderPixelSprites(String& materialName, RenderTarget* rt, int width, int height)
{
        SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
        
        if(pixelSprites == 0)
        {       
                int resolutionX = width;
                int resolutionY = height;
                pixelSprites = new BillboardSet(spriteSetName, resolutionX * resolutionY, true);
                pixelSprites->setBillboardsInWorldSpace(true);
                pixelSprites->setCullIndividually(false);
                pixelSprites->setPointRenderingEnabled(true);
                //pixelSprites->setDefaultDimensions(1.0 / (float) resolutionX, 1.0 / resolutionY);
                pixelSprites->beginBillboards();
                for(int i = 0; i < resolutionX; i++)
                {
                        for(int j = 0; j < resolutionY; j++)
                        {                               
                                Billboard bb( Vector3(
                                                                                ( (float)i + 0.5 )/ (float) resolutionX, //position x
                                                                                ( (float)j + 0.5 )/ (float) resolutionY, //position y
                                                                                0),
                                                          pixelSprites);
                                bb.setDimensions(1.0 / (float) resolutionX, 1.0 / resolutionY);                         
                                pixelSprites->injectBillboard(bb);                              
                        }
                }
                pixelSprites->endBillboards();

                sm->getRootSceneNode()->attachObject(pixelSprites);
                
                pixelSprites->setVisible(false);
        }
        
        pixelSprites->setMaterialName(materialName);

        sm->getRenderQueue()->clear();
        sm->getRenderQueue()->addRenderable(pixelSprites);
        sm->setFindVisibleObjects(false);
        rt->update();
        sm->setFindVisibleObjects(true);
                
}