#include "trop.h"
#include "tfxparam.h"
#include "stdfx.h"
#include "tpluginmanager.h"
#include "tpixelutils.h"
#include "tspectrumparam.h"
#include "ttzpimagefx.h"
#include "gradients.h"
#include "tunit.h"
#include "tparamuiconcept.h"

#include <QCoreApplication>

#ifdef WIN32
#pragma warning(disable : 4996)
#endif
#undef max
//==================================================================

bool isAlmostIsotropic(const TAffine &aff)
{
	return aff.isIsotropic(0.001);
}

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

class FadeFx : public TStandardRasterFx
{
	FX_PLUGIN_DECLARATION(FadeFx)
	TRasterFxPort m_input;
	TDoubleParamP m_value;

public:
	FadeFx() : m_value(50)
	{
		m_value->setValueRange(0, 100);
		bindParam(this, "value", m_value);

		addInputPort("Source", m_input);
	};

	~FadeFx(){};

	bool doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)
	{
		if (m_input.isConnected()) {
			bool ret = m_input->doGetBBox(frame, bBox, info);
			// devo scurire bgColor
			return ret;
		} else {
			bBox = TRectD();
			return false;
		}
	};

	void doCompute(TTile &tile, double frame, const TRenderSettings &ri)
	{
		if (!m_input.isConnected())
			return;

		m_input->compute(tile, frame, ri);

		double v = 1 - m_value->getValue(frame) / 100;
		TRop::rgbmScale(tile.getRaster(), tile.getRaster(), 1, 1, 1, v);
	}

	bool canHandle(const TRenderSettings &info, double frame) { return true; }
};

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

class SpiralFx : public TStandardZeraryFx
{
	FX_PLUGIN_DECLARATION(SpiralFx)
	TDoubleParamP m_freq;
	TDoubleParamP m_phase;
	TSpectrumParamP m_spectrum;

public:
	SpiralFx()
		: m_freq(0.1) // args, "Freq")
		  ,
		  m_phase(0.0) // args, "Phase")
	{

		// m_freq->setDefaultValue(0.1);
		// m_phase->setDefaultValue(0.0);
		const TPixel32 transparent(0, 0, 0, 0);
		/*
	 TPixel32 colors[] = {
			TPixel32::Magenta, 
			TPixel32::Black, 
			TPixel32::Red, 
			TPixel32::Yellow, 
			transparent};    
 */
		TSpectrum::ColorKey colors[] = {
			TSpectrum::ColorKey(0, TPixel32::Magenta),
			TSpectrum::ColorKey(0.25, TPixel32::Black),
			TSpectrum::ColorKey(0.5, TPixel32::Red),
			TSpectrum::ColorKey(0.75, TPixel32::Yellow),
			TSpectrum::ColorKey(1, transparent)};

		m_spectrum = TSpectrumParamP(tArrayCount(colors), colors);

		bindParam(this, "colors", m_spectrum);
		bindParam(this, "freq", m_freq);
		bindParam(this, "phase", m_phase);
		m_freq->setValueRange(0, 1);
		//m_spectrum->setDefaultValue(tArrayCount(colors), colors);
	};
	~SpiralFx(){};

	bool doGetBBox(double, TRectD &bBox, const TRenderSettings &info)
	{
		bBox = TConsts::infiniteRectD;
		return true;
	};

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

	bool canHandle(const TRenderSettings &info, double frame) { return true; }
};

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

namespace
{
template <class T>
void doComputeT(TRasterPT<T> raster, TPointD posTrasf, const TAffine &aff,
				const TSpectrumT<T> &spectrum, double freq, double phase)
{
	raster->lock();
	for (int y = 0; y < raster->getLy(); y++) {
		TPointD posAux = posTrasf;
		T *pix = raster->pixels(y);
		for (int x = 0; x < raster->getLx(); x++) {
			double ang = 0.0;
			if (posAux.x != 0 || posAux.y != 0)
				ang = atan2(posAux.y, posAux.x);
			double r = sqrt(posAux.x * posAux.x + posAux.y * posAux.y);
			double v = 0.5 * (1 + sin(r * freq + ang + phase));
			*pix++ = spectrum.getPremultipliedValue(v);
			posAux.x += aff.a11;
			posAux.y += aff.a21;
		}
		posTrasf.x += aff.a12;
		posTrasf.y += aff.a22;
	}
	raster->unlock();
}
}

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

void SpiralFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
	double phase = m_phase->getValue(frame);
	double freq = m_freq->getValue(frame);

	TAffine aff = ri.m_affine.inv();
	TPointD posTrasf = aff * tile.m_pos;

	if (TRaster32P ras32 = tile.getRaster())
		doComputeT<TPixel32>(ras32, posTrasf, aff, m_spectrum->getValue(frame), freq, phase);
	else if (TRaster64P ras64 = tile.getRaster())
		doComputeT<TPixel64>(ras64, posTrasf, aff, m_spectrum->getValue64(frame), freq, phase);
	else
		throw TException("SpiralFx: unsupported Pixel Type");
}

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

class MultiLinearGradientFx : public TStandardZeraryFx
{
	FX_PLUGIN_DECLARATION(MultiLinearGradientFx)
	TDoubleParamP m_period;
	TDoubleParamP m_count;
	TDoubleParamP m_cycle;
	TDoubleParamP m_wave_amplitude;
	TDoubleParamP m_wave_freq;
	TDoubleParamP m_wave_phase;
	TSpectrumParamP m_colors;

public:
	MultiLinearGradientFx()
		: m_period(100) //args, "Period")
		  ,
		  m_count(2) //args, "Count")
		  ,
		  m_cycle(0.0) //args, "Cycle")
		  ,
		  m_wave_amplitude(0.0) //args, "Cycle")
		  ,
		  m_wave_freq(0.0) //args, "Cycle")
		  ,
		  m_wave_phase(0.0) //args, "Cycle")
							//    , m_colors (0) //args, "Colors")
	{
		TSpectrum::ColorKey colors[] = {
			TSpectrum::ColorKey(0, TPixel32::White),
			TSpectrum::ColorKey(0.33, TPixel32::Yellow),
			TSpectrum::ColorKey(0.66, TPixel32::Red),
			TSpectrum::ColorKey(1, TPixel32::White)};
		m_colors = TSpectrumParamP(tArrayCount(colors), colors);

		bindParam(this, "period", m_period);
		bindParam(this, "count", m_count);
		bindParam(this, "cycle", m_cycle);
		bindParam(this, "wave_amplitude", m_wave_amplitude);
		bindParam(this, "wave_frequency", m_wave_freq);
		bindParam(this, "wave_phase", m_wave_phase);
		bindParam(this, "colors", m_colors);
		m_period->setValueRange(0, (std::numeric_limits<double>::max)());
		m_cycle->setValueRange(0, (std::numeric_limits<double>::max)());
		m_wave_amplitude->setValueRange(0, (std::numeric_limits<double>::max)());
		m_count->setValueRange(0, (std::numeric_limits<double>::max)());
		m_period->setMeasureName("fxLength");
		m_wave_amplitude->setMeasureName("fxLength");
	}
	~MultiLinearGradientFx(){};

	bool doGetBBox(double, TRectD &bBox, const TRenderSettings &info)
	{
		bBox = TConsts::infiniteRectD;

		return true;
		// si potrebbe/dovrebbe fare meglio
	};

	void doCompute(TTile &tile, double frame, const TRenderSettings &ri);
	bool canHandle(const TRenderSettings &info, double frame) { return true; }

	void getParamUIs(TParamUIConcept *&concepts, int &length)
	{
		concepts = new TParamUIConcept[length = 1];

		concepts[0].m_type = TParamUIConcept::WIDTH;
		concepts[0].m_label = "Size";
		concepts[0].m_params.push_back(m_period);
	}
};

class LinearGradientFx : public TStandardZeraryFx
{
	FX_PLUGIN_DECLARATION(LinearGradientFx)
	TDoubleParamP m_period;

	TDoubleParamP m_wave_amplitude;
	TDoubleParamP m_wave_freq;
	TDoubleParamP m_wave_phase;
	TPixelParamP m_color1;
	TPixelParamP m_color2;

public:
	LinearGradientFx()
		: m_period(100) //args, "Period")
		  ,
		  m_wave_amplitude(0.0) //args, "Cycle")
		  ,
		  m_wave_freq(0.0) //args, "Cycle")
		  ,
		  m_wave_phase(0.0) //args, "Cycle")
		  ,
		  m_color1(TPixel32::Black), m_color2(TPixel32::White)
	//    , m_colors (0) //args, "Colors")
	{

		bindParam(this, "period", m_period);
		bindParam(this, "wave_amplitude", m_wave_amplitude);
		bindParam(this, "wave_frequency", m_wave_freq);
		bindParam(this, "wave_phase", m_wave_phase);
		bindParam(this, "color1", m_color1);
		bindParam(this, "color2", m_color2);
		m_period->setValueRange(0, std::numeric_limits<double>::max());
		m_wave_amplitude->setValueRange(0, std::numeric_limits<double>::max());
		m_period->setMeasureName("fxLength");
		m_wave_amplitude->setMeasureName("fxLength");
	}
	~LinearGradientFx(){};

	bool doGetBBox(double, TRectD &bBox, const TRenderSettings &info)
	{
		bBox = TConsts::infiniteRectD;

		return true;
		// si potrebbe/dovrebbe fare meglio
	};

	void doCompute(TTile &tile, double frame, const TRenderSettings &ri);
	bool canHandle(const TRenderSettings &info, double frame) { return true; }

	void getParamUIs(TParamUIConcept *&concepts, int &length)
	{
		concepts = new TParamUIConcept[length = 1];

		concepts[0].m_type = TParamUIConcept::WIDTH;
		concepts[0].m_label = "Size";
		concepts[0].m_params.push_back(m_period);
	}
};

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

namespace
{
template <class T>
void doComputeT(TRasterPT<T> ras, TPointD posTrasf, const TSpectrumT<T> &spectrum,
				double period, double count, double w_amplitude, double w_freq, double w_phase, double cycle, const TAffine &aff)
{
	double shift = 0;
	double maxRadius = period * count / 2.;
	double freq = 1.0 / period;
	int j;
	ras->lock();
	for (j = 0; j < ras->getLy(); j++) {
		TPointD posAux = posTrasf;

		//TPointD pos = tile.m_pos;
		//pos.y += j;
		T *pix = ras->pixels(j);
		T *endPix = pix + ras->getLx();
		while (pix < endPix) {
			if (w_amplitude)
				shift = w_amplitude * sin(w_freq * posAux.y + w_phase);
			double radius = posAux.x + shift;
			double t = 1;
			if (fabs(radius) < maxRadius) {
				t = (radius + maxRadius + cycle) * freq;
				t -= floor(t);
			} else if (radius < 0)
				t = 0;
			double polinomfactor = (-2 * t + 3) * (t * t);
			//pos.x += 1.0;
			*pix++ = spectrum.getPremultipliedValue(polinomfactor);
			posAux.x += aff.a11;
			posAux.y += aff.a21;
		}
		posTrasf.x += aff.a12;
		posTrasf.y += aff.a22;
	}
	ras->unlock();
}
}

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

void LinearGradientFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
	assert((TRaster32P)tile.getRaster() || (TRaster64P)tile.getRaster());

	double period = m_period->getValue(frame) / ri.m_shrinkX;
	double count = 1.0;
	double cycle = 0;
	double w_amplitude = m_wave_amplitude->getValue(frame) / ri.m_shrinkX;
	double w_freq = m_wave_freq->getValue(frame) * ri.m_shrinkX;
	double w_phase = m_wave_phase->getValue(frame);
	w_freq = (w_freq * 0.01 * TConsts::pi) / 180;

	TSpectrum::ColorKey colors[] = {
		TSpectrum::ColorKey(0, m_color1->getValue(frame)),
		TSpectrum::ColorKey(1, m_color2->getValue(frame))};
	TSpectrumParamP m_colors = TSpectrumParamP(tArrayCount(colors), colors);

	TAffine aff = ri.m_affine.inv();
	TPointD posTrasf = aff * tile.m_pos;
	multiLinear(tile.getRaster(), posTrasf, m_colors, period, count, w_amplitude, w_freq, w_phase, cycle, aff, frame);
	/*
	if (TRaster32P ras32 = tile.getRaster())
    doComputeT<TPixel32>(
      ras32, posTrasf, 
      m_colors->getValue(frame), 
      period, count, w_amplitude, w_freq, w_phase, cycle, aff);
  else if (TRaster64P ras64 = tile.getRaster())
    doComputeT<TPixel64>(
      ras64, posTrasf, 
      m_colors->getValue64(frame), 
      period, count, w_amplitude, w_freq, w_phase, cycle, aff);
  else
    throw TException("MultiLinearGradientFx: unsupported Pixel Type");
    */
}

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

void MultiLinearGradientFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
	assert((TRaster32P)tile.getRaster() || (TRaster64P)tile.getRaster());

	double period = m_period->getValue(frame) / ri.m_shrinkX;
	double count = m_count->getValue(frame);
	double cycle = m_cycle->getValue(frame) / ri.m_shrinkX;
	double w_amplitude = m_wave_amplitude->getValue(frame) / ri.m_shrinkX;
	double w_freq = m_wave_freq->getValue(frame) * ri.m_shrinkX;
	double w_phase = m_wave_phase->getValue(frame);
	w_freq = (w_freq * 0.01 * TConsts::pi) / 180;

	TAffine aff = ri.m_affine.inv();
	TPointD posTrasf = aff * tile.m_pos;
	multiLinear(tile.getRaster(), posTrasf, m_colors, period, count, w_amplitude, w_freq, w_phase, cycle, aff, frame);
	/*
	if (TRaster32P ras32 = tile.getRaster())
    doComputeT<TPixel32>(
      ras32, posTrasf, 
      m_colors->getValue(frame), 
      period, count, w_amplitude, w_freq, w_phase, cycle, aff);
  else if (TRaster64P ras64 = tile.getRaster())
    doComputeT<TPixel64>(
      ras64, posTrasf, 
      m_colors->getValue64(frame), 
      period, count, w_amplitude, w_freq, w_phase, cycle, aff);
  else
    throw TException("MultiLinearGradientFx: unsupported Pixel Type");
    */
}

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

class RadialGradientFx : public TStandardZeraryFx
{
	FX_PLUGIN_DECLARATION(RadialGradientFx)
	TDoubleParamP m_period;
	TDoubleParamP m_innerperiod;
	TPixelParamP m_color1;
	TPixelParamP m_color2;

public:
	RadialGradientFx()
		: m_period(100.0), m_innerperiod(0.0) //args, "Period")
		  ,
		  m_color1(TPixel32::White), m_color2(TPixel32::Transparent)
	//    , m_colors (0) //args, "Colors")
	{
		m_period->setMeasureName("fxLength");
		m_innerperiod->setMeasureName("fxLength");
		bindParam(this, "period", m_period);
		bindParam(this, "innerperiod", m_innerperiod);
		bindParam(this, "color1", m_color1);
		bindParam(this, "color2", m_color2);
		m_period->setValueRange(0.0, std::numeric_limits<double>::max());
		m_innerperiod->setValueRange(0.0, std::numeric_limits<double>::max());
	}
	~RadialGradientFx(){};

	bool doGetBBox(double, TRectD &bBox, const TRenderSettings &info)
	{
		bBox = TConsts::infiniteRectD;
		return true;
		// si potrebbe/dovrebbe fare meglio
	};

	void doCompute(TTile &tile, double frame, const TRenderSettings &ri);
	bool canHandle(const TRenderSettings &info, double frame) { return true; }

	void getParamUIs(TParamUIConcept *&concepts, int &length)
	{
		concepts = new TParamUIConcept[length = 2];

		concepts[0].m_type = TParamUIConcept::RADIUS;
		concepts[0].m_label = "Inner Size";
		concepts[0].m_params.push_back(m_innerperiod);

		concepts[1].m_type = TParamUIConcept::RADIUS;
		concepts[1].m_label = "Outer Size";
		concepts[1].m_params.push_back(m_period);
	}
};

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

class MultiRadialGradientFx : public TStandardZeraryFx
{
	FX_PLUGIN_DECLARATION(MultiRadialGradientFx)
	TDoubleParamP m_period;
	TDoubleParamP m_count;
	TDoubleParamP m_cycle;
	TSpectrumParamP m_colors;

public:
	MultiRadialGradientFx()
		: m_period(100) //args, "Period")
		  ,
		  m_count(2) //args, "Count")
		  ,
		  m_cycle(0.0) //args, "Count")
					   //    , m_colors (0) //args, "Colors")
	{
		m_period->setMeasureName("fxLength");
		TSpectrum::ColorKey colors[] = {
			TSpectrum::ColorKey(0, TPixel32::White),
			TSpectrum::ColorKey(0.33, TPixel32::Yellow),
			TSpectrum::ColorKey(0.66, TPixel32::Red),
			TSpectrum::ColorKey(1, TPixel32::White)};

		m_colors = TSpectrumParamP(tArrayCount(colors), colors);

		bindParam(this, "period", m_period);
		bindParam(this, "count", m_count);
		bindParam(this, "cycle", m_cycle);
		bindParam(this, "colors", m_colors);
		m_period->setValueRange(0, (std::numeric_limits<double>::max)());
		m_cycle->setValueRange(0, (std::numeric_limits<double>::max)());
		m_count->setValueRange(0, (std::numeric_limits<double>::max)());
	}
	~MultiRadialGradientFx(){};

	bool doGetBBox(double, TRectD &bBox, const TRenderSettings &info)
	{
		bBox = TConsts::infiniteRectD;
		return true;
		// si potrebbe/dovrebbe fare meglio
	};

	void doCompute(TTile &tile, double frame, const TRenderSettings &ri);
	bool canHandle(const TRenderSettings &info, double frame) { return true; }

	void getParamUIs(TParamUIConcept *&concepts, int &length)
	{
		concepts = new TParamUIConcept[length = 1];

		concepts[0].m_type = TParamUIConcept::RADIUS;
		concepts[0].m_label = "Period";
		concepts[0].m_params.push_back(m_period);
	}
};

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

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

void MultiRadialGradientFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
	assert((TRaster32P)tile.getRaster() || (TRaster64P)tile.getRaster());
	double period = m_period->getValue(frame) / ri.m_shrinkX;
	double count = m_count->getValue(frame);
	double cycle = m_cycle->getValue(frame) / ri.m_shrinkX;

	TAffine aff = ri.m_affine.inv();
	TPointD posTrasf = aff * tile.m_pos;
	multiRadial(tile.getRaster(), posTrasf, m_colors, period, count, cycle, aff, frame);
}

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

void RadialGradientFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
	assert((TRaster32P)tile.getRaster() || (TRaster64P)tile.getRaster());
	double period = m_period->getValue(frame) / ri.m_shrinkX;
	double innerperiod = m_innerperiod->getValue(frame) / ri.m_shrinkX;
	double count = 1.0;
	double cycle = 0.0;
	double inner = 0.0;
	if (innerperiod < period)
		inner = innerperiod / period;
	else
		inner = 1 - TConsts::epsilon;
	TSpectrum::ColorKey colors[] = {
		TSpectrum::ColorKey(0, m_color1->getValue(frame)),
		TSpectrum::ColorKey(inner, m_color1->getValue(frame)),
		TSpectrum::ColorKey(1, m_color2->getValue(frame))};
	TSpectrumParamP m_colors = TSpectrumParamP(tArrayCount(colors), colors);
	TAffine aff = ri.m_affine.inv();
	TPointD posTrasf = aff * tile.m_pos;
	multiRadial(tile.getRaster(), posTrasf, m_colors, period, count, cycle, aff, frame);
}

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

class LightSpotFx : public TStandardZeraryFx
{
	FX_PLUGIN_DECLARATION(LightSpotFx)
	TDoubleParamP m_softness;
	TDoubleParamP m_a;
	TDoubleParamP m_b;
	TPixelParamP m_color;

public:
	LightSpotFx()
		: m_softness(0.2) //args, "Softness")
		  ,
		  m_a(200) //args, "A")
		  ,
		  m_b(100) //args, "B")
		  ,
		  m_color(TPixel::Magenta) //args, "Color")
	{
		m_a->setMeasureName("fxLength");
		m_b->setMeasureName("fxLength");
		bindParam(this, "softness", m_softness);
		bindParam(this, "a", m_a);
		bindParam(this, "b", m_b);
		bindParam(this, "color", m_color);
		/*
	  m_a->setDefaultValue(200);
	  m_b->setDefaultValue(100);
    m_color->setDefaultValue(TPixel::Magenta);
*/
	}
	~LightSpotFx(){};

	bool doGetBBox(double, TRectD &bBox, const TRenderSettings &info)
	{
		bBox = TConsts::infiniteRectD;
		return true;
		// si potrebbe/dovrebbe fare meglio
	};

	void doCompute(TTile &tile, double frame, const TRenderSettings &ri);
	bool canHandle(const TRenderSettings &info, double frame) { return true; }

	void getParamUIs(TParamUIConcept *&concepts, int &length)
	{
		concepts = new TParamUIConcept[length = 1];

		concepts[0].m_type = TParamUIConcept::RECT;
		concepts[0].m_params.push_back(m_a);
		concepts[0].m_params.push_back(m_b);
	}
};

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

namespace
{
template <class T>
void doComputeT(TRasterPT<T> raster, TPointD posTrasf, const TAffine &aff, const T &pixelColor,
				double softness, double a, double b)
{
	double aa = a * a;
	double bb = b * b;
	double invaa = 1 / aa;
	double invbb = 1 / bb;
	double num = 2 * (aa + bb);
	double normax = num / (5 * aa + bb);
	int j;

	raster->lock();
	for (j = 0; j < raster->getLy(); j++) {
		TPointD posAux = posTrasf;
		T *pix = raster->pixels(j);
		T *endPix = pix + raster->getLx();
		while (pix < endPix) {
			double yyrot = (posAux.y) * (posAux.y);
			double yvar = (yyrot)*invbb + 1;
			double result;
			double fact, xrot, tempvar, normtmp, outsideslope;
			//pos.x += 1.0;
			xrot = (posAux.x);
			tempvar = xrot * xrot * invaa + yvar;
			fact = tempvar * 0.5;
			if (fact < 1) {
				normtmp = num / (aa + bb + (xrot - a) * (xrot - a) + yyrot);
				result = normtmp;
			} else {
				outsideslope = 1 / (1 + (fact - 1) * softness);
				result = normax * outsideslope;
			}
			if (result > 1)
				result = 1;
			if (result < 0)
				result = 0;
			*pix++ = blend(T::Black, pixelColor, result);
			posAux.x += aff.a11;
			posAux.y += aff.a21;
		}
		posTrasf.x += aff.a12;
		posTrasf.y += aff.a22;
	}
	raster->unlock();
}
}

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

void LightSpotFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{

	double a = m_a->getValue(frame) / ri.m_shrinkX;
	double b = m_b->getValue(frame) / ri.m_shrinkX;

	if (a == 0.0 || b == 0.0) {
		if ((TRaster32P)tile.getRaster())
			((TRaster32P)tile.getRaster())->fill(TPixel32::Black);
		else if ((TRaster64P)tile.getRaster())
			((TRaster64P)tile.getRaster())->fill(TPixel64::Black);
		return;
	}

	TAffine aff = ri.m_affine.inv();
	TPointD posTrasf = aff * tile.m_pos;
	const TPixel32 pixelColor = m_color->getValue(frame);
	double softness = m_softness->getValue(frame);
	if ((TRaster32P)tile.getRaster())
		doComputeT<TPixel32>(tile.getRaster(), posTrasf, aff, pixelColor, softness, a, b);
	else if ((TRaster64P)tile.getRaster())
		doComputeT<TPixel64>(tile.getRaster(), posTrasf, aff, toPixel64(pixelColor), softness, a, b);
}

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

FX_PLUGIN_IDENTIFIER(SpiralFx, "spiralFx")
FX_PLUGIN_IDENTIFIER(FadeFx, "fadeFx")
FX_PLUGIN_IDENTIFIER(RadialGradientFx, "radialGradientFx")
FX_PLUGIN_IDENTIFIER(MultiRadialGradientFx, "multiRadialGradientFx")
FX_PLUGIN_IDENTIFIER(LinearGradientFx, "linearGradientFx")
FX_PLUGIN_IDENTIFIER(MultiLinearGradientFx, "multiLinearGradientFx")
FX_PLUGIN_IDENTIFIER(LightSpotFx, "lightSpotFx")

/*
TLIBMAIN {
static TPluginInfo info("stdfx");
return &info;
};

*/

DV_EXPORT_API void initStdFx()
{
}