/*
 * License (based on zlib/libpng):
 *
 * Copyright (c) 2005-2007 Dominik Göddeke, University of Dortmund, Germany.
 *
 * This software is provided 'as-is', without any express or implied warranty.
 * In no event will the authors be held liable for any damages arising from 
 * the use of this software.
 * 
 * Permission is granted to anyone to use this software for any purpose, 
 * including commercial applications, and to alter it and redistribute it 
 * freely.
 *
 */



/*
 * GPGPU Reduction Tutorial: Computes maximum of a vector on the GPU.
 *
 * Limitation: vector length must be 2^k by 2^k.
 *
 * This version: texture rectangles, precomputed texcoords
 *
 * More details: www.mathematik.uni-dortmund.de/~goeddeke/gpgpu
 *
 * Please drop me a note if you encounter any bugs, or if you have suggestions 
 * on how to improve this tutorial: dominik.goeddeke@math.uni-dortmund.de
 *
 */


// includes
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <GL/glew.h>
#include <GL/glut.h>
#include <Cg/cgGL.h>


// error codes
static int ERROR_CG = -1;
static int ERROR_GLEW = -2;
static int ERROR_TEXTURE = -3;
static int ERROR_BINDFBO = -4;
static int ERROR_FBOTEXTURE = -5;
static int ERROR_PARAMS = -6;

// prototypes
void cgErrorCallback(void);
bool checkFramebufferStatus(void);
void checkGLErrors(const char *label);
void compareResults(void);
void createTextures(void);
void drawQuad(int w, int h);
void initCG(void);
void initFBOandViewport(void);
void initGLEW(void);
void initGLUT(int argc, char** argv);
void performComputation(void);
void setupTexture(const GLuint texID);
void swap(void);



// problem size (must be power of 2 by power of 2)
int N = 1024*1024;
int texSize = 1024;


// texture identifiers
GLuint pingpongTexID[2];
GLuint inputTexID;


// ping pong management vars
int writeTex = 0;
int readTex = 1;
GLenum attachmentpoints[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT };

// Cg vars
CGcontext cgContext;
CGprofile fragmentProfile;
CGprogram fragmentProgram;
CGparameter textureParam;

// FBO identifier
GLuint fb;

// handle to offscreen "window", only used to properly shut down the app
GLuint glutWindowHandle;

// shortcuts for texture internals
GLenum texTarget = GL_TEXTURE_RECTANGLE_ARB;
GLenum texInternalFormat = GL_FLOAT_R32_NV;
GLenum texFormat = GL_LUMINANCE;

// see course web page for details on this shader
char* shader = \
"float maximum( " \
"       float2 left: TEXCOORD0,"\
"       float2 right: TEXCOORD1,"\
"       float2 top: TEXCOORD2,"\
"       float2 bottom: TEXCOORD3,"\
"		uniform samplerRECT texture) : COLOR { "\
"float val1 = texRECT(texture, left);"\
"float val2 = texRECT(texture, right);"\
"float val3 = texRECT(texture, top);"\
"float val4 = texRECT(texture, bottom);"\
"return max(val1,max(val2,max(val3,val4)));}";

// actual data
float* data;

/**
 * main, just calls things in the appropriate order
 */
int main(int argc, char **argv) {
    printf("--------------------------------------------------------------\n");
    printf("Parallel reduction example\n\n");
    printf("see www.mathematik.uni-dortmund.de/~goeddeke/gpgpu for details\n");
    printf("--------------------------------------------------------------\n");
    //
    // create data vector
    //
    srand(time(NULL));
	data = (float*)malloc(N*sizeof(float));
    for (int i=0; i<N; i++) {
		data[i] = rand() / (((float)rand())+1.0) / 1000;
    }
    //
    // init glut and glew
    //
    initGLUT(argc, argv);
    initGLEW();
    //
    // init offscreen framebuffer
    //
    initFBOandViewport();
    //
    // create textures for data vector and pingpong
    //	
    createTextures();
    //
    // init shader runtime
    //
    initCG();
    //
    // and start computation
    //
    performComputation();
    //
    // compare results
    //
    compareResults();
    //
    // and clean up
    //
    glDeleteFramebuffersEXT(1,&fb);
    free(data);
    glDeleteTextures(2,pingpongTexID);
    glDeleteTextures(1,&inputTexID);
    cgDestroyProgram(fragmentProgram);
    cgDestroyContext(cgContext);
    glutDestroyWindow (glutWindowHandle);
    return 0;
}

/**
 * Callback for Cg errors
 */
void cgErrorCallback(void) {
    CGerror lastError = cgGetError();
    if(lastError) {
	printf(cgGetErrorString(lastError));
	printf(cgGetLastListing(cgContext));
	exit(ERROR_CG);
    }
} 

/**
 * Sets up a floating point texture with NEAREST filtering.
 * (mipmaps etc. are unsupported for floating point textures)
 */
void setupTexture (const GLuint texID) {
    // make active and bind
    glBindTexture(texTarget,texID);
    // turn off filtering and wrap modes
    glTexParameteri(texTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(texTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(texTarget, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(texTarget, GL_TEXTURE_WRAP_T, GL_CLAMP);
    // define texture with floating point format
    glTexImage2D(texTarget,0,texInternalFormat,texSize,texSize,0,texFormat,GL_FLOAT,0);
    // check if that worked
    if (glGetError() != GL_NO_ERROR) {
	printf("glTexImage2D():\t\t\t [FAIL]\n");
	exit (ERROR_TEXTURE);
    } else {
	printf("glTexImage2D():\t\t\t [PASS]\n");
    }
}

/**
 * creates textures and populates the input texture
 */
void createTextures (void) {
    // pingpong needs two textures, alternatingly read-only and write-only, 
    // input is just read-only
    glGenTextures (2, pingpongTexID);
    glGenTextures (1, &inputTexID);
    // set up textures
    setupTexture (pingpongTexID[readTex]);
    setupTexture (pingpongTexID[writeTex]);
    setupTexture (inputTexID);
    // attach pingpong textures to FBO
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, attachmentpoints[writeTex], texTarget, pingpongTexID[writeTex], 0);
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, attachmentpoints[readTex], texTarget, pingpongTexID[readTex], 0);
    // check if that worked
    if (!checkFramebufferStatus()) {
	printf("glFramebufferTexture2DEXT():\t [FAIL]\n");
	exit (ERROR_FBOTEXTURE);
    } else  {
	printf("glFramebufferTexture2DEXT():\t [PASS]\n");
    }
    // transfer data vector to input texture
    glBindTexture(texTarget, inputTexID);
    glTexSubImage2D(texTarget,0,0,0,texSize,texSize,texFormat,GL_FLOAT,data);
    // check if something went completely wrong
    checkGLErrors ("createTextures()");
}

/**
 * Sets up GLUT, creates "window" (better put: valid GL context, since the window is never displayed)
 */
void initGLUT(int argc, char **argv) {
    glutInit ( &argc, argv );
    glutWindowHandle = glutCreateWindow("MAXIMUM DEMO");  
}

/**
 * Sets up GLEW to initialise OpenGL extensions
 */
void initGLEW (void) {
    int err = glewInit();
    // sanity check
    if (GLEW_OK != err) {
	printf((char*)glewGetErrorString(err));
	exit(ERROR_GLEW);
    }  
}

/**
 * Creates framebuffer object, binds it to reroute rendering operations 
 * from the traditional framebuffer to the offscreen buffer
 */
void initFBOandViewport(void) {
    // create FBO (off-screen framebuffer)
    glGenFramebuffersEXT(1, &fb); 
    // bind offscreen framebuffer (that is, skip the window-specific render target)
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
    // viewport for 1:1 pixel=texel mapping
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0, texSize, 0.0, texSize);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glViewport(0, 0, texSize, texSize);
}

/**
 * Sets up the Cg runtime and creates shader.
 */
void initCG(void) {
    // set up Cg
    cgSetErrorCallback(cgErrorCallback);
    cgContext = cgCreateContext();
    fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
    cgGLSetOptimalOptions(fragmentProfile);
    // create fragment program
    fragmentProgram = cgCreateProgram (cgContext, CG_SOURCE, shader, fragmentProfile, "maximum", NULL);
    // load program
    cgGLLoadProgram (fragmentProgram);
    // and get parameter handle to input texture by name
    textureParam = cgGetNamedParameter (fragmentProgram, "texture");
}


/**
 * Computes maximum on the CPU, compares results
 */
void compareResults () {
    // get GPU result (last render pass did pingpong "swap")
    float gpuResult;
    glReadBuffer(attachmentpoints[readTex]);
    glReadPixels(0, 0, 1, 1,texFormat,GL_FLOAT,&gpuResult);
    // calc on CPU
    float cpuResult = data[0];
    for (int i=1; i<N; i++) 
        if (data[i] > cpuResult)
	    cpuResult = data[i];
    // and print out results
    printf("--------------------------------------------------------------\n");
    printf("GPU result:\t%f\n",gpuResult);
    printf("CPU result:\t%f\n",cpuResult);	
    printf("--------------------------------------------------------------\n");
}


/**
 * Performs the actual calculation.
 */
void performComputation(void) {
    printf("--------------------------------------------------------------\n");
    // enable fragment profile
    cgGLEnableProfile(fragmentProfile);
    // bind "maximum" program
    cgGLBindProgram(fragmentProgram);
    //
    // pass 1: read from inputTexture, first reduction step
    //         idea: do not overwrite input during pingpong
    //
    // enable input texture
    cgGLSetTextureParameter(textureParam, inputTexID);
    cgGLEnableTextureParameter(textureParam);
    // set render destination
    glDrawBuffer (attachmentpoints[writeTex]);
    // calculate output region width and height
    int outputWidth = texSize / 2;
    printf("Input size    :\t%dx%d\n",texSize,texSize);
    printf("Reduction step:\t%dx%d to %dx%d.\n",texSize, texSize, outputWidth, outputWidth);
    // perform computation and ping-pong output textures
    drawQuad(outputWidth,outputWidth);
/*	float* result = (float*)malloc(outputWidth*outputWidth*sizeof(float));
    glReadBuffer(attachmentpoints[writeTex]);
	glReadPixels(0, 0, outputWidth, outputWidth,texFormat,GL_FLOAT,result);
	for (int i=0; i<outputWidth*outputWidth; i++)
		printf("%d: %f\n",i,result[i]);
	exit(0);
*/
    swap();
    // 
    // calculate number of remaining passes:
    // log_2 of current output width
    //
    int numPasses = (int)(log((double)outputWidth)/log(2.0));
    //
    // perform remaining reduction steps
    //
    for (int i=0; i<numPasses; i++) {
	// input texture is read-only texture of pingpong textures
	cgGLSetTextureParameter(textureParam,pingpongTexID[readTex]);
	cgGLEnableTextureParameter(textureParam);
	// set render destination
	glDrawBuffer (attachmentpoints[writeTex]);
	// calculate output region width and height
	outputWidth = outputWidth / 2;
	printf("Reduction step:\t%dx%d to %dx%d.\n",outputWidth*2, outputWidth*2, outputWidth, outputWidth);
	// perform computation and ping-pong output textures
	drawQuad(outputWidth,outputWidth);
	swap();
    }
    // done, just do some checks if everything went smoothly.
    checkFramebufferStatus();
    checkGLErrors("render()");
}


/**
 * Renders w x h quad in top left corner of the viewport.
 */
void drawQuad(int w, int h) {
    glBegin(GL_QUADS);
    glMultiTexCoord2f(GL_TEXTURE0, -0.5, -0.5);
    glMultiTexCoord2f(GL_TEXTURE1,  0.5, -0.5);
    glMultiTexCoord2f(GL_TEXTURE2, -0.5,  0.5);
    glMultiTexCoord2f(GL_TEXTURE3,  0.5,  0.5);
    glVertex2f(0.0, 0.0);

    glMultiTexCoord2f(GL_TEXTURE0, 2*w-0.5, -0.5);
    glMultiTexCoord2f(GL_TEXTURE1, 2*w+0.5, -0.5);
    glMultiTexCoord2f(GL_TEXTURE2, 2*w-0.5,  0.5);
    glMultiTexCoord2f(GL_TEXTURE3, 2*w+0.5,  0.5);
    glVertex2f(w, 0.0);

    glMultiTexCoord2f(GL_TEXTURE0, 2*w-0.5, 2*h-0.5);
    glMultiTexCoord2f(GL_TEXTURE1, 2*w+0.5, 2*h-0.5);
    glMultiTexCoord2f(GL_TEXTURE2, 2*w-0.5, 2*h+0.5);
    glMultiTexCoord2f(GL_TEXTURE3, 2*w+0.5, 2*h+0.5);
    glVertex2f(w, h);

    glMultiTexCoord2f(GL_TEXTURE0, -0.5, 2*h-0.5);
    glMultiTexCoord2f(GL_TEXTURE1,  0.5, 2*h-0.5);
    glMultiTexCoord2f(GL_TEXTURE2, -0.5, 2*h+0.5);
    glMultiTexCoord2f(GL_TEXTURE3,  0.5, 2*h+0.5);
    glVertex2f(0.0, h);
    glEnd();
}



/**
 * Checks for OpenGL errors.
 * Extremely useful debugging function: When developing, 
 * make sure to call this after almost every GL call.
 */
void checkGLErrors (const char *label) {
    GLenum errCode;
    const GLubyte *errStr;
    if ((errCode = glGetError()) != GL_NO_ERROR) {
	errStr = gluErrorString(errCode);
	printf("OpenGL ERROR: ");
	printf((char*)errStr);
	printf("(Label: ");
	printf(label);
	printf(")\n.");
    }
}

/**
 * Checks framebuffer status.
 * Copied directly out of the spec, modified to deliver a return value.
 */
bool checkFramebufferStatus() {
    GLenum status;
    status = (GLenum) glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
    switch(status) {
    case GL_FRAMEBUFFER_COMPLETE_EXT:
	return true;
    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
	printf("Framebuffer incomplete, incomplete attachment\n");
	return false;
    case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
	printf("Unsupported framebuffer format\n");
	return false;
    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
	printf("Framebuffer incomplete, missing attachment\n");
	return false;
    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
	printf("Framebuffer incomplete, attached images must have same dimensions\n");
	return false;
    case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
	printf("Framebuffer incomplete, attached images must have same format\n");
	return false;
    case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
	printf("Framebuffer incomplete, missing draw buffer\n");
	return false;
    case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
	printf("Framebuffer incomplete, missing read buffer\n");
	return false;
    }
    return false;
}

/**
 * swaps the role of the two y-textures (read-only and write-only)
 * Can be done smarter :-)
 */
void swap(void) {
    if (writeTex == 0) {
	writeTex = 1;
	readTex = 0;
    } else {
	writeTex = 0;
	readTex = 1;
    }
}