/************************************************************************
	filename: 	OgreCEGUITexture.cpp
	created:	11/5/2004
	author:		Paul D Turner
	
	purpose:	Implementation of Texture using Ogre engine
*************************************************************************/
/*************************************************************************
    Crazy Eddie's GUI System (http://www.cegui.org.uk)
    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*************************************************************************/

// Workaround for GCC 4.6
#include <cstddef>

#include <CEGUISystem.h>
#include <CEGUIExceptions.h>
#include "OgreCEGUITexture.h"
#include "OgreCEGUIRenderer.h"

#include <OgreTextureManager.h>

// Start of CEGUI namespace section
namespace CEGUI
{
/*************************************************************************
	Static data definition / initialisation
*************************************************************************/
uint32 OgreCEGUITexture::d_texturenumber		= 0;


/*************************************************************************
	Constructor
*************************************************************************/
OgreCEGUITexture::OgreCEGUITexture(Renderer* owner) :
	Texture(owner)
{
	d_ogre_texture.setNull();
	d_isLinked = false;
}


/*************************************************************************
	Destructor
*************************************************************************/
OgreCEGUITexture::~OgreCEGUITexture(void)
{
	freeOgreTexture();
}


/*************************************************************************
	Loads the specified image file into the texture.  The texture is
	resized as required to hold the image.	
*************************************************************************/
void OgreCEGUITexture::loadFromFile(const String& filename, const String& resourceGroup)
{
	using namespace Ogre;

	// unload old ogre texture
	freeOgreTexture();

	// create / load a new ogre texture from the specified image
	try
	{
		TextureManager& textureManager = TextureManager::getSingleton();

		// see if texture already exists
		Ogre::TexturePtr ogreTexture = (Ogre::TexturePtr)textureManager.getByName(filename.c_str());

		if (!ogreTexture.isNull())
		{
			// texture already exists, so create a 'linked' texture (ensures texture is not destroyed twice)
			d_ogre_texture = ogreTexture;
			d_isLinked = true;
		}
		// texture does not already exist, so load it in
		else
		{
            String orpGroup;
            if (resourceGroup.empty())
            {
                const String& defGrp = CEGUI::System::getSingleton().getResourceProvider()->getDefaultResourceGroup();
                orpGroup = defGrp.empty() ? Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str() : defGrp;
            }
            else
            {
                orpGroup = resourceGroup;
            }

			d_ogre_texture = TextureManager::getSingleton().load(filename.c_str(), orpGroup.c_str(), TEX_TYPE_2D, 0, 1.0f);
			d_isLinked = false;
		}

	}
	catch(Ogre::Exception e)
	{
		throw RendererException((utf8*)"Failed to create Texture object from file '" + filename + "'. Additional Information:\n" + e.getFullDescription().c_str());
	}

	// if we got a pointer cache some details
	if (!d_ogre_texture.isNull())
	{
		d_width		= d_ogre_texture->getWidth();
		d_height	= d_ogre_texture->getHeight();
	}
	// no texture from image so throw.
	else
	{
		throw RendererException((utf8*)"Failed to create Texture object from file '" + filename + "'.  Ogre returned a NULL pointer.");
	}

}


/*************************************************************************
	Loads (copies) an image in memory into the texture.  The texture is
	resized as required to hold the image.	
*************************************************************************/

void _byteSwap(unsigned char* b, int n)
{
    register int i = 0;
    register int j = n-1;
    while (i<j)
    {
        std::swap(b[i], b[j]);
        i++, j--;
    }
}
#define byteSwap(x) _byteSwap((unsigned char*) &x,sizeof(x))

void OgreCEGUITexture::loadFromMemory(const void* buffPtr, uint buffWidth, uint buffHeight, PixelFormat pixelFormat)
{
	using namespace Ogre;

	// get rid of old texture
	freeOgreTexture();

	// wrap input buffer with an Ogre DataChunk
    uint32 bytesize = ((buffWidth * sizeof(uint32)) * buffHeight);

#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
    uint32* swappedBuffer = new uint32[bytesize/4];
    memcpy(swappedBuffer, buffPtr, bytesize);

    for (int i=0; i < bytesize/4; i++)
        byteSwap(swappedBuffer[i]);

    DataStreamPtr odc(new MemoryDataStream(static_cast<void*>(swappedBuffer), bytesize, false));
#else
	DataStreamPtr odc(new MemoryDataStream(const_cast<void*>(buffPtr), bytesize, false));
#endif

	// get pixel type for the target texture - the elements here might look wrong, but is just
	// differences in definition (at the core level, between GL and D3D).
	Ogre::PixelFormat targetFmt =
		(pixelFormat == PF_RGBA) ? Ogre::PF_A8R8G8B8 : Ogre::PF_R8G8B8;

	// try to create a Ogre::Texture from the input data
	d_ogre_texture = TextureManager::getSingleton().loadRawData(getUniqueName(), "General", odc, buffWidth, buffHeight, targetFmt , TEX_TYPE_2D, 0, 1.0f);

	// if we got a pointer cache some details
	if (!d_ogre_texture.isNull())
	{
		d_width		= d_ogre_texture->getWidth();
		d_height	= d_ogre_texture->getHeight();
	}
	// no texture from memory so throw.
	else
	{
		throw RendererException((utf8*)"Failed to create Texture object from memory:  Ogre returned a NULL Ogre::Texture pointer.");
	}

}


/*************************************************************************
	set the size of the internal Ogre texture.  Previous Ogre texture
	is lost.	
*************************************************************************/
void OgreCEGUITexture::setOgreTextureSize(uint size)
{
	using namespace Ogre;

	// unload any current Ogre::Texture
	freeOgreTexture();

	// Try to create an empty texture of the given size
	d_ogre_texture = TextureManager::getSingleton().createManual(getUniqueName(), "General", TEX_TYPE_2D, size, size, 0, PF_A8R8G8B8, TU_DEFAULT);

	// if we got a pointer cache some details
	if (!d_ogre_texture.isNull())
	{
		d_width		= d_ogre_texture->getWidth();
		d_height	= d_ogre_texture->getHeight();
	}
	// no texture so throw.
	else
	{
		throw RendererException((utf8*)"Failed to create texture of specified size: Ogre::Texture creation failed.");
	}

}


/*************************************************************************
	safely free Ogre::Texture texture (can be called multiple times with
	no ill effect)
*************************************************************************/
void OgreCEGUITexture::freeOgreTexture(void)
{
	if ((!d_ogre_texture.isNull()) && !d_isLinked)
	{
		Ogre::TextureManager::getSingleton().remove(d_ogre_texture->getHandle());
	}
	d_ogre_texture.setNull();
}


/*************************************************************************
	return a Ogre::string that contains a unique name.	
*************************************************************************/
Ogre::String OgreCEGUITexture::getUniqueName(void)
{
	Ogre::String str;

#ifdef CEGUI_USEOLDOGRESTRING
	str << "_cegui_ogre_" << d_texturenumber;
#else
	Ogre::StringUtil::StrStreamType strstream;
	strstream << "_cegui_ogre_" << d_texturenumber;
	str = strstream.str();
#endif

	++d_texturenumber;

	return str;
}


/*************************************************************************
	Set the internal Ogre::Texture object.
*************************************************************************/
void OgreCEGUITexture::setOgreTexture(Ogre::TexturePtr& texture)
{
	freeOgreTexture();

	d_ogre_texture = texture;
	d_width	 = d_ogre_texture->getWidth();
	d_height = d_ogre_texture->getHeight();
	d_isLinked = true;
}


} // End of  CEGUI namespace section