#include "toonz/textureutils.h"
 
// TnzLib includes
#include "toonz/txshleveltypes.h"
#include "toonz/txshsimplelevel.h"
#include "toonz/txshchildlevel.h"
#include "toonz/txsheet.h"
#include "toonz/tstageobjecttree.h"
#include "toonz/txshcell.h"
#include "toonz/tstageobject.h"
#include "toonz/stage.h"
#include "toonz/toonzscene.h"
#include "toonz/imagemanager.h"
#include "imagebuilders.h"
 
// TnzCore includes
#include "tpalette.h"
#include "tconvert.h"
#include "ttoonzimage.h"
#include "trop.h"
#include "tropcm.h"
#include "tgl.h"
 
//********************************************************************************************
//    TXshSimpleLevel Texture Utilities  locals
//********************************************************************************************
 
namespace
{
 
TRasterImageP convert32(const TImageP &img)
{
	struct locals {
		static TRasterImageP depremultiplied(const TRasterImageP &ri)
		{
			assert(ri->getRaster());
 
			TRop::depremultiply(ri->getRaster());
			return ri;
		}
	}; // locals
 
	if (TRasterImageP ri = img) {
		TRasterP ras(ri->getRaster());
 
		TRaster32P ras32;
		{
			if (TRaster32P(ras))
				ras32 = ras->clone();
			else {
				ras32 = TRaster32P(ras->getSize());
				TRop::convert(ras32, ras);
			}
		}
 
		TPointD dpi;
		ri->getDpi(dpi.x, dpi.y);
 
		TRasterImageP ri32(ras32);
		ri32->setDpi(dpi.x, dpi.y);
		ri32->setSubsampling(ri->getSubsampling());
		ri32->setOffset(ri->getOffset());
 
		return locals::depremultiplied(ri32);
	}
 
	if (TToonzImageP ti = img) {
		TRasterCM32P rasCM32(ti->getRaster());
 
		TRaster32P ras32(rasCM32->getSize());
		TRop::convert(ras32, rasCM32, ti->getPalette());
 
		TPointD dpi;
		ti->getDpi(dpi.x, dpi.y);
 
		TRasterImageP ri32(ras32);
		ri32->setDpi(dpi.x, dpi.y);
		ri32->setSubsampling(ti->getSubsampling());
		ri32->setOffset(ti->getOffset());
 
		return locals::depremultiplied(ri32);
	}
 
	return TRasterImageP();
}
 
//-----------------------------------------------------------------------------
 
TRasterImageP getTexture(const TXshSimpleLevel *sl, const TFrameId &fid, int subsampling)
{
	if (sl->getType() != PLI_XSHLEVEL) {
		TImageP texImg = sl->getFrame(fid, ImageManager::dontPutInCache, subsampling);
		return convert32(texImg);
	}
 
	// Vector case
	std::string id = sl->getImageId(fid) + "_rasterized";
 
	ImageLoader::BuildExtData extData(sl, fid);
	TRasterImageP ri(ImageManager::instance()->getImage(id, ImageManager::dontPutInCache, &extData));
 
	return ri;
}
 
} // namespace
 
//********************************************************************************************
//    TXshSimpleLevel Texture Utilities  implementation
//********************************************************************************************
 
DrawableTextureDataP texture_utils::getTextureData(
	const TXshSimpleLevel *sl, const TFrameId &fid, int subsampling)
{
	const std::string &texId = sl->getImageId(fid);
 
	// Now, we must associate a texture
	DrawableTextureDataP data(TTexturesStorage::instance()->getTextureData(texId));
	if (data)
		return data;
 
	// There was no associated texture. We must bind the texture and repeat
 
	// First, retrieve the image to be used as texture
	TRasterImageP ri(::getTexture(sl, fid, subsampling));
	if (!ri)
		return DrawableTextureDataP();
 
	TRaster32P ras(ri->getRaster());
	assert(ras);
 
	TRectD geom(0, 0, ras->getLx(), ras->getLy());
	geom = TScale(ri->getSubsampling()) *
		   TTranslation(convert(ri->getOffset()) - ras->getCenterD()) *
		   geom;
 
	return TTexturesStorage::instance()->loadTexture(texId, ras, geom);
}
 
//-----------------------------------------------------------------------------
 
void texture_utils::invalidateTexture(const TXshSimpleLevel *sl, const TFrameId &fid)
{
	const std::string &texId = sl->getImageId(fid);
	TTexturesStorage::instance()->unloadTexture(texId);
}
 
//-----------------------------------------------------------------------------
 
void texture_utils::invalidateTextures(const TXshSimpleLevel *sl)
{
	int f, fCount = sl->getFrameCount();
 
	for (f = 0; f != fCount; ++f)
		invalidateTexture(sl, sl->getFrameId(f));
}
 
//********************************************************************************************
//    TXsheet Texture Utilities  locals
//********************************************************************************************
 
namespace
{
 
std::string getImageId(const TXsheet *xsh, int frame)
{
	return "X" + toString(xsh->id()) + "_" + toString(frame);
}
 
} // namespace
 
//********************************************************************************************
//    TXsheet Texture Utilities  implementation
//********************************************************************************************
 
DrawableTextureDataP texture_utils::getTextureData(const TXsheet *xsh, int frame)
{
	// Check if an xsheet texture already exists
	const std::string &texId = ::getImageId(xsh, frame);
 
	DrawableTextureDataP data(TTexturesStorage::instance()->getTextureData(texId));
	if (data)
		return data;
 
	// No available texture - we must build and load it
	TRaster32P tex(1024, 1024); // Fixed texture size. It's the same that currently happens with
								// vector images' textures - and justified since this is camstand
								// mode, and besides we want to make sure that textures are limited.
 
	// Retrieve the sub-xsheet bbox (world coordinates of the sub-xsheet)
	TRectD bbox(xsh->getBBox(frame));
 
	// Since xsh represents a sub-xsheet, its camera affine must be applied
	const TAffine &cameraAff = xsh->getPlacement(xsh->getStageObjectTree()->getCurrentCameraId(), frame);
	bbox = (cameraAff.inv() * bbox).enlarge(1.0);
 
	// Render the xsheet on the specified bbox
 
	// The call below will change context (I know, it's a shame :( )
	TGlContext currentContext = tglGetCurrentContext();
	{
		tglDoneCurrent(currentContext);
		xsh->getScene()->renderFrame(tex, frame, xsh, bbox, TAffine());
		tglMakeCurrent(currentContext);
	}
 
	TRop::depremultiply(tex); // Stored textures are rendered nonpremultiplied
 
	// Store the texture for future retrieval
	return TTexturesStorage::instance()->loadTexture(texId, tex, bbox);
}
 
//-----------------------------------------------------------------------------
 
void texture_utils::invalidateTexture(const TXsheet *xsh, int frame)
{
	const std::string &texId = ::getImageId(xsh, frame);
	TTexturesStorage::instance()->unloadTexture(texId);
}
 
//-----------------------------------------------------------------------------
 
void texture_utils::invalidateTextures(const TXsheet *xsh)
{
	int f, fCount = xsh->getFrameCount();
	for (f = 0; f != fCount; ++f)
		invalidateTexture(xsh, f);
}