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

#include "tsimplecolorstyles.h"

#include "ttessellator.h"

#include "trop.h"

#include "drawutil.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 lengthNextP1NextP2 = tdistance(newP.first, newP.second);

  // compute parameter texture offset starting from 0.5

  double texParameterOffset = lengthNextP1NextP2 / 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);

}

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

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

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;

  os << m_params.m_rotation;

  os << m_params.m_displacement.x;

  os << m_params.m_displacement.y;

  os << m_params.m_contrast;

}

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

int TTextureStyle::getColorParamCount() const { return 1; }

TPixel32 TTextureStyle::getColorParamValue(int index) const {

  return m_params.m_patternColor;

}

void TTextureStyle::setColorParamValue(int index, const TPixel32 &color) {

  m_params.m_patternColor = color;

}

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

inline void drawdot(TPixel32 *pix, int wrap) {

  for (int i = -wrap; i <= wrap; i += wrap)

    for (int j = -1; j <= 1; j++) *(pix + i + j) = TPixel::Red;

}

void TTextureStyle::fillCustomTextureIcon(const TRaster32P &r) {

  r->fill(TPixel::White);

  int x1, x2, x3;

  x2 = r->getLx() / 2;

  x1 = x2 + ((r->getLx() <= 64) ? 6 : 9);

  x3 = x2 - ((r->getLx() <= 64) ? 6 : 9);

  TPixel32 *pix = r->pixels(r->getLy() / 4);

  drawdot(pix + x1, r->getWrap());

  drawdot(pix + x2, r->getWrap());

  drawdot(pix + x3, r->getWrap());

  // TImageWriter::save(TFilePath("C:\\temp\\boh.png"), r);

  /**(pix+x1) = TPixel::Black;

*(pix+x2) = TPixel::Black;

*(pix+x3) = TPixel::Black;*/

}

void TTextureStyle::makeIcon(const TDimension &outputRect) {

  if (!m_icon || m_icon->getSize() != outputRect) {

    TRaster32P ras(outputRect);

    ras->fill(TPixel::Red);

    m_icon = ras;

  }

  if (!loadTextureRaster()) {