// TnzCore includes

#include "tcolorfunctions.h"

#include "trandom.h"

#include "tflash.h"

#include "tcurves.h"

#include "tvectorrenderdata.h"

#include "tmathutil.h"

#include "colorfxutils.h"

#include "tpixelutils.h"

// tcg includes

#include "tcg/tcg_misc.h"

// Qt includes

#include <qcoreapplication></qcoreapplication>

#include <qstringlist></qstringlist>

#include "strokestyles.h"

using namespace std;

#define MINTHICK 1.0

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

namespace

{

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

class TOptimizedStrokePropT : public TStrokeProp

{

protected:

	double m_pixelSize;

	TOptimizedStrokeStyleT<t> *m_colorStyle;</t>

	T m_data;

public:

	TOptimizedStrokePropT(const TStroke *stroke, TOptimizedStrokeStyleT<t> *style);</t>

	~TOptimizedStrokePropT() { m_colorStyle->release(); }

	const TColorStyle *getColorStyle() const;

	TStrokeProp *clone(const TStroke *stroke) const;

	void draw(const TVectorRenderData &rd);

	void draw(TFlash &flash)

	{

		getColorStyle()->drawStroke(flash, getStroke());

	}

};

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

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

TOptimizedStrokePropT<t>::TOptimizedStrokePropT(const TStroke *stroke, TOptimizedStrokeStyleT<t> *style)</t></t>

	: TStrokeProp(stroke), m_colorStyle(style), m_pixelSize(0)

{

	m_styleVersionNumber = style->getVersionNumber();

	m_colorStyle->addRef();

}

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

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

const TColorStyle *TOptimizedStrokePropT<t>::getColorStyle() const</t>

{

	return m_colorStyle;

}

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

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

TStrokeProp *TOptimizedStrokePropT<t>::clone(const TStroke *stroke) const</t>

{

	TOptimizedStrokePropT<t> *prop = new TOptimizedStrokePropT<t>(stroke, m_colorStyle);</t></t>

	prop->m_strokeChanged = m_strokeChanged;

	prop->m_data = m_data;

	return prop;

}

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

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

void TOptimizedStrokePropT<t>::draw(const TVectorRenderData &rd) /*assenza di const non e' una dimenticanza! Alcune sottoclassi devono ridefinire questo metodo e serbve che non sia const*/</t>

{

	if (rd.m_clippingRect != TRect() && !rd.m_is3dView && !convert(rd.m_aff * m_stroke->getBBox()).overlaps(rd.m_clippingRect))

		return;

	glPushMatrix();

	tglMultMatrix(rd.m_aff);

	double pixelSize = sqrt(tglGetPixelSize2());

	if (m_strokeChanged ||

		m_styleVersionNumber != m_colorStyle->getVersionNumber() ||

		!isAlmostZero(pixelSize - m_pixelSize, 1e-5)) {

		m_strokeChanged = false;

		m_pixelSize = pixelSize;

		m_styleVersionNumber = m_colorStyle->getVersionNumber();

		m_colorStyle->computeData(m_data, m_stroke, rd.m_cf);

	}

	m_colorStyle->drawStroke(rd.m_cf, m_data, m_stroke);

	glPopMatrix();

}

}

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

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

TStrokeProp *TOptimizedStrokeStyleT<t>::makeStrokeProp(const TStroke *stroke)</t>

{

	return new TOptimizedStrokePropT<t>(stroke, this);</t>

}

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

inline void tglNormal(const T3DPointD &p)

{

	glNormal3d(p.x, p.y, p.z);

}

inline void tglVertex(const T3DPointD &p)

{

	glVertex3d(p.x, p.y, p.z);

}

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

TFurStrokeStyle::TFurStrokeStyle()

	: m_color(TPixel32::Black), m_angle(120.0), m_length(1.0), m_cs(0.0), m_sn(0.0)

{

	double rad = m_angle * M_PI_180;

	m_cs = cos(rad);

	m_sn = sin(rad);

}

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

TColorStyle *TFurStrokeStyle::clone() const

{

	return new TFurStrokeStyle(*this);

}

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

int TFurStrokeStyle::getParamCount() const

{

	return 2;

}

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

TColorStyle::ParamType TFurStrokeStyle::getParamType(int index) const

{

	assert(0 <= index && index < getParamCount());

	return TColorStyle::DOUBLE;

}

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

QString TFurStrokeStyle::getParamNames(int index) const

{

	assert(0 <= index && index < getParamCount());

	return index == 0 ? QCoreApplication::translate("TFurStrokeStyle", "Angle") : QCoreApplication::translate("TFurStrokeStyle", "Size");

}

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

void TFurStrokeStyle::getParamRange(int index, double &min, double &max) const

{

	assert(0 <= index && index < getParamCount());

	if (index == 0) {

		min = 0.0;

		max = 180.0;

	} else {

		min = 0.0;

		max = 1.0;

	}

}

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

double TFurStrokeStyle::getParamValue(TColorStyle::double_tag, int index) const

{

	assert(0 <= index && index < getParamCount());

	return index == 0 ? m_angle : m_length;

}

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

void TFurStrokeStyle::setParamValue(int index, double value)

{

	assert(0 <= index && index < getParamCount());

	if (index == 0) {

		m_angle = value;

		double rad = m_angle * M_PI_180;

		m_cs = cos(rad);

		m_sn = sin(rad);

	} else

		m_length = value;

	updateVersionNumber();

}

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

void TFurStrokeStyle::drawStroke(TFlash &flash, const TStroke *stroke) const

{

	//TStroke *stroke = getStroke();

	double length = stroke->getLength();

	double s = 0.0;

	double ds = 4;

	double vs = 1;

	TRandom rnd;

	flash.setLineColor(m_color);

	vector<tsegment> segmentsArray;</tsegment>

	while (s <= length) {

		double w = stroke->getParameterAtLength(s);

		TThickPoint pos = stroke->getThickPoint(w);

		TPointD pos1 = (TPointD)pos;

		TPointD u = stroke->getSpeed(w);

		if (norm2(u) == 0.0) {

			s += 0.5;

			continue;

		}

		u = normalize(u);

		TPointD v = rotate90(u);

		double length = m_length * pos.thick;

		vs = -vs;

		double q = 0.01 * (rnd.getFloat() * 2 - 1);

		segmentsArray.push_back(TSegment(pos1, pos1 + length * ((m_cs + q) * u + (vs * m_sn) * v)));

		s += ds;

	}

	flash.drawSegments(segmentsArray, true);

}

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

void TFurStrokeStyle::computeData(Points &positions,

								  const TStroke *stroke,

								  const TColorFunction *cf) const

{

	double length = stroke->getLength();

	double s = 0.0;

	double ds = 4;

	double vs = 1;

	TRandom rnd;

	positions.clear();

	positions.reserve(tceil(length / ds) + 1);

	while (s <= length) {

		double w = stroke->getParameterAtLength(s);

		TThickPoint pos = stroke->getThickPoint(w);

		TPointD u = stroke->getSpeed(w);

		if (norm2(u) == 0.0) {

			s += 0.5;

			continue;

		}

		u = normalize(u);

		TPointD v = rotate90(u);

		double length = 0;

		if (pos.thick)

			length = m_length * pos.thick;

		else

			length = 1.0;

		vs = -vs;

		positions.push_back(pos);

		double q = 0.01 * (rnd.getFloat() * 2 - 1);

		positions.push_back(pos + length * ((m_cs + q) * u + (vs * m_sn) * v));

		s += ds;

	}

}

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

void TFurStrokeStyle::drawStroke(const TColorFunction *cf, Points &positions, const TStroke *stroke) const

{

	TPixel32 color;

	if (cf)

		color = (*(cf))(m_color);

	else

		color = m_color;

	tglColor(color);

	for (UINT i = 0; i < positions.size(); i += 2) {

		glBegin(GL_LINE_STRIP);

		tglColor(color);

		tglVertex(positions[i]);

		glColor4d(1, 1, 1, 0.0);

		tglVertex(positions[i + 1]);

		glEnd();

	}

}

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

TChainStrokeStyle::TChainStrokeStyle(const TPixel32 &color)

	: m_color(color)

{

}

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

TChainStrokeStyle::TChainStrokeStyle()

	: m_color(TPixel32(20, 10, 0))

{

}

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

TColorStyle *TChainStrokeStyle::clone() const

{

	return new TChainStrokeStyle(*this);

}

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

void TChainStrokeStyle::computeData(Points &data, const TStroke *stroke, const TColorFunction *cf) const

{

	//TStroke *stroke = getStroke();

	double length = stroke->getLength();

	// spessore della catena = spessore "medio" dello stroke

	double thickness = 0.25 * (stroke->getThickPoint(0).thick +

							   stroke->getThickPoint(1.0 / 3.0).thick +

							   stroke->getThickPoint(2.0 / 3.0).thick +

							   stroke->getThickPoint(1).thick);

	if (thickness == 0)

		thickness = 0.1;

	double ringHeight = thickness;

	double ringWidth = 1.5 * ringHeight;

	// distanza fra i centri degli anelli

	double ringDistance = 2 * 1.2 * ringWidth;

	// distanza fra il centro dell'anello e il punto di attacco dell'anello trasversale

	//double joinPos = 0.45 * ringWidth;

	TPointD oldPos;

	//bool firstRing = true;

	double s = 0;

	data.clear();

	data.reserve(tceil(length / ringDistance) * 2 + 2);

	while (s <= length) {

		double w = stroke->getParameterAtLength(s);

		//if(w<0) {s+=0.1; continue;} // per tamponare il baco della getParameterAtLength()

		TThickPoint pos = stroke->getThickPoint(w);

		TPointD u = stroke->getSpeed(w);

		if (norm2(u) == 0) {

			s += 0.1;

			continue;

		} // non dovrebbe succedere mai, ma per prudenza....

		u = normalize(u);

		data.push_back(pos);

		data.push_back(u);

		// se e' il caso unisco la catena alla precedente

		s += ringDistance;

	}

}

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

void TChainStrokeStyle::drawStroke(const TColorFunction *cf, Points &data, const TStroke *stroke) const

{

	//TStroke *stroke = getStroke();

	//double length = stroke->getLength();

	// spessore della catena = spessore "medio" dello stroke

	double thickness = 0.25 * (stroke->getThickPoint(0).thick +

							   stroke->getThickPoint(1.0 / 3.0).thick +

							   stroke->getThickPoint(2.0 / 3.0).thick +

							   stroke->getThickPoint(1).thick);

	if (thickness * thickness < 4 * tglGetPixelSize2()) {

		TCenterLineStrokeStyle *appStyle = new TCenterLineStrokeStyle(m_color, 0x0, thickness);

		appStyle->drawStroke(cf, stroke);

		delete appStyle;

		return;

	}

	assert(thickness);

	double ringHeight = thickness;

	double ringWidth = 1.5 * ringHeight;

	// distanza fra i centri degli anelli

	//double ringDistance = 2 * 1.2 * ringWidth;

	// distanza fra il centro dell'anello e il punto di attacco dell'anello trasversale

	double joinPos = 0.45 * ringWidth;

	// definisco la forma dell'anello della catena

	GLuint ringId;

	ringId = glGenLists(1);

	double a = .6, b = .6;

	glNewList(ringId, GL_COMPILE);

	glPushMatrix();

	glScaled(ringWidth, ringHeight, 1);

	glBegin(GL_LINE_STRIP);

	glVertex2d(1, b);

	glVertex2d(a, 1);

	glVertex2d(-a, 1);

	glVertex2d(-1, b);

	glVertex2d(-1, -b);

	glVertex2d(-a, -1);

	glVertex2d(a, -1);

	glVertex2d(1, -b);

	glVertex2d(1, b);

	glEnd();

	glPopMatrix();

	glEndList();

	// disegno la catena

	if (cf)

		tglColor((*cf)(m_color));

	else

		tglColor(m_color);

	TPointD oldPos;

	//bool firstRing = true;

	//double s = 0;

	for (UINT i = 0; i < data.size(); i += 2) {

		TPointD pos = data[i];

		TPointD u = data[i + 1];

		TPointD v = rotate90(u);

		// disegno un anello della catena

		glPushMatrix();

		TAffine aff(u.x, v.x, pos.x, u.y, v.y, pos.y);

		tglMultMatrix(aff);

		glCallList(ringId);

		glPopMatrix();

		// se e' il caso unisco la catena alla precedente

		if (i != 0) {

			TPointD q = pos - u * joinPos;

			tglDrawSegment(oldPos, q);

		}

		oldPos = pos + u * joinPos;

	}

	glDeleteLists(ringId, 1);

}

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

void TChainStrokeStyle::drawStroke(TFlash &flash, const TStroke *stroke) const

{

	//TStroke *stroke = getStroke();

	double length = stroke->getLength();

	// spessore della catena = spessore "medio" dello stroke

	double thickness = 0.25 * (stroke->getThickPoint(0).thick +

							   stroke->getThickPoint(1.0 / 3.0).thick +

							   stroke->getThickPoint(2.0 / 3.0).thick +

							   stroke->getThickPoint(1).thick);

	if (thickness < 2) {

		TCenterLineStrokeStyle *appStyle = new TCenterLineStrokeStyle(m_color, 0x0, thickness);

		appStyle->drawStroke(flash, stroke);

		delete appStyle;

		return;

	}

	assert(thickness);

	double ringHeight = thickness;

	double ringWidth = 1.5 * ringHeight;

	double ringDistance = 2 * 1.2 * ringWidth;

	double joinPos = 0.45 * ringWidth;

	//const int ringId = 124;

	double a = .6, b = .6;

	TScale scaleM(ringWidth, ringHeight);

	vector<tpointd> chain;</tpointd>

	chain.push_back(scaleM * TPointD(1, b));   //0

	chain.push_back(scaleM * TPointD(a, 1));   //1

	chain.push_back(scaleM * TPointD(-a, 1));  //2

	chain.push_back(scaleM * TPointD(-1, b));  //3

	chain.push_back(scaleM * TPointD(-1, -b)); //4

	chain.push_back(scaleM * TPointD(-a, -1)); //5

	chain.push_back(scaleM * TPointD(a, -1));  //6

	chain.push_back(scaleM * TPointD(1, -b));  //7

	chain.push_back(scaleM * TPointD(1, b));   //8

	/*  

  chain.push_back( TPointD(1, b));	//0

  chain.push_back( TPointD( a, 1));	//1

  chain.push_back( TPointD(-a, 1));	//2

  chain.push_back( TPointD(-1, b));	//3

  chain.push_back( TPointD(-1,-b));	//4

  chain.push_back( TPointD(-a,-1));	//5

  chain.push_back( TPointD( a,-1));	//6

  chain.push_back( TPointD( 1,-b));	//7

  chain.push_back( TPointD(1, b));	//8

*/

	vector<tsegment> chainS;</tsegment>

	chainS.push_back(TSegment(chain[0], chain[1]));

	chainS.push_back(TSegment(chain[1], chain[2]));

	chainS.push_back(TSegment(chain[2], chain[3]));

	chainS.push_back(TSegment(chain[3], chain[4]));

	chainS.push_back(TSegment(chain[4], chain[5]));

	chainS.push_back(TSegment(chain[5], chain[6]));

	chainS.push_back(TSegment(chain[6], chain[7]));

	chainS.push_back(TSegment(chain[7], chain[0]));

	flash.setLineColor(m_color);

	TPointD oldPos;

	bool firstRing = true;

	double s = 0;

	while (s <= length) {

		double w = stroke->getParameterAtLength(s);

		//if(w<0) {s+=0.1; continue;} // per tamponare il baco della getParameterAtLength()

		TThickPoint pos = stroke->getThickPoint(w);

		TPointD u = stroke->getSpeed(w);

		if (norm2(u) == 0) {

			s += 0.1;

			continue;

		} // non dovrebbe succedere mai, ma per prudenza....

		u = normalize(u);

		//     TPointD v = rotate90(u);

		TTranslation translM(pos.x, pos.y);

		TRotation rotM(rad2degree(atan(u)));

		TAffine tM = translM * rotM;

		//	 With direct transformation

		vector<tsegment> lchainS;</tsegment>

		for (int i = 0; i < 8; i++)

			lchainS.push_back(TSegment(tM * chain[i], tM * chain[i + 1]));

		flash.drawSegments(lchainS, false);

		/*	 

// With TFlash transformations

	 flash.pushMatrix();

	 flash.multMatrix(translM);

	 flash.multMatrix(rotM);

//	 flash.multMatrix(scaleM);

     flash.drawSegments(chainS,false);

//	 if (chainId==-1) 

//		chainId=flash.drawSegments(chainS,false);

//	 else

//		 flash.drawShape(chainId);

	 flash.popMatrix();

*/

		if (!firstRing) {

			TPointD q = pos - u * joinPos;

			vector<tsegment> sv;</tsegment>

			sv.push_back(TSegment(oldPos, q));

			flash.drawSegments(sv, false);

		} else

			firstRing = false;

		oldPos = pos + u * joinPos;

		s += ringDistance;

	}

}

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

TSprayStrokeStyle::TSprayStrokeStyle()

	: m_color(TPixel32::Blue), m_blend(0.5), m_intensity(10.0), m_radius(0.3)

{

}

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

TColorStyle *TSprayStrokeStyle::clone() const

{

	return new TSprayStrokeStyle(*this);

}

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

int TSprayStrokeStyle::getParamCount() const

{

	return 3;

}

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

TColorStyle::ParamType TSprayStrokeStyle::getParamType(int index) const

{

	assert(0 <= index && index < getParamCount());

	return TColorStyle::DOUBLE;

}

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

QString TSprayStrokeStyle::getParamNames(int index) const

{

	assert(0 <= index && index < 3);

	QString value;

	switch (index) {

	case 0:

		value = QCoreApplication::translate("TSprayStrokeStyle", "Border Fade");

		break;

	case 1:

		value = QCoreApplication::translate("TSprayStrokeStyle", "Density");

		break;

	case 2:

		value = QCoreApplication::translate("TSprayStrokeStyle", "Size");

		break;

	}

	return value;

}

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

void TSprayStrokeStyle::getParamRange(int index, double &min, double &max) const

{

	assert(0 <= index && index < 3);

	switch (index) {

	case 0:

		min = 0.0;

		max = 1.0;

		break;

	case 1:

		min = 0.0;

		max = 100.0;

		break;

	case 2:

		min = 0.0;

		max = 1.0;

		break;

	}

}

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

double TSprayStrokeStyle::getParamValue(TColorStyle::double_tag, int index) const

{

	assert(0 <= index && index < 3);

	double value = 0;

	switch (index) {

	case 0:

		value = m_blend;

		break;

	case 1:

		value = m_intensity;

		break;

	case 2:

		value = m_radius;

		break;

	}

	return value;

}

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

void TSprayStrokeStyle::setParamValue(int index, double value)

{

	assert(0 <= index && index < 3);

	switch (index) {

	case 0:

		m_blend = value;

		break;

	case 1:

		m_intensity = value;

		break;

	case 2:

		m_radius = value;

		break;

	}

	updateVersionNumber();

}

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

void TSprayStrokeStyle::drawStroke(const TColorFunction *cf, const TStroke *stroke) const

{

	//  TStroke *stroke = getStroke();

	double length = stroke->getLength();

	double step = 4;

	double blend = m_blend;			//distanza che controlla da dove il gessetto comincia il fade out  (0, 1)

	double intensity = m_intensity; //quanti punti vengono disegnati ad ogni step

	double radius = m_radius;

	double decay = 1 - blend;

	bool fill = 0;

	TPointD pos1;

	TRandom rnd;

	TPixelD dcolor;

	TPixel32 color;

	if (cf)

		color = (*(cf))(m_color);

	else

		color = m_color;

	dcolor = toPixelD(color);

	double s = 0;

	double minthickness = MINTHICK * sqrt(tglGetPixelSize2());

	double thickness = 0;

	while (s <= length) {

		double w = stroke->getParameterAtLength(s);

		//if(w<0) {s+=0.1; continue;} // per tamponare il baco della getParameterAtLength()

		TThickPoint pos = stroke->getThickPoint(w);

		TPointD u = stroke->getSpeed(w);

		double normu = norm2(u);

		if (normu == 0) {

			s += 0.1;

			continue;

		} // non dovrebbe succedere mai, ma per prudenza....

		u = normalize(u);

		TPointD v = rotate90(u);

		TPointD shift;

		if (pos.thick < MINTHICK)

			thickness = minthickness;

		else

			thickness = pos.thick;

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

			double vrandnorm = (0.5 - rnd.getFloat()) * 2;

			double randomv = vrandnorm * pos.thick;

			double randomu = (0.5 - rnd.getFloat()) * step;

			shift = u * randomu + v * randomv;

			pos1 = pos + shift;

			double mod = fabs(vrandnorm);

			if (mod < decay)

				glColor4d(dcolor.r, dcolor.g, dcolor.b, rnd.getFloat() * dcolor.m);

			else

				glColor4d(dcolor.r, dcolor.g, dcolor.b, rnd.getFloat() * (1 - mod) * dcolor.m);

			if (fill)

				tglDrawDisk(pos1, radius * thickness * rnd.getFloat());

			else

				tglDrawCircle(pos1, radius * thickness * rnd.getFloat());

		}

		s += step;

	}

}

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

void TSprayStrokeStyle::drawStroke(TFlash &flash, const TStroke *stroke) const

{

	double length = stroke->getLength();

	double step = 4;

	double blend = m_blend;			//distanza che controlla da dove il gessetto comincia il fade out  (0, 1)