Example #1
0
void OpenGLRenderer::renderPoints(const glm::vec3* positions, const Color256* colors, const int num, const Camera &camera) {
  //always use the point shaders to render points
  glUseProgram(points_program_);
  GLuint mvp_location = glGetUniformLocation(points_program_, "u_mvpMatrix");

  //Declare CUDA device pointers for it to use
  float3* dptr_pos;
  float3* dptr_col;

  //Setup position buffer
  glBindBuffer(GL_ARRAY_BUFFER, buffers_[0]);
  glBufferData(GL_ARRAY_BUFFER, 3 * num*sizeof(float), NULL, GL_DYNAMIC_DRAW);
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
  glEnableVertexAttribArray(0);

  //Setup color buffer
  glBindBuffer(GL_ARRAY_BUFFER, buffers_[1]);
  glBufferData(GL_ARRAY_BUFFER, 3 * num*sizeof(float), NULL, GL_DYNAMIC_DRAW);
  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL);
  glEnableVertexAttribArray(1);

  //Register position and normal buffers with CUDA
  cudaGLRegisterBufferObject(buffers_[0]);
  cudaGLRegisterBufferObject(buffers_[1]);

  //Map buffers to CUDA
  cudaGLMapBufferObject((void**)&dptr_pos, buffers_[0]);
  cudaGLMapBufferObject((void**)&dptr_col, buffers_[1]);

  //Copy data to buffer with CUDA
  copyPointsToGL(positions, colors, dptr_pos, dptr_col, num);

  //Unmap buffers from CUDA
  cudaGLUnmapBufferObject(buffers_[0]);
  cudaGLUnmapBufferObject(buffers_[1]);

  //Unregister position and normal buffers with CUDA
  cudaGLUnregisterBufferObject(buffers_[0]);
  cudaGLUnregisterBufferObject(buffers_[1]);

  //Send the MVP Matrix
  glUniformMatrix4fv(mvp_location, 1, GL_FALSE, glm::value_ptr(camera.mvp));

  //Draw
  glPointSize(1.0f);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glDrawArrays(GL_POINTS, 0, 3 * num);
}
Example #2
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();
}
Example #3
0
void runCuda(){
  // 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();

  cudaGLMapBufferObject((void**)&dptr, pbo);
  cudaRasterizeCore(dptr, glm::vec2(width, height), frame, vbo, vbosize, cbo, cbosize, ibo, ibosize);
  cudaGLUnmapBufferObject(pbo);

  vbo = NULL;
  cbo = NULL;
  ibo = NULL;

  frame++;
  fpstracker++;

}
Example #4
0
void runCuda(){
  // 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);
  // Invert camera to convert to view matrix
  cudaRasterizeCore(glm::inverse(cam), projection, light, draw_mode, dptr, glm::vec2(width, height), frame, vbo, vbosize, nbo, nbosize, cbo, cbosize, ibo, ibosize);
  cudaGLUnmapBufferObject(pbo);

  vbo = NULL;
  cbo = NULL;
  ibo = NULL;

  frame++;
  fpstracker++;

}
Example #5
0
void runCuda()
{
	//////////////////////
	// Timing cuda call //
	//////////////////////
	float time;
	cudaEvent_t start, stop;
	cudaEventCreate(&start);
	cudaEventCreate(&stop);
	cudaEventRecord(start, 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();

	nbo = mesh->getNBO();
	nbosize = mesh->getNBOsize();

#if RGBONLY == 1
	float newcbo[] = {0.0, 1.0, 0.0, 
					0.0, 0.0, 1.0, 
					1.0, 0.0, 0.0};
	cbo = newcbo;
	cbosize = 9;
#elif RGBONLY == 0
	vec3 defaultColor(0.5f, 0.5f, 0.5f);
	mesh->changeColor(defaultColor);
	cbo = mesh->getCBO();
	cbosize = mesh->getCBOsize();
#endif

	ibo = mesh->getIBO();
	ibosize = mesh->getIBOsize();

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

	updateCamera();

	cudaRasterizeCore(cam, dptr, glm::vec2(width, height), frame, vbo, vbosize, cbo, cbosize, ibo, ibosize, nbo, nbosize, lights, lightsize, alpha, beta, displayMode);
	cudaGLUnmapBufferObject(pbo);

	vbo = NULL;
	cbo = NULL;
	ibo = NULL;

	frame++;
	fpstracker++;

	//////////////////////
	// Timing cuda call //
	//////////////////////
	cudaEventRecord(stop, 0);
	cudaEventSynchronize(stop);
	cudaEventElapsedTime(&time, start, stop);
	printf("runCuda runtime: %3.1f ms \n", time);
}
void runCuda() {
    if (camchanged) {
        iteration = 0;
        Camera &cam = renderState->camera;
        glm::vec3 v = cam.view;
        glm::vec3 u = cam.up;
        glm::vec3 r = glm::cross(v, u);
        glm::mat4 rotmat = glm::rotate(theta, r) * glm::rotate(phi, u);
        cam.view = glm::vec3(rotmat * glm::vec4(v, 0.f));
        cam.up = glm::vec3(rotmat * glm::vec4(u, 0.f));
        cam.position += cammove.x * r + cammove.y * u + cammove.z * v;

		// Camera to grid center
		float distance = cam.resolution.x / 2 / tan(cam.fov.x / 2);
		cam.toGrid = glm::vec3(cam.view.x*distance, cam.view.y*distance, cam.view.z*distance);
		// Find camera right vector
		float rAngle = -PI / 2;
		float qx = cam.view.x * sin(rAngle / 2);
		float qy = cam.view.y * sin(rAngle / 2);
		float qz = cam.view.z * sin(rAngle / 2);
		float qw = cos(rAngle / 2);

		glm::quat q = glm::quat(qw, qx, qy, qz);
		cam.right = q * cam.up;

        theta = phi = 0;
        cammove = glm::vec3();
        camchanged = false;
    }

    // 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

    if (iteration == 0) {
        pathtraceFree();
        pathtraceInit(scene);
    }

    if (iteration < renderState->iterations) {
        uchar4 *pbo_dptr = NULL;
        iteration++;
        cudaGLMapBufferObject((void**)&pbo_dptr, pbo);

        // execute the kernel
        int frame = 0;
        pathtrace(pbo_dptr, frame, iteration);

        // unmap buffer object
        cudaGLUnmapBufferObject(pbo);
    } else {
        saveImage();
        pathtraceFree();
        cudaDeviceReset();
        exit(EXIT_SUCCESS);
    }
}
Example #7
0
void Mandelbrot::WriteBuffer() {

	checkCudaErrors( cudaGLMapBufferObject( ( void** ) &this->devArray, this->buffer ), __LINE__, false );

	cudaMemcpy( this->devArray, this->devCalcArray, this->iSize, cudaMemcpyDeviceToDevice );

	checkCudaErrors( cudaGLUnmapBufferObject( this->buffer ), __LINE__, false );

	this->bIsFlushed = true;
}
void runCuda()
{
    // 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

    float *dptrvert=NULL;
	float *velptr=NULL;
    cudaGLMapBufferObject((void**)&dptrvert, planetVBO);
	cudaGLMapBufferObject((void**)&velptr, velocityVBO);

    // execute the kernel
    cudaFlockingUpdateWrapper(DT, seekTarget);
#if VISUALIZE == 1
    cudaUpdateVBO(dptrvert, velptr);
#endif
    // unmap buffer object
    cudaGLUnmapBufferObject(planetVBO);
	cudaGLUnmapBufferObject(velocityVBO);
}
Example #9
0
void Renderer::render(const Camera& camera, float time) {

	// calc cam vars
  glm::vec3 A,B,C;
  {
    // camera ray
    C = glm::normalize(camera.getLookAt()-camera.getPosition());

    // calc A (screen x)
    // calc B (screen y) then scale down relative to aspect
    // fov is for screen x axis
    A = glm::normalize(glm::cross(C,camera.getUp()));
    B = 1.0f/camera.getAspect()*glm::normalize(glm::cross(A,C));

    // scale by FOV
    float tanFOV = tan(glm::radians(camera.getFOV()));
    A *= tanFOV;
    B *= tanFOV;
  }

  // cuda call
  unsigned int* out_data;
	checkCudaErrors(cudaGLMapBufferObject((void**)&out_data, pbo));
  
  if (mode == RAYTRACE) {
    raytrace1(out_data, image_width, image_height, time,
      camera.getPosition(), A, B, C,
      scene_d, sceneSize);
  }
  else if (mode == PATHTRACE) {
    ++filmIters;

    pathtrace(out_data, image_width, image_height, time,
      camera.getPosition(), A, B, C,
      camera.m_lensRadius, camera.m_focalDist,
      scene_d, sceneSize,
      rand_d, rays_d, col_d, idx_d,
      film_d, filmIters);
  }

	checkCudaErrors(cudaGLUnmapBufferObject(pbo));

	// download texture from destination PBO
	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo);
  glActiveTexture(GL_TEXTURE0 + RENDER_TEXTURE);
	glBindTexture(GL_TEXTURE_2D, result_texture);
	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, image_width, image_height, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
  glActiveTexture(GL_TEXTURE0 + UNUSED_TEXTURE);

	SDK_CHECK_ERROR_GL();

  
  fullScreenQuad.display();
}
Example #10
0
void runCuda()
{
    // 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

    float4 *dptr=NULL;
    float *dptrvert=NULL;
    cudaGLMapBufferObject((void**)&dptr, pbo);
    cudaGLMapBufferObject((void**)&dptrvert, planetVBO);

    // execute the kernel
    cudaNBodyUpdateWrapper(DT);
#if VISUALIZE == 1
    cudaUpdatePBO(dptr, field_width, field_height);
    cudaUpdateVBO(dptrvert, field_width, field_height);
#endif
    // unmap buffer object
    cudaGLUnmapBufferObject(planetVBO);
    cudaGLUnmapBufferObject(pbo);
}
Example #11
0
//-------------------------------
//---------RUNTIME STUFF---------
//-------------------------------
void runCuda() {
    // 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;

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

    frame++;
    fpstracker++;
}
Example #12
0
int cu2_map_buf(QSP_ARG_DECL  Data_Obj *dp)
{
	cudaError_t e;

	e = cudaGLMapBufferObject( &OBJ_DATA_PTR(dp),  OBJ_BUF_ID(dp) );
	if( e != cudaSuccess ){
		describe_cuda_driver_error2("cu2_map_buf",
				"cudaGLMapBufferObject",e);
		return -1;
	}
	return 0;
}
Example #13
0
//====================================
// Main loop
//====================================
void RunCuda(){
    // 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
    uchar4 *dptr = NULL;
    cudaGLMapBufferObject((void**)&dptr, m_pbo);

    // Execute the kernel
    CudaKernel(dptr, m_width, m_height, m_major, m_minor);

    // Unmap buffer object
    cudaGLUnmapBufferObject(m_pbo);
}
Example #14
0
// This is the normal display path
void display(void)
{	  
    cutilCheckError(cutStartTimer(timer));  

    // Sobel operation
    Pixel *data = NULL;
    cutilSafeCall(cudaGLMapBufferObject((void**)&data, pbo_buffer));
    sobelFilter(data, imWidth, imHeight, g_SobelDisplayMode, imageScale );
    cutilSafeCall(cudaGLUnmapBufferObject(pbo_buffer));   

    glClear(GL_COLOR_BUFFER_BIT);

    glBindTexture(GL_TEXTURE_2D, texid);
    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo_buffer);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, imWidth, imHeight, 
                   GL_LUMINANCE, GL_UNSIGNED_BYTE, OFFSET(0));
    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);

    glDisable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_2D);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        
    glBegin(GL_QUADS);
    glVertex2f(0, 0); glTexCoord2f(0, 0);
    glVertex2f(0, 1); glTexCoord2f(1, 0);
    glVertex2f(1, 1); glTexCoord2f(1, 1);
    glVertex2f(1, 0); glTexCoord2f(0, 1);
    glEnd();
    glBindTexture(GL_TEXTURE_2D, 0);

    if (g_CheckRender && g_CheckRender->IsQAReadback() && g_Verify) {
        printf("> (Frame %d) readback BackBuffer\n", frameCount);
        g_CheckRender->readback( imWidth, imHeight );
        g_CheckRender->savePPM ( sOriginal_ppm[g_Index], true, NULL );
        if (!g_CheckRender->PPMvsPPM(sOriginal_ppm[g_Index], sReference_ppm[g_Index], MAX_EPSILON_ERROR, 0.15f)) {
            g_TotalErrors++;
        }
        g_Verify = false;
    }
    glutSwapBuffers();

    cutilCheckError(cutStopTimer(timer));  

    computeFPS();

    glutPostRedisplay();
}
// display results using OpenGL
void display()
{
    cutilCheckError(cutStartTimer(timer));  

    // execute filter, writing results to pbo
    unsigned int *d_result;
    cutilSafeCall(cudaGLMapBufferObject((void**)&d_result, pbo));
    gaussianFilterRGBA(d_img, d_result, d_temp, width, height, sigma, order, nthreads);
    cutilSafeCall(cudaGLUnmapBufferObject(pbo));

    // load texture from pbo
    glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
    glBindTexture(GL_TEXTURE_2D, texid);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
    glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);

    // display results
    glClear(GL_COLOR_BUFFER_BIT);

    glEnable(GL_TEXTURE_2D);
    glDisable(GL_DEPTH_TEST);

    glBegin(GL_QUADS);
    glTexCoord2f(0, 1); glVertex2f(0, 0);
    glTexCoord2f(1, 1); glVertex2f(1, 0);
    glTexCoord2f(1, 0); glVertex2f(1, 1);
    glTexCoord2f(0, 0); glVertex2f(0, 1);
    glEnd();

    glDisable(GL_TEXTURE_2D);

    if (g_CheckRender && g_CheckRender->IsQAReadback() && g_Verify) {
        // readback for QA testing
        printf("> (Frame %d) Readback BackBuffer\n", frameCount);
        g_CheckRender->readback( width, height );
        g_CheckRender->savePPM(sOriginal[g_Index], true, NULL);
        if (!g_CheckRender->PPMvsPPM(sOriginal[g_Index], sReference[g_Index], MAX_EPSILON_ERROR, 0.50f )) {
            g_TotalErrors++;
        }
        g_Verify = false;
    }

    glutSwapBuffers();

    cutilCheckError(cutStopTimer(timer));  

    computeFPS();
}
Example #16
0
void initCuda(){
  // Use device with highest Gflops/s
  cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );

  initPBO(&pbo);
  dptr=NULL;
  cudaGLMapBufferObject((void**)&dptr, pbo);
  clearPBOpos(dptr,width,height);
  cudaGLUnmapBufferObject(pbo);
  // Clean up on program exit
  atexit(cleanupCuda);
  SetScissorWindow(glm::vec4(300,300,500,500));
  texture.mapptr = stbi_load("cow.jpeg",&texture.width, &texture.height,&texture.depth,0);
  runCuda();
}
Example #17
0
// Run the Cuda part of the computation
void runCuda()
{
  uchar4 *dptr=NULL;
 
  // 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
  cudaGLMapBufferObject((void**)&dptr, pbo);
 
  // execute the kernel
  launch_kernel(dptr, image_width, image_height, animTime);
 
  // unmap buffer object
  cudaGLUnmapBufferObject(pbo);
}
void runCuda() {
    if (camchanged) {
        iteration = 0;
        Camera &cam = renderState->camera;
        glm::vec3 v = cam.view;
        glm::vec3 u = cam.up;
        glm::vec3 r = glm::cross(v, u);
        glm::mat4 rotmat = glm::rotate(theta, r) * glm::rotate(phi, u);
        cam.view = glm::vec3(rotmat * glm::vec4(v, 0.f));
        cam.up = glm::vec3(rotmat * glm::vec4(u, 0.f));
        cam.position += cammove.x * r + cammove.y * u + cammove.z * v;
        theta = phi = 0;
        cammove = glm::vec3();
        camchanged = false;
    }

    // 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

    if (iteration == 0) {
        pathtraceFree();
        pathtraceInit(scene);
    }

    if (iteration < renderState->iterations) {
        uchar4 *pbo_dptr = NULL;
        iteration++;
        cudaGLMapBufferObject((void**)&pbo_dptr, pbo);

        // execute the kernel
        if( scene->blur ) {
        	for( int frame = 0; frame<(scene->frames); frame++ ){
        		pathtrace(pbo_dptr, frame, scene->frames, iteration);
        		//printf("frame is : %d", frame);
        	}
        } else {
        	pathtrace(pbo_dptr, 0, 0, iteration);
        }

        // unmap buffer object
        cudaGLUnmapBufferObject(pbo);
    } else {
        saveImage();
        pathtraceFree();
        cudaDeviceReset();
        exit(EXIT_SUCCESS);
    }
}
Example #19
0
////////////////////////////////////////////////////////////////////////////////
//! Run the Cuda part of the computation
////////////////////////////////////////////////////////////////////////////////
void runCuda(GLuint vbo)
{
    // map OpenGL buffer object for writing from CUDA
    float4 *dptr;
    cutilSafeCall(cudaGLMapBufferObject((void**)&dptr, vbo));

    // execute the kernel
//    dim3 block(8, 8, 1);
//    dim3 grid(mesh_width / block.x, mesh_height / block.y, 1);
//    kernel<<< grid, block>>>(dptr, mesh_width, mesh_height, anim);

    launch_kernel(dptr, mesh_width, mesh_height, anim);

    // unmap buffer object
    cutilSafeCall(cudaGLUnmapBufferObject(vbo));
}
Example #20
0
File: cu2.c Project: E-LLP/QuIP
static int cu2_map_buf(QSP_ARG_DECL  Data_Obj *dp)
{
#ifdef HAVE_OPENGL
	cudaError_t e;

	e = cudaGLMapBufferObject( &OBJ_DATA_PTR(dp),  OBJ_BUF_ID(dp) );
	if( e != cudaSuccess ){
		describe_cuda_driver_error2("cu2_map_buf",
				"cudaGLMapBufferObject",e);
		return -1;
	}
	return 0;
#else // ! HAVE_OPENGL
	WARN("cu2_map_buf:  Sorry, no OpenGL support in this build!?");
	return -1;
#endif // ! HAVE_OPENGL
}
//====================================
// Main loop
//====================================
void runCUDA() {
    // 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

    float4 *dptr = NULL;
    float *dptrvert = NULL;
    cudaGLMapBufferObject((void**)&dptrvert, planetVBO);

    // execute the kernel
    Nbody::stepSimulation(DT);
#if VISUALIZE
    Nbody::copyPlanetsToVBO(dptrvert);
#endif
    // unmap buffer object
    cudaGLUnmapBufferObject(planetVBO);
}
void runCuda(){
  // 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();

  // Update view and model to projection transform matrices in each step when interacting with keyboard or mouse
  *view = glm::lookAt(cam.position, glm::vec3(0.0f), cam.up);
  *transformModel2Projection = utilityCore::glmMat4ToCudaMat4(*projection * *view * *model);
  viewPort = glm::normalize(utilityCore::multiplyMat(utilityCore::glmMat4ToCudaMat4(*projection * *view), glm::vec4(cam.view, 1.0f)));

  // Transformation Feedback
  std::cout <<  "\n The model-view-projection transformation is:" << std::endl;
  utilityCore::printMat4(*projection * *view * *model);

  std::cout <<  "\n The view port in the clip space is:" << std::endl;
  utilityCore::printVec3(viewPort);

  cudaGLMapBufferObject((void**)&dptr, pbo);
  cudaRasterizeCore(dptr, glm::vec2(width, height), frame, vbo, vbosize, cbo, cbosize, ibo, ibosize, nbo, nbosize, transformModel2Projection, viewPort, antialiasing, depthFlag, flatcolorFlag, color, multicolorFlag);
  cudaGLUnmapBufferObject(pbo);

  vbo = NULL;
  cbo = NULL;
  ibo = NULL;
  nbo = NULL;

  frame++;
  fpstracker++;

}
Example #23
0
static void cuda_display_finish(QSP_ARG_DECL  Data_Obj *dp)
{
	cudaError_t e;

	// re-map so we can use again with CUDA
	// BUG?  Is it safe to do this before the call to swap_buffers???
	//cutilSafeCall(cudaGLMapBufferObject( &OBJ_DATA_PTR(dp),  OBJ_BUF_ID(dp) ));

	e = cudaGLMapBufferObject( &OBJ_DATA_PTR(dp),  OBJ_BUF_ID(dp) );

	if( e != cudaSuccess ){
		WARN("Error mapping buffer object!?");
		// should we return now, with possibly other cleanup???
	}

	SET_OBJ_FLAG_BITS(dp, DT_BUF_MAPPED);
	// propagate change to children and parents
	propagate_flag(dp,DT_BUF_MAPPED);
}
Example #24
0
void runCuda(){
  // 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

	

  vbo = mesh->getVBO();

  vbosize = mesh->getVBOsize();
  nbo = mesh->getNBO();

  nbosize = mesh->getNBOsize();
  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();
 
  calcuatetransformationMatrix( eye,glm::vec2(width, height), front,  back);
    dptr=NULL;
  cudaGLMapBufferObject((void**)&dptr, pbo);
  if(ReadBlendType() == ADD)
  {
	  drawTexture(dptr,width, height,texture);
  }
 
  //clearPBOpos(dptr,width,height);
  cudaRasterizeCore(dptr, glm::vec2(width, height), frame, vbo, vbosize, nbo, nbosize, cbo, cbosize, ibo, ibosize);
  cudaGLUnmapBufferObject(pbo);

 
  vbo = NULL;
  cbo = NULL;
  ibo = NULL;

  frame++;
  fpstracker++;

}
// display results using OpenGL
void display()
{
    sdkStartTimer(&timer);

    // execute filter, writing results to pbo
    unsigned int *d_result;
    checkCudaErrors(cudaGLMapBufferObject((void **)&d_result, pbo));
    gaussianFilterRGBA(d_img, d_result, d_temp, width, height, sigma, order, nthreads);
    checkCudaErrors(cudaGLUnmapBufferObject(pbo));

    // load texture from pbo
    glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
    glBindTexture(GL_TEXTURE_2D, texid);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
    glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);

    // display results
    glClear(GL_COLOR_BUFFER_BIT);

    glEnable(GL_TEXTURE_2D);
    glDisable(GL_DEPTH_TEST);

    glBegin(GL_QUADS);
    glTexCoord2f(0, 1);
    glVertex2f(0, 0);
    glTexCoord2f(1, 1);
    glVertex2f(1, 0);
    glTexCoord2f(1, 0);
    glVertex2f(1, 1);
    glTexCoord2f(0, 0);
    glVertex2f(0, 1);
    glEnd();

    glDisable(GL_TEXTURE_2D);
    glutSwapBuffers();

    sdkStopTimer(&timer);

    computeFPS();
}
Example #26
0
static void select_reference_color(int x, int y) {
    static float offset = SCREEN_WIDTH/1280.0f;
    printf("(After scaling) Handling click on x = %d, y = %d\n", x, y);
    GLuint left_buffer, right_buffer, buffer;
    kb_images_current_buffers(&left_buffer, &right_buffer);
    printf("left texture id = %d, right = %d\n", left_buffer, right_buffer);
    uchar4 *gpu_buffer = NULL;
    if (x < 640*offset) {
        /* The clicked pixel is in the left image */
        buffer = left_buffer;
    } else {
        /* The clicked pixel is in the right image */
        buffer = right_buffer;
        x -= 640*offset;
    }
    cutilSafeCall(cudaGLMapBufferObject((void**)&gpu_buffer, buffer));
    uchar4 pixel;
    cudaMemcpy(&pixel, gpu_buffer + (y * 640) + x, sizeof(uchar4), cudaMemcpyDeviceToHost);
    printf("pixel-value: %d, %d, %d (%d)\n", pixel.x, pixel.y, pixel.z, pixel.w);
    static char rgbbuffer[4096];
    snprintf(rgbbuffer, sizeof(rgbbuffer), "%d,%d,%d", pixel.x, pixel.y, pixel.z);
    kb_ui_call_javascript("SetRGB", rgbbuffer);

    double r = pixel.z;
    double g = pixel.y;
    double b = pixel.x;
    double nominator = sqrt((r * r) + (g * g) + (b * b));
    printf("nominator = %f\n", nominator);
    reference_color.x = r / nominator;
    reference_color.y = g / nominator;
    reference_color.z = b / nominator;
    printf("reference_color final: %f %f %f\n",
            reference_color.x, reference_color.y, reference_color.z);

    cutilSafeCall(cudaGLUnmapBufferObject(buffer));
}
Example #27
0
void CMarchingCubes::ComputeIsosurface(ElemType* _pFval, ElemType _isoValue, RenderData* _pRender)
{
	int threads = 128;
	dim3 grid(m_NumVoxels / threads, 1, 1);
	// get around maximum grid size of 65535 in each dimension
	if (grid.x > 65535) {
		grid.y = grid.x / 32768;
		grid.x = 32768;
	}

	uint totalVerts = 0;
	int size = m_GridSize.x * m_GridSize.y * m_GridSize.z * sizeof(float);
	//////////////////////////////////////////////////////////////////////////
	int len = m_GridSize.x * m_GridSize.y * m_GridSize.z;
	float *pFvalTemp = new float[len];
	for (int i = 0; i < len; i++)
	{
		pFvalTemp[i] = _pFval[i];
	}
	//////////////////////////////////////////////////////////////////////////
	float* pdVolumeFval;				// ¶¥µãº¯ÊýÖµÎÆÀí(n¡¡Surface)
	cutilSafeCall(cudaMalloc((void**) &pdVolumeFval, size));
	cutilSafeCall(cudaMemcpy(pdVolumeFval, pFvalTemp, size, cudaMemcpyHostToDevice) );
	bindVolumeValTexture(pdVolumeFval);
	delete []pFvalTemp;

	// calculate number of vertices need per voxel
	launch_classifyVoxel(grid, threads, 
		m_pdVoxelVerts, m_pdVoxelOccupied, pdVolumeFval,
		m_GridSize,	m_NumVoxels, _isoValue);

#if DEBUG_BUFFERS
	printf("voxelVerts:\n");
	dumpBuffer(m_pdVoxelVerts, m_NumVoxels);
#endif

#if SKIP_EMPTY_VOXELS

	// scan voxel occupied array
	cudppScan(m_Scanplan, m_pdVoxelOccupiedScan, m_pdVoxelOccupied, m_NumVoxels);

#if DEBUG_BUFFERS
	printf("voxelOccupiedScan:\n");
	dumpBuffer(m_pdVoxelOccupiedScan, m_NumVoxels);
#endif

	// read back values to calculate total number of non-empty voxels
	// since we are using an exclusive scan, the total is the last value of
	// the scan result plus the last value in the input array
	{
		uint lastElement, lastScanElement;
		cutilSafeCall(cudaMemcpy((void *) &lastElement, 
			(void *) (m_pdVoxelOccupied + m_NumVoxels - 1), 
			sizeof(uint), cudaMemcpyDeviceToHost));
		cutilSafeCall(cudaMemcpy((void *) &lastScanElement, 
			(void *) (m_pdVoxelOccupiedScan + m_NumVoxels - 1), 
			sizeof(uint), cudaMemcpyDeviceToHost));
		m_ActiveVoxels = lastElement + lastScanElement;
	}

	if (0 == m_ActiveVoxels) {
		// return if there are no full voxels
		totalVerts = 0;
		return;
	}

	// compact voxel index array
	launch_compactVoxels(grid, threads, m_pdCompactedVoxelArray, m_pdVoxelOccupied, m_pdVoxelOccupiedScan, m_NumVoxels);
	cutilCheckMsg("compactVoxels failed");

#endif // SKIP_EMPTY_VOXELS

	// scan voxel vertex count array
	cudppScan(m_Scanplan, m_pdVoxelVertsScan, m_pdVoxelVerts, m_NumVoxels);
#if DEBUG_BUFFERS
	printf("voxelVertsScan:\n");
	dumpBuffer(m_pdVoxelVertsScan, m_NumVoxels);
#endif

	// readback total number of vertices
	{
		uint lastElement, lastScanElement;
		cutilSafeCall(cudaMemcpy((void *) &lastElement, 
			(void *) (m_pdVoxelVerts + m_NumVoxels - 1), 
			sizeof(uint), cudaMemcpyDeviceToHost));
		cutilSafeCall(cudaMemcpy((void *) &lastScanElement, 
			(void *) (m_pdVoxelVertsScan + m_NumVoxels - 1), 
			sizeof(uint), cudaMemcpyDeviceToHost));
		totalVerts = lastElement + lastScanElement;
	}

	// create VBOs
	GLuint	posVbo, normalVbo;
	createVBO(&posVbo, totalVerts * sizeof(float) * 4);
	cutilSafeCall(cudaGLRegisterBufferObject(posVbo));
	createVBO(&normalVbo, totalVerts * sizeof(float) * 4);
	cutilSafeCall(cudaGLRegisterBufferObject(normalVbo));

	// generate triangles, writing to vertex buffers
	float4 *d_pos = 0, *d_normal = 0;
	cutilSafeCall(cudaGLMapBufferObject((void**)&d_pos, posVbo));
	cutilSafeCall(cudaGLMapBufferObject((void**)&d_normal, normalVbo));

#if SKIP_EMPTY_VOXELS
	dim3 grid2((int) ceil(m_ActiveVoxels / (float) NTHREADS), 1, 1);
#else
	dim3 grid2((int) ceil(m_NumVoxels / (float) NTHREADS), 1, 1);
#endif
	while(grid2.x > 65535) {
		grid2.x/=2;
		grid2.y*=2;
	}

	launch_generateTriangles(grid2, NTHREADS, d_pos, d_normal, 
		m_pdCompactedVoxelArray, m_pdVoxelVertsScan,
		m_pdVolume, pdVolumeFval,
		m_GridSize, _isoValue,
		m_ActiveVoxels, m_MaxVerts);

	cutilSafeCall(cudaGLUnmapBufferObject(normalVbo));
	cutilSafeCall(cudaGLUnmapBufferObject(posVbo));

	_pRender->posVbo = posVbo;
	_pRender->normalVbo = normalVbo;
	_pRender->totalVerts = totalVerts;
	cutilSafeCall(cudaFree(pdVolumeFval));
}
void runCuda(){

  // 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
  
  if((unsigned int)iterations < renderCam->iterations){
    uchar4 *dptr=NULL;
    ++iterations;
    cudaGLMapBufferObject((void**)&dptr, pbo);
  
    //pack geom and material arrays
	unsigned int objectsSize = renderScene->objects.size(), materialsSize = renderScene->materials.size(), lightsSize = renderScene->lights.size();
    geom* geoms = new geom[objectsSize];
    material* materials = new material[materialsSize];
	light* lights = new light[lightsSize];

    
    for(unsigned int i=0; i< objectsSize; ++i){
      geoms[i] = renderScene->objects[i];
    }
    for(unsigned int i=0; i< materialsSize; ++i){
      materials[i] = renderScene->materials[i];
    }
	for(unsigned int i=0; i< lightsSize; ++i){
      lights[i] = renderScene->lights[i];
    }
    
  
    // execute the kernel
    cudaRaytraceCore(dptr, renderCam, targetFrame, iterations, materials, materialsSize, geoms, objectsSize, lights, lightsSize);
    
    // unmap buffer object
    cudaGLUnmapBufferObject(pbo);
  }else{

    if(!finishedRender){
      //output image file
      image outputImage(renderCam->resolution.x, renderCam->resolution.y);

      for(int x=0; x<renderCam->resolution.x; ++x){
        for(int y=0; y<renderCam->resolution.y; ++y){
          int index = x + (y * renderCam->resolution.x);
          outputImage.writePixelRGB(x,y,renderCam->image[index]);
        }
      }
      
      gammaSettings gamma;
      gamma.applyGamma = true;
      gamma.gamma = 1.0/2.2;
      gamma.divisor = renderCam->iterations;
      outputImage.setGammaSettings(gamma);
      string filename = renderCam->imageName;
      string s;
      stringstream out;
      out << targetFrame;
      s = out.str();
      utilityCore::replaceString(filename, ".bmp", "."+s+".bmp");
      utilityCore::replaceString(filename, ".png", "."+s+".png");
      outputImage.saveImageRGB(filename);
      cout << "Saved frame " << s << " to " << filename << endl;
      finishedRender = true;
      if(singleFrameMode==true){
        cudaDeviceReset(); 
        exit(0);
      }
    }
    if(targetFrame < renderCam->frames - 1){

      //clear image buffer and move onto next frame
      ++targetFrame;
      iterations = 0;
      for(int i=0; i<renderCam->resolution.x*renderCam->resolution.y; ++i){
        renderCam->image[i] = glm::vec3(0,0,0);
      }
      cudaDeviceReset(); 
      finishedRender = false;
    }
  }
  
}
Example #29
0
void runCuda(){

  // 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
  
  if(iterations<renderCam->iterations){
    uchar4 *dptr=NULL;
    iterations++;
    cudaGLMapBufferObject((void**)&dptr, pbo);
  
    //pack geom and material arrays
    geom* geoms = new geom[renderScene->objects.size()];
    material* materials = new material[renderScene->materials.size()];
    map* maps = new map[renderScene->maps.size()];

    for(int i=0; i<renderScene->objects.size(); i++){
      geoms[i] = renderScene->objects[i];
    }
    for(int i=0; i<renderScene->materials.size(); i++){
      materials[i] = renderScene->materials[i];
    }
    
  	for(int i=0; i<renderScene->maps.size(); i++){
      maps[i] = renderScene->maps[i];
    }
    // execute the kernel
	if(!textureMode)
		cudaRaytraceCore(dptr, renderCam, targetFrame, iterations, materials, renderScene->materials.size(),maps,renderScene->maps.size(), geoms, renderScene->objects.size(), mblur,dof);
	else
		cudaRaytraceCoreT(dptr, renderCam, targetFrame, iterations, materials, renderScene->materials.size(),maps,renderScene->maps.size(), geoms, renderScene->objects.size(), mblur,dof);

	// unmap buffer object
    cudaGLUnmapBufferObject(pbo);
  }else{

    if(!finishedRender){
      //output image file
      image outputImage(renderCam->resolution.x, renderCam->resolution.y);
	  image depthImage(renderCam->resolution.x, renderCam->resolution.y);
      for(int x=0; x<renderCam->resolution.x; x++){
        for(int y=0; y<renderCam->resolution.y; y++){
          int index = x + (y * renderCam->resolution.x);
		  glm::vec3 justRGB(renderCam->image[index].x,renderCam->image[index].y,renderCam->image[index].z);
          outputImage.writePixelRGB(renderCam->resolution.x-1-x,y,justRGB);
		  float d = abs(renderCam->image[index].w-renderCam->positions[targetFrame].z)/40.0f;
		  depthImage.writePixelRGB(renderCam->resolution.x-1-x,y,  glm::vec3(d,d,d));
        }
      }
      
      gammaSettings gamma;
      gamma.applyGamma = true;
      gamma.gamma = 1.0/2.2;
      gamma.divisor = renderCam->iterations;
      outputImage.setGammaSettings(gamma);
      string filename = renderCam->imageName;
      string s;
      stringstream out;
      out << targetFrame;
      s = out.str();
      utilityCore::replaceString(filename, ".bmp", "."+s+".bmp");
      utilityCore::replaceString(filename, ".png", "."+s+".png");
      outputImage.saveImageRGB(filename);
	  depthImage.saveImageRGB("depth."+s+".bmp");
      cout << "Saved frame " << s << " to " << filename << endl;
      finishedRender = true;
      if(singleFrameMode==true){
        //cudaDeviceReset(); 
        exit(0);
      }
    }
    if(targetFrame<renderCam->frames-1){

      //clear image buffer and move onto next frame
      targetFrame++;
      iterations = 0;
      for(int i=0; i<renderCam->resolution.x*renderCam->resolution.y; i++){
        renderCam->image[i] = glm::vec4(0,0,0,-1);
      }
      //cudaDeviceReset(); 
      finishedRender = false;
    }
  }
  
}
Example #30
0
// This is the normal display path
static void update_pf_viewer(QSP_ARG_DECL  Platform_Viewer *pvp, Data_Obj *dp) 
{
#ifdef HAVE_OPENGL
	int t;
	//cudaError_t e;

	// unmap buffer before using w/ GL
	if( BUF_IS_MAPPED(dp) ){
		if( (*PF_UNMAPBUF_FN(PFDEV_PLATFORM(OBJ_PFDEV(dp))))
				(QSP_ARG  dp) < 0 ) {
			WARN("update_pf_viewer:  buffer unmap error!?");
		}
#ifdef FOOBAR
		e = cudaGLUnmapBufferObject( OBJ_BUF_ID(dp) );   
		if( e != cudaSuccess ){
			describe_cuda_driver_error2("update_pf_viewer",
				"cudaGLUnmapBufferObject",e);
			NERROR1("failed to unmap buffer object");
		}
#endif // FOOBAR
		CLEAR_OBJ_FLAG_BITS(dp, DT_BUF_MAPPED);
		// propagate change to children and parents
		propagate_flag(dp,DT_BUF_MAPPED);

	}

	//
	//bind_texture(OBJ_DATA_PTR(dp));

	glClear(GL_COLOR_BUFFER_BIT);

/*
sprintf(ERROR_STRING,"update_pf_viewer:  tex_id = %d, buf_id = %d",
OBJ_TEX_ID(dp),OBJ_BUF_ID(dp));
advise(ERROR_STRING);
*/
	glBindTexture(GL_TEXTURE_2D, OBJ_TEX_ID(dp));
	// is glBindBuffer REALLY part of libGLEW???
//#ifdef HAVE_LIBGLEW
	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, OBJ_BUF_ID(dp));
//#endif // HAVE_LIBGLEW

#ifdef FOOBAR
	switch(OBJ_COMPS(dp)){
		/* what used to be here??? */
	}
#endif /* FOOBAR */

	t=gl_pixel_type(dp);
	glTexSubImage2D(GL_TEXTURE_2D, 0,	// target, level
		0, 0,				// x0, y0
		OBJ_COLS(dp), OBJ_ROWS(dp), 	// dx, dy
		t,
		GL_UNSIGNED_BYTE,		// type
		OFFSET(0));			// offset into PIXEL_UNPACK_BUFFER

//#ifdef HAVE_LIBGLEW
	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
//#endif // HAVE_LIBGLEW

	glBegin(GL_QUADS);
	glTexCoord2f(0, 1); glVertex2f(-1.0, -1.0);
	glTexCoord2f(0, 0); glVertex2f(-1.0, 1.0);
	glTexCoord2f(1, 0); glVertex2f(1.0, 1.0);
	glTexCoord2f(1, 1); glVertex2f(1.0, -1.0);
	glEnd();
	glBindTexture(GL_TEXTURE_2D, 0);

#ifdef FOOBAR
	e = cudaGLMapBufferObject( &OBJ_DATA_PTR(dp),  OBJ_BUF_ID(dp) );
	if( e != cudaSuccess ){
		WARN("Error mapping buffer object!?");
		// should we return now, with possibly other cleanup???
	}
#endif // FOOBAR
	if( (*PF_MAPBUF_FN(PFDEV_PLATFORM(OBJ_PFDEV(dp))))(QSP_ARG  dp) < 0 ){
		WARN("update_pf_viewer:  Error mapping buffer!?");
	}


	SET_OBJ_FLAG_BITS(dp, DT_BUF_MAPPED);
	// propagate change to children and parents
	propagate_flag(dp,DT_BUF_MAPPED);
#else // ! HAVE_OPENGL
	NO_OGL_MSG
#endif // ! HAVE_OPENGL
}