// System-core includes

#include "tsystem.h"  //Processors count

#include "timagecache.h"

#include "tw/stringtable.h"

// Toonz scene-stage structures

#include "toonz/toonzscene.h"

#include "toonz/tscenehandle.h"

#include "toonz/sceneproperties.h"

#include "toonz/tframehandle.h"

#include "toonz/tfxhandle.h"

#include "toonz/tpalettehandle.h"

#include "toonz/txshlevel.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/tcamera.h"

#include "toonz/palettecontroller.h"

#include "tapp.h"  //Toonz current objects

// Images stuff

#include "trasterimage.h"

#include "trop.h"

// Fxs stuff

#include "toutputproperties.h"

#include "trasterfx.h"

#include "toonz/scenefx.h"  //Fxs tree build-up

#include "toonz/tcolumnfx.h"

// Cache management

#include "tpassivecachemanager.h"

// Flipbook

#include "flipbook.h"

#include "toonzqt/flipconsole.h"

// Qt stuff

#include <qmetatype></qmetatype>

#include <qregion></qregion>

#include "toonzqt/gutil.h"  //For conversions between TRects and QRects

// Preferences

#include "toonz/preferences.h"

#include "previewfxmanager.h"

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

// Resume: The 'Preview Fx' command shows a flipbook associated with given fx,

// containing the appearance

//         of the fx under current rendering status (including current camera,

//         preview settings, schematic tree).

//

// There are some considerations to be aware of:

//   1. A Preview Fx flipbook must hold the render of the whole Preview settings

//   range. Plus, many Preview Fx

//      could live altogether. It could be that more than one Preview Fx window

//      is active for the same fx.

//   2. The flipbook associated with a 'Preview Fx' command should react to

//   updates of the rendering status.

//      This should happen as long as the fx actually has a meaning in the

//      rendering context - that is, if

//      the user enters sub- or super-xsheets, the flipbook should continue

//      rendering with

//      the old data. Possibly, if modifying a sub-xsheet, an 'upper' Preview Fx

//      should react accordingly.

//   3. Fx Subtree aliases retrieved through TRasterFx::getAlias() may be used

//   to decide if some frame has to

//      be rebuilt.

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

//  Forward declarations

class PreviewFxInstance;

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

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

//    Preliminary functions

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

namespace {

bool suspendedRendering             = false;

PreviewFxManager *previewerInstance = 0;

// Timer used to deliver scene changes notifications in an 'overridden' fashion.

// In practice, only the last (up to a fixed time granularity) of these

// notifications

// is actually received by the manager's associated slots.

QTimer levelChangedTimer, fxChangedTimer, xsheetChangedTimer,

    objectChangedTimer;

const int notificationDelay = 300;

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

inline std::string getCacheId(const TFxP &fx, int frame) {

  return std::to_string(fx->getIdentifier()) + ".noext" + std::to_string(frame);

}

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

// NOTE: This method will not currently trespass xsheet level boundaries. It

// will not

// recognize descendants in sub-xsheets....

bool areAncestorAndDescendant(const TFxP &ancestor, const TFxP &descendant) {

  if (ancestor.getPointer() == descendant.getPointer()) return true;

  int i;

  for (i = 0; i < ancestor->getInputPortCount(); ++i)

    if (areAncestorAndDescendant(ancestor->getInputPort(i)->getFx(),

                                 descendant))

      return true;

  return false;

}

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

// Qt's contains actually returns QRegion::intersected... I wonder why...

inline bool contains(const QRegion ®ion, const TRect &rect) {

  return QRegion(toQRect(rect)).subtracted(region).isEmpty();

}

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

inline void adaptView(FlipBook *flipbook, TDimension cameraSize) {

  TRect imgRect(cameraSize);

  flipbook->getImageViewer()->adaptView(imgRect, imgRect);

}

};  // namespace

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

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

//    PreviewFxRenderPort class

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

//! This class receives and handles notifications from a TRenderer executing the

//! preview fx

//! rendering job.

class PreviewFxRenderPort final : public QObject, public TRenderPort {

  PreviewFxInstance *m_owner;

public:

  PreviewFxRenderPort(PreviewFxInstance *owner);

  ~PreviewFxRenderPort();

  void onRenderRasterStarted(

      const TRenderPort::RenderData &renderData) override;

  void onRenderRasterCompleted(const RenderData &renderData) override;

  void onRenderFailure(const RenderData &renderData, TException &e) override;

  void onRenderFinished(bool inCanceled = false) override;

};

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

PreviewFxRenderPort::PreviewFxRenderPort(PreviewFxInstance *owner)

    : m_owner(owner) {}

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

PreviewFxRenderPort::~PreviewFxRenderPort() {}

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

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

//    PreviewFxInstance

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

class PreviewFxInstance {

public:

  struct FrameInfo {

    std::string m_alias;

    QRegion m_renderedRegion;

    FrameInfo(const std::string &alias) : m_alias(alias) {}

  };

public:

  TXsheetP m_xsheet;

  TRasterFxP m_fx;

  TRenderer m_renderer;

  PreviewFxRenderPort m_renderPort;

  std::set<flipbook *=""> m_flipbooks;</flipbook>

  std::set<flipbook *=""> m_frozenFlips;  // Used externally by PreviewFxManager</flipbook>

  int m_start, m_end, m_step, m_initFrame;

  std::map<int, frameinfo=""> m_frameInfos;  // Used to resume fx tree structures</int,>

  std::vector<uchar> m_pbStatus;</uchar>

  TRenderSettings m_renderSettings;

  TDimension m_cameraRes;

  TRectD m_renderArea;

  TPointD m_cameraPos;

  TPointD m_subcameraDisplacement;

  bool m_subcamera;

  QRegion m_overallRenderedRegion;

  TRect m_rectUnderRender;

  bool m_renderFailed;

  TLevelP m_level;

  TSoundTrackP m_snd;

public:

  PreviewFxInstance(TFxP fx, TXsheet *xsh);

  ~PreviewFxInstance();

  void addFlipbook(FlipBook *&flipbook);

  void detachFlipbook(FlipBook *flipbook);

  void updateFlipbooks();

  void refreshViewRects(bool rebuild = false);

  void reset();

  void reset(int frame);

  // Updater methods. These refresh the manager's status, but do not launch new

  // renders

  // on their own. The refreshViewRects method must be invoked to trigger it.

  // Observe that there may exist dependencies among them - invoking in the

  // following

  // declaration order is safe.

  void updateFrameRange();

  void updateInitialFrame();

  void updateRenderSettings();

  void updateCamera();

  void updateFlipbookTitles();

  void updatePreviewRect();

  void updateAliases();

  void updateAliasKeyword(const std::string &keyword);

  void updateProgressBarStatus();

  void onRenderRasterStarted(const TRenderPort::RenderData &renderData);

  void onRenderRasterCompleted(const TRenderPort::RenderData &renderData);

  void onRenderFailure(const TRenderPort::RenderData &renderData,

                       TException &e);

  void onRenderFinished(bool isCanceled = false);

  void doOnRenderRasterCompleted(const TRenderPort::RenderData &renderData);

  void doOnRenderRasterStarted(const TRenderPort::RenderData &renderData);

  bool isSubCameraActive() { return m_subcamera; }

private:

  void cropAndStep(int &frame);

  bool isFullPreview();

  TFxP buildSceneFx(int frame);

  void addRenderData(std::vector<trenderer::renderdata> &datas,</trenderer::renderdata>

                     ToonzScene *scene, int frame, bool rebuild);

  void startRender(bool rebuild = false);

};

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

inline bool PreviewFxInstance::isFullPreview() {

  return dynamic_cast<toutputfx *="">((TFx *)m_fx.getPointer());</toutputfx>

}

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

inline void PreviewFxInstance::cropAndStep(int &frame) {

  frame = frame < m_start ? m_start : frame;

  frame = (frame > m_end && m_end > -1) ? m_end : frame;

  // If a step was specified, ensure that frame is on step multiples.

  int framePos = (frame - m_start) / m_step;

  frame        = m_start + (framePos * m_step);

}

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

inline TFxP PreviewFxInstance::buildSceneFx(int frame) {

  TApp *app         = TApp::instance();

  ToonzScene *scene = app->getCurrentScene()->getScene();

  if (isFullPreview())

    return ::buildSceneFx(scene, m_xsheet.getPointer(), frame,

                          m_renderSettings.m_shrinkX, true);

  else

    return ::buildPartialSceneFx(scene, m_xsheet.getPointer(), frame, m_fx,

                                 m_renderSettings.m_shrinkX, true);

}

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

void PreviewFxInstance::addRenderData(std::vector<trenderer::renderdata> &datas,</trenderer::renderdata>

                                      ToonzScene *scene, int frame,

                                      bool rebuild) {

  // Seek the image associated to the render data in the cache.

  std::map<int, frameinfo="">::iterator it;</int,>

  it = m_frameInfos.find(frame);

  TRasterFxP builtFx =

      buildSceneFx(frame);  // when stereoscopic, i use this only for the alias

  TRasterFxP builtFxA, builtFxB;

  if (m_renderSettings.m_stereoscopic) {

    ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();

    scene->shiftCameraX(-m_renderSettings.m_stereoscopicShift / 2);

    builtFxA = buildSceneFx(frame);

    scene->shiftCameraX(m_renderSettings.m_stereoscopicShift);

    builtFxB = buildSceneFx(frame);

    scene->shiftCameraX(-m_renderSettings.m_stereoscopicShift / 2);

  } else

    builtFxA = builtFx;

  if (it == m_frameInfos.end()) {

    // Should not be - however, in this case build an associated Frame info

    it = m_frameInfos.insert(std::make_pair(frame, FrameInfo(std::string())))

             .first;

    it->second.m_alias =

        builtFx ? builtFx->getAlias(frame, m_renderSettings) : "";

  }

  bool isCalculated =

      (!builtFx) || ((!rebuild) && ::contains(it->second.m_renderedRegion,

                                              m_rectUnderRender));

  m_pbStatus[(frame - m_start) / m_step] = isCalculated

                                               ? FlipSlider::PBFrameFinished

                                               : FlipSlider::PBFrameNotStarted;

  // If it is already present, return

  if (isCalculated) return;

  datas.push_back(TRenderer::RenderData(frame, m_renderSettings,

                                        TFxPair(builtFxA, builtFxB)));

}

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

PreviewFxInstance::PreviewFxInstance(TFxP fx, TXsheet *xsh)

    : m_renderer(TSystem::getProcessorCount())

    , m_renderPort(this)

    , m_fx(fx)

    , m_cameraRes(0, 0)

    , m_start(0)

    , m_end(-1)

    , m_initFrame(0)

    , m_xsheet(xsh) {

  // Install the render port on the instance renderer

  m_renderer.addPort(&m_renderPort);

  updateRenderSettings();

  updateCamera();

  updateFrameRange();

  updateAliases();

}

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

PreviewFxInstance::~PreviewFxInstance() {

  // Stop the render - there is no need to wait for a complete (and blocking)

  // render stop.

  m_renderer.removePort(

      &m_renderPort);  // No more images to be stored in the cache!

  m_renderer.stopRendering();

  // Release the user cache about this instance

  std::string contextName("PFX");

  contextName += std::to_string(m_fx->getIdentifier());

  TPassiveCacheManager::instance()->releaseContextNamesWithPrefix(contextName);

  // Clear the cached images

  int i;

  for (i = m_start; i <= m_end; i += m_step)

    TImageCache::instance()->remove(getCacheId(m_fx, i));

}

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

//! Clears the preview instance information about passed frame, including any

//! cached image.

//! Information needed to preview again are NOT rebuilt.

void PreviewFxInstance::reset(int frame) {

  TImageCache::instance()->remove(getCacheId(m_fx, frame));

  std::map<int, frameinfo="">::iterator it = m_frameInfos.find(frame);</int,>

  if (it != m_frameInfos.end()) {

    TRasterFxP builtFx = buildSceneFx(frame);

    it->second.m_alias =

        builtFx ? builtFx->getAlias(frame, m_renderSettings) : "";

    it->second.m_renderedRegion = QRegion();

    m_overallRenderedRegion     = QRegion();

  }

}

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

//! Clears the preview instance information, including cached images.

//! Information needed

//! to preview again are rebuilt.

void PreviewFxInstance::reset() {

  int i;

  for (i = m_start; i <= m_end; i += m_step)

    TImageCache::instance()->remove(getCacheId(m_fx, i));

  m_frameInfos.clear();

  updateFrameRange();

  updateRenderSettings();

  updateCamera();

  updateFlipbookTitles();

  updateAliases();

}

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

void PreviewFxInstance::addFlipbook(FlipBook *&flipbook) {

  TApp *app         = TApp::instance();

  ToonzScene *scene = app->getCurrentScene()->getScene();

  TOutputProperties *properties =

      scene->getProperties()->getPreviewProperties();

  int currFrame = flipbook ? flipbook->getCurrentFrame() - 1

                           : app->getCurrentFrame()->getFrame();

  cropAndStep(currFrame);

  if (!flipbook) {

    /*-- 使用可能なFlipbookを取り出す。Poolに無い場合は新たに作る --*/

    flipbook = FlipBookPool::instance()->pop();

    // In case this is a subcamera preview, fit the flipbook's view. This is

    // done *before* associating

    // m_fx to the flipbook (using Flipbook::setLevel) - so there is no

    // duplicate view refresh.

    /*-- Preview Settingsで"Use Sub Camera"

     * がONのとき、サブカメラ枠の外は計算しないようになる --*/

    if (m_subcamera) {

      // result->adaptGeometry(TRect(previewInstance->m_cameraRes));   //This

      // one fits the panel, too.

      adaptView(flipbook, m_cameraRes);  // This one adapts the view. If has

                                         // associated fx, calls refresh...

    } else {

      // Retrieve the eventual sub-camera

      TCamera *currCamera = TApp::instance()

                                ->getCurrentScene()

                                ->getScene()

                                ->getCurrentPreviewCamera();

      TRect subcameraRect(currCamera->getInterestRect());

      /*-- Viewer上でサブカメラが指定されている状態でFxPreviewをした場合 --*/

      if (subcameraRect.getLx() > 0 && subcameraRect.getLy() > 0) {

        /*-- サブカメラ枠のShrink --*/

        if (m_renderSettings.m_shrinkX > 1 || m_renderSettings.m_shrinkY > 1) {

          subcameraRect.x0 /= m_renderSettings.m_shrinkX;

          subcameraRect.y0 /= m_renderSettings.m_shrinkY;

          subcameraRect.x1 =

              (subcameraRect.x1 + 1) / m_renderSettings.m_shrinkX - 1;

          subcameraRect.y1 =

              (subcameraRect.y1 + 1) / m_renderSettings.m_shrinkY - 1;

        }

        // Fit & pan the panel to cover the sub-camera

        flipbook->adaptGeometry(subcameraRect, TRect(TPoint(), m_cameraRes));

      }

    }

    /*-- フリーズボタンの表示 --*/

    flipbook->addFreezeButtonToTitleBar();

  }

  m_flipbooks.insert(flipbook);

  /*-- タイトルの設定。Previewコマンドから呼ばれた場合はisFullPreviewがON --*/

  // Build the fx string description - Should really be moved in a better

  // function...

  std::wstring fxId;

  TLevelColumnFx *columnFx = dynamic_cast<tlevelcolumnfx *="">(m_fx.getPointer());</tlevelcolumnfx>

  TZeraryColumnFx *sfx     = dynamic_cast<tzerarycolumnfx *="">(m_fx.getPointer());</tzerarycolumnfx>

  if (columnFx)

    fxId =

        L"Col" + QString::number(columnFx->getColumnIndex() + 1).toStdWString();

  else if (sfx)

    fxId = sfx->getZeraryFx()->getFxId();

  else {

    fxId = m_fx->getFxId();

    if (fxId.empty()) fxId = m_fx->getName();

  }

  // Adjust the flipbook appropriately

  // Decorate the description for the flipbook

  if (isFullPreview()) {

    flipbook->setTitle(

        /*"Rendered Frames  ::  From " + QString::number(m_start+1) +

            " To " + QString::number(m_end+1) +

     "  ::  Step " + QString::number(m_step)*/

        QObject::tr("Rendered Frames  ::  From %1 To %2  ::  Step %3")

            .arg(QString::number(m_start + 1))

            .arg(QString::number(m_end + 1))

            .arg(QString::number(m_step)));

    TXsheet::SoundProperties *prop = new TXsheet::SoundProperties();

    prop->m_frameRate              = properties->getFrameRate();

    m_snd                          = m_xsheet->makeSound(prop);

    if (Preferences::instance()->fitToFlipbookEnabled())

      flipbook->getImageViewer()->adaptView(TRect(m_cameraRes),

                                            TRect(m_cameraRes));

  } else

    flipbook->setTitle(

        QObject::tr("Preview FX :: %1 ").arg(QString::fromStdWString(fxId)));

  // In case the render is a full preview, add the soundtrack

  // Associate the rendered level to flipbook

  flipbook->setLevel(m_fx.getPointer(), m_xsheet.getPointer(),

                     m_level.getPointer(), 0, m_start + 1, m_end + 1, m_step,

                     currFrame + 1, m_snd.getPointer());

  // Add the progress bar status pointer

  flipbook->setProgressBarStatus(&m_pbStatus);

}

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

void PreviewFxInstance::detachFlipbook(FlipBook *flipbook) {

  // Just remove the flipbook from the flipbooks container

  std::set<flipbook *="">::iterator it = m_flipbooks.find(flipbook);</flipbook>

  if (it == m_flipbooks.end()) return;

  m_flipbooks.erase(it);

  // If the flipbook set associated with the render is now empty, stop the

  // render

  if (m_flipbooks.empty()) m_renderer.stopRendering();

}

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

void PreviewFxInstance::updateFlipbooks() {

  std::set<flipbook *="">::iterator it;</flipbook>

  for (it = m_flipbooks.begin(); it != m_flipbooks.end(); ++it) (*it)->update();

}

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

void PreviewFxInstance::updateFrameRange() {

  TApp *app         = TApp::instance();

  ToonzScene *scene = app->getCurrentScene()->getScene();

  TOutputProperties *properties =

      scene->getProperties()->getPreviewProperties();

  int frameCount = m_xsheet->getFrameCount();

  // Initialize the render starting from current frame. If not in the preview

  // range,

  // start from the closest range extreme.

  properties->getRange(m_start, m_end, m_step);

  if (m_end < 0) m_end = frameCount - 1;

  // Intersect with the fx active frame range

  TRasterFxP rasterFx(m_fx);

  TFxTimeRegion timeRegion(rasterFx->getTimeRegion());

  m_start = std::max(timeRegion.getFirstFrame(), m_start);

  m_end   = std::min(timeRegion.getLastFrame(), m_end);

  // Release all images not in the new frame range

  std::map<int, frameinfo="">::iterator it, jt;</int,>

  for (it = m_frameInfos.begin(); it != m_frameInfos.end();) {

    if (it->first < m_start || it->first > m_end ||

        ((it->first - m_start) % m_step)) {

      TImageCache::instance()->remove(getCacheId(m_fx, it->first));

      jt = it++;

      m_frameInfos.erase(jt);

    } else

      ++it;

  }

  // Build a level to associate the flipbook with the rendered output

  m_level->setName(std::to_string(m_fx->getIdentifier()) + ".noext");

  int i;

  for (i = 0; i < frameCount; i++) m_level->setFrame(TFrameId(i), 0);

  // Resize and update internal containers

  if (m_start > m_end) {

    m_frameInfos.clear();

    m_pbStatus.clear();

  } else {

    // Build the new frame-alias range

    for (i = m_start; i <= m_end; i += m_step)

      if (m_frameInfos.find(i) == m_frameInfos.end()) {

        // Clear the overall rendered region and build the frame info

        m_overallRenderedRegion = QRegion();

        m_frameInfos.insert(std::make_pair(i, std::string()));

      }

    // Resize the progress bar

    m_pbStatus.resize((m_end - m_start) / m_step + 1);

  }

  // Reset the flipbooks' frame range

  std::set<flipbook *="">::iterator kt;</flipbook>

  int currFrame;

  bool fullPreview = isFullPreview();

  for (kt = m_flipbooks.begin(); kt != m_flipbooks.end(); ++kt) {

    currFrame = (*kt)->getCurrentFrame() - 1;

    cropAndStep(currFrame);

    (*kt)->setLevel(m_fx.getPointer(), m_xsheet.getPointer(),

                    m_level.getPointer(), 0, m_start + 1, m_end + 1, m_step,

                    currFrame + 1, m_snd.getPointer());

  }

}

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

void PreviewFxInstance::updateInitialFrame() {

  // Search all flipbooks and take the minimum of each's current

  std::set<flipbook *="">::iterator kt;</flipbook>

  m_initFrame = (std::numeric_limits<int>::max)();</int>

  for (kt = m_flipbooks.begin(); kt != m_flipbooks.end(); ++kt)

    m_initFrame = std::min(m_initFrame, (*kt)->getCurrentFrame() - 1);

  cropAndStep(m_initFrame);

}

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

void PreviewFxInstance::updateFlipbookTitles() {

  if (isFullPreview() && m_start <= m_end) {

    int start = m_start + 1;

    int end   = m_end + 1;

    std::set<flipbook *="">::iterator kt;</flipbook>

    for (kt = m_flipbooks.begin(); kt != m_flipbooks.end(); ++kt) {

      // In the full preview case, the title must display the frame range

      // information

      (*kt)->setTitle(

          /*"Rendered Frames  ::  From " + QString::number(start) +

        " To " + QString::number(end) +

 "  ::  Step " + QString::number(m_step)*/

          QObject::tr("Rendered Frames  ::  From %1 To %2  ::  Step %3")

              .arg(QString::number(start))

              .arg(QString::number(end))

              .arg(QString::number(m_step)));

    }

  }

}

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

void PreviewFxInstance::updateAliases() {

  if (m_start > m_end) return;

  std::string newAlias;

  // Build and compare the new aliases with the stored ones

  std::map<int, frameinfo="">::iterator it;</int,>

  for (it = m_frameInfos.begin(); it != m_frameInfos.end(); ++it) {

    TRasterFxP builtFx = buildSceneFx(it->first);

    newAlias = builtFx ? builtFx->getAlias(it->first, m_renderSettings) : "";

    if (newAlias != it->second.m_alias) {

      // Clear the overall and frame-specific rendered regions

      m_overallRenderedRegion     = QRegion();

      it->second.m_renderedRegion = QRegion();

      it->second.m_alias = newAlias;

    }

  }

}

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

void PreviewFxInstance::updateAliasKeyword(const std::string &keyword) {

  if (m_start > m_end) return;

  // Remove the rendered image whose alias contains keyword

  std::map<int, frameinfo="">::iterator it;</int,>

  for (it = m_frameInfos.begin(); it != m_frameInfos.end(); ++it) {

    if (it->second.m_alias.find(keyword) != std::string::npos) {

      // Clear the overall and frame-specific rendered regions

      m_overallRenderedRegion     = QRegion();

      it->second.m_renderedRegion = QRegion();

      // Clear the cached image

      TRasterImageP ri =

          TImageCache::instance()->get(getCacheId(m_fx, it->first), true);

      if (ri) ri->getRaster()->clear();

    }

  }

}

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

void PreviewFxInstance::updateProgressBarStatus() {

  int i;

  unsigned int j;

  std::map<int, frameinfo="">::iterator it;</int,>

  for (i = m_start, j = 0; i <= m_end; i += m_step, ++j) {

    it            = m_frameInfos.find(i);

    m_pbStatus[j] = ::contains(it->second.m_renderedRegion, m_rectUnderRender)

                        ? FlipSlider::PBFrameFinished

                        : FlipSlider::PBFrameNotStarted;

  }

}

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

void PreviewFxInstance::updateRenderSettings() {

  TApp *app         = TApp::instance();

  ToonzScene *scene = app->getCurrentScene()->getScene();

  TOutputProperties *properties =

      scene->getProperties()->getPreviewProperties();

  m_subcamera = properties->isSubcameraPreview();

  TRenderSettings renderSettings = properties->getRenderSettings();

  if (m_renderSettings != renderSettings) {

    m_renderSettings = renderSettings;

    // Erase all previuosly previewed images

    int i;

    for (i = m_start; i <= m_end; i += m_step)

      TImageCache::instance()->remove(getCacheId(m_fx, i));

    // Clear all frame-specific rendered regions

    std::map<int, frameinfo="">::iterator it;</int,>

    for (it = m_frameInfos.begin(); it != m_frameInfos.end(); ++it)

      it->second.m_renderedRegion = QRegion();

  }

}

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

void PreviewFxInstance::updateCamera() {

  // Clear the overall rendered region

  m_overallRenderedRegion = QRegion();

  // Retrieve the preview camera

  TCamera *currCamera = TApp::instance()

                            ->getCurrentScene()

                            ->getScene()

                            ->getCurrentPreviewCamera();

  TRect subCameraRect = currCamera->getInterestRect();

  TPointD cameraPos(-0.5 * currCamera->getRes().lx,

                    -0.5 * currCamera->getRes().ly);

  // Update the camera region and camera stage area

  TDimension cameraRes(0, 0);

  TRectD renderArea;

  if (m_subcamera && subCameraRect.getLx() > 0 && subCameraRect.getLy() > 0) {

    cameraRes  = TDimension(subCameraRect.getLx(), subCameraRect.getLy());

    renderArea = TRectD(subCameraRect.x0, subCameraRect.y0,

                        subCameraRect.x1 + 1, subCameraRect.y1 + 1) +

                 cameraPos;

  } else {

    cameraRes  = currCamera->getRes();

    renderArea = TRectD(cameraPos, TDimensionD(cameraRes.lx, cameraRes.ly));

  }

  cameraRes.lx /= m_renderSettings.m_shrinkX;

  cameraRes.ly /= m_renderSettings.m_shrinkY;

  if (m_cameraRes != cameraRes || m_renderArea != renderArea) {

    m_cameraRes  = cameraRes;

    m_renderArea = renderArea;

    m_cameraPos  = cameraPos;

    // Build the displacement needed when extracting the flipbooks' views

    m_subcameraDisplacement =

        TPointD(0.5 * (m_renderArea.x0 + m_renderArea.x1),

                0.5 * (m_renderArea.y0 + m_renderArea.y1));

    // Erase all previuosly previewed images

    int i;

    for (i = m_start; i <= m_end; i += m_step)

      TImageCache::instance()->remove(getCacheId(m_fx, i));

    // Clear all frame-specific rendered regions

    std::map<int, frameinfo="">::iterator it;</int,>

    for (it = m_frameInfos.begin(); it != m_frameInfos.end(); ++it)

      it->second.m_renderedRegion = QRegion();

  }

}

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

void PreviewFxInstance::updatePreviewRect() {

  bool isFullRender = false;

  if (!m_subcamera) {

    // Retrieve the eventual sub-camera

    TCamera *currCamera = TApp::instance()

                              ->getCurrentScene()

                              ->getScene()

                              ->getCurrentPreviewCamera();

    TRect subcameraRect(currCamera->getInterestRect());

    /*-- Viewer上でサブカメラが指定されていない状態でFxPreviewをした場合 --*/

    if (subcameraRect.getLx() == 0 || subcameraRect.getLy() == 0)

      isFullRender = true;

  }

  // Build all the viewRects to be calculated. They will be computed on

  // consecutive

  // render operations.

  // NOTE: For now, we'll perform a simplicistic solution - coalesce all the

  // flipbooks'

  // viewrects and launch just one render.

  TRectD previewRectD;

  m_rectUnderRender = TRect();

  int shrinkX = m_renderSettings.m_shrinkX;

  int shrinkY = m_renderSettings.m_shrinkY;

  if (!isFullRender) {

    // For each opened flipbook

    /*-- 開いているFlipbookの表示範囲を足しこんでいく --*/

    std::set<flipbook *="">::iterator it;</flipbook>

    for (it = m_flipbooks.begin(); it != m_flipbooks.end(); ++it) {

      // Only visible flipbooks are considered

      if ((*it)->isVisible())

        // Retrieve the flipbook's viewRect. Observe that this image geometry

        // is intended in shrinked image reference, and assumes that the camera

        // center

        // lies at coords (0.0, 0.0).

        previewRectD += (*it)->getPreviewedImageGeometry();

    }

    // Pass from shrinked to standard image geometry

    /*-- いったんShrinkを元に戻す --*/

    previewRectD.x0 *= shrinkX;

    previewRectD.y0 *= shrinkY;

    previewRectD.x1 *= shrinkX;

    previewRectD.y1 *= shrinkY;

    // Now, the viewer will center the subcamera's raster instead than camera's.

    // So, we have

    // to correct the previewRectD by the stored displacement.

    previewRectD += m_subcameraDisplacement;

    /*-- 表示範囲と計算範囲の共通部分を得る --*/

    previewRectD *= m_renderArea;

  } else

    previewRectD = m_renderArea;

  // Ensure that rect has the same pixel geometry as the preview camera

  /*-- 再度Shrink --*/

  previewRectD -= m_cameraPos;

  previewRectD.x0 = previewRectD.x0 / shrinkX;

  previewRectD.y0 = previewRectD.y0 / shrinkY;

  previewRectD.x1 = previewRectD.x1 / shrinkX;

  previewRectD.y1 = previewRectD.y1 / shrinkY;

  // Now, pass to m_cameraRes-relative coordinates

  /*-- 計算エリア基準の座標 → カメラ基準の座標 --*/

  TPointD shrinkedRelPos((m_renderArea.x0 - m_cameraPos.x) / shrinkX,

                         (m_renderArea.y0 - m_cameraPos.y) / shrinkY);

  previewRectD -= shrinkedRelPos;

  previewRectD.x0 = tfloor(previewRectD.x0);

  previewRectD.y0 = tfloor(previewRectD.y0);

  previewRectD.x1 = tceil(previewRectD.x1);

  previewRectD.y1 = tceil(previewRectD.y1);

  /*-- 表示しなくてはいけないRect --*/

  QRect qViewRect(previewRectD.x0, previewRectD.y0, previewRectD.getLx(),

                  previewRectD.getLy());

  /*-- 表示しなくてはいけないRectから、既に計算済みの範囲を引く ＝

   * 新たに計算が必要な領域 --*/

  QRegion viewRectRegionToRender(

      QRegion(qViewRect).subtracted(m_overallRenderedRegion));

  // If the rect to render has already been calculated, continue.

  /*-- 新たに計算が必要な領域が無ければReturn --*/

  if (viewRectRegionToRender.isEmpty()) return;

  // Retrieve the minimal box containing the region yet to be rendered

  /*-- 新たに計算が必要な領域を含む最小のRectを得る --*/