// TnzCore includes

#include "tpixelutils.h"

#include "tstroke.h"

#include "tofflinegl.h"

#include "tstencilcontrol.h"

#include "tvectorgl.h"

#include "tvectorrenderdata.h"

#include "tcolorfunctions.h"

#include "tpalette.h"

#include "tropcm.h"

#include "trasterimage.h"

#include "tvectorimage.h"

#include "tmeshimage.h"

#include "tcolorstyles.h"

#include "timage_io.h"

#include "tregion.h"

#include "toonz/toonzscene.h"

// TnzBase includes

#include "tenv.h"

// TnzExt includes

#include "ext/meshutils.h"

#include "ext/plasticskeleton.h"

#include "ext/plasticskeletondeformation.h"

#include "ext/plasticdeformerstorage.h"

// TnzLib includes

#include "toonz/stageplayer.h"

#include "toonz/stage.h"

#include "toonz/stage2.h"

#include "toonz/tcolumnfx.h"

#include "toonz/txsheet.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txshchildlevel.h"

#include "toonz/txshcolumn.h"

#include "toonz/txshcell.h"

#include "toonz/onionskinmask.h"

#include "toonz/dpiscale.h"

#include "toonz/imagemanager.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/glrasterpainter.h"

#include "toonz/preferences.h"

#include "toonz/fill.h"

#include "toonz/levelproperties.h"

#include "toonz/autoclose.h"

#include "toonz/txshleveltypes.h"

#include "imagebuilders.h"

#include "toonz/tframehandle.h"

#include "toonz/preferences.h"

// Qt includes

#include <qimage></qimage>

#include <qpainter></qpainter>

#include <qpolygon></qpolygon>

#include <qthreadstorage></qthreadstorage>

#include <qmatrix></qmatrix>

#include <qthread></qthread>

#include <qguiapplication></qguiapplication>

#include "toonz/stagevisitor.h"

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

//    Stage namespace

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

/*! \namespace Stage

    \brief The Stage namespace provides objects, classes and methods useful to

   view or display images.

*/

using namespace Stage;

/*! \var Stage::inch

                For historical reasons camera stand is defined in a coordinate

   system in which

                an inch is equal to 'Stage::inch' unit.

                Pay attention: modify this value condition apparent line

   thickness of

                images .pli.

*/

// const double Stage::inch = 53.33333;

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

//    Local namespace

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

namespace {

QImage rasterToQImage(const TRaster32P &ras) {

  QImage image(ras->getRawData(), ras->getLx(), ras->getLy(),

               QImage::Format_ARGB32_Premultiplied);

  return image;

}

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

QImage rasterToQImage(const TRasterGR8P &ras) {

  QImage image(ras->getLx(), ras->getLy(), QImage::Format_ARGB32_Premultiplied);

  int lx = ras->getLx(), ly = ras->getLy();

  for (int y = 0; y < ly; y++) {

    TPixelGR8 *pix    = ras->pixels(y);

    TPixelGR8 *endPix = pix + lx;

    QRgb *outPix      = (QRgb *)image.scanLine(y);

    for (; pix < endPix; ++pix) {

      int value = pix->value;

      *outPix++ = qRgba(value, value, value, 255);

    }

  }

  return image;

}

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

QImage rasterToQImage(const TRasterP &ras) {

  if (TRaster32P src32 = ras)

    return rasterToQImage(src32);

  else if (TRasterGR8P srcGr8 = ras)

    return rasterToQImage(srcGr8);

  // assert(!"Cannot use drawImage with this image!");

  return QImage();

}

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

//! Draw orthogonal projection of \b bbox onto x-axis and y-axis.

void draw3DShadow(const TRectD &bbox, double z, double phi) {

  // bruttino assai, ammetto

  double a = bigBoxSize[0];

  double b = bigBoxSize[1];

  glColor3d(0.9, 0.9, 0.86);

  glBegin(GL_LINE_STRIP);

  glVertex3d(bbox.x0, bbox.y0, z);

  glVertex3d(bbox.x0, bbox.y1, z);

  glVertex3d(bbox.x1, bbox.y1, z);

  glVertex3d(bbox.x1, bbox.y0, z);

  glVertex3d(bbox.x0, bbox.y0, z);

  glEnd();

  double y = -b;

  double x = phi >= 0 ? a : -a;

  double xm = 0.5 * (bbox.x0 + bbox.x1);

  double ym = 0.5 * (bbox.y0 + bbox.y1);

  if (bbox.y0 > y) {

    glBegin(GL_LINE_STRIP);

    glVertex3d(xm, y, z);

    glVertex3d(xm, bbox.y0, z);

    glEnd();

  } else if (bbox.y1 < y) {

    glBegin(GL_LINE_STRIP);

    glVertex3d(xm, y, z);

    glVertex3d(xm, bbox.y1, z);

    glEnd();

  }

  if (bbox.x0 > x) {

    glBegin(GL_LINE_STRIP);

    glVertex3d(x, ym, z);

    glVertex3d(bbox.x0, ym, z);

    glEnd();

  } else if (bbox.x1 < x) {

    glBegin(GL_LINE_STRIP);

    glVertex3d(x, ym, z);

    glVertex3d(bbox.x1, ym, z);

    glEnd();

  }

  glColor3d(0.0, 0.0, 0.0);

  glBegin(GL_LINE_STRIP);

  glVertex3d(bbox.x0, -b, z);

  glVertex3d(bbox.x1, -b, z);

  glEnd();

  glBegin(GL_LINE_STRIP);

  glVertex3d(x, bbox.y0, z);

  glVertex3d(x, bbox.y1, z);

  glEnd();

}

//=====================================================================

//  Plastic function declarations

/*!

  Returns from the specified player the stage object to be plastic

  deformed - or 0 if current Toonz rules prevent it from being deformed.

*/

TStageObject *plasticDeformedObj(const Stage::Player &player,

                                 const PlasticVisualSettings &pvs);

//! Draws the specified mesh image

void onMeshImage(TMeshImage *mi, const Stage::Player &player,

                 const ImagePainter::VisualSettings &vs,

                 const TAffine &viewAff);

//! Applies Plastic deformation of the specified player's stage object.

void onPlasticDeformedImage(TStageObject *playerObj,

                            const Stage::Player &player,

                            const ImagePainter::VisualSettings &vs,

                            const TAffine &viewAff);

}  // namespace

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

//    Picker  implementation

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

Picker::Picker(const TAffine &viewAff, const TPointD &point,

               const ImagePainter::VisualSettings &vs, int devPixRatio)

    : Visitor(vs)

    , m_viewAff(viewAff)

    , m_point(point)

    , m_columnIndexes()

    , m_minDist2(25.0)

    , m_devPixRatio(devPixRatio) {}

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

void Picker::setMinimumDistance(double d) {

  m_minDist2 = (double)(m_devPixRatio * m_devPixRatio) * d * d;

}

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

void Picker::onImage(const Stage::Player &player) {

  // if m_currentColumnIndex is other than the default value (-1),

  // then pick only the current column.

  if (m_currentColumnIndex != -1 &&

      m_currentColumnIndex != player.m_ancestorColumnIndex)

    return;

  bool picked   = false;

  TAffine aff   = m_viewAff * player.m_placement;

  TPointD point = aff.inv() * m_point;

  const TImageP &img = player.image();

  if (TVectorImageP vi = img) {

    double w         = 0;

    UINT strokeIndex = 0;

    double dist2     = 0;

    TRegion *r       = vi->getRegion(point);

    int styleId      = 0;

    if (r) styleId = r->getStyle();

    if (styleId != 0)

      picked = true;

    else if (vi->getNearestStroke(point, w, strokeIndex, dist2)) {

      dist2 *= aff.det();

      TStroke *stroke        = vi->getStroke(strokeIndex);

      TThickPoint thickPoint = stroke->getThickPoint(w);

      double len2            = thickPoint.thick * thickPoint.thick * aff.det();

      double checkDist       = std::max(m_minDist2, len2);

      if (dist2 < checkDist) picked = true;

    }

  } else if (TRasterImageP ri = img) {

    TRaster32P ras = ri->getRaster();

    if (!ras) return;

    ras->lock();

    TPointD pp = player.m_dpiAff.inv() * point + ras->getCenterD();

    TPoint p(tround(pp.x), tround(pp.y));

    if (!ras->getBounds().contains(p)) return;

    TPixel32 *pix = ras->pixels(p.y);

    if (pix[p.x].m != 0) picked = true;

    TAffine aff2 = (aff * player.m_dpiAff).inv();

    TPointD pa(p.x, p.y);

    TPointD dx = aff2 * (m_point + TPointD(3, 0)) - aff2 * m_point;

    TPointD dy = aff2 * (m_point + TPointD(0, 3)) - aff2 * m_point;

    double rx  = dx.x * dx.x + dx.y * dx.y;

    double ry  = dy.x * dy.x + dy.y * dy.y;

    int radius = tround(sqrt(rx > ry ? rx : ry));

    TRect rect = TRect(p.x - radius, p.y - radius, p.x + radius, p.y + radius) *

                 ras->getBounds();

    for (int y = rect.y0; !picked && y <= rect.y1; y++) {

      pix = ras->pixels(y);

      for (int x = rect.x0; !picked && x <= rect.x1; x++)

        if (pix[x].m != 0) picked = true;

    }

    ras->unlock();

  } else if (TToonzImageP ti = img) {

    TRasterCM32P ras = ti->getRaster();

    if (!ras) return;

    ras->lock();

    TPointD pp = player.m_dpiAff.inv() * point + ras->getCenterD();

    TPoint p(tround(pp.x), tround(pp.y));

    if (!ras->getBounds().contains(p)) return;

    TPixelCM32 *pix = ras->pixels(p.y) + p.x;

    if (!pix->isPurePaint() || pix->getPaint() != 0) picked = true;

    ras->unlock();

  }

  if (picked) {

    int columnIndex = player.m_ancestorColumnIndex;

    if (m_columnIndexes.empty() || m_columnIndexes.back() != columnIndex)

      m_columnIndexes.push_back(columnIndex);

    int row = player.m_frame;

    if (m_rows.empty() || m_rows.back() != row) m_rows.push_back(row);

  }

}

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

void Picker::beginMask() {}

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

void Picker::endMask() {}

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

void Picker::enableMask() {}

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

void Picker::disableMask() {}

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

int Picker::getColumnIndex() const {

  if (m_columnIndexes.empty())

    return -1;

  else

    return m_columnIndexes.back();

}

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

void Picker::getColumnIndexes(std::vector<int> &indexes) const {</int>

  indexes = m_columnIndexes;

}

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

int Picker::getRow() const {

  if (m_rows.empty())

    return -1;

  else

    return m_rows.back();

}

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

//    RasterPainter  implementation

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

RasterPainter::RasterPainter(const TDimension &dim, const TAffine &viewAff,

                             const TRect &rect,

                             const ImagePainter::VisualSettings &vs,

                             bool checkFlags)

    : Visitor(vs)

    , m_dim(dim)

    , m_viewAff(viewAff)

    , m_clipRect(rect)

    , m_maskLevel(0)

    , m_singleColumnEnabled(false)

    , m_checkFlags(checkFlags)

    , m_doRasterDarkenBlendedView(false) {}

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

//! Utilizzato solo per TAB Pro

void RasterPainter::beginMask() {

  flushRasterImages();  // per evitare che venga fatto dopo il beginMask

  ++m_maskLevel;

  TStencilControl::instance()->beginMask();

}

//! Utilizzato solo per TAB Pro

void RasterPainter::endMask() {

  flushRasterImages();  // se ci sono delle immagini raster nella maschera

                        // devono uscire ora

  --m_maskLevel;

  TStencilControl::instance()->endMask();

}

//! Utilizzato solo per TAB Pro

void RasterPainter::enableMask() {

  TStencilControl::instance()->enableMask(TStencilControl::SHOW_INSIDE);

}

//! Utilizzato solo per TAB Pro

void RasterPainter::disableMask() {

  flushRasterImages();  // se ci sono delle immagini raster mascherate devono

                        // uscire ora

  TStencilControl::instance()->disableMask();

}

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

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

TEnv::DoubleVar AutocloseDistance("InknpaintAutocloseDistance", 10.0);

TEnv::DoubleVar AutocloseAngle("InknpaintAutocloseAngle", 60.0);

TEnv::IntVar AutocloseInk("InknpaintAutocloseInk", 1);

TEnv::IntVar AutocloseOpacity("InknpaintAutocloseOpacity", 255);

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

int RasterPainter::getNodesCount() { return m_nodes.size(); }

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

void RasterPainter::clearNodes() { m_nodes.clear(); }

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

TRasterP RasterPainter::getRaster(int index, QMatrix &matrix) {

  if ((int)m_nodes.size() <= index) return TRasterP();

  if (m_nodes[index].m_onionMode != Node::eOnionSkinNone) return TRasterP();

  if (m_nodes.empty()) return TRasterP();

  double delta = sqrt(fabs(m_nodes[0].m_aff.det()));

  TRectD bbox  = m_nodes[0].m_bbox.enlarge(delta);

  int i;

  for (i = 1; i < (int)m_nodes.size(); i++) {

    delta = sqrt(fabs(m_nodes[i].m_aff.det()));

    bbox += m_nodes[i].m_bbox.enlarge(delta);

  }

  TRect rect(tfloor(bbox.x0), tfloor(bbox.y0), tceil(bbox.x1), tceil(bbox.y1));

  rect = rect * TRect(0, 0, m_dim.lx - 1, m_dim.ly - 1);

  TAffine aff = TTranslation(-rect.x0, -rect.y0) * m_nodes[index].m_aff;

  matrix      = QMatrix(aff.a11, aff.a21, aff.a12, aff.a22, aff.a13, aff.a23);

  return m_nodes[index].m_raster;

}

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

/*! Make frame visualization.

\n	If onon-skin is active, create a new raster with dimension containing

all

                frame with onion-skin; recall \b TRop::quickPut with argument

each frame

                with onion-skin and new raster. If onion-skin is not active

recall

                \b TRop::quickPut with argument current frame and new raster.

*/

namespace {

QThreadStorage<std::vector<char> *> threadBuffers;</std::vector<char>

}

void RasterPainter::flushRasterImages() {

  if (m_nodes.empty()) return;

  // Build nodes bbox union

  double delta = sqrt(fabs(m_nodes[0].m_aff.det()));

  TRectD bbox  = m_nodes[0].m_bbox.enlarge(delta);

  int i, nodesCount = m_nodes.size();

  for (i = 1; i < nodesCount; ++i) {

    delta = sqrt(fabs(m_nodes[i].m_aff.det()));

    bbox += m_nodes[i].m_bbox.enlarge(delta);

  }

  TRect rect(tfloor(bbox.x0), tfloor(bbox.y0), tceil(bbox.x1), tceil(bbox.y1));

  rect = rect * TRect(0, 0, m_dim.lx - 1, m_dim.ly - 1);

  int lx = rect.getLx(), ly = rect.getLy();

  TDimension dim(lx, ly);

  // this is needed since a stop motion live view

  // doesn't register as a node correctly

  // there is probably a better way to do this.

  if (rect.getLx() == 0 && lx == 0) {

    rect = m_clipRect;

    dim  = m_dim;

  }

  // Build a raster buffer of sufficient size to hold said union.

  // The buffer is per-thread cached in order to improve the rendering speed.

  if (!threadBuffers.hasLocalData())

    threadBuffers.setLocalData(new std::vector<char>());</char>

  int size = dim.lx * dim.ly * sizeof(TPixel32);

  std::vector<char> *vbuff = (std::vector<char> *)threadBuffers.localData();</char></char>

  if (size > (int)vbuff->size()) vbuff->resize(size);

  TRaster32P ras(dim.lx, dim.ly, dim.lx, (TPixel32 *)&(*vbuff)[0]);

  TRaster32P ras2;

  if (m_vs.m_colorMask != 0) {

    ras2 = TRaster32P(ras->getSize());

    ras->clear();

  } else

    ras2 = ras;

  // Clear the buffer - it will hold all the stacked nodes content to be overed

  // on top of the OpenGL buffer through a glDrawPixel()

  ras->lock();

  ras->clear();  // ras is typically reused - and we need it transparent first

  TRect r                 = rect - rect.getP00();

  TRaster32P viewedRaster = ras->extract(r);

  int current = -1;

  // Retrieve preferences-related data

  int tc    = m_checkFlags ? ToonzCheck::instance()->getChecks() : 0;

  int index = ToonzCheck::instance()->getColorIndex();

  TPixel32 frontOnionColor, backOnionColor;

  bool onionInksOnly;

  Preferences::instance()->getOnionData(frontOnionColor, backOnionColor,

                                        onionInksOnly);

  // Stack every node on top of the raster buffer

  for (i = 0; i < nodesCount; ++i) {

    if (m_nodes[i].m_isCurrentColumn) current = i;

    TAffine aff         = TTranslation(-rect.x0, -rect.y0) * m_nodes[i].m_aff;

    TDimension imageDim = m_nodes[i].m_raster->getSize();

    TPointD offset(0.5, 0.5);

    aff *= TTranslation(offset);  // very quick and very dirty fix: in

                                  // camerastand the images seems shifted of an

                                  // half pixel...it's a quickput approximation?

    TPixel32 colorscale = TPixel32(0, 0, 0, m_nodes[i].m_alpha);

    int inksOnly;

    if (m_nodes[i].m_onionMode != Node::eOnionSkinNone) {

      inksOnly = onionInksOnly;

      if (m_nodes[i].m_onionMode == Node::eOnionSkinFront)

        colorscale = TPixel32(frontOnionColor.r, frontOnionColor.g,

                              frontOnionColor.b, m_nodes[i].m_alpha);

      else if (m_nodes[i].m_onionMode == Node::eOnionSkinBack)

        colorscale = TPixel32(backOnionColor.r, backOnionColor.g,

                              backOnionColor.b, m_nodes[i].m_alpha);

    } else {

      if (m_nodes[i].m_filterColor != TPixel32::Black) {

        colorscale   = m_nodes[i].m_filterColor;

        colorscale.m = (typename TPixel32::Channel)((int)colorscale.m *

                                                    (int)m_nodes[i].m_alpha /

                                                    TPixel32::maxChannelValue);

      }

      inksOnly = tc & ToonzCheck::eInksOnly;

    }

    if (TRaster32P src32 = m_nodes[i].m_raster)

      TRop::quickPut(viewedRaster, src32, aff, colorscale,

                     m_nodes[i].m_doPremultiply, m_nodes[i].m_whiteTransp,

                     m_nodes[i].m_isFirstColumn, m_doRasterDarkenBlendedView);

    else if (TRasterGR8P srcGr8 = m_nodes[i].m_raster)

      TRop::quickPut(viewedRaster, srcGr8, aff, colorscale);

    else if (TRasterCM32P srcCm = m_nodes[i].m_raster) {

      assert(m_nodes[i].m_palette);

      int oldframe = m_nodes[i].m_palette->getFrame();

      m_nodes[i].m_palette->setFrame(m_nodes[i].m_frame);

      TPaletteP plt;

      int styleIndex = -1;

      if ((tc & ToonzCheck::eGap || tc & ToonzCheck::eAutoclose) &&

          m_nodes[i].m_isCurrentColumn) {

        srcCm      = srcCm->clone();

        plt        = m_nodes[i].m_palette->clone();

        styleIndex = plt->addStyle(TPixel::Magenta);

        if (tc & ToonzCheck::eAutoclose)

          TAutocloser(srcCm, AutocloseDistance, AutocloseAngle, styleIndex,

                      AutocloseOpacity)

              .exec();

        if (tc & ToonzCheck::eGap)

          AreaFiller(srcCm).rectFill(m_nodes[i].m_savebox, 1, true, true,

                                     false);

      } else

        plt = m_nodes[i].m_palette;

      if (tc == 0 || tc == ToonzCheck::eBlackBg ||

          !m_nodes[i].m_isCurrentColumn)

        TRop::quickPut(viewedRaster, srcCm, plt, aff, colorscale, inksOnly);

      else {

        TRop::CmappedQuickputSettings settings;

        settings.m_globalColorScale = colorscale;

        settings.m_inksOnly         = inksOnly;

        settings.m_transparencyCheck =

            tc & (ToonzCheck::eTransparency | ToonzCheck::eGap);

        settings.m_blackBgCheck = tc & ToonzCheck::eBlackBg;

        /*-- InkCheck, Ink#1Check, PaintCheckはカレントカラムにのみ有効 --*/

        settings.m_inkIndex =

            m_nodes[i].m_isCurrentColumn

                ? (tc & ToonzCheck::eInk ? index

                                         : (tc & ToonzCheck::eInk1 ? 1 : -1))

                : -1;

        settings.m_paintIndex = m_nodes[i].m_isCurrentColumn

                                    ? (tc & ToonzCheck::ePaint ? index : -1)

                                    : -1;

        Preferences::instance()->getTranspCheckData(

            settings.m_transpCheckBg, settings.m_transpCheckInk,

            settings.m_transpCheckPaint);

        settings.m_isOnionSkin = m_nodes[i].m_onionMode != Node::eOnionSkinNone;

        settings.m_gapCheckIndex = styleIndex;

        TRop::quickPut(viewedRaster, srcCm, plt, aff, settings);

      }

      srcCm = TRasterCM32P();

      plt   = TPaletteP();

      m_nodes[i].m_palette->setFrame(oldframe);

    } else

      assert(!"Cannot use quickput with this raster combination!");

  }

  if (m_vs.m_colorMask != 0) {

    TRop::setChannel(ras, ras, m_vs.m_colorMask, false);

    TRop::quickPut(ras2, ras, TAffine());

  }

  // Now, output the raster buffer on top of the OpenGL buffer

  glPushAttrib(GL_COLOR_BUFFER_BIT);  // Preserve blending and stuff

  glEnable(GL_BLEND);

  glBlendFunc(GL_ONE,

              GL_ONE_MINUS_SRC_ALPHA);  // The raster buffer is intended in

  // premultiplied form - thus the GL_ONE on src

  glDisable(GL_DEPTH_TEST);

  glDisable(GL_DITHER);

  glDisable(GL_LOGIC_OP);

/* disable, since these features are never enabled, and cause OpenGL to assert

 * on systems that don't support them: see #591 */

#if 0

#ifdef GL_EXT_convolution

  if( GLEW_EXT_convolution ) {

    glDisable(GL_CONVOLUTION_1D_EXT);

    glDisable(GL_CONVOLUTION_2D_EXT);

    glDisable(GL_SEPARABLE_2D_EXT);

  }

#endif

#ifdef GL_EXT_histogram

  if( GLEW_EXT_histogram ) {

    glDisable(GL_HISTOGRAM_EXT);

    glDisable(GL_MINMAX_EXT);

  }

#endif

#endif

#ifdef GL_EXT_texture3D

  if (GL_EXT_texture3D) {

    glDisable(GL_TEXTURE_3D_EXT);

  }

#endif

  glPushMatrix();

  glLoadIdentity();

  glRasterPos2d(rect.x0, rect.y0);

  glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

  glDrawPixels(ras2->getLx(), ras2->getLy(),            // Perform the over

               TGL_FMT, TGL_TYPE, ras2->getRawData());  //

  ras->unlock();

  glPopMatrix();

  glPopAttrib();  // Restore blending status

  if (m_vs.m_showBBox && current > -1) {

    glPushMatrix();

    glLoadIdentity();

    tglColor(TPixel(200, 200, 200));

    tglMultMatrix(m_nodes[current].m_aff);

    tglDrawRect(m_nodes[current].m_raster->getBounds());

    glPopMatrix();

  }

  m_nodes.clear();

}

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

/*! Make frame visualization in QPainter.

\n	Draw in painter mode just raster image in m_nodes.

\n  Onon-skin or channel mode are not considered.

*/

void RasterPainter::drawRasterImages(QPainter &p, QPolygon cameraPol) {

  if (m_nodes.empty()) return;

  double delta = sqrt(fabs(m_nodes[0].m_aff.det()));

  TRectD bbox  = m_nodes[0].m_bbox.enlarge(delta);

  int i;

  for (i = 1; i < (int)m_nodes.size(); i++) {

    delta = sqrt(fabs(m_nodes[i].m_aff.det()));

    bbox += m_nodes[i].m_bbox.enlarge(delta);

  }

  TRect rect(tfloor(bbox.x0), tfloor(bbox.y0), tceil(bbox.x1), tceil(bbox.y1));

  rect = rect * TRect(0, 0, m_dim.lx - 1, m_dim.ly - 1);

  TRect r = rect - rect.getP00();

  TAffine flipY(1, 0, 0, 0, -1, m_dim.ly);

  p.setClipRegion(QRegion(cameraPol));

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

    if (m_nodes[i].m_onionMode != Node::eOnionSkinNone) continue;

    p.resetTransform();

    TRasterP ras = m_nodes[i].m_raster;

    TAffine aff  = TTranslation(-rect.x0, -rect.y0) * flipY * m_nodes[i].m_aff;

    QMatrix matrix(aff.a11, aff.a21, aff.a12, aff.a22, aff.a13, aff.a23);

    QImage image = rasterToQImage(ras);

    if (image.isNull()) continue;

    p.setMatrix(matrix);

    p.drawImage(rect.getP00().x, rect.getP00().y, image);

  }

  p.resetTransform();

  m_nodes.clear();

}

static void buildAutocloseImage(

    TVectorImage *vaux, TVectorImage *vi,

    const std::vector<std::pair<int, double="">> &startPoints,</std::pair<int,>

    const std::vector<std::pair<int, double="">> &endPoints) {</std::pair<int,>

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

    TThickPoint p1 = vi->getStroke(startPoints[i].first)

                         ->getThickPoint(startPoints[i].second);

    TThickPoint p2 =

        vi->getStroke(endPoints[i].first)->getThickPoint(endPoints[i].second);

    std::vector<tthickpoint> points(3);</tthickpoint>

    points[0]       = p1;

    points[1]       = 0.5 * (p1 + p2);

    points[2]       = p2;

    points[0].thick = points[1].thick = points[2].thick = 0.0;

    TStroke *auxStroke                                  = new TStroke(points);

    auxStroke->setStyle(2);

    vaux->addStroke(auxStroke);

  }

}

TEnv::DoubleVar AutocloseFactor("InknpaintAutocloseFactor", 4.0);

static void drawAutocloses(TVectorImage *vi, TVectorRenderData &rd) {

  static TPalette *plt = 0;

  if (!plt) {

    plt = new TPalette();

    plt->addStyle(TPixel::Magenta);

  }

  std::vector<std::pair<int, double="">> startPoints, endPoints;</std::pair<int,>

  getClosingPoints(vi->getBBox(), AutocloseFactor, vi, startPoints, endPoints);

  TVectorImage *vaux = new TVectorImage();

  rd.m_palette = plt;

  buildAutocloseImage(vaux, vi, startPoints, endPoints);

  // temporarily disable fill check, to preserve the gap indicator color

  bool tCheckEnabledOriginal = rd.m_tcheckEnabled;

  rd.m_tcheckEnabled         = false;

  // draw

  tglDraw(rd, vaux);

  // restore original value

  rd.m_tcheckEnabled = tCheckEnabledOriginal;

  delete vaux;

}

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

/*! Take image from \b Stage::Player \b data and recall the right method for

                this kind of image, for vector image recall \b onVectorImage(),

   for raster

                image recall \b onRasterImage() for toonz image recall \b

   onToonzImage().

*/

void RasterPainter::onImage(const Stage::Player &player) {

  if (m_singleColumnEnabled && !player.m_isCurrentColumn) return;

  // Attempt Plastic-deformed drawing

  // For now generating icons of plastic-deformed image causes crash as

  // QOffscreenSurface is created outside the gui thread.

  // As a quick workaround, ignore the deformation if this is called from

  // non-gui thread (i.e. icon generator thread)

  // 12/1/2018 Now the scene icon is rendered without deformation either

  // since it causes unknown error with opengl contexts..

  TStageObject *obj =

      ::plasticDeformedObj(player, m_vs.m_plasticVisualSettings);

  if (obj && QThread::currentThread() == qGuiApp->thread() &&

      !m_vs.m_forSceneIcon) {

    flushRasterImages();

    ::onPlasticDeformedImage(obj, player, m_vs, m_viewAff);

  } else {

    // Common image draw

    const TImageP &img = player.image();

    if (TVectorImageP vi = img)

      onVectorImage(vi.getPointer(), player);

    else if (TRasterImageP ri = img)

      onRasterImage(ri.getPointer(), player);

    else if (TToonzImageP ti = img)

      onToonzImage(ti.getPointer(), player);

    else if (TMeshImageP mi = img) {

      flushRasterImages();

      ::onMeshImage(mi.getPointer(), player, m_vs, m_viewAff);

    }

  }

}

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

/*! View a vector cell images.

\n	If onion-skin is active compute \b TOnionFader value.

                Create and boot a \b TVectorRenderData and recall \b tglDraw().

*/

void RasterPainter::onVectorImage(TVectorImage *vi,

                                  const Stage::Player &player) {

  flushRasterImages();

  // When loaded, vectorimages needs to have regions recomputed, but doing that

  // while loading them

  // is quite slow (think about loading whole scenes!..). They are recomputed

  // the first time they

  // are selected and shown on screen...except when playing back, to avoid

  // slowness!

  // (Daniele) This function should *NOT* be responsible of that.

  //           It's the *image itself* that should recalculate or initialize

  //           said data

  //           if queried about it and turns out it's not available...

  if (!player.m_isPlaying && player.m_isCurrentColumn)

    vi->recomputeRegionsIfNeeded();

  const Preferences &prefs = *Preferences::instance();

  TColorFunction *cf = 0, *guidedCf = 0;

  TPalette *vPalette = vi->getPalette();

  TPixel32 bgColor   = TPixel32::White;

  int tc        = (m_checkFlags && player.m_isCurrentColumn)

                      ? ToonzCheck::instance()->getChecks()

                      : 0;

  bool inksOnly = tc & ToonzCheck::eInksOnly;

  int oldFrame = vPalette->getFrame();

  vPalette->setFrame(player.m_frame);

  if (player.m_onionSkinDistance != c_noOnionSkin) {

    TPixel32 frontOnionColor, backOnionColor;

    if (player.m_onionSkinDistance != 0 &&

        (!player.m_isShiftAndTraceEnabled ||

         Preferences::instance()->areOnionColorsUsedForShiftAndTraceGhosts())) {

      prefs.getOnionData(frontOnionColor, backOnionColor, inksOnly);

      bgColor =

          (player.m_onionSkinDistance < 0) ? backOnionColor : frontOnionColor;

    }

    double m[4] = {1.0, 1.0, 1.0, 1.0}, c[4];

    // Weighted addition to RGB and matte multiplication

    m[3] = 1.0 -

           ((player.m_onionSkinDistance == 0)

                ? 0.1

                : OnionSkinMask::getOnionSkinFade(player.m_onionSkinDistance));

    c[0] = (1.0 - m[3]) * bgColor.r, c[1] = (1.0 - m[3]) * bgColor.g,

    c[2] = (1.0 - m[3]) * bgColor.b;

    c[3] = 0.0;

    cf = new TGenericColorFunction(m, c);