#include "stdfx.h"
#include "tfxparam.h"
//#include "trop.h"
#include "tdoubleparam.h"
//#include "tnotanimatableparam.h"
#include "tpixelgr.h"
#include "trasterfx.h"
 
//-------------------------------------------------------------------
 
namespace
{
 
//==================================================================
 
enum Status {
	StatusGood = 0,
	OutOfTime = 1 << 1, //Non utilizzato
	Port0NotConnected = 1 << 2,
	Port1NotConnected = 1 << 3,
	NoPortsConnected = Port0NotConnected | Port1NotConnected
};
inline Status operator|(const Status &l, const Status &r)
{
	return Status(((int)l | (int)r));
}
inline int operator&(const Status &l)
{
	return int(l);
}
Status getFxStatus(const TRasterFxPort &port0, const TRasterFxPort &port1)
{
	Status status = StatusGood;
	if (!port0.isConnected())
		status = status | Port0NotConnected;
	if (!port1.isConnected())
		status = status | Port1NotConnected;
	return status;
}
 
/*inline*/
template <typename T, typename Q, typename P>
void doLocalTransparency(TRasterPT<T> out, TRasterPT<T> src, TRasterPT<T> ref, double transp)
{
	out->lock();
	ref->lock();
	src->lock();
 
	T *outRow = out->pixels();
	T *refRow = ref->pixels();
	T *srcRow = src->pixels();
	int outWrap = out->getWrap();
	int refWrap = ref->getWrap();
	int srcWrap = src->getWrap();
 
	T *outPix = outRow;
	T *srcPix = srcRow;
	T *refPix = refRow;
	T *lastPix = outRow + outWrap * out->getLy();
 
	const int cropVal = T::maxChannelValue;
	double factor = transp / (double)cropVal;
 
	while (outPix < lastPix) {
		T *endPix = outPix + out->getLx();
		while (outPix < endPix) {
			double local_transp = 1 - (Q::from(*refPix).value) * factor;
			if (local_transp > 0.0) {
				int val = (int)(local_transp * srcPix->r + 0.5);
				outPix->r = (P)((val < cropVal) ? val : cropVal);
				val = (int)(local_transp * srcPix->g + 0.5);
				outPix->g = (P)((val < cropVal) ? val : cropVal);
				val = (int)(local_transp * srcPix->b + 0.5);
				outPix->b = (P)((val < cropVal) ? val : cropVal);
				val = (int)(local_transp * srcPix->m + 0.5);
				outPix->m = (P)((val < cropVal) ? val : cropVal);
			} else {
				outPix->r = outPix->g = outPix->b = outPix->m = 0;
			}
			++outPix;
			++refPix;
			++srcPix;
		}
		srcRow += srcWrap;
		outRow += outWrap;
		refRow += refWrap;
		srcPix = srcRow;
		outPix = outRow;
		refPix = refRow;
	}
	out->unlock();
	ref->unlock();
	src->unlock();
}
 
//-------------------------------------------------------------------
 
inline double func(int x, int y, int lx, int ly)
{
	return ((1 + sin(3.14 * x / (0.5 * lx))) * (1 + cos(3.14 * y / (0.5 * ly))));
}
 
void drawCheckboard(TRaster32P &raster)
{
	int lx = raster->getLx();
	int ly = raster->getLy();
	//int chessSize = 4;
	int x, y;
	raster->lock();
	for (y = 0; y < ly; ++y) {
		TPixel32 *pix = raster->pixels(y);
		for (x = 0; x < lx; ++x, ++pix) {
			pix->r = pix->g = pix->b = troundp(255.0 * func(x, y, lx, ly) / func(lx - 1, ly - 1, lx, ly));
			pix->m = 255;
		}
	}
	raster->unlock();
}
};
 
//-------------------------------------------------------------------
 
class LocalTransparencyFx : public TStandardRasterFx
{
	FX_PLUGIN_DECLARATION(LocalTransparencyFx)
protected:
	TRasterFxPort m_src, m_ref;
	TDoubleParamP m_value;
 
public:
	LocalTransparencyFx()
		: m_value(100)
	{
		addInputPort("Source", m_src);
		addInputPort("Reference", m_ref);
		bindParam(this, "value", m_value);
		m_value->setValueRange(0, 100);
	}
	virtual ~LocalTransparencyFx() {}
 
	bool doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)
	{
		if (m_src.isConnected())
			return m_src->doGetBBox(frame, bBox, info);
		else {
			bBox = TRectD();
			return false;
		}
	}
 
	void doCompute(TTile &tile, double frame, const TRenderSettings &ri)
	{
		if (!checkBeforeCompute(tile, frame, ri))
			return;
		TTile srcTile;
		m_src->allocateAndCompute(srcTile, tile.m_pos, tile.getRaster()->getSize(), tile.getRaster(), frame, ri);
		//TTile refTile = tile;
		m_ref->compute(tile, frame, ri);
 
		//TRaster32P ref32 (refTile.getRaster());
		TRaster32P out32(tile.getRaster());
		TRaster32P src32(srcTile.getRaster());
		if (out32 && src32)
			doLocalTransparency<TPixelRGBM32, TPixelGR8, UCHAR>(out32, src32, out32, m_value->getValue(frame) / 100.);
		else {
			//TRaster64P ref64(refTile.getRaster());
			TRaster64P out64(tile.getRaster());
			TRaster64P src64(srcTile.getRaster());
			if (out64 && src64)
				doLocalTransparency<TPixelRGBM64, TPixelGR16, USHORT>(out64, src64, out64, m_value->getValue(frame) / 100.);
			else
				throw TException("LocalTransparencyFx: unsupported raster type");
		}
	}
 
	bool checkBeforeCompute(TTile &tile, double frame, const TRenderSettings &info)
	{
		Status status = getFxStatus(m_src, m_ref);
		if ((status & NoPortsConnected) == NoPortsConnected)
			return false;
		if ((status & OutOfTime) == OutOfTime)
			return false;
		if ((status & Port0NotConnected) == Port0NotConnected)
			return false;
		if ((status & Port1NotConnected) == Port1NotConnected) {
			m_src->compute(tile, frame, info);
			return false;
		}
		assert(status == StatusGood);
		return true;
	}
 
	bool canHandle(const TRenderSettings &info, double frame) { return true; }
 
	int getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info)
	{
		return TRasterFx::memorySize(rect, info.m_bpp);
	}
};
 
//-------------------------------------------------------------------
 
FX_PLUGIN_IDENTIFIER(LocalTransparencyFx, "localTransparencyFx")