////////////////////////////////////////////////////////////////////////////////
//! Create offscreen render target
////////////////////////////////////////////////////////////////////////////////
void
createFBO( GLuint* fbo, GLuint* tex) {
// create a new fbo
glGenFramebuffersEXT( 1, fbo);
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, *fbo);
CUT_CHECK_ERROR_GL();
// check if the fbo is valid
if( ! glIsFramebufferEXT( *fbo)) {
fprintf( stderr, "Framebuffer object creation failed.\n");
fflush( stderr);
return;
}
// create attachment
createTexture( tex, image_width, image_height);
CUT_CHECK_ERROR_GL();
// attach texture to fbo
glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D,
*tex,
0);
CUT_CHECK_ERROR_GL();
// deactivate offsreen render target
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0);
CUT_CHECK_ERROR_GL();
}
void initCUDAMemory()
{
uint resolution = r_width * r_height;
void* data = malloc(sizeof(GLubyte) * resolution * 4);
glGenBuffers(1, &pbo);
glBindBuffer(GL_ARRAY_BUFFER, pbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLubyte) * resolution * 4, data, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
free(data);
cutilSafeCall(cudaGLRegisterBufferObject(pbo));
// initialize the PBO for transferring data from CUDA to openGL
CUT_CHECK_ERROR_GL();
glGenTextures(1, &framebuffer);
glBindTexture(GL_TEXTURE_2D, framebuffer);
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_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, r_width, r_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
CUT_CHECK_ERROR_GL();
}
////////////////////////////////////////////////////////////////////////////////
//! Check if the result is correct or write data to file for external
//! regression testing
////////////////////////////////////////////////////////////////////////////////
void checkResultCuda(int argc, char** argv, const GLuint& vbo)
{
cutilSafeCall(cudaGLUnregisterBufferObject(vbo));
// map buffer object
glBindBuffer(GL_ARRAY_BUFFER_ARB, vbo );
float* data = (float*) glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
// check result
if(cutCheckCmdLineFlag(argc, (const char**) argv, "regression")) {
// write file for regression test
cutilCheckError(cutWriteFilef("./data/regression.dat",
data, mesh_width * mesh_height * 3, 0.0));
}
// unmap GL buffer object
if(! glUnmapBuffer(GL_ARRAY_BUFFER)) {
fprintf(stderr, "Unmap buffer failed.\n");
fflush(stderr);
}
cutilSafeCall(cudaGLRegisterBufferObject(vbo));
CUT_CHECK_ERROR_GL();
}
// Main program
int main(int argc, char** argv)
{
// Create the CUTIL timer
cutilCheckError( cutCreateTimer( &timer));
if (CUTFalse == initGL(argc, argv)) {
return CUTFalse;
}
initCuda(argc, argv);
CUT_CHECK_ERROR_GL();
// register callbacks
glutDisplayFunc(fpsDisplay);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
// start rendering mainloop
glutMainLoop();
// clean up
cudaThreadExit();
cutilExit(argc, argv);
}
////////////////////////////////////////////////////////////////////////////////
//! Initialize GL
////////////////////////////////////////////////////////////////////////////////
CUTBoolean initGL(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutInitWindowSize(window_width, window_height);
glutCreateWindow("Cuda GL Interop (VBO)");
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMotionFunc(motion);
// initialize necessary OpenGL extensions
glewInit();
if (! glewIsSupported("GL_VERSION_2_0 ")) {
fprintf(stderr, "ERROR: Support for necessary OpenGL extensions missing.");
fflush(stderr);
return CUTFalse;
}
// default initialization
glClearColor(0.0, 0.0, 0.0, 1.0);
glDisable(GL_DEPTH_TEST);
// viewport
glViewport(0, 0, window_width, window_height);
// projection
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)window_width / (GLfloat) window_height, 0.1, 10.0);
CUT_CHECK_ERROR_GL();
return CUTTrue;
}
void displayTexture()
{
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);//?
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glViewport(0, 0, w_width, w_height);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 0.5f);
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 0.5f);
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 0.5f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 0.5f);
glEnd();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
CUT_CHECK_ERROR_GL();
}
int main(){
//Change this line to use your name!
yourName = "Karl Li";
// 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();
initCuda();
CUT_CHECK_ERROR_GL();
initVAO();
initTextures();
GLuint passthroughProgram;
passthroughProgram = initShader("shaders/passthroughVS.glsl", "shaders/passthroughFS.glsl");
glUseProgram(passthroughProgram);
glActiveTexture(GL_TEXTURE0);
// send into GLFW main loop
while(1){
display();
if (glfwGetKey(GLFW_KEY_ESC) == GLFW_PRESS || !glfwGetWindowParam( GLFW_OPENED )){
exit(0);
}
}
glfwTerminate();
return 0;
}
void raytrace()
{
uint* imagedata;
cutilSafeCall(cudaGLMapBufferObject((void**)&imagedata, pbo));
float3 A, B, C;
camera.getImagePlane(A, B, C);
dev_camera d_cam(camera.getPosition(), A, B, C, aperture, focal);
dev_light d_light(light.getPosition(), light.getColor(), 4096);
//need to change here.
float3 minAABB, maxAABB;
world.getAABB(minAABB, maxAABB);
sceneInfo scene(world.getNumTriangles(), world.getNumSpheres(), world.getNumBoxes(), minAABB, maxAABB);
//TODO: add control for clear buffer here.
//change here for the many object case
raytraceImage(imagedata, dev_lastframe_ptr, dev_num_layers, r_width, r_height, moved, d_cam, d_light, scene);
//for showing the real frame rate
cudaMemcpy(&frame_num, dev_num_layers, sizeof(float), cudaMemcpyDeviceToHost);
frame_num++;
cudaMemcpy(dev_num_layers, &frame_num, sizeof(int), cudaMemcpyHostToDevice);
cutilSafeCall(cudaGLUnmapBufferObject(pbo));
//download texture from pbo
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
glBindTexture(GL_TEXTURE_2D, framebuffer);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_width, r_height, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
CUT_CHECK_ERROR_GL();
}
// copy image and process using CUDA
void processImage()
{
// tell cuda we are going to get into these buffers
pboUnregister(pbo_source);
// read data into pbo
// activate destination buffer
glBindBuffer( GL_PIXEL_PACK_BUFFER_ARB, pbo_source);
// read
glReadPixels( 0, 0, image_width, image_height, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
// Done : re-register for Cuda
pboRegister(pbo_source);
// run the Cuda kernel
process( pbo_source, pbo_dest, image_width, image_height, blur_radius);
// blit convolved texture onto the screen
// detach from CUDA
pboUnregister(pbo_dest);
// download texture from PBO
glBindBuffer( GL_PIXEL_UNPACK_BUFFER_ARB, pbo_dest);
glBindTexture( GL_TEXTURE_2D, tex_screen);
glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, image_width, image_height, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
CUT_CHECK_ERROR_GL();
}
////////////////////////////////////////////////////////////////////////////////
//!
////////////////////////////////////////////////////////////////////////////////
void
deleteTexture( GLuint* tex) {
glDeleteTextures( 1, tex);
CUT_CHECK_ERROR_GL();
*tex = 0;
}
////////////////////////////////////////////////////////////////////////////////
//! Delete PBO
////////////////////////////////////////////////////////////////////////////////
void
deletePBO( GLuint* pbo) {
glBindBuffer( GL_ARRAY_BUFFER, *pbo);
glDeleteBuffers( 1, pbo);
CUT_CHECK_ERROR_GL();
*pbo = 0;
}
////////////////////////////////////////////////////////////////////////////////
//! Create VBO
////////////////////////////////////////////////////////////////////////////////
void createVBO(GLuint* vbo, int size)
{
// create buffer object
glGenBuffers(1, vbo);
glBindBuffer(GL_ARRAY_BUFFER, *vbo);
glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
CUT_CHECK_ERROR_GL();
}
////////////////////////////////////////////////////////////////////////////////
//! Cleanup offscreen render target
////////////////////////////////////////////////////////////////////////////////
void
deleteFBO( GLuint* fbo, GLuint* tex) {
glDeleteFramebuffersEXT( 1, fbo);
CUT_CHECK_ERROR_GL();
deleteTexture( tex);
*fbo = 0;
}
CUTBoolean initGL(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutInitWindowSize(10, 10);
int bla = glutCreateWindow("Cuda GL Interop (VBO)");
glutDisplayFunc(dumm_display);
// initialize necessary OpenGL extensions
glewInit();
if (! glewIsSupported("GL_VERSION_2_0 ")) {
fprintf(stderr, "ERROR: Support for necessary OpenGL extensions missing.");
fflush(stderr);
return CUTFalse;
}
// default initialization
glClearColor(0.0, 0.0, 0.0, 1.0);
glDisable(GL_DEPTH_TEST);
// viewport
glViewport(0, 0, 10, 10);
// projection
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)10 / (GLfloat) 10, 0.1, 10.0);
CUT_CHECK_ERROR_GL();
// start gui for the main application
//cudaError_t error = cudaGLSetGLDevice(0);
//cutilGLDeviceInit(argc, argv);
int deviceCount;
cutilSafeCallNoSync(cudaGetDeviceCount(&deviceCount));
if (deviceCount == 0) {
fprintf(stderr, "CUTIL CUDA error: no devices supporting CUDA.\n");
exit(-1);
}
int dev = 0;
cudaDeviceProp deviceProp;
cutilSafeCallNoSync(cudaGetDeviceProperties(&deviceProp, dev));
if (deviceProp.major < 1) {
fprintf(stderr, "cutil error: device does not support CUDA.\n");
exit(-1);
}
printf("gpu=%s\n", deviceProp.name);
cutilSafeCall(cudaGLSetGLDevice(dev));
glutDestroyWindow(bla);
return CUTTrue;
}
void ParticleRenderer::setPositions(float *pos, int numParticles)
{
m_pos = pos;
m_numParticles = numParticles;
if (!m_pbo)
{
glGenBuffers(1, (GLuint*)&m_pbo);
}
glBindBuffer(GL_ARRAY_BUFFER_ARB, m_pbo);
glBufferData(GL_ARRAY_BUFFER_ARB, numParticles * 4 * sizeof(float), pos, GL_STATIC_DRAW_ARB);
glBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
CUT_CHECK_ERROR_GL();
}
void displayImage()
{
// render a screen sized quad
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glMatrixMode( GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
glMatrixMode( GL_MODELVIEW);
glLoadIdentity();
glViewport(0, 0, window_width, window_height);
glBegin( GL_QUADS);
glTexCoord2f( 0.0, 0.0);
glVertex3f( -1.0, -1.0, 0.5);
glTexCoord2f( 1.0, 0.0);
glVertex3f( 1.0, -1.0, 0.5);
glTexCoord2f( 1.0, 1.0);
glVertex3f( 1.0, 1.0, 0.5);
glTexCoord2f( 0.0, 1.0);
glVertex3f( -1.0, 1.0, 0.5);
glEnd();
glMatrixMode( GL_PROJECTION);
glPopMatrix();
glDisable( GL_TEXTURE_2D);
glBindBuffer( GL_PIXEL_PACK_BUFFER_ARB, 0);
glBindBuffer( GL_PIXEL_UNPACK_BUFFER_ARB, 0);
// re-attach to CUDA
pboRegister(pbo_dest);
CUT_CHECK_ERROR_GL();
}
////////////////////////////////////////////////////////////////////////////////
//! Create VBO
////////////////////////////////////////////////////////////////////////////////
void createVBO(GLuint* vbo)
{
// create buffer object
glGenBuffers(1, vbo);
glBindBuffer(GL_ARRAY_BUFFER, *vbo);
// initialize buffer object
unsigned int size = mesh_width * mesh_height * 4 * sizeof(float);
glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// register buffer object with CUDA
cutilSafeCall(cudaGLRegisterBufferObject(*vbo));
CUT_CHECK_ERROR_GL();
}
////////////////////////////////////////////////////////////////////////////////
//! Initialize GL
////////////////////////////////////////////////////////////////////////////////
CUTBoolean initGL(int *argc, char **argv)
{
// Create GL context
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(windowW, windowH);
glutCreateWindow("CUDA FFT Ocean Simulation");
vertShaderPath = cutFindFilePath("ocean.vert", argv[0]);
fragShaderPath = cutFindFilePath("ocean.frag", argv[0]);
if (vertShaderPath == 0 || fragShaderPath == 0) {
fprintf(stderr, "Error finding shader files!\n");
cudaThreadExit();
exit(EXIT_FAILURE);
}
// initialize necessary OpenGL extensions
glewInit();
if (! glewIsSupported("GL_VERSION_2_0 "
)) {
fprintf(stderr, "ERROR: Support for necessary OpenGL extensions missing.");
fflush(stderr);
return CUTFalse;
}
if (!glewIsSupported( "GL_VERSION_1_5 GL_ARB_vertex_buffer_object GL_ARB_pixel_buffer_object" )) {
fprintf(stderr, "Error: failed to get minimal extensions for demo\n");
fprintf(stderr, "This sample requires:\n");
fprintf(stderr, " OpenGL version 1.5\n");
fprintf(stderr, " GL_ARB_vertex_buffer_object\n");
fprintf(stderr, " GL_ARB_pixel_buffer_object\n");
cleanup();
exit(-1);
}
// default initialization
glClearColor(0.0, 0.0, 0.0, 1.0);
glEnable(GL_DEPTH_TEST);
// load shader
shaderProg = loadGLSLProgram(vertShaderPath, fragShaderPath);
CUT_CHECK_ERROR_GL();
return CUTTrue;
}
////////////////////////////////////////////////////////////////////////////////
//!
////////////////////////////////////////////////////////////////////////////////
void
createTexture( GLuint* tex_name, unsigned int size_x, unsigned int size_y) {
// create a tex as attachment
glGenTextures( 1, tex_name);
glBindTexture( GL_TEXTURE_2D, *tex_name);
// set basic parameters
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_MIN_FILTER, GL_NEAREST);
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
// buffer data
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, size_x, size_y, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
CUT_CHECK_ERROR_GL();
}
VBO::VBO(unsigned int n_points, unsigned int vbo_res_flags)
: dev_vbo(NULL), n_points(n_points), draw_points(n_points)
{
// create buffer object
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// initialize buffer object
unsigned int size = n_points * 4 * sizeof(float);
glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// register this buffer object with CUDA
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_vbo_resource, vbo, vbo_res_flags));
CUT_CHECK_ERROR_GL();
}
// render a simple 3D scene
void renderScene()
{
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode( GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0, 0.0, -3.0);
glRotatef(rotate[0], 1.0, 0.0, 0.0);
glRotatef(rotate[1], 0.0, 1.0, 0.0);
glRotatef(rotate[2], 0.0, 0.0, 1.0);
glViewport(0, 0, 512, 512);
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glutSolidTeapot(1.0);
CUT_CHECK_ERROR_GL();
}
////////////////////////////////////////////////////////////////////////////////
//! Initialize GL
////////////////////////////////////////////////////////////////////////////////
CUTBoolean
initGL() {
// initialize necessary OpenGL extensions
glewInit();
if (! glewIsSupported(
"GL_VERSION_2_0 "
"GL_ARB_pixel_buffer_object "
"GL_EXT_framebuffer_object "
)) {
fprintf( stderr, "ERROR: Support for necessary OpenGL extensions missing.");
fflush( stderr);
return CUTFalse;
}
// default initialization
glClearColor( 0.5, 0.5, 0.5, 1.0);
glDisable( GL_DEPTH_TEST);
// viewport
glViewport( 0, 0, window_width, window_height);
// projection
glMatrixMode( GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)window_width / (GLfloat) window_height, 0.1, 10.0);
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_LIGHT0);
float red[] = { 1.0, 0.1, 0.1, 1.0 };
float white[] = { 1.0, 1.0, 1.0, 1.0 };
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, red);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, white);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60.0);
CUT_CHECK_ERROR_GL();
return CUTTrue;
}
////////////////////////////////////////////////////////////////////////////////
//! Initialize GL
////////////////////////////////////////////////////////////////////////////////
CUTBoolean initGL(int *argc, char **argv)
{
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutInitWindowSize(window_width, window_height);
glutCreateWindow("Mephitisizer");
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMotionFunc(motion);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_POINT_SMOOTH);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
glewInit();
if (! glewIsSupported("GL_VERSION_2_0 ")) {
fprintf(stderr, "ERROR: Support for necessary OpenGL extensions missing.");
fflush(stderr);
return CUTFalse;
}
// default initialization
glClearColor(0.0, 0.0, 0.0, 1.0);
glDisable(GL_DEPTH_TEST);
// viewport
glViewport(0, 0, window_width, window_height);
// projection
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)window_width / (GLfloat) window_height, 0.1, 100.0);
CUT_CHECK_ERROR_GL();
return CUTTrue;
}
void initOpenGLBuffers()
{
printf("Creating GL texture...\n");
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &gl_Tex);
glBindTexture(GL_TEXTURE_2D, gl_Tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, imageW, imageH, 0, GL_RGBA, GL_UNSIGNED_BYTE, h_Src);
printf("Texture created.\n");
printf("Creating PBO...\n");
glGenBuffers(1, &gl_PBO);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, gl_PBO);
glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, imageW * imageH * 4, h_Src, GL_STREAM_COPY);
//While a PBO is registered to CUDA, it can't be used
//as the destination for OpenGL drawing calls.
//But in our particular case OpenGL is only used
//to display the content of the PBO, specified by CUDA kernels,
//so we need to register/unregister it only once.
// DEPRECATED: cutilSafeCall( cudaGLRegisterBufferObject(gl_PBO) );
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_pbo_resource, gl_PBO,
cudaGraphicsMapFlagsWriteDiscard));
CUT_CHECK_ERROR_GL();
printf("PBO created.\n");
// load shader program
shader = compileASMShader(GL_FRAGMENT_PROGRAM_ARB, shader_code);
if (g_FrameBufferObject) {
delete g_FrameBufferObject; g_FrameBufferObject = NULL;
}
if (g_bFBODisplay) {
g_FrameBufferObject = new CFrameBufferObject(imageW, imageH, 32, false, GL_TEXTURE_2D);
}
}
////////////////////////////////////////////////////////////////////////////////
//! Create PBO
////////////////////////////////////////////////////////////////////////////////
void
createPBO( GLuint* pbo) {
// set up vertex data parameter
num_texels = image_width * image_height;
num_values = num_texels * 4;
size_tex_data = sizeof(GLubyte) * num_values;
void *data = malloc(size_tex_data);
// create buffer object
glGenBuffers( 1, pbo);
glBindBuffer( GL_ARRAY_BUFFER, *pbo);
// buffer data
glBufferData( GL_ARRAY_BUFFER, size_tex_data, data, GL_DYNAMIC_DRAW);
free(data);
glBindBuffer( GL_ARRAY_BUFFER, 0);
// attach this Buffer Object to CUDA
pboRegister(*pbo);
CUT_CHECK_ERROR_GL();
}
void ParticleRenderer::display(DisplayMode mode /* = PARTICLE_POINTS */)
{
switch (mode)
{
case PARTICLE_POINTS:
glColor3f(1, 1, 1);
glPointSize(m_pointSize);
_drawPoints();
break;
case PARTICLE_SPRITES:
default:
{
// setup point sprites
glEnable(GL_POINT_SPRITE_ARB);
glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
glPointSize(m_spriteSize);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnable(GL_BLEND);
glDepthMask(GL_FALSE);
glUseProgram(m_program);
GLuint texLoc = glGetUniformLocation(m_program, "splatTexture");
glUniform1i(texLoc, 0);
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D, m_texture);
glColor3f(1, 1, 1);
glSecondaryColor3fv(m_baseColor);
_drawPoints();
glUseProgram(0);
glDisable(GL_POINT_SPRITE_ARB);
glDisable(GL_BLEND);
glDepthMask(GL_TRUE);
}
break;
case PARTICLE_SPRITES_COLOR:
{
// setup point sprites
glEnable(GL_POINT_SPRITE_ARB);
glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
glPointSize(m_spriteSize);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnable(GL_BLEND);
glDepthMask(GL_FALSE);
glUseProgram(m_program);
GLuint texLoc = glGetUniformLocation(m_program, "splatTexture");
glUniform1i(texLoc, 0);
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D, m_texture);
glColor3f(1, 1, 1);
glSecondaryColor3fv(m_baseColor);
_drawPoints(true);
glUseProgram(0);
glDisable(GL_POINT_SPRITE_ARB);
glDisable(GL_BLEND);
glDepthMask(GL_TRUE);
}
break;
}
CUT_CHECK_ERROR_GL();
}
