#pragma once

/*------------------------------------

Iwa_GlareFx

------------------------------------*/

#ifndef IWA_GLAREFX_H

#define IWA_GLAREFX_H

#include "stdfx.h"

#include "tfxparam.h"

#include "traster.h"

#include "tparamset.h"

#include <qlist></qlist>

#include <qthread></qthread>

#include "tools/kiss_fftnd.h"

const int LAYER_NUM = 5;

struct double2 {

  double x, y;

};

struct int2 {

  int x, y;

};

struct double3 {

  double x, y, z;

};

class Iwa_GlareFx : public TStandardRasterFx {

  FX_PLUGIN_DECLARATION(Iwa_GlareFx)

protected:

  TRasterFxPort m_source;

  TRasterFxPort m_iris;

  // rendering mode (filter preview / render / iris)

  TIntEnumParamP m_renderMode;

  TIntEnumParamP m_irisMode;

  TDoubleParamP m_irisScale;

  TDoubleParamP m_irisGearEdgeCount;

  TIntParamP m_irisRandomSeed;

  TDoubleParamP m_irisSymmetry;

  TIntEnumParamP m_irisAppearance;

  TDoubleParamP m_intensity;

  TDoubleParamP m_size;

  TDoubleParamP m_rotation;

  TDoubleParamP m_aberration;

  TDoubleParamP m_noise_factor;

  TDoubleParamP m_noise_size;

  TIntEnumParamP m_noise_octave;

  TDoubleParamP m_noise_evolution;

  TPointParamP m_noise_offset;

  enum { RenderMode_FilterPreview = 0, RenderMode_Render, RenderMode_Iris };

  enum {

    Iris_InputImage = 0,

    Iris_Square,

    Iris_Hexagon,

    Iris_Octagon,

    Iris_GearShape

  };

  enum {

    Appearance_ThinLine,

    Appearance_MediumLine,

    Appearance_ThickLine,

    Appearance_Fill,

  };

  double getSizePixelAmount(const double val, const TAffine affine);

  void drawPresetIris(TRaster32P irisRas, double irisSize, const double frame);

  // Resize / flip the iris image according to the size ratio.

  // Normalize the brightness of the iris image.

  // Enlarge the iris to the output size.

  void convertIris(kiss_fft_cpx *kissfft_comp_iris_before, const int &dimIris,

                   const TRectD &irisBBox, const TRasterP irisRaster);

  void powerSpectrum2GlarePattern(const double frame, const TAffine affine,

                                  kiss_fft_cpx *spectrum, double3 *glare,

                                  int dimIris, double intensity,

                                  double irisResizeFactor);

  void distortGlarePattern(const double frame, const TAffine affine,

                           double *glare, const int dimIris);

  // filter preview mode

  template <typename pixel="" raster,="" typename=""></typename>

  void setFilterPreviewToResult(const RASTER ras, double3 *glare, int dimIris,

                                int2 margin);

  // put the source tile's brightness to fft buffer

  template <typename pixel="" raster,="" typename=""></typename>

  void setSourceTileToBuffer(const RASTER ras, kiss_fft_cpx *buf);

  template <typename pixel="" raster,="" typename=""></typename>

  void setSourceTileToBuffer(const RASTER ras, kiss_fft_cpx *buf, int channel);

  void setGlarePatternToBuffer(const double3 *glare, kiss_fft_cpx *buf,

                               const int channel, const int dimIris,

                               const TDimensionI &dimOut);

  void multiplyFilter(kiss_fft_cpx *glare, const kiss_fft_cpx *source,

                      const int count);

  template <typename pixel="" raster,="" typename=""></typename>

  void setChannelToResult(const RASTER ras, kiss_fft_cpx *buf, int channel,

                          const TDimensionI &dimOut);

public:

  Iwa_GlareFx();

  void doCompute(TTile &tile, double frame,

                 const TRenderSettings &settings) override;

  bool doGetBBox(double frame, TRectD &bBox,

                 const TRenderSettings &info) override;

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

  void getParamUIs(TParamUIConcept *&concepts, int &length) override;

  bool toBeComputedInLinearColorSpace(bool settingsIsLinear,

                                      bool tileIsLinear) const override;

};

#endif