#include <qstringlist.h></qstringlist.h>

#include "tsimplecolorstyles.h"

#include "ttessellator.h"

#include "trop.h"

#include "drawutil.h"

#include "tflash.h"

#include "tpixelutils.h"

#include "tlevel_io.h"

#include "timage_io.h"

#include "trandom.h"

#include "tvectorimage.h"

#include "toonz/toonzscene.h"

#include "toonz/imagestyles.h"

//*************************************************************************************

//    TTextureStyle  implementation

//*************************************************************************************

namespace

{

TRandom Random;

#define QUAD_PRIMITIVE GL_QUAD_STRIP

typedef std::pair<tpointd, tpointd=""> PointPair;</tpointd,>

typedef std::vector<tpointd> PointArray;</tpointd>

PointPair computeTexParameters(const TPointD &p1,

							   const TPointD &p2,

							   const TPointD &tex1,

							   const TPointD &tex2,

							   const PointPair &newP,

							   const TDimension &size)

{

	// texture points

	static PointPair tex;

	// set vector of movement

	TPointD v = (newP.first + newP.second) * 0.5 - (p2 + p1) * 0.5;

	// compute length of opposite segment

	double lenghtNextP1NextP2 = tdistance(newP.first, newP.second);

	// compute parameter texture offset starting from 0.5

	double texParameterOffset = lenghtNextP1NextP2 / size.lx * 0.5;

	// fix value for s

	tex.first.x = 0.5 - texParameterOffset;

	tex.second.x = 0.5 + texParameterOffset;

	// get length

	double disty = norm(v);

	assert(tex1.y == tex2.y);

	// find parameter for t

	texParameterOffset = disty / size.ly;

	// fix values for t (oldValue + newValue)

	tex.first.y =

		tex.second.y = tex1.y + texParameterOffset;

	return tex;

}

//-----------------------------------------------------------------------------

void setTexCoords(const TPointD tex, TOutlinePoint &p)

{

	p.u = tex.x;

	p.v = tex.y;

}

//-----------------------------------------------------------------------------

TPointD getTexCoords(const TOutlinePoint &p)

{

	return TPointD(p.u, p.v);

}

} //namespace

//-----------------------------------------------------------------------------

TTextureStyle::TTextureStyle(const TRasterP &ras, const TFilePath &texturePath)

	: m_texture(ras), m_texturePath(texturePath), m_tessellator(new TglTessellator), m_params(), m_texturePathLoaded()

{

	setAverageColor();

}

//-----------------------------------------------------------------------------

TFilePath TImageStyle::m_libraryDir;

ToonzScene *TImageStyle::m_currentScene = 0;

//-----------------------------------------------------------------------------

TTextureStyle::TTextureStyle(const TTextureStyle &other)

	: TOutlineStyle(other), TRasterStyleFx(other), TImageStyle(other), m_texture(other.m_texture), m_texturePath(other.m_texturePath), m_texturePathLoaded(other.m_texturePathLoaded), m_params(other.m_params), m_tessellator(new TglTessellator)

{

	setAverageColor();

}

//-----------------------------------------------------------------------------

TTextureStyle::~TTextureStyle()

{

	delete m_tessellator;

}

//-----------------------------------------------------------------------------

TColorStyle *TTextureStyle::clone() const

{

	return new TTextureStyle(*this);

}

//-----------------------------------------------------------------------------

QString TTextureStyle::getDescription() const

{

	return "TextureStyle";

}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

int TTextureStyle::getTagId() const

{

	return 4;

}

//-----------------------------------------------------------------------------

TRasterP TTextureStyle::getTexture() const

{

	return m_texture;

}

//-----------------------------------------------------------------------------

void TTextureStyle::setAverageColor()

{

	loadTextureRaster();

	TRaster32P r32 = (TRaster32P)m_texture;

	if (!r32) {

		m_averageColor = TPixel::Black;

		return;

	}

	if (m_params.m_isPattern) {

		m_averageColor = m_params.m_patternColor;

		return;

	}

	TPixelD color(0, 0, 0, 0);

	r32->lock();

	for (int i = 0; i < r32->getLy(); i++) {

		TPixel32 *buf = r32->pixels(i);

		for (int j = 0; j < r32->getLx(); j++, buf++) {

			color.r += buf->r;

			color.g += buf->g;

			color.b += buf->b;

			color.m += buf->m;

		}

	}

	r32->unlock();

	int pixels = r32->getLx() * r32->getLy();

	m_averageColor.r = (int)(color.r / pixels);

	m_averageColor.g = (int)(color.g / pixels);

	m_averageColor.b = (int)(color.b / pixels);

	m_averageColor.m = (int)(color.m / pixels);

}

void TTextureStyle::setTexture(const TRasterP &ras)

{

	m_texture = ras;

	delete m_tessellator;

	m_tessellator = new TglTessellator;

	setAverageColor();

}

//-----------------------------------------------------------------------------

TPixel32 TTextureStyle::getAverageColor() const

{

	return m_averageColor;

}

//-----------------------------------------------------------------------------

void TTextureStyle::computeOutline(const TStroke *stroke,

								   TStrokeOutline &outline,

								   TOutlineUtil::OutlineParameter param) const

{

	TOutlineStyle::computeOutline(stroke, outline, param);

	std::vector<toutlinepoint> &v = outline.getArray();</toutlinepoint>

	PointPair newPnt;

	TDimension size = m_texture->getSize();

	UINT i = 0;

	for (i = 2; i < v.size(); i += 2) {

		newPnt.first = convert(v[i]);

		newPnt.second = convert(v[i + 1]);

		newPnt = computeTexParameters(convert(v[i - 2]), convert(v[i - 1]),

									  getTexCoords(v[i - 2]), getTexCoords(v[i - 1]),

									  newPnt,

									  size);

		setTexCoords(newPnt.first, v[i]);

		setTexCoords(newPnt.second, v[i + 1]);

	}

	for (i = 0; i < v.size(); i++) {

		v[i].u = (i & 1) == 0 ? 0 : 1;

	}

}

//-----------------------------------------------------------------------------

void TTextureStyle::drawStroke(const TColorFunction *cf, TStrokeOutline *outline, const TStroke *stroke) const

{

	/*struct locals {

    static float adaptToGLTextureFunction( USHORT style )

    {

      switch( style )

      {

      case TTextureStyle::DECAL:

        return GL_DECAL;

        break;

      case TTextureStyle::MODULATE:

        return GL_MODULATE;

        break;

      case TTextureStyle::BLEND:

        return GL_BLEND;

        break;

      }

      return GL_DECAL;

    }

  };    // locals;*/

	UINT i;

	std::vector<toutlinepoint> &v = outline->getArray();</toutlinepoint>

	if (v.empty())

		return;

	const TRasterP texture = m_texture;

	assert(!v.empty() || !texture);

	if (v.empty() || !texture)

		return;

	static const int stride = sizeof(TOutlinePoint);

	glColor4d(1.0, 1.0, 1.0, 1.0);

	// information about vertex

	glEnableClientState(GL_VERTEX_ARRAY);

	glVertexPointer(2, GL_DOUBLE, stride, &v[0]);

	glEnable(GL_TEXTURE_2D);

#ifdef _DEBUG

	GLboolean blendEnabled;

	glGetBooleanv(GL_BLEND, &blendEnabled);

	assert(blendEnabled);

#endif

	glEnableClientState(GL_TEXTURE_COORD_ARRAY);

	glTexCoordPointer(2, GL_DOUBLE, stride, &(v[0].u));

	TextureInfoForGL texInfo;

	m_texture->lock();

	TRasterP texImage = prepareTexture(m_texture, texInfo);

	// Generate a texture id and bind it.

	GLuint texId;

	glGenTextures(1, &texId);

	glBindTexture(GL_TEXTURE_2D, texId);

	// Specify texture parameters

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

	glTexEnvf(GL_TEXTURE_ENV,

			  GL_TEXTURE_ENV_MODE,

			  GL_MODULATE); // change texture blending function

	glPixelStorei(GL_UNPACK_ROW_LENGTH,

				  texImage->getWrap() != texImage->getLx() ? texImage->getWrap() : 0);

	if (texImage != m_texture)

		texImage->lock();

	// Load texture

	glTexImage2D(GL_TEXTURE_2D,

				 0,						 // one level only

				 texInfo.internalformat, // pixel channels count

				 texInfo.width,			 // width

				 texInfo.height,		 // height

				 0,						 // border size

				 texInfo.type,			 // pixel format           // crappy names

				 texInfo.format,		 // pixel data type        // oh, SO much

				 texImage->getRawData());

	m_texture->unlock();

	if (texImage != m_texture)

		texImage->lock();

	// Step 1: draw outline

	glBegin(GL_LINE_STRIP);

	for (i = 0; i < v.size(); i += 2)

		glArrayElement(i);

	glEnd();

	glBegin(GL_LINE_STRIP);

	for (i = 1; i < v.size(); i += 2)

		glArrayElement(i);

	glEnd();

	// Step 2: draw texturized stroke

	/*

  #ifdef MACOSX                   //NON SI CAPISCE PERCHE DRAWARRAY E DISPLAY LIST PROVOCHINO UN CRASH SU MAC

  #warning "INDAGARE ANCORA!!!!"  //PER ADESSO CHIEDO SE STA REGISTANDO UNA DISPLAYLIST E IN QUEL CASO NON USO GLI ARRAY 

  GLuint listId;

  glGetIntegerv(GL_LIST_INDEX,(GLint*)&listId);   

  if(listId==0)

  {

  #endif  

  */

	glDrawArrays(QUAD_PRIMITIVE, 0, v.size());

	/*

  #ifdef MACOSX      

  }

  else

  {

    glBegin( GL_QUAD_STRIP );

    for(UINT i=0; i< v.size(); i++) 

      glVertex2dv( &v[i].x );

    glEnd();

  } 

  #endif

  */

	// Delete texture

	glDeleteTextures(1, &texId);

	glDisableClientState(GL_VERTEX_ARRAY);

	glDisableClientState(GL_TEXTURE_COORD_ARRAY);

	glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

	glDisable(GL_TEXTURE_2D);

}

//-----------------------------------------------------------------------------

//drawRegion( const TVectorRenderData &rd,  TRegionOutline &boundary ) const

void TTextureStyle::drawRegion(const TColorFunction *cf, const bool antiAliasing, TRegionOutline &boundary) const

{

	if (m_tessellator)

		m_tessellator->tessellate(cf, antiAliasing, boundary, m_texture);

}

//-----------------------------------------------------------------------------

void TTextureStyle::drawRegion(TFlash &flash, const TRegion *r) const

{

	flash.setTexture(m_texture);

	flash.setFillStyleMatrix(TAffine());

	flash.drawRegion(*r);

	//rd.setTexture(m_colorStyle->getMainColor());

}

//-----------------------------------------------------------------------------

void TTextureStyle::setFill(TFlash &flash) const

{

	flash.setTexture(getTexture());

}

//-----------------------------------------------------------------------------

//----------------------------------------

namespace

{

void tileRaster(const TRaster32P &tile, const TRaster32P &rout)

{

	int x0, y0;

	if (rout->getLy() > tile->getLy()) ///tile must be centered in rout

		y0 = tile->getLy() - (((rout->getLy() - tile->getLy()) / 2) % tile->getLy());

	else

		y0 = (tile->getLy() - rout->getLy()) / 2;

	if (rout->getLx() > tile->getLx()) ///tile must be centered in rout

		x0 = tile->getLx() - (((rout->getLx() - tile->getLx()) / 2) % tile->getLx());

	else

		x0 = (tile->getLx() - rout->getLx()) / 2;

	//x0-=tround(offs.x);

	//y0-=tround(offs.y);

	while (x0 < 0)

		x0 += tile->getLx();

	while (y0 < 0)

		y0 += tile->getLy();

	x0 = x0 % tile->getLx();

	y0 = y0 % tile->getLy();

	int y = y0;

	for (int i = 0; i < rout->getLy(); i++, y++) {

		if (y == tile->getLy())

			y = 0;

		int x = x0;

		TPixel32 *pixout = rout->pixels(i);

		TPixel32 *pixin = tile->pixels(y) + x;

		for (int j = 0; j < rout->getLx(); j++, pixin++, pixout++, x++) {

			if (x == tile->getLx()) {

				x = 0, pixin = tile->pixels(y);

			}

			*pixout = *pixin;

		}

	}

}

//---------------------------------------------------------------------

void doContrast(double contrast, const TRaster32P &rin)

{

	TPixel32 *row, *pix;

	int i, j, lx, ly, wrap;

	double line_avg_r, line_avg_g, line_avg_b;

	double avg_r = 0, avg_g = 0, avg_b = 0;

	lx = rin->getLx();

	ly = rin->getLy();

	wrap = rin->getWrap();

	for (j = 0, row = (TPixel32 *)rin->getRawData(); j < ly; j++, row += wrap) {

		line_avg_r = 0;

		line_avg_g = 0;

		line_avg_b = 0;

		for (i = 0, pix = row; i < lx; i++, pix++) {

			line_avg_r += pix->r;

			line_avg_g += pix->g;

			line_avg_b += pix->b;

		}

		avg_r += line_avg_r / lx;

		avg_g += line_avg_g / lx;

		avg_b += line_avg_b / lx;

	}

	avg_r /= ly;

	avg_g /= ly;

	avg_b /= ly;

	int ires;

	double dres;

	TPixel32 lut[256];

	for (int i = 0; i < 256; i++) {

		dres = contrast * (i - avg_r) + avg_r;

		ires = tround(dres);

		lut[i].r = tcrop(ires, 0, 255);

		dres = contrast * (i - avg_g) + avg_g;

		ires = tround(dres);

		lut[i].g = tcrop(ires, 0, 255);

		dres = contrast * (i - avg_b) + avg_b;

		ires = tround(dres);

		lut[i].b = tcrop(ires, 0, 255);

	}

	for (j = 0, row = (TPixel32 *)rin->getRawData(); j < ly; j++, row += wrap) {

		for (i = 0, pix = row; i < lx; i++, pix++) {

			pix->r = lut[pix->r].r;

			pix->g = lut[pix->g].g;

			pix->b = lut[pix->b].b;

			if (pix->r > pix->m)

				pix->r = pix->m;

			if (pix->g > pix->m)

				pix->g = pix->m;

			if (pix->b > pix->m)

				pix->b = pix->m;

		}

	}

}

//------------------------------------------------------------------------------------

#define BYTE_ROUND(A) ((UINT)((A) + (1U << 23)) >> 24)

#define MAGICFAC (257U * 256U + 1U)

static void doPattern(const TRaster32P &r, TPixel32 color)

{

	int i, j, fac = 0;

	if (TPixelGR8::from(color).value < 128)

		fac = 255 - color.m * (255.0 - color.m) / 255.0;

	TPixel32 *buf;

	UINT b;

	for (i = 0; i < r->getLy(); i++) {

		buf = (TPixel32 *)r->pixels(i);

		for (j = 0; j < r->getLx(); j++, buf++) {

			if (buf->m > 0) {

				b = TPixelGR8::from(*buf).value * MAGICFAC;

				buf->r = BYTE_ROUND(b * color.r + fac);

				buf->g = BYTE_ROUND(b * color.g + fac);

				buf->b = BYTE_ROUND(b * color.b + fac);

				if (buf->m < 255 || color.m < 255) {

					buf->m = BYTE_ROUND(buf->m * color.m / 255.0);

					premult(*buf);

				} else

					buf->m = 255;

			}

		}

	}

}

//--------------------------------------------------------

void applyTexture(const TRaster32P &rTex, const TRaster32P &r, TPoint p)

{

	while (p.x < 0)

		p.x += rTex->getLx();

	while (p.y < 0)

		p.y += rTex->getLy();

	r->lock();

	rTex->lock();

	for (int y = 0, yTex = p.y; y < r->getLy(); y++, yTex++) {

		TPixel32 *pixIn = r->pixels(y);

		if (yTex >= rTex->getLy())

			yTex -= rTex->getLy();

		TPixel32 *pixTex = (TPixel32 *)(rTex->pixels(yTex)) + p.x;

		for (int x = 0, xTex = p.x; x < r->getLx(); x++, xTex++, pixIn++, pixTex++) {

			if (xTex >= rTex->getLx())

				xTex -= rTex->getLx(), pixTex -= rTex->getLx();

			if (pixIn->m == 0)

				continue;

			if (pixIn->m == 255)

				*pixIn = *pixTex;

			else {

				pixIn->r = pixIn->m * pixTex->r / 255;

				pixIn->g = pixIn->m * pixTex->g / 255;

				pixIn->b = pixIn->m * pixTex->b / 255;

				pixIn->m = pixIn->m * pixTex->m / 255;

			}

		}

	}

	r->unlock();

	rTex->unlock();

}

} //namespace

//---------------------------------------------------------------------------------------------------------------

TPoint computeCentroid(const TRaster32P &r);

//-----------------------------------------------------------------------------

int TTextureStyle::getParamCount() const

{

	return 8;

}

//-------------------------------------------------------------------

QString TTextureStyle::getParamNames(int index) const

{

	switch (index) {

	case 0: return "Use As Pattern";

	case 1: return "Position";

	case 2: return "Scale";

	case 3: return "Rotation(degrees)";

	case 4: return "X displ";

	case 5: return "Y displ";

	case 6: return "Contrast";

	case 7: return "Load From File";

	default:

		assert(false);

	}

	return QString("");

}

//-------------------------------------------------------------------

void TTextureStyle::getParamRange(int index, double &min, double &max) const

{

	assert(index > 1);

	switch (index) {

	case 2:

		min = 0.15;

		max = 10;

		break;

	case 3:

		min = -180;

		max = 180;

		break;

	case 4:

		min = -500;

		max = 500;

		break;

	case 5:

		min = -500;

		max = 500;

		break;

	case 6:

		min = 0.01;

		max = 10;

		break;

	default:

		assert(false);

	}

}

//-------------------------------------------------------------------

TColorStyle::ParamType TTextureStyle::getParamType(int index) const

{

	assert(0 <= index && index < getParamCount());

	if (index == 0)

		return TColorStyle::BOOL;

	else if (index == 1)

		return TColorStyle::ENUM;

	else if (index == 7)

		return TColorStyle::FILEPATH;

	return TColorStyle::DOUBLE;

}

//-----------------------------------------------------------------------------

void TTextureStyle::getParamRange(int index, QStringList &enumItems) const

{

	assert(index == 1 || index == 7);

	if (index == 1)

		enumItems << "FIXED"

				  << "AUTOMATIC"

				  << "RANDOM";

	else if (index == 7)

		enumItems << "bmp"

				  << "jpg"

				  << "png"

				  << "tif"

				  << "tiff"

				  << "gif";

}

//-------------------------------------------------------------------------

bool TTextureStyle::getParamValue(TColorStyle::bool_tag, int index) const

{

	assert(index == 0);

	return m_params.m_isPattern;

}

//---------------------------------------------------

double TTextureStyle::getParamValue(TColorStyle::double_tag, int index) const

{

	assert(index > 1);

	switch (index) {

	case 2: return m_params.m_scale;

	case 3: return m_params.m_rotation;

	case 4: return m_params.m_displacement.x;

	case 5: return m_params.m_displacement.y;

	case 6: return m_params.m_contrast;

	default:

		assert(false);

	}

	return 0;

}

TFilePath TTextureStyle::getParamValue(TColorStyle::TFilePath_tag, int index) const

{

	assert(index == 7);

	return m_texturePath;

}

//-------------------------------------------------------------------

int TTextureStyle::getParamValue(TColorStyle::int_tag, int index) const

{

	assert(index == 1);

	return m_params.m_type;

}

//-------------------------------------------------------------------

void TTextureStyle::setParamValue(int index, const TFilePath &value)

{

	assert(index == 7);

	m_texturePath = value;

	setAverageColor();

}

//-----------------------------------------------------------------

void TTextureStyle::setParamValue(int index, int value)

{

	assert(index == 1);

	m_params.m_type = (TTextureParams::TYPE)value;

}

//-------------------------------------------------------------------

void TTextureStyle::setParamValue(int index, bool value)

{

	assert(index == 0);

	m_params.m_isPattern = value;

}

//--------------------------------------------------------------------------

void TTextureStyle::setParamValue(int index, double value)

{

	assert(index > 1);

	switch (index) {

	case 0:

		m_params.m_isPattern = (((int)value == 0) ? false : true);

		break;

	case 1:

		m_params.m_type = (((int)value == 0) ? TTextureParams::FIXED : ((int)value == 1) ? TTextureParams::AUTOMATIC : TTextureParams::RANDOM);

		break;

	case 2:

		m_params.m_scale = value;

		break;

	case 3:

		m_params.m_rotation = value;

		break;

	case 4:

		m_params.m_displacement.x = value;

		break;

	case 5:

		m_params.m_displacement.y = value;

		break;

	case 6:

		m_params.m_contrast = value;

		break;

	default:

		assert(false);

	}

}

//------------------------------------------------------------

bool TTextureStyle::loadTextureRaster()

{

	if (m_texturePathLoaded != TFilePath() && m_texturePath == m_texturePathLoaded)

		return true;

	m_texturePathLoaded = m_texturePath;

	TFilePath path;

	if (m_texturePath.getParentDir() != TFilePath()) //It's a custom texture

	{

		assert(m_currentScene);

		path = m_currentScene->decodeFilePath(m_texturePath);

		if (path.isLevelName()) {

			TLevelReader lr(path);

			path = path.withFrame(lr.loadInfo()->begin()->first);

		}

	} else //is a library texture

	{

		path = m_texturePath.withParentDir(m_libraryDir + "textures");

	}

	TRasterP aux;

	if (!TImageReader::load(path, aux)) {

		m_texture = TRaster32P(128, 128);

		m_texture->clear();

		m_texturePathLoaded = TFilePath();

		return false;

	}

	m_texture = aux;

	return true;

}

//----------------------------------------------------------------------------

TRaster32P TTextureStyle::loadTextureRasterWithFrame(int frame) const

{

	if (m_texturePathLoaded != TFilePath() && m_texturePath == m_texturePathLoaded && (!m_texturePath.isLevelName() || frame == 0))

		return m_texture->clone();

	TFilePath path;

	if (m_texturePath.getParentDir() != TFilePath()) //It's a custom texture

	{

		assert(m_currentScene);

		path = m_currentScene->decodeFilePath(m_texturePath);

		if (path.isLevelName()) {

			TLevelReader lr(path);

			TLevelP info = lr.loadInfo();

			TLevel::Iterator it = info->begin();

			//frame = frame % (lr.loadInfo()->getFrameCount());

			std::advance(it, frame % (info->getFrameCount()));

			//

			path = path.withFrame(it->first);

		}

	} else //is a library texture

	{

		path = m_texturePath.withParentDir(m_libraryDir + "textures");

	}

	TRasterP aux;

	if (!TImageReader::load(path, aux)) {

		aux = TRaster32P(128, 128);

		aux->clear();

	}

	return aux;

}

//---------------------------------------------

void TTextureStyle::loadData(TInputStreamInterface &is)

{

	if (is.versionNumber().first < 71) {

		is >> m_texture;

		setTexture(m_texture);

		return;

	}

	std::string path;

	is >> path;

	m_texturePath = TFilePath(path);

	//TOutlineStyle::loadData(is);

	//is >> m_texture;

	loadTextureRaster();

	is >> m_params.m_patternColor;

	m_averageColor = m_params.m_patternColor;

	double value;

	is >> value;

	m_params.m_isPattern = value == 1.0 ? true : false;

	is >> value;

	m_params.m_type = (((int)value == 0) ? TTextureParams::FIXED : ((int)value == 1) ? TTextureParams::AUTOMATIC : TTextureParams::RANDOM);

	is >> m_params.m_scale;

	is >> m_params.m_rotation;

	is >> m_params.m_displacement.x;

	is >> m_params.m_displacement.y;

	is >> m_params.m_contrast;

	delete m_tessellator;

	m_tessellator = new TglTessellator;

	setAverageColor();

}

//------------------------------------------------------------

void TTextureStyle::saveData(TOutputStreamInterface &os) const

{

	//TOutlineStyle::saveData(os);

	//os << m_texture;

	std::wstring wstr = m_texturePath.getWideString();

	std::string str;

	str.assign(wstr.begin(), wstr.end());

	os << str;

	os << m_params.m_patternColor;

	os << ((double)m_params.m_isPattern);

	double value = (m_params.m_type == TTextureParams::FIXED) ? 0 : ((m_params.m_type == TTextureParams::AUTOMATIC) ? 1 : 2);

	os << value;

	os << m_params.m_scale;