#include "texception.h"

#include "stdfx.h"

#include "tpixelutils.h"

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

class BacklitFx : public TStandardRasterFx

{

	FX_PLUGIN_DECLARATION(BacklitFx)

	TRasterFxPort m_input;

	//TDoubleParamP m_value;

public:

	BacklitFx()

	//    , m_value (args, "Blur")

	{

		//m_value->setDefaultValue(100);

		addInputPort("Source", m_input);

	}

	~BacklitFx(){};

	bool doGetBBox(double frame, TRectD &bBox);

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

	int getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info);

	TRect getInvalidRect(const TRect &max);

};

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

bool BacklitFx::doGetBBox(double frame, TRectD &bBox)

{

	if (m_input.isConnected()) {

		bool ret = m_input->doGetBBox(frame, bBox);

		// devo scurire bgColor

		return ret;

	} else {

		bBox = TRectD();

		return false;

	}

}

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

namespace

{

template <class t=""></class>

void computeBacklit(TRasterPT<t> dst,</t>

					TRasterPT<t> src,</t>

					const TPoint &srcPos,

					// cordinate di src[0,0] rispetto a dst;

					// in genere srcPos.x,.y <= 0

					const TPoint ¢er

					// coordinate della sorgente di luce rispetto a dst;

					)

{

	//TRect srcRect = src->getBounds() + srcPos;

	//assert(srcRect.contains(dst->getBounds()));

	//assert(srcRect.contains(center));

	UINT max = T::maxChannelValue;

	dst->lock();

	for (int x = 0; x < dst->getLx(); x++)

		for (int y = 0; y < dst->getLy(); y++) {

			int dx = x - center.x;

			int dy = y - center.y;

			int dist = (int)sqrt((float)(dx * dx + dy * dy));

			int d = tmin(100, dist) + 1;

			double value = 0.0;

			for (int i = 0; i <= d; i++) {

				int xx = center.x + (x - center.x) * i / d - srcPos.x;

				int yy = center.y + (y - center.y) * i / d - srcPos.y;

				assert(src->getBounds().contains(TPoint(xx, yy)));

				value += (max - src->pixels(yy)[xx].m) * 2;

			}

			value = value / dist;

			//    double value = sin(dist)<0?0:255;

			int v = tcrop((int)value, 0, (int)max);

			int srcX = -srcPos.x + x;

			int srcY = -srcPos.y + y;

			T srcPix(0, 0, 0, 0);

			if (src->getBounds().contains(TPoint(srcX, srcY)))

				srcPix = src->pixels(srcY)[srcX];

			srcPix.r = srcPix.r * (max - v) / max;

			srcPix.g = srcPix.g * (max - v) / max;

			srcPix.b = srcPix.b * (max - v) / max;

			dst->pixels(y)[x] = overPix(srcPix, T(v, v, v, v / 2));

		}

	dst->unlock();

}

} // namespace

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

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

{

	if (!m_input.isConnected()) {

		tile.getRaster()->clear();

		return;

	}

	TTile srcTile;

	srcTile.m_pos = tile.m_pos;

	TPoint srcPos(0, 0);

	TDimension srcSize = tile.getRaster()->getSize();

	TPoint center(-(int)tile.m_pos.x, -(int)tile.m_pos.y);

	center += TPoint(10, 10);

	if (center.x < 0) {

		srcSize.lx += -center.x;

		srcPos.x += center.x;

		srcTile.m_pos.x += center.x;

	} else if (center.x >= srcSize.lx) {

		srcSize.lx += center.x - srcSize.lx + 1;

	}

	if (center.y < 0) {

		srcSize.ly += -center.y;

		srcPos.y += center.y;

		srcTile.m_pos.y += center.y;

	} else if (center.y >= srcSize.ly) {

		srcSize.ly += center.y - srcSize.ly + 1;

	}

	if ((TRaster32P)tile.getRaster()) {

		TRaster32P src = TRaster32P(srcSize);

		src->clear();

		srcTile.getRaster() = src;

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

		TRaster32P dst = tile.getRaster();

		assert(dst);

		computeBacklit<tpixel32>(dst, src, srcPos, center);</tpixel32>

	} else if ((TRaster64P)tile.getRaster()) {

		TRaster64P src = TRaster64P(srcSize);

		src->clear();

		srcTile.getRaster() = src;

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

		TRaster64P dst = tile.getRaster();

		assert(dst);

		computeBacklit<tpixel64>(dst, src, srcPos, center);</tpixel64>

	}

	//dst->copy(src,srcPos);

}

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

int BacklitFx::getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info)

{

	return TRasterFx::memorySize(rect, frame, info);

}

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

TRect BacklitFx::getInvalidRect(const TRect &max)

{

	if (!m_input.isConnected())

		return TRect();

	TRect rect = m_input->getInvalidRect(max);

	TRect ris = max;

	if (rect.x0 >= 0)

		ris.x0 = tmin(rect.x0, max.x1);

	else if (rect.x1 <= 0)

		ris.x1 = tmax(rect.x1, max.x0);

	if (rect.y0 >= 0)

		ris.y0 = tmin(rect.y0, max.y1);

	else if (rect.y1 <= 0)

		ris.y1 = tmax(rect.y1, max.y0);

	return ris;

}

//FX_PLUGIN_IDENTIFIER(BacklitFx        , "backlitFx")