#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>


#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>

#include <GL/glfw.h>
#include <GL/glext.h>
#include <GL/wglext.h>


int width=800;
int height=600;
int pheight=512;
int pwidth=512;

//int nb_buffers=4;
#define nb_buffers 12
#define nb_quadsperbuffer 1
int running=TRUE;
int wireframe=FALSE;
int vsync=FALSE;
int blur=TRUE;
//int fullscreen=FALSE;
int fullscreen=FALSE;
double blur_duration = 0.5; // 0.0 = pas de blur, full blur à 1.0, style cinema à 0.5

int GLOBAL_COUNTER =0;
GLuint pbuffers_tex_id;
HDC hpbufdc[nb_buffers];
HGLRC hpbufglrc[nb_buffers];

HPBUFFERARB  pbuffer[nb_buffers];


PFNWGLCREATEPBUFFERARBPROC  wglCreatePbufferARB;
PFNWGLGETPBUFFERDCARBPROC  wglGetPbufferDCARB;
PFNWGLCHOOSEPIXELFORMATARBPROC  wglChoosePixelFormatARB;
PFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB;
PFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB;
PFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB;
PFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB;
PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT;

HDC hDC;
HGLRC hRC;

double FPS_time_elapsed = 0.0;
unsigned int FPS_number_of_frames = 0;


//========================================================================
// PrintGetLastError()
//========================================================================

void PrintGetLastError(void ) {
	DWORD j ;
	LPVOID lpMsgBuf;
	j = GetLastError() ;//& 0x0000FFFF;
	FormatMessage(
		FORMAT_MESSAGE_ALLOCATE_BUFFER |
		FORMAT_MESSAGE_FROM_SYSTEM |
		FORMAT_MESSAGE_IGNORE_INSERTS ,
		NULL,
		j,
		MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
		(LPTSTR) &lpMsgBuf,
		0,
		NULL);
	printf("yop : %s",lpMsgBuf);
}


//========================================================================
// Resize() - GLFW window resize callback function
//========================================================================

void Resize( int x, int y )
{
	width = x;
	height = y > 0 ? y : 1;   // Prevent division by zero in aspect calc.
		// Setup viewport
	glViewport( 0, 0, width,height );

}


//========================================================================
// Input cllback functions
//========================================================================

void KeyFun( int key, int action )
{
	if( action == GLFW_PRESS )
	{
		switch( key )
		{
		case GLFW_KEY_ESC:
			running = FALSE;
			break;
		case 'W':
			wireframe = !wireframe;
			glPolygonMode( GL_FRONT_AND_BACK, wireframe ? GL_LINE : GL_FILL );
			break;
		case 'V':
			vsync = !vsync;
			(vsync) ? glfwSwapInterval( 1 ) : glfwSwapInterval( 0 );
			glFinish();
			break;
		case 'B':
			blur = !blur;
			(blur) ? glEnable(GL_BLEND): glDisable(GL_BLEND);
			break;
		default:
			break;
		}
	}
}



void initGL(void) {
	int i;

	// Initialize GLFW
	glfwInit();

	// Open OpenGL fullscreen window
	if (fullscreen) {
	    if( !glfwOpenWindow( width, height, 8,8,8,8, 24,8, GLFW_FULLSCREEN ) )
			{
				glfwTerminate();
				exit( 0 );
			}
	} else {
		if( !glfwOpenWindow( width, height, 8,8,8,8, 24,8, GLFW_WINDOW ) )
			{
				glfwTerminate();
				exit( 0 );
			}
	}

	// Set window title
	glfwSetWindowTitle( "True Motion Blur" );
	// Disable VSync (we want to get as high FPS as possible!)
	// well, it depends...
	if (vsync)
		glfwSwapInterval( 1 );
	else glfwSwapInterval( 0 );

//	wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) glfwGetProcAddress("wglSwapIntervalEXT");
//	if (wglSwapIntervalEXT == NULL) exit(-3);
//	wglSwapIntervalEXT(1);

	// Window resize callback function
	glfwSetWindowSizeCallback( Resize );
	// Set keyboard input callback function
	glfwSetKeyCallback( KeyFun );

	// sometimes extensions are present but not advertised so the line below is disabled
	// if (glfwExtensionSupported("WGL_ARB_pbuffer")==GL_TRUE) {} else exit(-2);

	// init des pointeurs de fonction des extensions GL 1.4 ou 1.5

	wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC) wglGetProcAddress( "wglCreatePbufferARB" );
	if (wglCreatePbufferARB == NULL) exit(-3);

	wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC) wglGetProcAddress( "wglGetPbufferDCARB" );
	if (wglGetPbufferDCARB == NULL) exit(-3);

	wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC) wglGetProcAddress( "wglChoosePixelFormatARB" );
	if (wglChoosePixelFormatARB == NULL) exit(-3);

	wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC) wglGetProcAddress( "wglBindTexImageARB" );
	if (wglBindTexImageARB == NULL) exit(-3);

	wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC) wglGetProcAddress( "wglReleaseTexImageARB" );
	if (wglReleaseTexImageARB == NULL) exit(-3);

	wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC) wglGetProcAddress( "wglReleasePbufferDCARB" );
	if (wglReleasePbufferDCARB == NULL) exit(-3);

	wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC) wglGetProcAddress( "wglDestroyPbufferARB" );
	if (wglDestroyPbufferARB == NULL) exit(-3);


		hDC = wglGetCurrentDC();
	hRC = wglGetCurrentContext();

	UINT nbformats=0;
	const int hdcAttributes [30]={
		WGL_SUPPORT_OPENGL_ARB, TRUE, // pbuffer will be used with gl
		WGL_BIND_TO_TEXTURE_RGB_ARB ,TRUE,
 		WGL_DRAW_TO_PBUFFER_ARB ,TRUE,
//		WGL_DRAW_TO_WINDOW_ARB ,TRUE,
		WGL_COLOR_BITS_ARB	,	24,
//		WGL_ALPHA_BITS_ARB	,	8,
		WGL_DEPTH_BITS_ARB	,24,
//		WGL_STENCIL_BITS_ARB	,8,
		WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
		0 			};
	int *pixelformats=(int*)calloc(256,4);

	wglChoosePixelFormatARB(hDC, hdcAttributes,
		NULL,
		256,
		pixelformats,
		&nbformats
		    );
	printf("nbformats:%d\n",nbformats);

	const int pbufferAttributes [50] = {
//		WGL_TEXTURE_FORMAT_ARB,WGL_TEXTURE_RGBA_ARB,
		WGL_TEXTURE_FORMAT_ARB,WGL_TEXTURE_RGB_ARB, // use it only for RenderToTexture, not ctsi
		WGL_TEXTURE_TARGET_ARB,WGL_TEXTURE_2D_ARB , // use it only for RenderToTexture, not ctsi
//		WGL_MIPMAP_TEXTURE_ARB,TRUE, // to have nice and fast mipmaps
		0
	};

	for (i=0;i<nb_buffers;i++) {
		pbuffer[i] = wglCreatePbufferARB(hDC,
			pixelformats[0],
			pwidth,
			pheight,
			pbufferAttributes);

		hpbufdc[i] = wglGetPbufferDCARB( pbuffer[i] );
		hpbufglrc[i] = wglCreateContext( hpbufdc[i]);

		if (pbuffer[i]==NULL) exit(-3);
		if (glGetError()!=GL_NO_ERROR) exit(-3);

		printf("pbuffer:%d = %p\n",i,pbuffer[i]);

		wglMakeCurrent(
			hpbufdc[i],	// device context of device that OpenGL calls are to be drawn on
			hpbufglrc[i] 	// OpenGL rendering context to be made the calling thread's current rendering context
		);
		glEnable(GL_DEPTH_TEST );
		glDisable(GL_POLYGON_STIPPLE );
		// Setup projection
		glMatrixMode( GL_PROJECTION );
		glLoadIdentity();
		//
		gluPerspective( 45.0, (double)pwidth/(double)pheight, 1.0, 100.0 );
		glTranslatef( 0.0f,0.0f,-10.0f);
		glMatrixMode( GL_MODELVIEW );
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
		glDisable(GL_BLEND);
	}

	wglMakeCurrent(
		hDC,	// device context of device that OpenGL calls are to be drawn on
		hRC 	// OpenGL rendering context to be made the calling thread's current rendering context
	);

		glGenTextures( 1, &(pbuffers_tex_id) );
		glBindTexture( GL_TEXTURE_2D, pbuffers_tex_id );
		glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );

		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0 ); // pas d'anisotropic

// high quality parameters ::
////////// do not forget to set earlier :
//////////		WGL_MIPMAP_TEXTURE_ARB,TRUE, // to have mipmaps
/*		float aniso_level;
		glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,&aniso_level);
		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
		glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
		glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE );
		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, aniso_level );
*/

		// Setup viewport
	glViewport( 0, 0, width, height);

	// Clear color and Z-buffer
	glDisable( GL_BLEND );
	glEnable( GL_DEPTH_TEST );
	glEnable( GL_TEXTURE_2D );
	glDisable( GL_LIGHTING );
	glDisable( GL_CULL_FACE );

	glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

	// Setup projection
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();
	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();
	glfwEnable( GLFW_STICKY_KEYS );
	glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );

	glFrontFace( GL_CW );
	glCullFace( GL_BACK );
	glEnable( GL_CULL_FACE );

	glClearColor(0.0f,0.0f,0.0f,1.0f);
	glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);

	glEnable(GL_BLEND);
	glBlendFunc( GL_SRC_ALPHA,GL_ONE);
//	glBlendFunc( GL_ONE,GL_ONE );
	glColor4f(1.0f,1.0f,1.0f,1.0/(nb_buffers*nb_quadsperbuffer)); // to blend the pbuffers

	glDisable(GL_DEPTH_TEST );
}


void DrawSquare(void) {
	glBegin(GL_QUADS);

		glTexCoord2f( 0.0f,0.0f );
		glVertex2f( -1.0f,-1.0f );

		glTexCoord2f( 0.0f, 1.0f  );
		glVertex2f( -1.0f, 1.0f  );

		glTexCoord2f(  1.0f, 1.0f );
		glVertex2f(  1.0f, 1.0f );

		glTexCoord2f(  1.0f,0.0f );
		glVertex2f(  1.0f,-1.0f );

	glEnd();
}

//========================================================================
// Draw() - Main rendering function
//========================================================================

void Draw( double time, double dt ) // time = old_time + dt !!
{
	double angle_z;

	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	angle_z = -500.0 * time;

	glPushMatrix();
		// Rotate camera
	//	glRotated( -angle_x, 1.0, 0.0, 0.0 );
	//	glRotated( -angle_y, 0.0, 1.0, 0.0 );
		glRotated( -angle_z, 0.0, 0.0, 1.0 );
		glColor4f(0.5f,0.0f,1.0f,1.0f);
		glTranslatef(100.0f,0.0f,0.0f);
		glScalef(100.0f,100.0f,1.0f);
		glTranslatef(0.0f,0.0f,-10.0f);
		DrawSquare();/////////// le VIOLET
	glPopMatrix();
	glPushMatrix();
		glColor4f(1.0f,1.0f,1.0f,1.0f);
//
		glRotated( -angle_z+90.0, 0.0, 0.0, 1.0 );
		glTranslatef(0.0f,3.5f,0.0f);
//		glRotated( angle_z, 0.0, 0.0, 1.0 );
		glScalef(0.1f,3.0f,0.01f);
		DrawSquare(); /////////// le BLANC
	glPopMatrix();
	glPushMatrix();
		// Rotate camera
		angle_z = 180.0 * time;
	//	glRotated( -angle_x, 1.0, 0.0, 0.0 );
	//	glRotated( -angle_y, 0.0, 1.0, 0.0 );
		glRotated( -angle_z, 0.0, 0.0, 1.0 );
		glColor4f(1.0f,0.0f,0.0f,1.0f);
		DrawSquare(); /////////// le ROUGE
	glPopMatrix();
	glPushMatrix();
		glColor4f(1.0f,1.0f,1.0f,1.0f);
		glScalef(0.1f,0.10f,0.1f);
		glTranslatef(0.0f,0.0f,5.0f);
		DrawSquare(); /////////// le petit BLANC
	glPopMatrix();
}

void DrawEmpty(int last) {
	wglBindTexImageARB ( pbuffer[last],WGL_FRONT_LEFT_ARB );
	DrawSquare();
	wglReleaseTexImageARB ( pbuffer[last], WGL_FRONT_LEFT_ARB );
}



//========================================================================
// main()
//========================================================================

int main( int argc, char **argv )
{
	int i,cpb=0;
	double t=0;

	initGL();

	t = glfwGetTime();
	glfwSwapBuffers();

	i = 0;
	cpb=0;

	// Main loop
	double old_time=0.0;
	double time=0.0;
	double  dt=0.0;
	double sub_dt=0.0;
	int xpos=0,ypos=0; //mouse absolute position
	int lastxpos=0,lastypos=0; //mouse previous position

	double dxpos=0.0,dypos=0.0; //mouse subrelative position

	glfwGetMousePos(&xpos,&ypos);
		lastxpos=xpos;
		lastypos=ypos;

	while( running )	{
		// Get frame time
		time = glfwGetTime();
		dt = time-old_time;
		sub_dt = (blur_duration*dt)/nb_buffers;//
		old_time = time;

		FPS_time_elapsed+=dt;
		FPS_number_of_frames++;

		////////////////////////
		if (blur) {
			for (i=0;i<nb_buffers;i++) {
				wglMakeCurrent(
					hpbufdc[i],	// device context of device that OpenGL calls are to be drawn on
					hpbufglrc[i] //hpbufglrc[cpb] 	// OpenGL rendering context to be made the calling thread's current rendering context
					);
				time+= sub_dt;
	//			wglReleaseTexImageARB ( pbuffer[i], WGL_FRONT_LEFT_ARB );
				Draw(time,sub_dt);
			}
		} else {
			wglMakeCurrent(
				hpbufdc[0],	// device context of device that OpenGL calls are to be drawn on
				hpbufglrc[0] //hpbufglrc[cpb] 	// OpenGL rendering context to be made the calling thread's current rendering context
				);
			time+= sub_dt;
//			wglReleaseTexImageARB ( pbuffer[i], WGL_FRONT_LEFT_ARB );
			Draw(time,sub_dt);
		}

		// on screen drawing
		wglMakeCurrent(
			hDC,	// device context of device that OpenGL calls are to be drawn on
			hRC 	// OpenGL rendering context to be made the calling thread's current rendering context
		);
		glClear( GL_COLOR_BUFFER_BIT);

		lastxpos=xpos;
		lastypos=ypos;

		glfwGetMousePos(&xpos,&ypos);
//		dxpos = (2.0*(xpos - lastxpos))/(width *nb_buffers);
//		dypos = (-2.0*(ypos - lastypos))/(height*nb_buffers);
		if (glfwGetMouseButton(GLFW_MOUSE_BUTTON_LEFT)==GLFW_PRESS) {
			dxpos = (blur_duration*2.0*(xpos - lastxpos))/(width *nb_buffers);
			dypos = (blur_duration*-2.0*(ypos - lastypos))/(height*nb_buffers);

//			dxpos_unseen = ((1.0-blur_duration)*2.0*(xpos - lastxpos))/(width *nb_buffers);
//			dypos_unseen = ((1.0-blur_duration)*-2.0*(ypos - lastypos))/(height*nb_buffers);
		} else {
			dxpos = 0.0;
			dypos = 0.0;
		}

//			dxpos = 0.015*sin((time)*3.0);
//			dypos = 0.015*cos((time)*3.0);
		int j;
		if (blur) {
			for (i=0;i<nb_buffers;i++) {
				for (j=0;j<nb_quadsperbuffer;j++) {
					glTranslated( dxpos/nb_quadsperbuffer, dypos/nb_quadsperbuffer,0.0);
					DrawEmpty(i);
				}
			}

			glTranslated( dxpos*nb_buffers, dypos*nb_buffers,0.0);

		} else {
			glTranslated( dxpos*2.0*nb_buffers, dypos*2.0*nb_buffers,0.0);
			DrawEmpty(0);
		}

		glfwSwapBuffers();
		if (FPS_time_elapsed >=1.0) {

			printf("FPS:%6.2f\n",FPS_number_of_frames/FPS_time_elapsed);
			FPS_time_elapsed=0.0;
			FPS_number_of_frames=0;

		}

		// Check if window was closed
		running = running && glfwGetWindowParam( GLFW_OPENED );
	}

	for (i=0;i<nb_buffers;i++) {
		wglDeleteContext( hpbufglrc );
		wglReleasePbufferDCARB( pbuffer, hpbufdc );
		wglDestroyPbufferARB( pbuffer );
	}
	// Terminate OpenGL
	glfwTerminate();
	return 0;
}