//-----------------------------------------------------------------------------
// Name: ReleaseTextures()
// Desc: Release Direct3D Textures (free-ing)
//-----------------------------------------------------------------------------
HRESULT ReleaseTextures()
{
// unregister the Cuda resources
cudaGraphicsUnregisterResource(g_texture_2d.cudaResource);
getLastCudaError("cudaGraphicsUnregisterResource (g_texture_2d) failed");
cudaFree(g_texture_2d.cudaLinearMemory);
getLastCudaError("cudaFree (g_texture_2d) failed");
cudaGraphicsUnregisterResource(g_texture_cube.cudaResource);
getLastCudaError("cudaGraphicsUnregisterResource (g_texture_cube) failed");
cudaFree(g_texture_cube.cudaLinearMemory);
getLastCudaError("cudaFree (g_texture_2d) failed");
cudaGraphicsUnregisterResource(g_texture_vol.cudaResource);
getLastCudaError("cudaGraphicsUnregisterResource (g_texture_vol) failed");
cudaFree(g_texture_vol.cudaLinearMemory);
getLastCudaError("cudaFree (g_texture_vol) failed");
//
// clean up Direct3D
//
{
// release the resources we created
g_texture_2d.pTexture->Release();
g_texture_cube.pTexture->Release();
g_texture_vol.pTexture->Release();
}
return S_OK;
}
void VolRenRaycastCuda::setTF(const mslib::TF &tf, bool preinteg, float stepsize, Filter filter)
{
TFIntegrated<VolRenRaycast>::setTF(tf, preinteg, stepsize, filter);
if (tfFullRes) cc(cudaGraphicsUnregisterResource(tfFullRes));
cc(cudaGraphicsGLRegisterImage(&tfFullRes, tfInteg->getTexFull()->textureId(), GL_TEXTURE_2D, cudaGraphicsRegisterFlagsReadOnly));
if (tfBackRes) cc(cudaGraphicsUnregisterResource(tfBackRes));
cc(cudaGraphicsGLRegisterImage(&tfBackRes, tfInteg->getTexBack()->textureId(), GL_TEXTURE_2D, cudaGraphicsRegisterFlagsReadOnly));
}
void DestroyGlut()
{
cudaGraphicsUnregisterResource(grSite);
cudaGraphicsUnregisterResource(grVbo);
cublasDestroy_v2(cublasHd);
cudaDeviceReset();
}
WaterPlaneCUDA::~WaterPlaneCUDA(){
cudaFree(gpu_normals);
cudaFree(gpu_newVertices);
cudaFree(gpu_oldVertices);
disturbances.clear();
cutilSafeCall(cudaGraphicsUnregisterResource(cuda_newVertex_resource));
cutilSafeCall(cudaGraphicsUnregisterResource(cuda_oldVertex_resource));
cutilSafeCall(cudaGraphicsUnregisterResource(cuda_normalsVB_resource));
//cudaFree(DIM);
}
TriangleMesh::~TriangleMesh()
{
if (registered)
{
if (bound)
{
PGA_CUDA_checkedCall(cudaGraphicsUnmapResources(1, &cudaVertexAttributesBuffer, 0));
PGA_CUDA_checkedCall(cudaGraphicsUnmapResources(1, &cudaIndexBuffer, 0));
}
PGA_CUDA_checkedCall(cudaGraphicsUnregisterResource(cudaVertexAttributesBuffer));
PGA_CUDA_checkedCall(cudaGraphicsUnregisterResource(cudaIndexBuffer));
}
}
//-----------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
VOID Cleanup()
{
if (g_pVB != NULL)
{
// Unregister vertex buffer
// DEPRECATED: checkCudaErrors(cudaD3D10UnregisterResource(g_pVB));
cudaGraphicsUnregisterResource(cuda_VB_resource);
getLastCudaError("cudaGraphicsUnregisterResource failed");
g_pVB->Release();
}
if (g_pInputLayout != NULL)
g_pInputLayout->Release();
if (g_pSimpleEffect != NULL)
g_pSimpleEffect->Release();
if (g_pSwapChainRTV != NULL)
g_pSwapChainRTV->Release();
if (g_pSwapChain != NULL)
g_pSwapChain->Release();
// Uninitialize CUDA
cudaDeviceReset();
getLastCudaError("cudaDeviceReset failed");
if (g_pd3dDevice != NULL)
g_pd3dDevice->Release();
}
void cleanup()
{
sdkDeleteTimer(&timer);
sdkDeleteTimer(&kernel_timer);
if (h_img)
{
free(h_img);
h_img=NULL;
}
if (d_img)
{
cudaFree(d_img);
d_img=NULL;
}
if (d_temp)
{
cudaFree(d_temp);
d_temp=NULL;
}
// Refer to boxFilter_kernel.cu for implementation
freeTextures();
cudaGraphicsUnregisterResource(cuda_pbo_resource);
glDeleteBuffersARB(1, &pbo);
glDeleteTextures(1, &texid);
glDeleteProgramsARB(1, &shader);
}
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 27:
g_bExitESC = true;
exit(EXIT_SUCCESS);
break;
case 'r':
memset(hvfield, 0, sizeof(cData) * DS);
cudaMemcpy(dvfield, hvfield, sizeof(cData) * DS,
cudaMemcpyHostToDevice);
initParticles(particles, DIM, DIM);
cudaGraphicsUnregisterResource(cuda_vbo_resource);
getLastCudaError("cudaGraphicsUnregisterBuffer failed");
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(cData) * DS,
particles, GL_DYNAMIC_DRAW_ARB);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
cudaGraphicsGLRegisterBuffer(&cuda_vbo_resource, vbo, cudaGraphicsMapFlagsNone);
getLastCudaError("cudaGraphicsGLRegisterBuffer failed");
break;
default:
break;
}
}
void shutdown()
{
// unregister buffer to cuda
cudaGraphicsUnregisterResource(cuVboResource);
cudaGraphicsUnregisterResource(cuIboResource);
if(glIsBuffer(clothVBO))
glDeleteBuffers(1, &clothVBO);
if (glIsBuffer(clothIBO))
glDeleteBuffers(1, &clothIBO);
SAFE_DELETE(camera);
SAFE_DELETE(volcanoShaderProgram);
SAFE_DELETE(fireShaderProgram);
}
void cleanup()
{
cutilCheckError( cutDeleteTimer( timer));
if(h_img)cutFree(h_img);
cutilSafeCall(cudaFree(d_img));
cutilSafeCall(cudaFree(d_temp));
// Refer to boxFilter_kernel.cu for implementation
freeTextures();
//DEPRECATED: cutilSafeCall(cudaGLUnregisterBufferObject(pbo));
cudaGraphicsUnregisterResource(cuda_pbo_resource);
glDeleteBuffersARB(1, &pbo);
glDeleteTextures(1, &texid);
glDeleteProgramsARB(1, &shader);
if (g_CheckRender) {
delete g_CheckRender;
g_CheckRender = NULL;
}
if (g_FrameBufferObject) {
delete g_FrameBufferObject;
g_FrameBufferObject = NULL;
}
}
void cleanup()
{
// DEPRECATED: cutilSafeCall(cudaGLUnregisterBufferObject(heightVertexBuffer));
cutilSafeCall(cudaGraphicsUnregisterResource(cuda_heightVB_resource));
// DEPRECATED: cutilSafeCall(cudaGLUnregisterBufferObject(slopeVertexBuffer));
cutilSafeCall(cudaGraphicsUnregisterResource(cuda_slopeVB_resource));
deleteVBO(&posVertexBuffer);
deleteVBO(&heightVertexBuffer);
deleteVBO(&slopeVertexBuffer);
cutilSafeCall( cudaFree(d_h0) );
cutilSafeCall( cudaFree(d_slope) );
free(h_h0);
cufftDestroy(fftPlan);
}
void cleanup(void)
{
cudaGraphicsUnregisterResource(cuda_vbo_resource);
unbindTexture();
deleteTexture();
// Free all host and device resources
free(hvfield);
free(particles);
cudaFree(dvfield);
cudaFree(vxfield);
cudaFree(vyfield);
cufftDestroy(planr2c);
cufftDestroy(planc2r);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
glDeleteBuffersARB(1, &vbo);
sdkDeleteTimer(&timer);
if (g_bExitESC)
{
checkCudaErrors(cudaDeviceReset());
}
}
void DX11CustomRenderTarget::OnD3D11DestroyDevice()
{
for (UINT i = 0; i < m_uNumTargets; i++) {
if (m_Targets) SAFE_RELEASE(m_Targets[i]);
if (m_TargetsRTV) SAFE_RELEASE(m_TargetsRTV[i]);
if (m_TargetsSRV) SAFE_RELEASE(m_TargetsSRV[i]);
}
SAFE_DELETE_ARRAY(m_Targets);
SAFE_DELETE_ARRAY(m_TargetsRTV);
SAFE_DELETE_ARRAY(m_TargetsSRV);
SAFE_RELEASE(m_DepthStencil);
SAFE_RELEASE(m_DepthStencilDSV);
SAFE_RELEASE(m_DepthStencilSRV);
if (m_dCudaFloat) {
for (UINT i = 0; i < m_uNumTargets; i++) {
cutilSafeCall(cudaGraphicsUnregisterResource(m_dCudaFloat[i]));
}
SAFE_DELETE_ARRAY(m_dCudaFloat)
}
m_Width = 0;
m_Height = 0;
}
void initPixelBuffer()
{
if (pbo) {
// unregister this buffer object from CUDA C
cutilSafeCall(cudaGraphicsUnregisterResource(cuda_pbo_resource));
// delete old buffer
glDeleteBuffersARB(1, &pbo);
glDeleteTextures(1, &tex);
}
// create pixel buffer object for display
glGenBuffersARB(1, &pbo);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, width*height*sizeof(GLubyte)*4, 0, GL_STREAM_DRAW_ARB);
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
// register this buffer object with CUDA
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_pbo_resource, pbo, cudaGraphicsMapFlagsWriteDiscard));
// create texture for display
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
}
void cleanup()
{
sdkDeleteTimer(&timer);
sdkDeleteTimer(&kernel_timer);
if (hImage)
{
free(hImage);
}
freeTextures();
//DEPRECATED: checkCudaErrors(cudaGLUnregisterBufferObject(pbo));
cudaGraphicsUnregisterResource(cuda_pbo_resource);
glDeleteBuffersARB(1, &pbo);
glDeleteTextures(1, &texid);
glDeleteProgramsARB(1, &shader);
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
cudaDeviceReset();
}
void exitfunc() {
if (pbo) {
cudaGraphicsUnregisterResource(cuda_pbo_resource);
glDeleteBuffers(1, &pbo);
glDeleteTextures(1, &tex);
}
}
void glcu::delete_cuda_resource(cudaGraphicsResource_t &resource)
{
if (resource)
{
HANDLE_ERROR(cudaGraphicsUnregisterResource(resource));
resource = 0;
}
}
OsdCudaGLVertexBuffer::~OsdCudaGLVertexBuffer() {
cudaThreadSynchronize();
unmap();
cudaGraphicsUnregisterResource(_cudaResource);
cudaThreadSynchronize();
glDeleteBuffers(1, &_vbo);
}
void CudaTexture::destroy()
{
if(_cuda_tex_resource) cudaGraphicsUnregisterResource(_cuda_tex_resource);
if(m_texture) glDeleteTextures(1, &m_texture);
m_texture = 0;
m_width = m_height = 0;
_cuda_tex_resource = 0;
}
////////////////////////////////////////////////////////////////////////////////
//! Delete VBO
////////////////////////////////////////////////////////////////////////////////
void
deleteVBO(GLuint* vbo, struct cudaGraphicsResource **cuda_resource)
{
glBindBuffer(1, *vbo);
glDeleteBuffers(1, vbo);
//DEPRECATED: cutilSafeCall(cudaGLUnregisterBufferObject(*vbo));
cudaGraphicsUnregisterResource(*cuda_resource);
*vbo = 0;
}
void DeleteVBO(GLuint *vbo, struct cudaGraphicsResource *resource)
{
// unregister this buffer object with CUDA
cudaGraphicsUnregisterResource(resource);
glBindBuffer(1, *vbo);
glDeleteBuffers(1, vbo);
*vbo = 0;
}
VBO::~VBO()
{
// unregister this buffer object with CUDA
cutilSafeCall(cudaGraphicsUnregisterResource(cuda_vbo_resource));
glBindBuffer(1, vbo); // is this really needed???
glDeleteBuffers(1, &vbo);
vbo = 0;
}
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 27:
g_bExitESC = true;
exit(EXIT_SUCCESS);
break;
case 'f':
if (!fullscreen)
{
fullscreen = 1;
glutFullScreenToggle();
}
else
{
fullscreen = 0;
glutLeaveFullScreen();
}
break;
case 'r':
pthread_mutex_lock(&display_mutex);
memset(hvfield, 0, sizeof(cData) * DS);
cudaMemcpy(dvfield, hvfield, sizeof(cData) * DS,
cudaMemcpyHostToDevice);
initParticles(particles, DIM, DIM);
#ifndef OPTIMUS
cudaGraphicsUnregisterResource(cuda_vbo_resource);
getLastCudaError("cudaGraphicsUnregisterBuffer failed");
#endif
#if defined(OPTIMUS) || defined(BROADCAST)
cudaMemcpy(particles_gpu, particles, sizeof(cData) * DS, cudaMemcpyHostToDevice);
#endif
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(cData) * DS,
particles, GL_DYNAMIC_DRAW_ARB);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
#ifndef OPTIMUS
cudaGraphicsGLRegisterBuffer(&cuda_vbo_resource, vbo, cudaGraphicsMapFlagsNone);
getLastCudaError("cudaGraphicsGLRegisterBuffer failed");
#endif
pthread_mutex_unlock(&display_mutex);
break;
default:
break;
}
}
void cleanup(void)
{
cudaGraphicsUnregisterResource(cuda_pbo_resource);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
glDeleteBuffers(1, &pbo_buffer);
glDeleteTextures(1, &texid);
deleteTexture();
sdkDeleteTimer(&timer);
}
void deletePBO(GLuint* pbo) {
if (pbo) {
// Unregister this buffer object with CUDA
cudaGraphicsUnregisterResource(cuda_pbo);
glBindBuffer(GL_ARRAY_BUFFER, *pbo);
glDeleteBuffers(1, pbo);
*pbo = NULL;
}
}
void VolRenRaycastCuda::updateCUDAResources()
{
QOpenGLFunctions f(QOpenGLContext::currentContext());
// update entry and exit resources
if (entryRes) cc(cudaGraphicsUnregisterResource(entryRes));
cc(cudaGraphicsGLRegisterImage(&entryRes, *frustum.entryTexture(), GL_TEXTURE_2D, cudaGraphicsRegisterFlagsReadOnly));
if (exitRes) cc(cudaGraphicsUnregisterResource(exitRes));
cc(cudaGraphicsGLRegisterImage(&exitRes, *frustum.exitTexture(), GL_TEXTURE_2D, cudaGraphicsRegisterFlagsReadOnly));
// update output PBO and CUDA resource
// clean up
if (0 != outPBO) f.glDeleteBuffers(1, &outPBO);
// pbo
f.glGenBuffers(1, &outPBO);
f.glBindBuffer(GL_PIXEL_UNPACK_BUFFER, outPBO);
f.glBufferData(GL_PIXEL_UNPACK_BUFFER, 3 * frustum.getTextureWidth() * frustum.getTextureHeight() * sizeof(float), NULL, GL_STREAM_COPY);
f.glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
// register cuda resource
if (outRes) cc(cudaGraphicsUnregisterResource(outRes));
cc(cudaGraphicsGLRegisterBuffer(&outRes, outPBO, cudaGraphicsMapFlagsWriteDiscard));
}
//-----------------------------------------------------------------------------
void QGLImageGpuWidget::deletePbo()
{
// printf("void QGLImageGpuWidget::deletePbo()\n");
if(gl_pbo_)
{
// delete the PBO
cudaGraphicsUnregisterResource(cuda_pbo_resource_);
glDeleteBuffers( 1, &gl_pbo_ );
gl_pbo_=0;
cuda_pbo_resource_ = NULL;
}
}
void BodySystemGPU<T>::_finalize()
{
assert(m_bInitialized);
if (m_bUseSysMem)
{
checkCudaErrors(cudaFreeHost(m_hPos[0]));
checkCudaErrors(cudaFreeHost(m_hPos[1]));
checkCudaErrors(cudaFreeHost(m_hVel));
for (unsigned int i = 0; i < m_numDevices; i++)
{
cudaEventDestroy(m_deviceData[i].event);
}
}
else
{
delete [] m_hPos[0];
delete [] m_hPos[1];
delete [] m_hVel;
checkCudaErrors(cudaFree((void **)m_deviceData[0].dVel));
if (m_bUsePBO)
{
checkCudaErrors(cudaGraphicsUnregisterResource(m_pGRes[0]));
checkCudaErrors(cudaGraphicsUnregisterResource(m_pGRes[1]));
glDeleteBuffers(2, (const GLuint *)m_pbo);
}
else
{
checkCudaErrors(cudaFree((void **)m_deviceData[0].dPos[0]));
checkCudaErrors(cudaFree((void **)m_deviceData[0].dPos[1]));
}
}
delete [] m_deviceData;
m_bInitialized = false;
}
void cleanup(void) {
cutilSafeCall(cudaGraphicsUnregisterResource(cuda_pbo_resource));
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
glDeleteBuffers(1, &pbo_buffer);
glDeleteTextures(1, &texid);
deleteTexture();
if (g_CheckRender) {
delete g_CheckRender; g_CheckRender = NULL;
}
cutilCheckError(cutDeleteTimer(timer));
}
void copy(Renderable& out, const T * devicePtr)
{
cudaGraphicsResource *cudaVBOResource;
CUDA_ERROR_CHECK(cudaGraphicsGLRegisterBuffer(&cudaVBOResource, out.vbo(), cudaGraphicsMapFlagsWriteDiscard));
size_t num_bytes;
T* vboDevicePtr = NULL;
CUDA_ERROR_CHECK(cudaGraphicsMapResources(1, &cudaVBOResource, 0));
CUDA_ERROR_CHECK(cudaGraphicsResourceGetMappedPointer((void **)&vboDevicePtr, &num_bytes, cudaVBOResource));
CUDA_ERROR_CHECK(cudaMemcpy(vboDevicePtr, devicePtr, num_bytes, cudaMemcpyDeviceToDevice));
CUDA_ERROR_CHECK(cudaGraphicsUnmapResources(1, &cudaVBOResource, 0));
CUDA_ERROR_CHECK(cudaGraphicsUnregisterResource(cudaVBOResource));
}
