bool loadedScene = false;

for(int i=1; i<argc; i++){

string header; string data;

istringstream liness(argv[i]);

getline(liness, header, '='); getline(liness, data, '=');

if(strcmp(header.c_str(), "mesh")==0){

//renderScene = new scene(data);

mesh = new obj();

objLoader* loader = new objLoader(data, mesh);

mesh->buildVBOs();

delete loader;

loadedScene = true;

}

}

if(!loadedScene){

cout << "Usage: mesh=[obj file]" << endl;

return 0;

}

frame = 0;

seconds = time (NULL);

fpstracker = 0;

// Launch CUDA/GL

#ifdef __APPLE__

// Needed in OSX to force use of OpenGL3.2

glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);

glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);

glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

init();

#else

init(argc, argv);

#endif

initCuda();

initVAO();

initTextures();

GLuint passthroughProgram;

passthroughProgram = initShader("shaders/passthroughVS.glsl", "shaders/passthroughFS.glsl");

glUseProgram(passthroughProgram);

glActiveTexture(GL_TEXTURE0);

#ifdef __APPLE__

// send into GLFW main loop

while(1){

display();

if (glfwGetKey(GLFW_KEY_ESC) == GLFW_PRESS || !glfwGetWindowParam( GLFW_OPENED )){

kernelCleanup();

cudaDeviceReset();

exit(0);

}

}

glfwTerminate();

#else

glutDisplayFunc(display);

glutKeyboardFunc(keyboard);

glutMouseFunc(mouseClick);

glutMotionFunc(mouseMove);

glutMainLoop();

#endif

kernelCleanup();

return 0;

glm::mat4 translationMat = glm::translate(0.0f, 0.0f, 0.0f);

glm::mat4 scaleMat = glm::scale(1.0f,1.0f,1.0f);

glm::vec3 myRotationAxis(1.0f, 0.0f, 0.0f);

glm::mat4 rotationMat = glm::rotate( 0.0f, myRotationAxis );

model = translationMat*rotationMat*scaleMat;

projection = glm::perspective(fovy, float(width)/float(height), zNear, zFar);

view = glm::lookAt(camCtlr.getCameraPosition(), camCtlr.getLookAtPosition(), glm::vec3(0,1,0));

// Map OpenGL buffer object for writing from CUDA on a single GPU

// No data is moved (Win & Linux). When mapped to CUDA, OpenGL should not use this buffer

dptr=NULL;

vbo = mesh->getVBO();

vbosize = mesh->getVBOsize();

float newcbo[] = {0.0, 1.0, 0.0,

0.0, 0.0, 1.0,

1.0, 0.0, 0.0};

cbo = newcbo;

cbosize = 9;

ibo = mesh->getIBO();

ibosize = mesh->getIBOsize();

nbo = mesh->getNBO();

nbosize = mesh->getNBOsize();

cudaGLMapBufferObject((void**)&dptr, pbo);

cudaRasterizeCore(dptr, glm::vec2(width, height), frame, vbo, vbosize, cbo, cbosize, ibo, ibosize,nbo, nbosize,model,view,projection,glm::vec2(zNear,zFar),sm,cameraPosition);

cudaGLUnmapBufferObject(pbo);

vbo = NULL;

cbo = NULL;

ibo = NULL;

frame++;

fpstracker++;

runCuda();

time_t seconds2 = time (NULL);

if(seconds2-seconds >= 1){

fps = fpstracker/(seconds2-seconds);

fpstracker = 0;

seconds = seconds2;

}

string title = "CIS565 Rasterizer | "+ utilityCore::convertIntToString((int)fps) + "FPS";

glfwSetWindowTitle(title.c_str());

glBindBuffer( GL_PIXEL_UNPACK_BUFFER, pbo);

glBindTexture(GL_TEXTURE_2D, displayImage);

glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height,

GL_RGBA, GL_UNSIGNED_BYTE, NULL);

glClear(GL_COLOR_BUFFER_BIT);

// VAO, shader program, and texture already bound

glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);

glfwSwapBuffers();

runCuda();

time_t seconds2 = time (NULL);

if(seconds2-seconds >= 1){

fps = fpstracker/(seconds2-seconds);

fpstracker = 0;

seconds = seconds2;

}

string title = "CIS565 Rasterizer | "+ utilityCore::convertIntToString((int)fps) + "FPS";

glutSetWindowTitle(title.c_str());

glBindBuffer( GL_PIXEL_UNPACK_BUFFER, pbo);

glBindTexture(GL_TEXTURE_2D, displayImage);

glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height,

GL_RGBA, GL_UNSIGNED_BYTE, NULL);

glClear(GL_COLOR_BUFFER_BIT);

// VAO, shader program, and texture already bound

glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);

glutPostRedisplay();

glutSwapBuffers();

{

switch (key)

{

case(27):

shut_down(1);

break;

case ('r'):

camCtlr.reset();

break;

case ('c'):

sm = COLOR;

break;

case ('l'):

sm = LIGHTING;

break;

case ('s'):

sm = SLIGHTING;

break;

case ('n'):

sm = NORMALS;

break;

case ('z'):

sm = ZDEPTH;

break;

}

if (glfwInit() != GL_TRUE){

shut_down(1);

}

// 16 bit color, no depth, alpha or stencil buffers, windowed

if (glfwOpenWindow(width, height, 5, 6, 5, 0, 0, 0, GLFW_WINDOW) != GL_TRUE){

shut_down(1);

}

// Set up vertex array object, texture stuff

initVAO();

initTextures();

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);

glutInitWindowSize(width, height);

glutCreateWindow("CIS565 Rasterizer");

// Init GLEW

glewInit();

GLenum err = glewInit();

if (GLEW_OK != err)

{

/* Problem: glewInit failed, something is seriously wrong. */

std::cout << "glewInit failed, aborting." << std::endl;

exit (1);

}

initVAO();

initTextures();

if (pbo) {

// set up vertex data parameter

int num_texels = width*height;

int num_values = num_texels * 4;

int size_tex_data = sizeof(GLubyte) * num_values;

// Generate a buffer ID called a PBO (Pixel Buffer Object)

glGenBuffers(1,pbo);

// Make this the current UNPACK buffer (OpenGL is state-based)

glBindBuffer(GL_PIXEL_UNPACK_BUFFER, *pbo);

// Allocate data for the buffer. 4-channel 8-bit image

glBufferData(GL_PIXEL_UNPACK_BUFFER, size_tex_data, NULL, GL_DYNAMIC_COPY);

cudaGLRegisterBufferObject( *pbo );

}

// Use device with highest Gflops/s

cudaGLSetGLDevice( compat_getMaxGflopsDeviceId() );

initPBO(&pbo);

// Clean up on program exit

atexit(cleanupCuda);

runCuda();

glGenTextures(1,&displayImage);

glBindTexture(GL_TEXTURE_2D, displayImage);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_BGRA,

GL_UNSIGNED_BYTE, NULL);

GLfloat vertices[] =

{

-1.0f, -1.0f,

1.0f, -1.0f,

1.0f, 1.0f,

-1.0f, 1.0f,

};

GLfloat texcoords[] =

{

1.0f, 1.0f,

0.0f, 1.0f,

0.0f, 0.0f,

1.0f, 0.0f

};

GLushort indices[] = { 0, 1, 3, 3, 1, 2 };

GLuint vertexBufferObjID[3];

glGenBuffers(3, vertexBufferObjID);

glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObjID[0]);

glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

glVertexAttribPointer((GLuint)positionLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);

glEnableVertexAttribArray(positionLocation);

glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObjID[1]);

glBufferData(GL_ARRAY_BUFFER, sizeof(texcoords), texcoords, GL_STATIC_DRAW);

glVertexAttribPointer((GLuint)texcoordsLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);

glEnableVertexAttribArray(texcoordsLocation);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertexBufferObjID[2]);

glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

GLuint program = glslUtility::createProgram(vertexShaderPath, fragmentShaderPath, attributeLocations, 2);

GLint location;

glUseProgram(program);

if ((location = glGetUniformLocation(program, "u_image")) != -1)

{

glUniform1i(location, 0);

}

return program;

if (pbo) {

// unregister this buffer object with CUDA

cudaGLUnregisterBufferObject(*pbo);

glBindBuffer(GL_ARRAY_BUFFER, *pbo);

glDeleteBuffers(1, pbo);

*pbo = (GLuint)NULL;

}

kernelCleanup();

cudaDeviceReset();

#ifdef __APPLE__

glfwTerminate();

#endif

exit(return_code);