//
// Simple Glut application that measures fill and polygon rate.

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>          /* for perror(3c) */
#include <string.h>
#include <math.h>
#include <values.h>
#include <signal.h>         /* for sigset for forked X event handler process */
//#include <getopt.h>         /* for cmdline handler */
#include <fcntl.h>
//#include <unistd.h>
#include <ctype.h>
#include <time.h>
#include <stdarg.h>

#include <sys/types.h>
#include <sys/stat.h>
//#include <sys/mman.h>
//#include <sys/wait.h>
//#include <sys/errno.h>
//#include <sys/socket.h>
//#include <sys/time.h>
//#include <sys/param.h>      /* for gethostname(2) */

//#include <netinet/in.h>
//#include <netdb.h>
//#include <arpa/inet.h>

#include <GL/glut.h>    // Header File For The GLUT Library 
#include <GL/gl.h>	// Header File For The OpenGL32 Library
#include <GL/glu.h>	// Header File For The GLu32 Library
//#include <unistd.h>     // Header File for sleeping.

//#include <Performer/pf.h>
//#include <Performer/pfutil.h>
//#include <Performer/pfui.h>
//#include <Performer/pf/pfChannel.h>
/* ASCII code for the escape key. */
#define ESCAPE 27

#define LIMIT_MIN(val, min)	if (val < (min)) val = min
#define LIMIT_MAX(val, max)	if (val > (max)) val = max

#define LIMIT_MINMAX(val, min, max)	LIMIT_MIN(val, min); LIMIT_MAX(val, max)

#define	LESSER(a, b, c)		c = a < b ? a : b
#define	GREATER(a, b, c)	c = a > b ? a : b

#define	DEBUG_MESSAGES	0
/* The number of our GLUT window */
int window; 

#define	RAD2DEG(a)	(a * 180.0 / M_PI)
#define	DEG2RAD(a) 	(a * M_PI / 180.0)


#define SCREEN_X 800
#define SCREEN_Y 800

typedef struct	_myOptions
{
	char		*fileName;

}	myOptions;

typedef struct	_mySharedData
{
	myOptions	*options;
	int			mode;
	int			done;
	char		fileName[1024];

}	mySharedData;

mySharedData		*shared;
//pfuXFont 			smallfont;

static	double 	myTimeStamp ( void );

void	print_file ( char *format, ... )
{
	va_list	ap;
	char	message[1024];

	va_start ( ap, format );
	vsprintf ( message, format, ap );
	va_end ( ap );

	if ( ! strlen ( shared->fileName ) )
	{
		fprintf ( stderr, "BENCHMARK PLUGIN ERROR: fileName not configured.\n" );
		return;
	}

	FILE	*file	= fopen ( shared->fileName, "a" );

	if ( ! file )
	{
		fprintf ( stderr, "BENCHMARK PLUGIN ERROR: cannot open %s for write.\n", 
					shared->fileName );
		return;
	}

	fputs ( message, file );
	fclose ( file );
}


static	void	clear_test ( int pixels )
{
        return;
	for ( int m=1; m<16; m++ )
	{
		print_file ( "Pixel Clear Rate (" );

		int		mask	= 0;
		
		if ( m & 1 )
		{
			mask	|= GL_COLOR_BUFFER_BIT;
			print_file ( "C" );
		}
		else
			print_file ( "-" );
		if ( m & 2 )
		{
			mask	|= GL_DEPTH_BUFFER_BIT;
			print_file ( "D" );
		}
		else
			print_file ( "-" );
		if ( m & 4 )
		{
			mask	|= GL_ACCUM_BUFFER_BIT;
			print_file ( "A" );
		}
		else
			print_file ( "-" );
		if ( m & 8 )
		{
			mask	|= GL_STENCIL_BUFFER_BIT;
			print_file ( "S" );
		}
		else
			print_file ( "-" );

		const	int		overlays	= 100;

		glFinish();

		double	start	= myTimeStamp();
		for ( int i=0; i<overlays; i++ )
			glClear ( mask );

		glFinish();

		double	elapsed		= myTimeStamp() - start;
//		double	pixPerSec	= pixels * overlays / elapsed;

	       //	print_file ( ") = %.2f Mpix/s\n",
	       //				pixPerSec / ( 1024 * 1024 ) );
	}
}

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

static	double	pixel_fill ( int pixels, int tex )
{
	const	int		overlays	= 100;

	glPolygonMode ( GL_FRONT_AND_BACK, GL_FILL );

	glFinish();
	//glFlush();
	double	start	= myTimeStamp();

	for ( int i=0; i<overlays; i++ )
	{
		glColor3f ( 0.0, 0.5, 0.0 );
		glBegin ( GL_POLYGON );
			if ( tex ) glTexCoord2f ( 0.0f, 0.0f );
			glVertex2f ( 0.0f, 0.0f );
			if ( tex ) glTexCoord2f ( 1.0f, 0.0f );
			glVertex2f ( 1.0f, 0.0f );
			if ( tex ) glTexCoord2f ( 1.0f, 1.0f );
			glVertex2f ( 1.0f, 1.0f );
			if ( tex ) glTexCoord2f ( 0.0f, 1.0f );
			glVertex2f ( 0.0f, 1.0f );
		glEnd();
	}

	glFinish();
	
	double	elapsed		= myTimeStamp() - start;
	double	pixPerSec	= pixels * overlays / elapsed;
	
	return	pixPerSec;
}

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

static	double	poly ( int sides, int tex )
{
	const	int		overlays		= 10;
	const	int		polys_a_side	= 100;
	const	int		total_polys		= polys_a_side * polys_a_side;
	const	float	poly_side		= 1.0f / polys_a_side;
        //return 0;
	glPolygonMode ( GL_FRONT_AND_BACK, GL_FILL );

	glFinish();

	double	start	= myTimeStamp();
        switch ( sides )
        {
                case 3:
                        glBegin ( GL_TRIANGLES );
                break;
                case 4:
                        glBegin ( GL_QUADS );
                break;
                default:
                        glBegin ( GL_TRIANGLE_STRIP );
                break;
        }
	for ( int i=0; i<overlays; i++ )
	{
		for ( int y=0; y<polys_a_side; y++ )
		{
			float	ys = y * poly_side;
			float	ye = ys + poly_side;
			for ( int x=0; x<polys_a_side; x++ )
			{
				float	xs = x * poly_side;
				float	xe = xs + poly_side;
				glColor3f ( 0.0, 0.5, 0.0 );
				switch ( sides )
				{
					case 0:
					case 1:
					case 2:
						break;
					case 3:
					       //	glBegin ( GL_TRIANGLES );
							if ( tex ) glTexCoord2f ( 0.0f, 0.0f );
							glVertex2f ( xs, ys );
							if ( tex ) glTexCoord2f ( 1.0f, 0.0f );
							glVertex2f ( xe, ys );
							if ( tex ) glTexCoord2f ( 1.0f, 1.0f );
							glVertex2f ( xe, ye );
					      //	glEnd();
						break;
					case 4:
					     //  glBegin ( GL_QUADS );
							if ( tex ) glTexCoord2f ( 0.0f, 0.0f );
							glVertex2f ( xs, ys );
							if ( tex ) glTexCoord2f ( 1.0f, 0.0f );
							glVertex2f ( xe, ys );
							if ( tex ) glTexCoord2f ( 1.0f, 1.0f );
							glVertex2f ( xe, ye );
							if ( tex ) glTexCoord2f ( 0.0f, 1.0f );
							glVertex2f ( xs, ye );
					      //	glEnd();
						break;
					default:
					     // 	glBegin ( GL_TRIANGLE_STRIP );
						for ( int j=0; j<sides; j++ )
						{
							float	u	= (float) j / (float) sides;
							float	v	= (j & 1) + 1;
							float	vx	= xs + u * poly_side;
							float	vy	= ys + v * poly_side;
							if ( tex )
								glTexCoord2f ( u, v );
							glVertex2f ( vx, vy );
						}
					   //	glEnd();
						break;
				}
			}
		}
	}
         glEnd(); 
	glFinish();

	double	elapsed		= myTimeStamp() - start;
	double	polysPerSec	= total_polys * overlays / elapsed;
	
	return	polysPerSec;
}

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

#define	texImageDim	2048

static	void	makeTexture ( int dim )
{
	static	GLubyte	texImage[texImageDim][texImageDim][3];

    int i, j, r, c;

    for ( i = 0; i < dim; i++ )
	{
		for ( j = 0; j < dim; j++ )
		{
	   		c	= ( ( ( ( i&0x8 ) ==0 ) ^ ( ( j&0x8 ) ) ==0 ) ) *255;
	   		texImage[i][j][0]	= ( GLubyte ) c;
	   		texImage[i][j][1]	= ( GLubyte ) c;
	   		texImage[i][j][2]	= ( GLubyte ) c;
		}
    }
    glTexImage2D ( 	GL_TEXTURE_2D, 0, 3,
					dim, dim, 0,
					GL_RGB, GL_UNSIGNED_BYTE, &texImage[0][0][0]
				);
    glTexParameterf ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
    glTexParameterf ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
    glTexParameterf ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
#if 1
    glTexParameterf ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
	gluBuild2DMipmaps ( GL_TEXTURE_2D, 3, dim, dim,
						GL_RGB, GL_UNSIGNED_BYTE, texImage );
#else
    glTexParameterf ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
#endif
    glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );

	glEnable ( GL_TEXTURE_2D );

	// Cause the texture to be paged into TRAM now
	glColor3f ( 0.0, 0.5, 0.0 );
	glBegin ( GL_POLYGON );
		glTexCoord2f ( 0.0f, 0.0f );
		glVertex2f ( 0.0f, 0.0f );
		glTexCoord2f ( 1.0f, 0.0f );
		glVertex2f ( 1.0f, 0.0f );
		glTexCoord2f ( 1.0f, 1.0f );
		glVertex2f ( 1.0f, 1.0f );
		glTexCoord2f ( 0.0f, 1.0f );
		glVertex2f ( 0.0f, 1.0f );
	glEnd();

}

/* A general OpenGL initialization function.  Sets all of the initial parameters. */
void InitGL(int Width, int Height)	        // We call this right after our OpenGL window is created.
{
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);		// This Will Clear The Background Color To Black
  glClearDepth(1.0);				// Enables Clearing Of The Depth Buffer
  glDepthFunc(GL_LESS);				// The Type Of Depth Test To Do
  glEnable(GL_DEPTH_TEST);			// Enables Depth Testing
  glShadeModel(GL_SMOOTH);			// Enables Smooth Color Shading

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();				// Reset The Projection Matrix

  gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);	// Calculate The Aspect Ratio Of The Window

  glMatrixMode(GL_MODELVIEW);
}

/* The function called when our window is resized (which shouldn't happen, because we're fullscreen) */
void ReSizeGLScene(int Width, int Height)
{
  if (Height==0)				// Prevent A Divide By Zero If The Window Is Too Small
    Height=1;

  glViewport(0, 0, Width, Height);		// Reset The Current Viewport And Perspective Transformation

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);
  glMatrixMode(GL_MODELVIEW);
}

int	PostAppCallBack ( int frame_count)
{
	static	int		first		= 1;
			double	now			= myTimeStamp();


#if DEBUG_MESSAGES
	fprintf ( stderr, "PLUGIN: PostAppCallBack begin\n" );
#endif

	
	if ( first )
	{
		first				= 0;
		//pfInit();
		char	hostname[256];
		//gethostname ( hostname, sizeof(hostname) );
		shared = (mySharedData*)malloc(sizeof(mySharedData));
		shared->options = (myOptions*)malloc(sizeof(myOptions));
		
		fprintf ( stderr, "BENCHMARK PLUGIN INFO: initialising\n" );
		shared->done		= 1;
		shared->mode		= -1;
		
		
		static char filename[] = "benchresults.txt";
		shared->options->fileName=(char*)filename;// (myOptions *) getPluginOptionBasePtr();
		
		
		if ( shared->options->fileName )
			strcpy ( shared->fileName, shared->options->fileName );
		else
		{
			strcpy ( shared->fileName, hostname );
			strcat ( shared->fileName, ".bench" );
		}
		unlink ( shared->fileName );

		time_t			now;
		time ( &now );

		struct tm		*calender	= localtime ( &now );

		print_file ( "Date:     %s", asctime ( calender ) );
		
		print_file ( "Hostname: %s\n", hostname );
	}

	if ( ! shared->options )
		return	0;

	if ( frame_count < 400 )
		return	0;


	if ( shared->done )
	{
		if ( shared->mode < 35 )
		{
			fprintf ( stderr, "BENCHMARK PLUGIN INFO: Collecting stats .... \n" );
			
			shared->mode	+= 2;
			shared->done	= 0;
		}
		else
		{
			print_file ( "\nMeasurements complete.\n" );
			fprintf ( stderr, "BENCHMARK PLUGIN INFO: Terminating.\n" );
			exit(0);
		}
	}

#if DEBUG_MESSAGES
	fprintf ( stderr, "PLUGIN: PostAppCallBack end\n" );
#endif

	return	1;
}


int	PostDrawCallBack ( unsigned int frame_count)
{
	static	int			first		= 1;
	const	float		yBase		= 0.1f;
	const	float		xMargin		= 0.1f;
	static	int			width, height, pixels;
			int			s, texture;
			double		PixelFillRate;

#if DEBUG_MESSAGES
	fprintf ( stderr, "PLUGIN: PostDrawCallBack begin\n" );
#endif

	if ( ! shared )
		return	0;

	if ( ! shared->options )
		return	0;
		
	if ( first )
	{
		width=SCREEN_X;
		height=SCREEN_Y;
		pixels	= width * height;

		print_file ( "Renderer: %s\n", glGetString ( GL_RENDERER ) );
		print_file ( "Vendor:   %s\n", glGetString ( GL_VENDOR ) );
		print_file ( "Version:  %s\n", glGetString ( GL_VERSION ) );

		print_file ( "\n\n" );

		clear_test ( pixels );

		first = 0;
	}

	// Mode bit 0 - enable benchmark
	if ( ! shared->mode & 1 || shared->done )
		return	0;

	glMatrixMode ( GL_PROJECTION );		// Store old viewport settings and
	glPushMatrix();						// setup the channel and window to
    glLoadIdentity();					// a basic flat plane for drawing
    gluOrtho2D ( 0, 1, 0, 1 );			// 2D objects on
    glMatrixMode ( GL_MODELVIEW );
    glPushMatrix();
    glLoadIdentity();
    //pfPushState();
	//pfBasicState();


	print_file ( "\n" );
	// Mode bit 1 - depth test
	print_file ( "Z-buffer " );
	if ( shared->mode & 0x2 )
	{
		glEnable ( GL_DEPTH_TEST );
		print_file ( "ON" );
	}
	else
	{
		glDisable ( GL_DEPTH_TEST );
		print_file ( "off" );
	}

	// Mode bits 3:5 - 2D texture
	print_file ( ", Texture " );
	texture	= ( shared->mode & 0xF6 ) >> 2;
	if ( texture )
	{
		glEnable ( GL_TEXTURE_2D );
		switch ( texture )
		{
			case 1:
				makeTexture ( 64 );
				print_file ( "64x64" );
				break;
			case 2:
				makeTexture ( 128 );
				print_file ( "128x128" );
				break;
			case 3:
				makeTexture ( 256 );
				print_file ( "256x256" );
				break;
			case 4:
				makeTexture ( 512 );
				print_file ( "512x512" );
				break;
			case 5:
				makeTexture ( 1024 );
				print_file ( "1Kx1K" );
				break;
			default:
				makeTexture ( 2048 );
				print_file ( "2Kx2K" );
				break;
		}
	}
	else
	{
		glDisable ( GL_TEXTURE_2D );
		print_file ( "off" );
	}


	PixelFillRate	= pixel_fill ( pixels, texture );
	print_file ( "\nPixel Fill Rate      = %.2f Mpix/s\n", 
				PixelFillRate / ( 1024 * 1024 ) );

	for ( s = 3; s <= 10; s ++ )
	{
		int		tris		= s - 2;
		double	PolygonRate	= poly ( s, texture );
		double	TriRate		= PolygonRate * tris;

	    	print_file ( "%2d-sided Polygon Rate = %.2f Mpoly/s (%.2f Mtri/s)\n",
					s,
					PolygonRate / ( 1024 * 1024 ),
					TriRate / ( 1024 * 1024 ) ); 
	}

	glEnable ( GL_LIGHTING );
	glEnable ( GL_TEXTURE_2D );
	glEnable ( GL_DEPTH_TEST );
	//pfPopState();						// Retrieve old viewport setttings
	glMatrixMode ( GL_MODELVIEW );		// and return viewport to proper
    glPopMatrix();						// projection and view mode etc.
    glMatrixMode ( GL_PROJECTION );
    glPopMatrix();

	shared->done		= 1;

#if DEBUG_MESSAGES
	fprintf ( stderr, "PLUGIN: PostDrawCallBack end\n" );
#endif

	return	1;
}
/* The main drawing function. */
void DrawGLScene()
{

  static int frame_count=0;
  PostAppCallBack ( frame_count );
  
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		// Clear The Screen And The Depth Buffer
 // glLoadIdentity();				// Reset The View
  PostDrawCallBack ( frame_count);
  glutSwapBuffers();
  
  frame_count++;
}

/* The function called whenever a key is pressed. */
void keyPressed(unsigned char key, int x, int y) 
{
    /* sleep to avoid thrashing this procedure */
    Sleep(100);

    /* If escape is pressed, kill everything. */
    if (key == ESCAPE) 
    { 
	/* shut down our window */
	glutDestroyWindow(window); 
	
	/* exit the program...normal termination. */
	exit(0);                   
    }
}

int main(int argc, char **argv) 
{  
  /* Initialize GLUT state - glut will take any command line arguments that pertain to it or 
     X Windows - look at its documentation at http://reality.sgi.com/mjk/spec3/spec3.html */  
  glutInit(&argc, argv);  

  /* Select type of Display mode:   
     Double buffer 
     RGBA color
     Alpha components supported 
     Depth buffer */  
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_ALPHA);  

  /* get a  x 480 window */
  glutInitWindowSize(SCREEN_X, SCREEN_Y);  

  /* the window starts at the upper left corner of the screen */
  glutInitWindowPosition(0, 0);  

  /* Open a window */  
  window = glutCreateWindow("Jeff Molofee's GL Code Tutorial ... NeHe '99");  

  /* Register the function to do all our OpenGL drawing. */
  glutDisplayFunc(&DrawGLScene);  

  /* Go fullscreen.  This is as soon as possible. */
 // glutFullScreen();

  /* Even if there are no events, redraw our gl scene. */
  glutIdleFunc(&DrawGLScene);

  /* Register the function called when our window is resized. */
//  glutReshapeFunc(&ReSizeGLScene);

  /* Register the function called when the keyboard is pressed. */
//  glutKeyboardFunc(&keyPressed);

  /* Initialize our window. */
  InitGL(SCREEN_X, SCREEN_Y);
  
  /* Start Event Processing Engine */  
  glutMainLoop();  

  return 1;
}


static	double	myTimeStamp ( void )
{
        static long double perf_cnt;
        static int first = 1;
        static long double firstCount=0;
        if (first)
        {
                QueryPerformanceFrequency((LARGE_INTEGER *) &perf_cnt);
                QueryPerformanceCounter((LARGE_INTEGER *) &firstCount);
                first=0;
        }
        static long double thisCount;
        QueryPerformanceCounter((LARGE_INTEGER *) &thisCount);
        long double currentCount =  thisCount - firstCount;
       
        return  (double)(currentCount / perf_cnt);
}