// TnzCore includes

#include "tsystem.h"

#include "tstream.h"

#include "tthreadmessage.h"

#include "tconvert.h"

#include "tstopwatch.h"

#include "tlevel_io.h"

#include "trasterimage.h"

#include "ttoonzimage.h"

#include "tvectorimage.h"

#include "timagecache.h"

#include "timageinfo.h"

#include "tropcm.h"

#include "tofflinegl.h"

#include "tvectorrenderdata.h"

// TnzBase includes

#include "ttzpimagefx.h"

#include "trasterfx.h"

#include "tzeraryfx.h"

#include "trenderer.h"

#include "tfxcachemanager.h"

// TnzLib includes

#include "toonz/toonzscene.h"

#include "toonz/txsheet.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshpalettecolumn.h"

#include "toonz/txshzeraryfxcolumn.h"

#include "toonz/txshlevel.h"

#include "toonz/txshcell.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txshpalettelevel.h"

#include "toonz/txshleveltypes.h"

#include "toonz/levelset.h"

#include "toonz/txshchildlevel.h"

#include "toonz/fxdag.h"

#include "toonz/tcolumnfxset.h"

#include "toonz/stage.h"

#include "toonz/fill.h"

#include "toonz/tstageobjectid.h"

#include "toonz/tstageobject.h"

#include "toonz/levelproperties.h"

#include "toonz/imagemanager.h"

#include "toonz/toonzimageutils.h"

#include "toonz/tvectorimageutils.h"

#include "toonz/preferences.h"

#include "toonz/dpiscale.h"

#include "imagebuilders.h"

// 4.6 compatibility - sandor fxs

#include "toonz4.6/raster.h"

#include "sandor_fxs/blend.h"

extern "C" {

#include "sandor_fxs/calligraph.h"

#include "sandor_fxs/patternmap.h"

}

#include "toonz/tcolumnfx.h"

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

//    Preliminaries

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

#ifdef _WIN32

template class DV_EXPORT_API TFxDeclarationT<tlevelcolumnfx>;</tlevelcolumnfx>

template class DV_EXPORT_API TFxDeclarationT<tzerarycolumnfx>;</tzerarycolumnfx>

template class DV_EXPORT_API TFxDeclarationT<txsheetfx>;</txsheetfx>

template class DV_EXPORT_API TFxDeclarationT<toutputfx>;</toutputfx>

#endif

TFxDeclarationT<tlevelcolumnfx> columnFxInfo(TFxInfo("Toonz_columnFx", true));</tlevelcolumnfx>

TFxDeclarationT<tpalettecolumnfx> paletteColumnFxInfo(</tpalettecolumnfx>

    TFxInfo("Toonz_paletteColumnFx", true));

TFxDeclarationT<tzerarycolumnfx> zeraryColumnFxInfo(</tzerarycolumnfx>

    TFxInfo("Toonz_zeraryColumnFx", true));

TFxDeclarationT<txsheetfx> infoTXsheetFx(TFxInfo("Toonz_xsheetFx", true));</txsheetfx>

TFxDeclarationT<toutputfx> infoTOutputFx(TFxInfo("Toonz_outputFx", true));</toutputfx>

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

//    Local namespace  -  misc functions

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

namespace {

void setMaxMatte(TRasterP r) {

  TRaster32P r32 = (TRaster32P)r;

  TRaster64P r64 = (TRaster64P)r;

  TRasterFP rF   = (TRasterFP)r;

  if (r32)

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

      TPixel *pix = r32->pixels(i);

      for (int j = 0; j < r32->getLx(); j++, pix++) pix->m = 255;

    }

  else if (r64)

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

      TPixel64 *pix = r64->pixels(i);

      for (int j = 0; j < r64->getLx(); j++, pix++) pix->m = 65535;

    }

  else if (rF)

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

      TPixelF *pix = rF->pixels(i);

      for (int j = 0; j < rF->getLx(); j++, pix++)

        pix->m = TPixelF::maxChannelValue;

    }

}

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

char *strsave(const char *t) {

  char *s;

  s = (char *)malloc(

      strlen(t) +

      1);  // I'm almost sure that this malloc is LEAKED! Please, check that !

  strcpy(s, t);

  return s;

}

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

inline TRect myConvert(const TRectD &r) {

  return TRect(tfloor(r.x0), tfloor(r.y0), tceil(r.x1), tceil(r.y1));

}

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

inline TRect myConvert(const TRectD &r, TPointD &dp) {

  TRect ri(tfloor(r.x0), tfloor(r.y0), tceil(r.x1), tceil(r.y1));

  dp.x = r.x0 - ri.x0;

  dp.y = r.y0 - ri.y0;

  assert(dp.x >= 0 && dp.y >= 0);

  return ri;

}

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

// Currently used on debug only

inline QString traduce(const TRectD &rect) {

  return "[" + QString::number(rect.x0) + " " + QString::number(rect.y0) + " " +

         QString::number(rect.x1) + " " + QString::number(rect.y1) + "]";

}

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

// Currently used on debug only

inline QString traduce(const TRectD &rect, const TRenderSettings &info) {

  return "[" + QString::number(rect.x0) + " " + QString::number(rect.y0) + " " +

         QString::number(rect.x1) + " " + QString::number(rect.y1) +

         "]; aff = (" + QString::number(info.m_affine.a11, 'f') + " " +

         QString::number(info.m_affine.a12, 'f') + " " +

         QString::number(info.m_affine.a13, 'f') + " " +

         QString::number(info.m_affine.a21, 'f') + " " +

         QString::number(info.m_affine.a22, 'f') + " " +

         QString::number(info.m_affine.a23, 'f') + ")";

}

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

inline int colorDistance(const TPixel32 &c0, const TPixel32 &c1) {

  return (c0.r - c1.r) * (c0.r - c1.r) + (c0.g - c1.g) * (c0.g - c1.g) +

         (c0.b - c1.b) * (c0.b - c1.b);

}

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

std::string getAlias(TXsheet *xsh, double frame, const TRenderSettings &info) {

  TFxSet *fxs = xsh->getFxDag()->getTerminalFxs();

  std::string alias;

  // Add the alias for each

  for (int i = 0; i < fxs->getFxCount(); ++i) {

    TRasterFx *fx = dynamic_cast<trasterfx *="">(fxs->getFx(i));</trasterfx>

    assert(fx);

    if (!fx) continue;

    alias += fx->getAlias(frame, info) + ";";

  }

  return alias;

}

}  // namespace

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

//    Local namespace  -  Colormap (Sandor) Fxs stuff

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

static bool vectorMustApplyCmappedFx(

    const std::vector<trasterfxrenderdatap> &fxs) {</trasterfxrenderdatap>

  std::vector<trasterfxrenderdatap>::const_iterator ft, fEnd(fxs.end());</trasterfxrenderdatap>

  for (ft = fxs.begin(); ft != fEnd; ++ft) {

    PaletteFilterFxRenderData *paletteFilterData =

        dynamic_cast<palettefilterfxrenderdata *="">(ft->getPointer());</palettefilterfxrenderdata>

    SandorFxRenderData *sandorData =

        dynamic_cast<sandorfxrenderdata *="">(ft->getPointer());</sandorfxrenderdata>

    // (Daniele) Sandor fxs perform on raster colormaps *only* - while texture

    // fxs use palette filters to work.

    // In the latter case, vector-to-colormap conversion makes sure that regions

    // are not rendered under full ink

    // pixels (which causes problems**).

    if (sandorData || (paletteFilterData &&

                       paletteFilterData->m_type != ::eApplyToInksAndPaints))

      return true;

    /*

(Daniele) Disregarding the above reasons - palette filter fxs do not forcibly

return true.

Err... ok, my fault - when I wrote that, I forgot to specify WHICH problems**

occurred. Whops!

Now, it happens that if palette filters DO NOT convert to colormapped forcedly,

special styles can be

retained... so, let's see what happens.

Will have to inquire further, though...

*/

  }

  return false;

}

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

static bool mustApplySandorFx(const std::vector<trasterfxrenderdatap> &fxs) {</trasterfxrenderdatap>

  std::vector<trasterfxrenderdatap>::const_iterator ft, fEnd(fxs.end());</trasterfxrenderdatap>

  for (ft = fxs.begin(); ft != fEnd; ++ft) {

    SandorFxRenderData *sandorData =

        dynamic_cast<sandorfxrenderdata *="">(ft->getPointer());</sandorfxrenderdata>

    if (sandorData) return true;

  }

  return false;

}

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

static int getEnlargement(const std::vector<trasterfxrenderdatap> &fxs,</trasterfxrenderdatap>

                          double scale) {

  int enlargement = 1;

  std::vector<trasterfxrenderdatap>::const_iterator ft, fEnd(fxs.end());</trasterfxrenderdatap>

  for (ft = fxs.begin(); ft != fEnd; ++ft) {

    SandorFxRenderData *sandorData =

        dynamic_cast<sandorfxrenderdata *="">(ft->getPointer());</sandorfxrenderdata>

    if (sandorData) {

      switch (sandorData->m_type) {

      case BlendTz: {

        // Nothing happen, unless we have color 0 among the blended ones. In

        // such case,

        // we have to enlarge the bbox proportionally to the amount param.

        std::vector<std::string> items;</std::string>

        std::string indexes = std::string(sandorData->m_argv[0]);

        parseIndexes(indexes, items);

        PaletteFilterFxRenderData paletteFilterData;

        insertIndexes(items, &paletteFilterData);

        if (!paletteFilterData.m_colors.empty() &&

            *paletteFilterData.m_colors.begin() == 0) {

          BlendTzParams ¶ms = sandorData->m_blendParams;

          enlargement           = params.m_amount * scale;

        }

        break;

      }

      case Calligraphic:

      case OutBorder: {

        CalligraphicParams ¶ms = sandorData->m_callParams;

        enlargement                = params.m_thickness * scale;

        break;

      }

      case ArtAtContour: {

        ArtAtContourParams ¶ms = sandorData->m_contourParams;

        enlargement = std::max(tceil(sandorData->m_controllerBBox.getLx()),

                               tceil(sandorData->m_controllerBBox.getLy())) *

                      params.m_maxSize;

        break;

      }

      }

    }

  }

  return enlargement;

}

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

static void applyPaletteFilter(TPalette *&plt, bool keep,

                               const std::set<int> &colors,</int>

                               const TPalette *srcPlt) {

  if (colors.empty()) return;

  if (!plt) plt = srcPlt->clone();

  if (keep) {

    for (int i = 0; i < plt->getStyleCount(); ++i) {

      if (colors.find(i) == colors.end())

        plt->setStyle(i, TPixel32::Transparent);

    }

  } else {

    std::set<int>::const_iterator ct, cEnd(colors.end());</int>

    for (ct = colors.begin(); ct != cEnd; ++ct) {

      TColorStyle *style = plt->getStyle(*ct);

      if (style) plt->setStyle(*ct, TPixel32::Transparent);

    }

  }

}

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

static TPalette *getPliPalette(const TFilePath &path) {

  TLevelReaderP levelReader = TLevelReaderP(path);

  if (!levelReader.getPointer()) return 0;

  TLevelP level = levelReader->loadInfo();

  TPalette *plt = level->getPalette();

  return plt ? plt->clone() : (TPalette *)0;

}

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

inline bool fxLess(TRasterFxRenderDataP a, TRasterFxRenderDataP b) {

  SandorFxRenderData *sandorDataA =

      dynamic_cast<sandorfxrenderdata *="">(a.getPointer());</sandorfxrenderdata>

  if (!sandorDataA) return false;

  SandorFxRenderData *sandorDataB =

      dynamic_cast<sandorfxrenderdata *="">(b.getPointer());</sandorfxrenderdata>

  if (!sandorDataB) return true;

  int aIndex = sandorDataA->m_type == OutBorder ? 2

               : sandorDataA->m_type == BlendTz ? 1

                                                : 0;

  int bIndex = sandorDataB->m_type == OutBorder ? 2

               : sandorDataB->m_type == BlendTz ? 1

                                                : 0;

  return aIndex < bIndex;

}

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

inline void sortCmappedFxs(std::vector<trasterfxrenderdatap> &fxs) {</trasterfxrenderdatap>

  std::stable_sort(fxs.begin(), fxs.end(), fxLess);

}

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

static std::vector<int> getAllBut(std::vector<int> &colorIds) {</int></int>

  assert(TPixelCM32::getMaxInk() == TPixelCM32::getMaxPaint());

  std::vector<int> curColorIds;</int>

  std::sort(colorIds.begin(), colorIds.end());

  // Taking all colors EXCEPT those in colorIds

  unsigned int count1 = 0, count2 = 0;

  int size = TPixelCM32::getMaxInk();

  curColorIds.resize(size + 1 - colorIds.size());

  for (int i = 0; i < size; i++)

    if (count1 < colorIds.size() && colorIds[count1] == i)

      count1++;

    else

      curColorIds[count2++] = i;

  return curColorIds;

}

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

//! \b IMPORTANT \b NOTE: This function is now written so that the passed Toonz

//! Image

//! will be destroyed at the most appropriate time. You should definitely *COPY*

//! all

//! necessary information before calling it - however, since the intent was

//! that of

//! optimizing memory usage, please avoid copying the entire image buffer...

static TImageP applyCmappedFx(TToonzImageP &ti,

                              const std::vector<trasterfxrenderdatap> &fxs,</trasterfxrenderdatap>

                              int frame, double scale) {

  TImageP result = ti;

  TTile resultTile;  // Just a quick wrapper to the ImageCache

  TPalette *inPalette, *tempPlt;

  TPaletteP filteredPalette;

  TRasterCM32P copyRas;

  std::string cmRasCacheId;

  // Retrieve the image dpi

  double dpiX, dpiY;

  ti->getDpi(dpiX, dpiY);

  double dpi = (dpiX > 0) ? dpiX / Stage::inch : 1.0;

  // First, sort the fxs.

  std::vector<trasterfxrenderdatap> fxsCopy = fxs;</trasterfxrenderdatap>

  sortCmappedFxs(fxsCopy);

  // First, let's deal with all fxs working on palettes

  inPalette = ti->getPalette();

  std::vector<trasterfxrenderdatap>::reverse_iterator it;</trasterfxrenderdatap>

  for (it = fxsCopy.rbegin(); it != fxsCopy.rend(); ++it) {

    ExternalPaletteFxRenderData *extpltData =

        dynamic_cast<externalpalettefxrenderdata *="">((*it).getPointer());</externalpalettefxrenderdata>

    PaletteFilterFxRenderData *PaletteFilterData =

        dynamic_cast<palettefilterfxrenderdata *="">((*it).getPointer());</palettefilterfxrenderdata>

    if (extpltData && extpltData->m_palette) {

      filteredPalette = extpltData->m_palette->clone();

      filteredPalette->setFrame(frame);

    } else if (PaletteFilterData &&

               PaletteFilterData->m_type == eApplyToInksAndPaints) {

      bool keep = PaletteFilterData->m_keep;

      std::set<int> colors;</int>

      colors.insert(PaletteFilterData->m_colors.begin(),

                    PaletteFilterData->m_colors.end());

      // Apply the palette filters

      tempPlt = filteredPalette.getPointer();

      applyPaletteFilter(tempPlt, keep, colors, inPalette);

      filteredPalette = tempPlt;

      inPalette = filteredPalette.getPointer();

    }

  }

  if (filteredPalette) {

    // result= ti = ti->clone();   //Is copying truly necessary??

    result = ti = TToonzImageP(ti->getRaster(), ti->getSavebox());

    filteredPalette->setFrame(frame);

    ti->setPalette(filteredPalette.getPointer());

  }

  // Next, deal with fxs working on colormaps themselves

  bool firstSandorFx = true;

  TRasterCM32P cmRas = ti->getRaster();

  TRect tiSaveBox(ti->getSavebox());

  TPaletteP tiPalette(ti->getPalette());

  ti = 0;  // Release the reference to colormap

  // Now, apply cmapped->cmapped fxs

  for (it = fxsCopy.rbegin(); it != fxsCopy.rend(); ++it) {

    PaletteFilterFxRenderData *PaletteFilterData =

        dynamic_cast<palettefilterfxrenderdata *="">(it->getPointer());</palettefilterfxrenderdata>

    if (PaletteFilterData &&

        PaletteFilterData->m_type != eApplyToInksAndPaints) {

      std::vector<int> indexes;</int>

      indexes.resize(PaletteFilterData->m_colors.size());

      std::set<int>::const_iterator jt = PaletteFilterData->m_colors.begin();</int>

      for (int j = 0; j < (int)indexes.size(); ++j, ++jt) indexes[j] = *jt;

      if (copyRas == TRasterCM32P())

        copyRas =

            cmRas->clone();  // Pixels are literally cleared on a copy buffer

      /*-- 処理するIndexを反転 --*/

      if (PaletteFilterData->m_keep) indexes = getAllBut(indexes);

      /*-- Paintの消去（"Lines Including All

       * Areas"のみ、Areaに何も操作をしない） --*/

      if (PaletteFilterData->m_type !=

          eApplyToInksKeepingAllPaints)  // se non e'

                                         // eApplyToInksKeepingAllPaints,

                                         // sicuramente devo cancellare dei

                                         // paint

        TRop::eraseColors(

            copyRas,

            PaletteFilterData->m_type == eApplyToInksDeletingAllPaints

                ? 0

                : &indexes,

            false);

      /*-- Inkの消去 --*/

      if (PaletteFilterData->m_type !=

          eApplyToPaintsKeepingAllInks)  // se non e'

                                         // eApplyToPaintsKeepingAllInks,

                                         // sicuramente devo cancellare degli

                                         // ink

        TRop::eraseColors(

            copyRas,

            PaletteFilterData->m_type == eApplyToPaintsDeletingAllInks

                ? 0

                : &indexes,

            true, PaletteFilterData->m_type == eApplyToInksAndPaints_NoGap);

    }

  }

  if (copyRas) {

    cmRas  = copyRas;

    result = TToonzImageP(cmRas, tiSaveBox);

    result->setPalette(tiPalette.getPointer());

  }

  // Finally, apply cmapped->fullcolor fxs

  // Prefetch all Blend fxs

  std::vector<blendparam> blendParams;</blendparam>

  for (it = fxsCopy.rbegin(); it != fxsCopy.rend(); ++it) {

    SandorFxRenderData *sandorData =

        dynamic_cast<sandorfxrenderdata *="">(it->getPointer());</sandorfxrenderdata>

    if (sandorData && sandorData->m_type == BlendTz) {

      BlendParam param;

      param.intensity =

          std::stod(std::string(sandorData->m_argv[3])) * scale * dpi;

      param.smoothness     = sandorData->m_blendParams.m_smoothness;

      param.stopAtCountour = sandorData->m_blendParams.m_noBlending;

      param.superSampling = sandorData->m_blendParams.m_superSampling;

      // Build the color indexes

      std::vector<std::string> items;</std::string>

      std::string indexes = std::string(sandorData->m_argv[0]);

      parseIndexes(indexes, items);

      PaletteFilterFxRenderData paletteFilterData;

      insertIndexes(items, &paletteFilterData);

      param.colorsIndexes.reserve(paletteFilterData.m_colors.size());

      std::set<int>::iterator it;</int>

      for (it = paletteFilterData.m_colors.begin();

           it != paletteFilterData.m_colors.end(); ++it)

        param.colorsIndexes.push_back(*it);

      blendParams.push_back(param);

    }

  }

  // Apply each sandor

  for (it = fxsCopy.rbegin(); it != fxsCopy.rend(); ++it) {

    SandorFxRenderData *sandorData =

        dynamic_cast<sandorfxrenderdata *="">(it->getPointer());</sandorfxrenderdata>

    if (sandorData) {

      // Avoid dealing with specific cases

      if ((sandorData->m_type == BlendTz && blendParams.empty()) ||

          (sandorData->m_type == OutBorder && !firstSandorFx))

        continue;

      if (!firstSandorFx) {

        // Retrieve the colormap from cache

        cmRas = TToonzImageP(TImageCache::instance()->get(cmRasCacheId, true))

                    ->getRaster();

        // Apply a palette filter in order to keep only the colors specified in

        // the sandor argv

        std::vector<std::string> items;</std::string>

        std::string indexes = std::string(sandorData->m_argv[0]);

        parseIndexes(indexes, items);

        PaletteFilterFxRenderData paletteFilterData;

        insertIndexes(items, &paletteFilterData);

        filteredPalette = tempPlt = 0;

        applyPaletteFilter(tempPlt, true, paletteFilterData.m_colors,

                           tiPalette.getPointer());

        filteredPalette = tempPlt;

      } else {

        // Pass the input colormap to the cache and release its reference as

        // final result

        cmRasCacheId = TImageCache::instance()->getUniqueId();

        TImageCache::instance()->add(cmRasCacheId,

                                     TToonzImageP(cmRas, tiSaveBox));

        result = 0;

      }

      // Convert current smart pointers to a 4.6 'fashion'. The former ones are

      // released - so they

      // do not occupy smart object references.

      RASTER *oldRasterIn, *oldRasterOut;

      oldRasterIn = TRop::convertRaster50to46(

          cmRas, filteredPalette ? filteredPalette : tiPalette.getPointer());

      cmRas = TRasterCM32P(0);

      {

        TRaster32P rasterOut(TDimension(oldRasterIn->lx, oldRasterIn->ly));

        oldRasterOut = TRop::convertRaster50to46(rasterOut, 0);

      }

      switch (sandorData->m_type) {

      case BlendTz: {

        if (blendParams.empty()) continue;

        // Retrieve the colormap from cache

        cmRas = TToonzImageP(TImageCache::instance()->get(cmRasCacheId, true))

                    ->getRaster();

        TToonzImageP ti(cmRas, tiSaveBox);

        ti->setPalette(filteredPalette ? filteredPalette.getPointer()

                                       : tiPalette.getPointer());

        TRasterImageP riOut(TImageCache::instance()->get(

            std::string(oldRasterOut->cacheId, oldRasterOut->cacheIdLength),

            true));

        TRaster32P rasterOut = riOut->getRaster();

        blend(ti, rasterOut, blendParams);

        blendParams.clear();

        break;

      }

      case Calligraphic:

      case OutBorder: {

        if (sandorData->m_type == OutBorder && !firstSandorFx) continue;

        const char *argv[12];

        memcpy(argv, sandorData->m_argv, 12 * sizeof(const char *));

        double thickness =

            std::stod(std::string(sandorData->m_argv[7])) * scale * dpi;

        argv[7] = strsave(std::to_string(thickness).c_str());

        calligraph(oldRasterIn, oldRasterOut, sandorData->m_border,

                   sandorData->m_argc, argv, sandorData->m_shrink,

                   sandorData->m_type == OutBorder);

        break;

      }

      case ArtAtContour: {

        const char *argv[12];

        memcpy(argv, sandorData->m_argv, 12 * sizeof(const char *));

        double distance =

            std::stod(std::string(sandorData->m_argv[6])) * scale * dpi;

        argv[6]  = strsave(std::to_string(distance).c_str());

        distance = std::stod(std::string(sandorData->m_argv[7])) * scale * dpi;

        argv[7]  = strsave(std::to_string(distance).c_str());

        double density =

            std::stod(std::string(sandorData->m_argv[8])) / sq(scale * dpi);

        argv[8] = strsave(std::to_string(density).c_str());

        double size =

            std::stod(std::string(sandorData->m_argv[1])) * scale * dpi;

        argv[1] = strsave(std::to_string(size).c_str());

        size    = std::stod(std::string(sandorData->m_argv[2])) * scale * dpi;

        argv[2] = strsave(std::to_string(size).c_str());

        RASTER *imgContour =

            TRop::convertRaster50to46(sandorData->m_controller, 0);

        patternmap(oldRasterIn, oldRasterOut, sandorData->m_border,

                   sandorData->m_argc, argv, sandorData->m_shrink, imgContour);

        TRop::releaseRaster46(imgContour);

        break;

      }

      default:

        assert(false);

      }

      TRasterImageP riOut(TImageCache::instance()->get(

          std::string(oldRasterOut->cacheId, oldRasterOut->cacheIdLength),

          true));

      TRaster32P rasterOut = riOut->getRaster();

      TRop::releaseRaster46(oldRasterIn);

      TRop::releaseRaster46(oldRasterOut);

      if (firstSandorFx) {

        resultTile.setRaster(rasterOut);

        firstSandorFx = false;

      } else

        TRop::over(resultTile.getRaster(), rasterOut);

    }

  }

  // Release cmRas cache identifier if any

  TImageCache::instance()->remove(cmRasCacheId);

  if (!result) result = TRasterImageP(resultTile.getRaster());

  return result;

}

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

static void applyCmappedFx(TVectorImageP &vi,

                           const std::vector<trasterfxrenderdatap> &fxs,</trasterfxrenderdatap>

                           int frame) {

  TRasterP ras;

  bool keep = false;

  TPaletteP modPalette;

  std::set<int> colors;</int>

  std::vector<trasterfxrenderdatap>::const_iterator it = fxs.begin();</trasterfxrenderdatap>

  // prima tutti gli effetti che agiscono sulla paletta....

  for (; it != fxs.end(); ++it) {

    ExternalPaletteFxRenderData *extpltData =

        dynamic_cast<externalpalettefxrenderdata *="">((*it).getPointer());</externalpalettefxrenderdata>

    PaletteFilterFxRenderData *pltFilterData =

        dynamic_cast<palettefilterfxrenderdata *="">((*it).getPointer());</palettefilterfxrenderdata>

    if (extpltData && extpltData->m_palette)

      modPalette = extpltData->m_palette->clone();

    else if (pltFilterData) {

      assert(

          pltFilterData->m_type ==

          eApplyToInksAndPaints);  // Must have been converted to CM32 otherwise

      keep = pltFilterData->m_keep;

      colors.insert(pltFilterData->m_colors.begin(),

                    pltFilterData->m_colors.end());

    }

  }

  TPalette *tempPlt = modPalette.getPointer();

  applyPaletteFilter(tempPlt, keep, colors, vi->getPalette());

  modPalette = tempPlt;

  if (modPalette) {

    vi = vi->clone();

    vi->setPalette(modPalette.getPointer());

  }

}

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

//    LevelFxResourceBuilder  definition

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

class LevelFxBuilder final : public ResourceBuilder {

  TRasterP m_loadedRas;

  TPaletteP m_palette;

  TXshSimpleLevel *m_sl;

  TFrameId m_fid;

  TRectD m_tileGeom;

  int m_bpp;

  // bool m_linear;

  // bool m_64bit;

  TRect m_rasBounds;

public:

  LevelFxBuilder(const std::string &resourceName, double frame,

                 const TRenderSettings &rs, TXshSimpleLevel *sl, TFrameId fid)

      : ResourceBuilder(resourceName, 0, frame, rs)

      , m_loadedRas()

      , m_palette()

      , m_sl(sl)

      , m_fid(fid)

      , m_bpp(rs.m_bpp) {}

  //, m_linear(rs.m_linearColorSpace){}

  void setRasBounds(const TRect &rasBounds) { m_rasBounds = rasBounds; }

  void compute(const TRectD &tileRect) override {

    UCHAR flag = ImageManager::dontPutInCache;

    if (m_bpp == 64 || m_bpp == 128) flag = flag | ImageManager::is64bitEnabled;

    if (m_bpp == 128) flag = flag | ImageManager::isFloatEnabled;

    // if (m_linear)

    //   flag = flag | ImageManager::isLinearEnabled;

    // Load the image

    TImageP img(m_sl->getFullsampledFrame(m_fid, flag));

    if (!img) return;

    TRasterImageP rimg(img);

    TToonzImageP timg(img);

    m_loadedRas = rimg   ? (TRasterP)rimg->getRaster()

                  : timg ? (TRasterP)timg->getRaster()

                         : TRasterP();

    assert(m_loadedRas);

    if (timg) m_palette = timg->getPalette();

    assert(tileRect ==

           TRectD(0, 0, m_loadedRas->getLx(), m_loadedRas->getLy()));

  }

  void simCompute(const TRectD &rect) override {}

  void upload(TCacheResourceP &resource) override {

    assert(m_loadedRas);

    resource->upload(TPoint(), m_loadedRas);

    if (m_palette) resource->uploadPalette(m_palette);

  }

  bool download(TCacheResourceP &resource) override {

    // If the image has been loaded in this builder, just use it

    if (m_loadedRas) return true;

    // If the image has yet to be loaded by this builder, skip without

    // allocating anything

    if (resource->canDownloadAll(m_rasBounds)) {

      m_loadedRas = resource->buildCompatibleRaster(m_rasBounds.getSize());

      resource->downloadPalette(m_palette);

      return resource->downloadAll(TPoint(), m_loadedRas);

    } else

      return false;

  }

  TImageP getImage() const {

    if (!m_loadedRas) return TImageP();

    TRasterCM32P cm(m_loadedRas);

    TImageP result(cm ? TImageP(TToonzImageP(cm, cm->getBounds()))

                      : TImageP(TRasterImageP(m_loadedRas)));

    if (m_palette) result->setPalette(m_palette.getPointer());

    return result;

  }

};

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

//    TLevelColumnFx  implementation

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

TLevelColumnFx::TLevelColumnFx()

    : m_levelColumn(0), m_isCachable(true), m_mutex(), m_offlineContext(0) {

  setName(L"LevelColumn");

  enableComputeInFloat(true);

}

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

TLevelColumnFx::~TLevelColumnFx() {

  if (m_offlineContext) delete m_offlineContext;

}

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

bool TLevelColumnFx::canHandle(const TRenderSettings &info, double frame) {

  // NOTE 1: Currently, it is necessary that level columns return FALSE for

  // raster levels - just a quick way to tell the cache functions that they

  // have to be cached.

  if (!m_levelColumn) return true;

  TXshCell cell = m_levelColumn->getCell(m_levelColumn->getFirstRow());

  if (cell.isEmpty()) return true;

  TXshSimpleLevel *sl = cell.m_level->getSimpleLevel();

  if (!sl) return true;

  return (sl->getType() == PLI_XSHLEVEL &&

          !vectorMustApplyCmappedFx(info.m_data));

}

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

TAffine TLevelColumnFx::handledAffine(const TRenderSettings &info,

                                      double frame) {

  if (!m_levelColumn) return TAffine();

  TXshCell cell = m_levelColumn->getCell(m_levelColumn->getFirstRow());

  if (cell.isEmpty()) return TAffine();

  TXshSimpleLevel *sl = cell.m_level->getSimpleLevel();

  if (!sl) return TAffine();

  if (sl->getType() == PLI_XSHLEVEL)

    return vectorMustApplyCmappedFx(info.m_data)

               ? TRasterFx::handledAffine(info, frame)

               : info.m_affine;

  // Accept any translation consistent with the image's pixels geometry

  TImageInfo imageInfo;

  getImageInfo(imageInfo, sl, cell.m_frameId);

  TPointD pixelsOrigin(-0.5 * imageInfo.m_lx, -0.5 * imageInfo.m_ly);

  const TAffine &aff = info.m_affine;

  if (aff.a11 != 1.0 || aff.a22 != 1.0 || aff.a12 != 0.0 || aff.a21 != 0.0)

    return TTranslation(-pixelsOrigin);

  // This is a translation, ok. Just ensure it is consistent.

  TAffine consistentAff(aff);