/* 
genetic wavegenerator, pd external
dna(at)basilar(dot)net
2006
*/

#include <flext.h>

#if !defined(FLEXT_VERSION) || (FLEXT_VERSION < 400)
#error you need at least flext version 0.4.0
#endif

class point {
public:
	float x;
	float y;
};

point* qb(const point* point1, const point* point2, const point* point3, const float t) {
	float x0 = point1->x; 
	float y0 = point1->y;
	float x1 = point2->x;
	float y1 = point2->y;
	float x2 = point3->x;
	float y2 = point3->y;

	float cx = 2*(x1-x0);
	float bx = (x2-x0)-cx;
	float cy = 2*(y1-y0);
	float by = (y2-y0)-cy;
	float tSquared = t*t;

	float x = bx * tSquared + cx*t + x0;
	float y = by * tSquared + cy*t + y0;

	if(1<y) y = 1;
	else if(y<-1) y = -1;

	point *p = new point();
	p->x = x;
	p->y = y;

	return p;
}

const int no_of_guide_points = 30;
point* guide_points[no_of_guide_points];

void cb(const point* start_point,const point* control_point,const point* end_point) {
	float dt = 1/((float)(no_of_guide_points-1));
	for(int i=0; i<no_of_guide_points; i++) {
		point* p = qb(start_point,control_point,end_point,((float)i)*dt);
		guide_points[i] = p;
	}
}

const int max_points = 512;
float final_points[max_points];

void ib(const int length, const float start_pos, const float control_pos, const float end_pos) {
	const int len = length-1; // easy bugfix
	point* ps = new point();
	ps->x = 0;
	ps->y = start_pos;
	point* pc = new point();
	pc->x = ((float)len)/2;
	pc->y = control_pos;
	point* ep = new point();
	ep->x = ((float)len);
	ep->y = end_pos;
	cb(ps,pc,ep);

	point* p = guide_points[0];
	float x = p->x;
	float y = p->y;
	int prev_idx = 0;
	float prev_x = x;
	float prev_y = y;
	final_points[0] = start_pos;

	for(int i=2; i<no_of_guide_points;i++) {
		float curr_x = guide_points[i]->x;
		float curr_y = guide_points[i]->y;
		int i_prevx = (int)prev_x;
		int i_currx = (int)curr_x;

		for(int j=i_prevx; j<i_currx+1; j++) {
			float fi = (float)(j-i_prevx);
			float h = curr_y-prev_y;
			float l = curr_x-prev_x;
			float dx = 0;
			if (0 != i_currx-i_prevx)
				dx = l/((float)(i_currx-i_prevx));
			float dy = 0;
			if (0 != l)
				dy = (h/l)*dx;

			float fl_x = prev_x+(fi*dx);
			float fl_y = prev_y+(fi*dy);
			int rs_x = i_prevx+((int)fi);
			if(!((0==i_prevx)&&(0==i_currx))) {
				if(!(prev_idx==rs_x)) {
					final_points[rs_x] = fl_y;
					prev_idx = rs_x;
				}
			}
		}
		prev_x = curr_x;
		prev_y = curr_y;
	}
}


// PD
class genwav:public flext_base
{
	FLEXT_HEADER(genwav,flext_base)

public:
	// constructor
	genwav();

protected:
	void m_setlength_and_process(int f);
	void m_setstart(float f);
	void m_setcontrol(float f);
	void m_setend(float f);

	int _length;
	float _start;
	float _control;
	float _end;

private:
	FLEXT_CALLBACK_I(m_setlength_and_process)  // length and kick off calculation
	FLEXT_CALLBACK_F(m_setstart) // start
	FLEXT_CALLBACK_F(m_setcontrol) // control
	FLEXT_CALLBACK_F(m_setend) // end
};

// instantiate the class
FLEXT_NEW("genwav",genwav)

genwav::genwav()
{ 
	// define inlets:
	// first inlet must always by of type anything (or signal for dsp objects)
	AddInAnything();  // length
	AddInFloat(); // start
	AddInFloat(); // control
	AddInFloat(); // end

	// define outlets:
	AddOutFloat();  // add one float outlet (has index 0)

	// register methods
	FLEXT_ADDMETHOD(0,m_setlength_and_process);
	FLEXT_ADDMETHOD(1,m_setstart);
	FLEXT_ADDMETHOD(2,m_setcontrol);
	FLEXT_ADDMETHOD(3,m_setend);
} 
void genwav::m_setlength_and_process(int length)
{
	_length = length;

	if(length <= 0) {
		post("%s - ERROR: length should be larger than zero...",thisName());
	} else {
		ib(_length,_start,_control,_end);
		for(int i=0;i<_length;i++)
			ToOutFloat(0,final_points[i]);
	}
}
void genwav::m_setstart(float start) {
	_start = start;
}
void genwav::m_setcontrol(float control) {
	_control = control;
}
void genwav::m_setend(float end) {
	_end = end;
}