// unregister this buffer object with CUDA and destroy buffer
private void DeleteTextureVBO()
{
if ((m_cudaTextureSource == null) && (m_cudaTextureVar == null))
{
return;
}
if (m_cudaTextureSource != null)
{
m_cudaTextureSource.Dispose();
m_cudaTextureSource = null;
}
else if (m_cudaTextureVar != null)
{
m_cudaTextureVar.Dispose();
m_cudaTextureVar = null;
}
GL.BindBuffer(BufferTarget.PixelUnpackBuffer, 0);
GL.DeleteBuffers(1, ref m_textureVBO);
GL.DeleteTextures(1, ref m_texture_id);
m_textureVBO = 0;
m_texture_id = 0;
}
private void DeleteVertexVBO()
{
// unregister this buffer object with CUDA and destroy buffer
if (m_cudaVertexSource != null)
{
m_cudaVertexSource.Dispose();
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
GL.DeleteBuffers(1, ref m_vertexVBO);
m_vertexVBO = 0;
}
}
private void DeleteTextureVBO()
{
// unregister this buffer object with CUDA and destroy buffer
if (m_cudaTextureSource != null)
{
m_cudaTextureSource.Dispose();
GL.BindBuffer(BufferTarget.PixelUnpackBuffer, 0);
GL.DeleteBuffers(1, ref m_textureVBO);
GL.DeleteTextures(1, ref m_texture_id);
m_textureVBO = 0;
m_texture_id = 0;
m_cudaTextureSource = null;
}
}
// unregister this buffer object with CUDA and destroy buffer
private void DeleteVertexVBO()
{
if ((m_cudaVertexSource == null) && (m_cudaVertexVar == null))
{
return;
}
if (m_cudaVertexSource != null)
{
m_cudaVertexSource.Dispose();
m_cudaVertexSource = null;
}
else if (m_cudaVertexVar != null)
{
m_cudaVertexVar.Dispose();
m_cudaVertexVar = null;
}
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
GL.DeleteBuffers(1, ref m_vertexVBO);
m_vertexVBO = 0;
}
internal void Dispose()
{
if (m_window == null)
{
return;
}
try
{
if (!m_context.IsDisposed && !m_context.IsCurrent && !m_window.Exists)
{
return;
}
m_context.MakeCurrent(m_window.WindowInfo);
ErrorCode err = GL.GetError();
if (err != ErrorCode.NoError)
{
MyLog.WARNING.WriteLine(Owner.Name + ": OpenGL error detected when disposing stuff, code: " + err);
}
// delete textures
if (m_textureHandles != null)
{
foreach (int handle in m_textureHandles.Values)
{
int h = handle;
GL.DeleteTextures(1, ref h);
}
m_textureHandles.Clear();
}
if (m_renderTextureHandle != 0)
{
GL.DeleteTextures(1, ref m_renderTextureHandle);
m_renderTextureHandle = 0;
}
if (m_scoreTextHandle != 0)
{
GL.DeleteTextures(1, ref m_scoreTextHandle);
m_scoreTextHandle = 0;
}
// delete FBO
if (m_fboHandle != 0)
{
GL.DeleteFramebuffers(1, ref m_fboHandle);
m_fboHandle = 0;
}
// delete PBO
if (m_sharedBufferHandle != 0)
{
GL.DeleteBuffers(1, ref m_sharedBufferHandle);
m_sharedBufferHandle = 0;
}
// delete CUDA <-> GL interop
if (m_renderResource != null)
{
m_renderResource.Dispose();
m_renderResource = null;
}
if (m_context != null)
{
m_context.Dispose();
m_context = null;
}
if (m_window != null)
{
m_window.Dispose();
m_window = null;
}
}
catch (AccessViolationException e)
{
MyLog.WARNING.WriteLine(Owner.Name + ": Failed when disposing OpenGL stuff. Cautious progress advised. Error: " + e.Message);
}
catch (Exception e)
{
MyLog.WARNING.WriteLine(Owner.Name + ": Failed when disposing OpenGL. Error: " + e.Message);
}
}
private T InitRR <T>(T rr, MyMemoryBlock <float> targetMemBlock, MyMemoryBlock <float> targetDepthMemBlock, Action <T> initializer = null)
where T : class, IRenderRequestBase
{
if (initializer != null)
{
initializer.Invoke(rr);
}
rr.FlipYAxis = true;
targetMemBlock.ExternalPointer = 0; // first reset ExternalPointer
// Setup image copying from RR through Cpu
if (Owner.CopyDataThroughCPU)
{
ImageSettings imageSettings = new ImageSettings(RenderRequestImageCopyingMode.Cpu)
{
CopyDepth = Owner.CopyDepthData && targetDepthMemBlock != null,
};
imageSettings.OnSceneBufferPrepared += (request, data, depthData) =>
{
int width = rr.Resolution.Width;
int stride = width * sizeof(uint);
int lines = data.Length / width;
for (int i = 0; i < lines; ++i)
{
Buffer.BlockCopy(data, i * stride, targetMemBlock.Host, i * width * sizeof(uint), stride);
}
if (imageSettings.CopyDepth)
{
for (int i = 0; i < lines; ++i)
{
Buffer.BlockCopy(depthData, i * stride, targetDepthMemBlock.Host, i * width * sizeof(float), stride);
}
}
// targetMemBlock.SafeCopyToDevice(); this needs to be called on the BrainSim thread
// targetDepthMemBlock.SafeCopyToDevice(); this needs to be called on the BrainSim thread
};
rr.Image = imageSettings;
return(rr);
}
// Setup image copying from RR through Pbo
ImageSettings image = new ImageSettings(RenderRequestImageCopyingMode.OpenglPbo)
{
CopyDepth = Owner.CopyDepthData && targetDepthMemBlock != null,
};
// Setup data copying to our unmanaged memblocks
uint renderTextureHandle = 0;
uint depthRenderTextureHandle = 0;
CudaOpenGLBufferInteropResource renderResource = null;
CudaOpenGLBufferInteropResource depthRenderResource = null;
image.OnPreRenderingEvent += (sender, vbo, depthVbo) =>
{
if (renderResource != null && renderResource.IsMapped)
{
renderResource.UnMap();
}
if (image.CopyDepth)
{
if (depthRenderResource != null && depthRenderResource.IsMapped)
{
depthRenderResource.UnMap();
}
}
};
image.OnPostRenderingEvent += (sender, vbo, depthVbo) =>
{
// Vbo can be allocated during drawing, create the resource after that (post-rendering)
MyKernelFactory.Instance.GetContextByGPU(Owner.GPU).SetCurrent();
// Fill color memblock
if (renderResource == null || vbo != renderTextureHandle)
{
if (renderResource != null)
{
renderResource.Dispose();
}
renderTextureHandle = vbo;
try
{
renderResource = new CudaOpenGLBufferInteropResource(renderTextureHandle,
image.CopyDepth ? CUGraphicsRegisterFlags.None : CUGraphicsRegisterFlags.ReadOnly); // Read only by CUDA
}
catch (Exception e)
{
MyLog.ERROR.WriteLine("calling CudaOpenGLBufferInteropResource returns " + e +
". Go to World properties and in Runtime section set Copy data through CPU to True");
throw e;
}
}
renderResource.Map();
targetMemBlock.ExternalPointer = renderResource.GetMappedPointer <uint>().DevicePointer.Pointer;
targetMemBlock.FreeDevice();
targetMemBlock.AllocateDevice();
// Fill depth memblock
if (image.CopyDepth)
{
if (depthRenderResource == null || depthVbo != depthRenderTextureHandle)
{
if (depthRenderResource != null)
{
depthRenderResource.Dispose();
}
depthRenderTextureHandle = depthVbo;
depthRenderResource = new CudaOpenGLBufferInteropResource(
depthRenderTextureHandle,
CUGraphicsRegisterFlags.ReadOnly); // Read only by CUDA
}
depthRenderResource.Map();
targetDepthMemBlock.ExternalPointer = depthRenderResource.GetMappedPointer <float>().DevicePointer.Pointer;
targetDepthMemBlock.FreeDevice();
targetDepthMemBlock.AllocateDevice();
}
};
rr.Image = image;
// Initialize the target memory block
// Use a dummy number that will get replaced on first Execute call to suppress MemBlock error during init
targetMemBlock.ExternalPointer = 1;
if (targetDepthMemBlock != null)
{
targetDepthMemBlock.ExternalPointer = 1;
}
return(rr);
}