source: GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/src/IMGTextureAtlas.cpp @ 751

#include "IMGTextureAtlas.h"

namespace IMG {

TextureAtlas::TextureAtlas(): references(0) // initialize references to 0
{
        mRectangle2D->setBoundingBox(Ogre::AxisAlignedBox(-100000.0 * Ogre::Vector3::UNIT_SCALE, 100000.0 * Ogre::Vector3::UNIT_SCALE));
        mRectangle2D->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND);
        mCurrentTextureAtlas = TEXTURE_ATLAS_PING;
        mFirstUpdate = true;
}

TextureAtlas::~TextureAtlas()
{
        mTextureList.clear();
}

unsigned int TextureAtlas::getReference()
{
        return references;
}

void TextureAtlas::update()
{
        if (mCurrentTextureAtlas == TEXTURE_ATLAS_PING)
        {
                if (!mFirstUpdate)
                {
                        mMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName(mTextureAtlasPong->getName());                   
                        mMaterial->reload();
                        mTexture->getBuffer(0, 0)->getRenderTarget()->update(); 
                }                               

                if (mFirstUpdate)
                {
                        mFirstUpdate = false;
                        mTexture->getBuffer(0, 0)->getRenderTarget()->update();
                }
        }
        else
        {
                mMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName(mTexture->getName());
                mMaterial->reload();
                mTextureAtlasPong->getBuffer(0, 0)->getRenderTarget()->update();
        }

        mCurrentTextureAtlas++;
        mCurrentTextureAtlas = mCurrentTextureAtlas % 2;
}

void TextureAtlas::setTextureAtlasName(Ogre::String textureAtlasName)
{
        mTextureAtlasName = textureAtlasName;
}

Ogre::String TextureAtlas::getTextureAtlasName()
{
        return mTextureAtlasName;
}

void TextureAtlas::addTexture(TexturePtr texture)
{
        mTextureList.push_back(texture);
        mTextureAtlasSceneNode->attachObject(texture->getRectangle2D());
}

TexturePtr TextureAtlas::getTexture(unsigned int iTexture)
{
        return mTextureList[iTexture];
}

void TextureAtlas::removeTexture(unsigned int iTexture)
{
        mTextureList.erase(mTextureList.begin()+iTexture);
}

unsigned int TextureAtlas::getNumTextures()
{
        return mTextureList.size();
}

void TextureAtlas::setTextureAtlasSceneNode(Ogre::SceneNode *textureAtlasSceneNode)
{
        mTextureAtlasSceneNode = textureAtlasSceneNode; 
        mTextureAtlasSceneNode->attachObject(mRectangle2D);
}

void TextureAtlas::create(Ogre::String fileName, unsigned int width, unsigned int height, Ogre::PixelFormat pixelFormat, Ogre::Camera *camera, Ogre::ColourValue backgroundColour)
{
        mCamera = camera;
        mWidth = width;
        mHeight = height;
        mPixelFormat = pixelFormat;

        {
                mTexture = Ogre::TextureManager::getSingleton().createManual(fileName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mWidth, mHeight, 0, mPixelFormat, Ogre::TU_RENDERTARGET).getPointer();
                mTexture->getBuffer(0, 0)->getRenderTarget();
                Ogre::RenderTexture *rt = mTexture->getBuffer()->getRenderTarget();
                rt->setAutoUpdated(false);
                Ogre::Viewport *v = rt->addViewport(mCamera);
                v->setClearEveryFrame(true);
                v->setBackgroundColour(backgroundColour);
                v->setOverlaysEnabled(false);
                v->setDimensions(0,0,1.0,1.0);  
        }

        {
                mTextureAtlasPong = Ogre::TextureManager::getSingleton().createManual("PONG" + fileName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mWidth, mHeight, 0, mPixelFormat, Ogre::TU_RENDERTARGET).getPointer();
                mTextureAtlasPong->getBuffer(0, 0)->getRenderTarget();
                Ogre::RenderTexture *rt = mTextureAtlasPong->getBuffer()->getRenderTarget();
                rt->setAutoUpdated(false);
                Ogre::Viewport *v = rt->addViewport(mCamera);
                v->setClearEveryFrame(true);
                v->setBackgroundColour(backgroundColour);
                v->setOverlaysEnabled(false);
                v->setDimensions(0,0,1.0,1.0);  
        }
        Ogre::Root::getSingleton().getRenderSystem()->clearFrameBuffer(Ogre::FBT_COLOUR, Ogre::ColourValue(1.0f,1.0f,1.0f,0.0f) );
}

Ogre::SceneNode* TextureAtlas::getTextureAtlasSceneNode()
{
        return mTextureAtlasSceneNode;
}

void TextureAtlas::debug()
{
        Ogre::Texture *texture;
        if (mCurrentTextureAtlas == TEXTURE_ATLAS_PONG)
        {
                texture = mTexture;
        }
        else
        {
                texture = mTextureAtlasPong;
        }

        unsigned char* pBufferBox = new unsigned char[texture->getBuffer(0, 0)->getSizeInBytes()];

    // Read pixels      
        Ogre::PixelBox pBox(mWidth, mHeight, 1, mPixelFormat, pBufferBox);

        texture->getBuffer(0, 0)->blitToMemory(pBox);

        if (mPixelFormat == Ogre::PF_FLOAT32_RGBA)
        {
                imdebug("rgba w=%d h=%d %p b=32f",pBox.getWidth(), pBox.getHeight(), pBox.data);
        }

        if (mPixelFormat == Ogre::PF_A8R8G8B8)
        {
                //unsigned char* pBufferDest = new unsigned char[pBox.getWidth()*pBox.getHeight()*4];   
                unsigned char* pBufferDest = new unsigned char[pBox.getWidth()*pBox.getHeight()*4];     
                Ogre::PixelBox pDest(mWidth, mHeight, 1, Ogre::PF_BYTE_RGBA, pBufferDest);
                Ogre::PixelUtil::bulkPixelConversion(pBox.data, mPixelFormat, pDest.data, Ogre::PF_BYTE_RGBA, pBox.getWidth()*pBox.getHeight());
                
                imdebug("rgba w=%d h=%d %p ", pDest.getWidth(), pDest.getHeight(), pDest.data);
                
                delete [] pBufferDest;
        }

        delete [] pBufferBox;
}

void TextureAtlas::save(Ogre::String folderName, Ogre::String fileName, Ogre::PixelFormat pixelFormat)
{       
        Ogre::Texture *texture;

        if (mCurrentTextureAtlas == TEXTURE_ATLAS_PONG)
        {
                texture = mTexture;
        }
        else
        {
                texture = mTextureAtlasPong;
        }

        unsigned char* pBufferBox = new unsigned char[texture->getBuffer(0, 0)->getSizeInBytes()];
        unsigned char* pBufferDest = new unsigned char[texture->getBuffer(0, 0)->getSizeInBytes()];

    // Read pixels      
        Ogre::PixelBox pBox(mWidth, mHeight, 1, mPixelFormat, pBufferBox);
        Ogre::PixelBox pDest(mWidth, mHeight, 1, pixelFormat, pBufferDest);     
        texture->getBuffer(0, 0)->blitToMemory(pBox);
        Ogre::PixelUtil::bulkPixelConversion(pBox.data,mPixelFormat,pDest.data,pixelFormat,pBox.getWidth()*pBox.getHeight());

        // copyToMemory
        Ogre::ImageCodec::ImageData *imgData = new Ogre::ImageCodec::ImageData();
    
    imgData->width = mWidth;
    imgData->height = mHeight;
        imgData->depth = 1;     
    imgData->format = pixelFormat;

        // Wrap buffer in a chunk
        Ogre::MemoryDataStreamPtr stream(new Ogre::MemoryDataStream(pBufferDest, texture->getBuffer(0, 0)->getSizeInBytes(), false));

    // Get codec 
    size_t pos = fileName.find_last_of(".");
    Ogre::String extension;
    if( pos == Ogre::String::npos )
        {
        OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Unable to determine image type for '" + fileName + "' - invalid extension.", "GLRenderTexture::writeContentsToFile" );
        }

    while( pos != fileName.length() - 1 )
        {
        extension += fileName[++pos];
        }

    // Get the codec
    Ogre::Codec * pCodec = Ogre::Codec::getCodec(extension);

    // Write out
    Ogre::Codec::CodecDataPtr codecDataPtr(imgData);

        pCodec->codeToFile(stream,folderName + fileName, codecDataPtr);

        delete [] pBufferDest;
        delete [] pBufferBox;
}

}