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

 Iwa_TileFx based on TileFx by Digital Video

 カメラ枠を基準にマージンを加えて敷き詰めることができ、繰り返しの有無も指定できる

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

#include "stdfx.h"

#include "tfxparam.h"

#include "ttzpimagefx.h"

#include "timage_io.h"

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

class Iwa_TileFx : public TStandardRasterFx

{

	FX_PLUGIN_DECLARATION(Iwa_TileFx)

	enum tileQuantity {

		eNoTile = 1,

		eOneTile = 2,

		eMultipleTiles = 3

	};

	enum inputSize {

		eBoundingBox = 1,

		eCameraBox = 2

	};

	TIntEnumParamP m_inputSizeMode;

	TRasterFxPort m_input;

	TIntEnumParamP m_leftQuantity;

	TIntEnumParamP m_rightQuantity;

	TIntEnumParamP m_topQuantity;

	TIntEnumParamP m_bottomQuantity;

	TBoolParamP m_xMirror;

	TBoolParamP m_yMirror;

	TDoubleParamP m_hmargin;

	TDoubleParamP m_vmargin;

public:

	Iwa_TileFx();

	~Iwa_TileFx();

	bool doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info);

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

	TRect getInvalidRect(const TRect &max) { return max; }

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

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

	void transform(

		double frame,

		int port,

		const TRectD &rectOnOutput,

		const TRenderSettings &infoOnOutput,

		TRectD &rectOnInput,

		TRenderSettings &infoOnInput);

	bool checkIfThisTileShouldBeComptedOrNot(int horizIndex, int vertIndex);

	bool isInRange(int quantityMode, int index);

private:

	void makeTile(const TTile &inputTile, const TTile &tile);

};

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

Iwa_TileFx::Iwa_TileFx()

	: m_inputSizeMode(new TIntEnumParam(eBoundingBox, "Bounding Box")), m_leftQuantity(new TIntEnumParam(eNoTile, "No Tile")), m_rightQuantity(new TIntEnumParam(eNoTile, "No Tile")), m_topQuantity(new TIntEnumParam(eNoTile, "No Tile")), m_bottomQuantity(new TIntEnumParam(eNoTile, "No Tile")), m_xMirror(false), m_yMirror(false), m_hmargin(5.24934) /*- スタンダードサイズのカメラとLevelのマージン（2.5mm）-*/

	  ,

	  m_vmargin(12.4934) /*- 5.95mm -*/

{

	addInputPort("Source", m_input);

	bindParam(this, "inputSize", m_inputSizeMode);

	m_inputSizeMode->addItem(eCameraBox, "Camera Box");

	bindParam(this, "leftQuantity", m_leftQuantity);

	m_leftQuantity->addItem(eOneTile, "1 Tile");

	m_leftQuantity->addItem(eMultipleTiles, "Mutiple Tiles");

	bindParam(this, "rightQuantity", m_rightQuantity);

	m_rightQuantity->addItem(eOneTile, "1 Tile");

	m_rightQuantity->addItem(eMultipleTiles, "Mutiple Tiles");

	bindParam(this, "xMirror", m_xMirror);

	bindParam(this, "hMargin", m_hmargin);

	m_hmargin->setMeasureName("fxLength");

	bindParam(this, "topQuantity", m_topQuantity);

	m_topQuantity->addItem(eOneTile, "1 Tile");

	m_topQuantity->addItem(eMultipleTiles, "Mutiple Tiles");

	bindParam(this, "bottomQuantity", m_bottomQuantity);

	m_bottomQuantity->addItem(eOneTile, "1 Tile");

	m_bottomQuantity->addItem(eMultipleTiles, "Mutiple Tiles");

	bindParam(this, "yMirror", m_yMirror);

	bindParam(this, "vMargin", m_vmargin);

	m_vmargin->setMeasureName("fxLength");

}

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

Iwa_TileFx::~Iwa_TileFx() {}

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

bool Iwa_TileFx::canHandle(const TRenderSettings &info, double frame)

{

	//Currently, only affines which transform the X and Y axis into themselves may

	//be handled by this fx...

	return (fabs(info.m_affine.a12) < 0.0001 &&

			fabs(info.m_affine.a21) < 0.0001) ||

		   (fabs(info.m_affine.a11) < 0.0001 &&

			fabs(info.m_affine.a22) < 0.0001);

}

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

bool Iwa_TileFx::doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)

{

	if (m_input.isConnected()) {

		bBox = TConsts::infiniteRectD;

		return true;

	} else {

		bBox = TRectD();

		return false;

	}

}

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

void Iwa_TileFx::transform(

	double frame,

	int port,

	const TRectD &rectOnOutput,

	const TRenderSettings &infoOnOutput,

	TRectD &rectOnInput,

	TRenderSettings &infoOnInput)

{

	infoOnInput = infoOnOutput;

	TRectD inputBox;

	m_input->getBBox(frame, inputBox, infoOnOutput);

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

	int hmargin = m_hmargin->getValue(frame) * scale;

	int vmargin = m_vmargin->getValue(frame) * scale;

	inputBox = inputBox.enlarge(hmargin, vmargin);

	if (inputBox.isEmpty()) {

		rectOnInput.empty();

		return;

	}

	if (inputBox == TConsts::infiniteRectD) {

		infoOnInput = infoOnOutput;

		return;

	}

	TDimensionD size(0, 0);

	size.lx = tceil(inputBox.getLx());

	size.ly = tceil(inputBox.getLy());

	rectOnInput = TRectD(inputBox.getP00(), size);

}

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

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

{

	TRectD inputBox;

	m_input->getBBox(frame, inputBox, info);

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

	int hmargin = m_hmargin->getValue(frame) * scale;

	int vmargin = m_vmargin->getValue(frame) * scale;

	inputBox = inputBox.enlarge(hmargin, vmargin);

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

}

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

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

{

	if (!m_input.isConnected()) {

		tile.getRaster()->clear();

		return;

	}

	TRectD inputBox;

	int inputSizeMode = m_inputSizeMode->getValue(); //	eBoundingBox = 1, eCameraBox = 2

	if (inputSizeMode == eBoundingBox)

		m_input->getBBox(frame, inputBox, ri);

	else if (inputSizeMode == eCameraBox) {

		TPointD offset = tile.m_pos + tile.getRaster()->getCenterD();

		inputBox = TRectD(TPointD(ri.m_cameraBox.x0 + offset.x, ri.m_cameraBox.y0 + offset.y),

						  TDimensionD(ri.m_cameraBox.getLx(), ri.m_cameraBox.getLy()));

	}

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

	int hmargin = m_hmargin->getValue(frame) * scale;

	int vmargin = m_vmargin->getValue(frame) * scale;

	inputBox = inputBox.enlarge(hmargin, vmargin);

	if (inputBox.isEmpty()) {

		tile.getRaster()->clear();

		return;

	}

	if (inputBox == TConsts::infiniteRectD) {

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

		return;

	}

	TDimension size(0, 0);

	size.lx = tceil(inputBox.getLx());

	size.ly = tceil(inputBox.getLy());

	TTile inputTile;

	m_input->allocateAndCompute(inputTile, inputBox.getP00(), size, tile.getRaster(), frame, ri);

	makeTile(inputTile, tile);

}

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

bool Iwa_TileFx::isInRange(int quantityMode, int index)

{

	switch (quantityMode) {

	case eNoTile:

		return false;

		break;

	case eOneTile:

		return (abs(index) < 2);

		break;

	case eMultipleTiles:

		return true;

		break;

	default:

		return false;

		break;

	}

}

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

bool Iwa_TileFx::checkIfThisTileShouldBeComptedOrNot(int horizIndex, int vertIndex)

{

	int leftQuantity = m_leftQuantity->getValue();

	int rightQuantity = m_rightQuantity->getValue();

	int topQuantity = m_topQuantity->getValue();

	int bottomQuantity = m_bottomQuantity->getValue();

	bool horizInRange, vertInRange;

	if (horizIndex == 0)

		horizInRange = true;

	else if (horizIndex < 0)

		horizInRange = isInRange(leftQuantity, horizIndex);

	else //horizIndex > 0

		horizInRange = isInRange(rightQuantity, horizIndex);

	if (vertIndex == 0)

		vertInRange = true;

	else if (vertIndex < 0)

		vertInRange = isInRange(bottomQuantity, vertIndex);

	else //horizIndex > 0

		vertInRange = isInRange(topQuantity, vertIndex);

	return horizInRange & vertInRange;

}

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

//! Make the tile of the image contained in \b inputTile in \b tile

/*

*/

void Iwa_TileFx::makeTile(const TTile &inputTile, const TTile &tile)

{

	tile.getRaster()->clear();

	//Build the mirroring pattern. It obviously repeats itself out of 2x2 tile blocks.

	std::map<std::pair<bool, bool="">, TRasterP> mirrorRaster;</std::pair<bool,>

	mirrorRaster[std::pair<bool, bool="">(false, false)] = inputTile.getRaster();</bool,>

	mirrorRaster[std::pair<bool, bool="">(false, true)] = inputTile.getRaster()->clone();</bool,>

	mirrorRaster[std::pair<bool, bool="">(false, true)]->yMirror();</bool,>

	mirrorRaster[std::pair<bool, bool="">(true, false)] = inputTile.getRaster()->clone();</bool,>

	mirrorRaster[std::pair<bool, bool="">(true, false)]->xMirror();</bool,>

	mirrorRaster[std::pair<bool, bool="">(true, true)] = mirrorRaster[std::pair<bool, bool="">(true, false)]->clone();</bool,></bool,>

	mirrorRaster[std::pair<bool, bool="">(true, true)]->yMirror();</bool,>

	TPoint animatedPos = convert(inputTile.m_pos - tile.m_pos);

	TDimension inSize = inputTile.getRaster()->getSize();

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

	bool mirrorX = false, mirrorY = false;

	int leftQuantity = m_leftQuantity->getValue();

	int rightQuantity = m_rightQuantity->getValue();

	int topQuantity = m_topQuantity->getValue();

	int bottomQuantity = m_bottomQuantity->getValue();

	bool tileHorizontally = leftQuantity != eNoTile || rightQuantity != eNoTile;

	bool tileVertically = topQuantity != eNoTile || bottomQuantity != eNoTile;

	/*- 現在のタイルのインデックス -*/

	int horizIndex = 0;

	int vertIndex = 0;

	/*- 左下のタイルのインデックスを計算 -*/

	//Reach the lower left tiling position

	while (animatedPos.x > 0 && tileHorizontally) {

		animatedPos.x -= inSize.lx;

		mirrorX = !mirrorX;

		horizIndex--;

	}

	while (animatedPos.x + inSize.lx < 0 && tileHorizontally) {

		animatedPos.x += inSize.lx;

		mirrorX = !mirrorX;

		horizIndex++;

	}

	while (animatedPos.y > 0 && tileVertically) {

		animatedPos.y -= inSize.ly;

		mirrorY = !mirrorY;

		vertIndex--;

	}

	while (animatedPos.y + inSize.ly < 0 && tileVertically) {

		animatedPos.y += inSize.ly;

		mirrorY = !mirrorY;

		vertIndex++;

	}

	bool doMirroX = mirrorX, doMirroY = mirrorY;

	//Write the tiling blocks.

	tile.getRaster()->lock();

	inputTile.getRaster()->lock();

	TPoint startTilingPos = animatedPos;

	int horizStartIndex = horizIndex;

	do {

		do {

			if (checkIfThisTileShouldBeComptedOrNot(horizIndex, vertIndex)) {

				std::pair<bool, bool=""> doMirror(doMirroX && m_xMirror->getValue(), doMirroY && m_yMirror->getValue());</bool,>

				tile.getRaster()->copy(mirrorRaster[doMirror], startTilingPos);

			}

			startTilingPos.x += inSize.lx;

			doMirroX = !doMirroX;

			horizIndex++;

		} while (startTilingPos.x < outSize.lx && tileHorizontally);

		startTilingPos.y += inSize.ly;

		startTilingPos.x = animatedPos.x;

		doMirroY = !doMirroY;

		doMirroX = mirrorX;

		horizIndex = horizStartIndex;

		vertIndex++;

	} while (startTilingPos.y < outSize.ly && tileVertically);

	inputTile.getRaster()->unlock();

	tile.getRaster()->unlock();

}

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

FX_PLUGIN_IDENTIFIER(Iwa_TileFx, "iwa_TileFx");