#include "stdfx.h"

#include "tfxparam.h"

#include "tparamset.h"

#include "toonz/tdistort.h"

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

//    Local namespace stuff

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

namespace {

class KaleidoDistorter final : public TDistorter {

  double m_angle;

  TAffine m_aff;

  TPointD m_shift;

public:

  KaleidoDistorter(double angle, const TAffine &aff, const TPointD shift)

      : m_angle(angle), m_aff(aff), m_shift(shift) {}

  TPointD map(const TPointD &p) const override { return TPointD(); }

  int maxInvCount() const override { return 1; }

  int invMap(const TPointD &p, TPointD *results) const override;

};

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

int KaleidoDistorter::invMap(const TPointD &p, TPointD *results) const {

  TPointD q(m_aff * p);

  // Build p's angular position

  double qAngle = atan2(q.y, q.x);

  if (qAngle < 0.0) qAngle += 2.0 * M_PI;

  assert(qAngle >= 0.0);

  int section  = tfloor(qAngle / m_angle);

  bool reflect = (bool)(section % 2);

  double normQ = norm(q);

  if (reflect) {

    double newAngle = qAngle - (section + 1) * m_angle;

    results[0].x = normQ * cos(newAngle) + m_shift.x;

    results[0].y = -normQ * sin(newAngle) + m_shift.y;

  } else {

    double newAngle = qAngle - section * m_angle;

    results[0].x = normQ * cos(newAngle) + m_shift.x;

    results[0].y = normQ * sin(newAngle) + m_shift.y;

  }

  return 1;

}

}  // namespace

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

//    Kaleido Fx

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

class KaleidoFx final : public TStandardRasterFx {

  FX_PLUGIN_DECLARATION(KaleidoFx)

  TRasterFxPort m_input;

  TPointParamP m_center;

  TDoubleParamP m_angle;

  TIntParamP m_count;

public:

  KaleidoFx() : m_center(TPointD()), m_angle(0.0), m_count(3) {

    m_center->getX()->setMeasureName("fxLength");

    m_center->getY()->setMeasureName("fxLength");

    m_angle->setMeasureName("angle");

    bindParam(this, "center", m_center);

    bindParam(this, "angle", m_angle);

    bindParam(this, "count", m_count);

    addInputPort("Source", m_input);

    m_count->setValueRange(1, 100);

    enableComputeInFloat(true);

  }

  ~KaleidoFx(){};

  bool doGetBBox(double frame, TRectD &bBox,

                 const TRenderSettings &info) override;

  void doDryCompute(TRectD &rect, double frame,

                    const TRenderSettings &ri) override;

  void doCompute(TTile &tile, double frame, const TRenderSettings &ri) override;

  int getMemoryRequirement(const TRectD &rect, double frame,

                           const TRenderSettings &info) override;

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

    return isAlmostIsotropic(info.m_affine);

  }

  bool toBeComputedInLinearColorSpace(bool settingsIsLinear,

                                      bool tileIsLinear) const override {

    return tileIsLinear;

  }

private:

  void buildSectionRect(TRectD &inRect, double angle);

  void rotate(TRectD &rect);

  TAffine buildInputReference(double frame, TRectD &inRect,

                              TRenderSettings &inInfo, const TRectD &outRect,

                              const TRenderSettings &outInfo);

};

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

void KaleidoFx::buildSectionRect(TRectD &inRect, double angle) {

  inRect.y0 = std::max(inRect.y0, 0.0);

  if (angle <= M_PI_2) {

    inRect.x0 = std::max(inRect.x0, 0.0);

    inRect.y1 = std::min(inRect.y1, inRect.x1 * tan(angle));

  }

}

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

void KaleidoFx::rotate(TRectD &rect) {

  TPointD pMax(std::max(-rect.x0, rect.x1), std::max(-rect.y0, rect.y1));

  double normPMax = norm(pMax);

  rect = TRectD(-normPMax, -normPMax, normPMax, normPMax);

}

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

TAffine KaleidoFx::buildInputReference(double frame, TRectD &inRect,

                                       TRenderSettings &inInfo,

                                       const TRectD &outRect,

                                       const TRenderSettings &outInfo) {

  double scale = fabs(sqrt(outInfo.m_affine.det()));

  double angle = M_PI / m_count->getValue();

  inInfo.m_affine = TRotation(-m_angle->getValue(frame) - angle) *

                    TScale(scale).place(m_center->getValue(frame), TPointD());

  TAffine outRefToInRef(inInfo.m_affine * outInfo.m_affine.inv());

  // Build the input bounding box

  TRectD inBBox;

  m_input->getBBox(frame, inBBox, inInfo);

  // Rotate the output rect in the input reference. This is required since the

  // rotational

  // deformation may rotate points outside the rect, inside it.

  TRectD outRect_inputRef(outRefToInRef * outRect);

  rotate(outRect_inputRef);

  // Intersect with the useful kaleido region

  inRect = inBBox * outRect_inputRef;

  buildSectionRect(inRect, angle);

  return outRefToInRef;

}

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

bool KaleidoFx::doGetBBox(double frame, TRectD &bBox,

                          const TRenderSettings &info) {

  // Remember: info.m_affine MUST NOT BE CONSIDERED in doGetBBox's

  // implementation

  // Retrieve the input bbox without applied affines.

  if (!m_input.getFx()) return false;

  double angle = M_PI / m_count->getValue();

  TRenderSettings inInfo(info);

  inInfo.m_affine = TRotation(-m_angle->getValue(frame) - angle) *

                    TTranslation(-m_center->getValue(frame));

  if (!m_input->getBBox(frame, bBox, inInfo)) return false;

  TRectD infiniteRect(TConsts::infiniteRectD);

  TRectD kaleidoRect((m_count->getValue() > 1) ? 0.0 : infiniteRect.x0, 0.0,

                     infiniteRect.x1, infiniteRect.y1);

  bBox *= kaleidoRect;

  if (bBox.x0 == infiniteRect.x0 || bBox.x1 == infiniteRect.x1 ||

      bBox.y1 == infiniteRect.y1) {

    bBox = infiniteRect;

    return true;

  }

  buildSectionRect(bBox, angle);

  // Now, we must rotate the bBox in order to obtain the kaleidoscoped box

  rotate(bBox);

  // Finally, bring it back to standard reference

  bBox = inInfo.m_affine.inv() * bBox;

  return true;

}

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

void KaleidoFx::doDryCompute(TRectD &rect, double frame,

                             const TRenderSettings &info) {

  if (!m_input.isConnected()) return;

  if (fabs(info.m_affine.det()) < TConsts::epsilon) return;

  // Build the input reference

  TRectD inRect;

  TRenderSettings inInfo(info);

  TAffine outRefToInRef(buildInputReference(frame, inRect, inInfo, rect, info));

  if (inRect.getLx() <= 0.0 || inRect.getLy() <= 0.0) return;

  inRect = inRect.enlarge(1.0);  // tdistort() seems to need it

  // Allocate a corresponding input tile and calculate it

  m_input->dryCompute(inRect, frame, inInfo);

}

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

void KaleidoFx::doCompute(TTile &tile, double frame,

                          const TRenderSettings &info) {

  if (!m_input.isConnected()) return;

  if (fabs(info.m_affine.det()) < TConsts::epsilon) return;

  // Build the output rect

  TDimension tileSize(tile.getRaster()->getSize());

  TRectD tileRect(tile.m_pos, TDimensionD(tileSize.lx, tileSize.ly));

  // Build the input reference

  TRectD inRect;

  TRenderSettings inInfo(info);

  TAffine outRefToInRef(

      buildInputReference(frame, inRect, inInfo, tileRect, info));

  if (inRect.getLx() <= 0.0 || inRect.getLy() <= 0.0) return;

  inRect = inRect.enlarge(1.0);  // tdistort() seems to need it

  // Allocate a corresponding input tile and calculate it

  TTile inTile;

  TDimension inDim(tceil(inRect.getLx()), tceil(inRect.getLy()));

  m_input->allocateAndCompute(inTile, inRect.getP00(), inDim, tile.getRaster(),

                              frame, inInfo);

  // Now, perform kaleido

  double angle = M_PI / m_count->getValue();

  KaleidoDistorter distorter(angle, outRefToInRef, -inRect.getP00());

  TRasterP inRas(inTile.getRaster());

  TRasterP tileRas(tile.getRaster());

  distort(tileRas, inRas, distorter, convert(tile.m_pos));

}

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

int KaleidoFx::getMemoryRequirement(const TRectD &rect, double frame,

                                    const TRenderSettings &info) {

  if (!m_input.isConnected()) return 0;

  if (fabs(info.m_affine.det()) < TConsts::epsilon) return 0;

  // Build the input reference

  TRectD inRect;

  TRenderSettings inInfo(info);

  TAffine outRefToInRef(buildInputReference(frame, inRect, inInfo, rect, info));

  if (inRect.getLx() <= 0.0 || inRect.getLy() <= 0.0) return 0;

  inRect = inRect.enlarge(1.0);  // tdistort() seems to need it

  return TRasterFx::memorySize(inRect, info.m_bpp);

}

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

FX_PLUGIN_IDENTIFIER(KaleidoFx, "kaleidoFx");