#include "trandom.h"
//#include "tfxparam.h"
#include "perlinnoise.h"

//using std::cout;
//using std::endl;
//-------------------------------------------------------------------

double PerlinNoise::LinearNoise(double x, double y, double t)
{

	int ix, iy, it, ix1, iy1, it1;
	double dx, dy, dt, val1, val2, val3, val4, val5, val6;

	ix = (int)x;
	iy = (int)y;
	it = (int)t;

	dx = x - ix;
	dy = y - iy;
	dt = t - it;

	ix = ix % Size;
	iy = iy % Size;
	it = it % TimeSize;

	ix1 = (ix + 1) % Size;
	iy1 = (iy + 1) % Size;
	it1 = (it + 1) % TimeSize;

	val1 = Noise[it + TimeSize * iy + TimeSize * Size * ix] +
		   dx * (Noise[it + TimeSize * iy + TimeSize * Size * ix1] -
				 Noise[it + TimeSize * iy + TimeSize * Size * ix]);
	val2 = Noise[it + TimeSize * iy1 + TimeSize * Size * ix] +
		   dx * (Noise[it + TimeSize * iy1 + TimeSize * Size * ix1] -
				 Noise[it + TimeSize * iy1 + TimeSize * Size * ix]);
	val3 = Noise[it1 + TimeSize * iy + TimeSize * Size * ix] +
		   dx * (Noise[it1 + TimeSize * iy + TimeSize * Size * ix1] -
				 Noise[it1 + TimeSize * iy + TimeSize * Size * ix]);
	val4 = Noise[it1 + TimeSize * iy1 + TimeSize * Size * ix] +
		   dx * (Noise[it1 + TimeSize * iy1 + TimeSize * Size * ix1] -
				 Noise[it1 + TimeSize * iy1 + TimeSize * Size * ix]);

	val5 = (val1 + dy * (val2 - val1));
	val6 = (val3 + dy * (val4 - val3));

	return (val5 + dt * (val6 - val5));
}

double PerlinNoise::Turbolence(double u, double v, double k, double grain)
{

	u += Offset;
	v += Offset;
	Pixel_size = 0.05;
	double t = 0.0, scale = 1.0, tscale = 0;

	u /= grain;
	v /= grain;
	k /= 10;
	while (scale > Pixel_size) {
		tscale += scale;
		t += LinearNoise(u / scale, v / scale, k / scale) * scale;
		scale /= 2.0;
	}
	return t / tscale;
}

double PerlinNoise::Turbolence(double u, double v, double k, double grain, double min, double max)
{

	u += Offset;
	v += Offset;
	Pixel_size = 0.05;
	double t = 0.0, scale = 1.0, tscale = 0;

	u /= grain;
	v /= grain;
	k /= 10;
	while (scale > Pixel_size) {
		tscale += scale;
		t += LinearNoise(u / scale, v / scale, k / scale) * scale;
		scale /= 2.0;
	}
	t = t / tscale;
	if (t < min)
		t = 0;
	else {
		if (t > max)
			t = 1;
		else
			t = (t - min) / ((max - min));
	}
	return t;
}

double PerlinNoise::Marble(double u, double v, double k, double grain)
{

	u += Offset;
	v += Offset;
	Pixel_size = 0.05;
	double t = 0.0, scale = 1.0, tscale = 0;

	u /= grain;
	v /= grain;
	k /= 10;
	while (scale > Pixel_size) {
		tscale += scale;
		t += LinearNoise(u / scale, v / scale, k / scale) * scale;
		scale /= 2.0;
	}
	t = 10 * t;
	return (t - (int)t);
}

double PerlinNoise::Marble(double u, double v, double k, double grain, double min, double max)
{

	u += Offset;
	v += Offset;
	Pixel_size = 0.05;
	double t = 0.0, scale = 1.0, tscale = 0;

	u /= grain;
	v /= grain;
	k /= 10;
	while (scale > Pixel_size) {
		tscale += scale;
		t += LinearNoise(u / scale, v / scale, k / scale) * scale;
		scale /= 2.0;
	}
	t = 10 * t;
	t = (t - (int)t);
	if (t < min)
		t = 0;
	else {
		if (t > max)
			t = 1;
		else
			t = (t - min) / ((max - min));
	}
	return t;
}

PerlinNoise::PerlinNoise()
{
	TRandom random(1);
	Noise = new float[Size * Size * TimeSize];
	for (int i = 0; i < Size; i++) {
		for (int j = 0; j < Size; j++) {
			for (int k = 0; k < TimeSize; k++) {
				float tmp = random.getFloat();
				//cout << "tmp = " << tmp << "HM = "<< HowMany<< endl;
				Noise[k + TimeSize * j + TimeSize * Size * i] = tmp;
			}
		}
	}

	//cout << "HowMany = " << HowMany <<endl;
}

int PerlinNoise::Size = 60;
int PerlinNoise::TimeSize = 20;
int PerlinNoise::Offset = 1000000;
double PerlinNoise::Pixel_size = 0.01; //il pixel size va animato da 1 (escluso)
									   //a 0.1 (consigliato) fino ad un min di 0.001

namespace
{
template <typename PIXEL>
void doCloudsT(const TRasterPT<PIXEL> &ras, const TSpectrumT<PIXEL> &spectrum,
			   TPointD &tilepos, double evolution, double size, double min, double max, int type, double scale)
{
	int j;
	TAffine aff = TScale(1 / scale);
	PerlinNoise Noise;
	ras->lock();
	if (type == PNOISE_CLOUDS) {
		for (j = 0; j < ras->getLy(); j++) {
			TPointD pos = tilepos;
			pos.y += j;
			PIXEL *pix = ras->pixels(j);
			PIXEL *endPix = pix + ras->getLx();
			while (pix < endPix) {
				TPointD posAff = aff * pos;
				double pnoise = Noise.Turbolence(posAff.x, posAff.y, evolution, size, min, max);
				pos.x += 1.0;
				*pix++ = spectrum.getPremultipliedValue(pnoise);
			}
		}
	} else {
		for (j = 0; j < ras->getLy(); j++) {
			TPointD pos = tilepos;
			pos.y += j;
			PIXEL *pix = ras->pixels(j);
			PIXEL *endPix = pix + ras->getLx();
			while (pix < endPix) {
				TPointD posAff = aff * pos;
				double pnoise = Noise.Marble(posAff.x, posAff.y, evolution, size, min, max);
				pos.x += 1.0;
				*pix++ = spectrum.getPremultipliedValue(pnoise);
			}
		}
	}
	ras->unlock();
}
}

void doClouds(
	const TRasterP &ras,
	const TSpectrumParamP colors,
	TPointD pos,
	double evolution,
	double size,
	double min,
	double max,
	int type,
	double scale,
	double frame)
{

	if ((TRaster32P)ras)
		doCloudsT<TPixel32>(
			ras,
			colors->getValue(frame),
			pos, evolution, size, min, max, type, scale);
	else if ((TRaster64P)ras)
		doCloudsT<TPixel64>(
			ras,
			colors->getValue64(frame),
			pos, evolution, size, min, max, type, scale);
	else
		throw TException("CloudsFx: unsupported Pixel Type");
}