/// <summary>
/// Creates a new <see cref="ComputeBuffer{T}"/> from an existing OpenGL buffer object.
/// </summary>
/// <typeparam name="TDataType"> The type of the elements of the <see cref="ComputeBuffer{T}"/>. <typeparamref name="T"/> should match the type of the elements in the OpenGL buffer. </typeparam>
/// <param name="context"> A <see cref="ComputeContext"/> with enabled CL/GL sharing. </param>
/// <param name="flags"> A bit-field that is used to specify usage information about the <see cref="ComputeBuffer{T}"/>. Only <see cref="ComputeMemoryFlags.ReadOnly"/>, <see cref="ComputeMemoryFlags.WriteOnly"/> and <see cref="ComputeMemoryFlags.ReadWrite"/> are allowed. </param>
/// <param name="bufferId"> The OpenGL buffer object id to use for the creation of the <see cref="ComputeBuffer{T}"/>. </param>
/// <returns> The created <see cref="ComputeBuffer{T}"/>. </returns>
public static ComputeBuffer <TDataType> CreateFromGLBuffer <TDataType>(ComputeContext context, ComputeMemoryFlags flags, int bufferId) where TDataType : struct
{
CLMemoryHandle handle = CL12.CreateFromGLBuffer(context.Handle, flags, bufferId, out var error);
ComputeException.ThrowOnError(error);
return(new ComputeBuffer <TDataType>(handle, context, flags));
}
internal ComputeSubBuffer(ComputeContext context, CLMemoryHandle handle, ComputeMemoryFlags flags)
: base(context, flags)
{
Handle = handle;
Init();
}
private ComputeImage3D(CLMemoryHandle handle, ComputeContext context, ComputeMemoryFlags flags)
: base(context, flags)
{
Handle = handle;
Init();
}
/// <summary>
/// Creates a new <see cref="ComputeImage2D"/> from an OpenGL renderbuffer object.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/> with enabled CL/GL sharing. </param>
/// <param name="flags"> A bit-field that is used to specify usage information about the <see cref="ComputeImage2D"/>. Only <c>ComputeMemoryFlags.ReadOnly</c>, <c>ComputeMemoryFlags.WriteOnly</c> and <c>ComputeMemoryFlags.ReadWrite</c> are allowed. </param>
/// <param name="renderbufferId"> The OpenGL renderbuffer object id to use. </param>
/// <returns> The created <see cref="ComputeImage2D"/>. </returns>
public static ComputeImage2D CreateFromGLRenderbuffer(ComputeContext context, ComputeMemoryFlags flags, int renderbufferId)
{
CLMemoryHandle image = CL12.CreateFromGLRenderbuffer(context.Handle, flags, renderbufferId, out var error);
ComputeException.ThrowOnError(error);
return(new ComputeImage2D(image, context, flags));
}
public ComputeImage3D(ComputeContext context, ComputeMemoryFlags flags, ComputeImageFormat format, int width, int height, int depth, long rowPitch, long slicePitch, IntPtr data)
: base(context, flags)
{
Handle = CL12.CreateImage3D(context.Handle, flags, ref format, new IntPtr(width), new IntPtr(height), new IntPtr(depth), new IntPtr(rowPitch), new IntPtr(slicePitch), data, out var error);
ComputeException.ThrowOnError(error);
Init();
}
public static ComputeImage3D CreateFromGLTexture3D(ComputeContext context, ComputeMemoryFlags flags, int textureTarget, int mipLevel, int textureId)
{
var image = CL12.CreateFromGLTexture3D(context.Handle, flags, textureTarget, mipLevel, textureId, out var error);
ComputeException.ThrowOnError(error);
return(new ComputeImage3D(image, context, flags));
}
/// <summary>
/// Creates a new ComputeBuffer from external memory handles.
/// </summary>
/// <param name="handle"></param>
/// <param name="context"></param>
/// <returns></returns>
public static ComputeBuffer <T> From(IntPtr handle, ComputeContext context)
{
var memoryHandle = new CLMemoryHandle(handle);
var flags = (ComputeMemoryFlags)GetInfo <CLMemoryHandle, ComputeMemoryInfo, long>(memoryHandle, ComputeMemoryInfo.Flags, CL12.GetMemObjectInfo);
return(new ComputeBuffer <T>(memoryHandle, context, flags));
}
/// <summary>
/// Creates a new <see cref="ComputeBuffer{T}"/>.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/> used to create the <see cref="ComputeBuffer{T}"/>. </param>
/// <param name="flags"> A bit-field that is used to specify allocation and usage information about the <see cref="ComputeBuffer{T}"/>. </param>
/// <param name="count"> The number of elements of the <see cref="ComputeBuffer{T}"/>. </param>
/// <param name="dataPtr"> A pointer to the data for the <see cref="ComputeBuffer{T}"/>. </param>
public ComputeBuffer(ComputeContext context, ComputeMemoryFlags flags, long count, IntPtr dataPtr)
: base(context, flags)
{
var size = ComputeTools.SizeOf <T>() * count;
Handle = CL12.CreateBuffer(context.Handle, flags, new IntPtr(size), dataPtr, out var error);
ComputeException.ThrowOnError(error);
Init(size, count);
}
internal ComputeUserEvent(ComputeContext context, CLEventHandle handle, ComputeCommandType type)
{
Handle = handle;
SetID(Handle.Value);
Type = type;
Context = context;
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="flags"></param>
/// <param name="type"></param>
/// <returns></returns>
protected static ICollection <ComputeImageFormat> GetSupportedFormats(ComputeContext context, ComputeMemoryFlags flags, ComputeMemoryType type)
{
ComputeErrorCode error = CL12.GetSupportedImageFormats(context.Handle, flags, type, 0, null, out var formatCountRet);
ComputeException.ThrowOnError(error);
ComputeImageFormat[] formats = new ComputeImageFormat[formatCountRet];
error = CL12.GetSupportedImageFormats(context.Handle, flags, type, formatCountRet, formats, out formatCountRet);
ComputeException.ThrowOnError(error);
return(new Collection <ComputeImageFormat>(formats));
}
/// <summary>
/// Creates a new <see cref="ComputeUserEvent"/>.
/// </summary>
/// <param name="context"> The <see cref="ComputeContext"/> in which the <see cref="ComputeUserEvent"/> is created. </param>
/// <remarks> Requires OpenCL 1.1. </remarks>
public ComputeUserEvent(ComputeContext context)
{
Handle = CL11.CreateUserEvent(context.Handle, out var error);
ComputeException.ThrowOnError(error);
SetID(Handle.Value);
Type = (ComputeCommandType)GetInfo <CLEventHandle, ComputeEventInfo, uint>(Handle, ComputeEventInfo.CommandType, CL12.GetEventInfo);
Context = context;
//HookNotifier();
//Debug.WriteLine("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
}
public XArrayMemory(ComputeContext context, ComputeMemoryFlags flags, XArray obj) : base(context, flags)
{
var hostPtr = IntPtr.Zero;
if ((flags & (ComputeMemoryFlags.CopyHostPointer | ComputeMemoryFlags.UseHostPointer)) != ComputeMemoryFlags.None)
{
hostPtr = obj.NativePtr;
}
ComputeErrorCode error = ComputeErrorCode.Success;
var handle = CL12.CreateBuffer(context.Handle, flags, new IntPtr(obj.Count), hostPtr, out error);
this.Size = obj.Count;
this.Handle = handle;
}
public GenericArrayMemory(ComputeContext context, ComputeMemoryFlags flags, object obj) : base(context, flags)
{
Array array = (Array)obj;
if (array.Length == 0)
{
return;
}
int size = Marshal.SizeOf(array.GetValue(0).GetType()) * array.Length;
var datagch = GCHandle.Alloc(obj, GCHandleType.Pinned);
ComputeErrorCode error = ComputeErrorCode.Success;
var handle = CL12.CreateBuffer(context.Handle, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.CopyHostPointer, new IntPtr(size), datagch.AddrOfPinnedObject(), out error);
this.Size = size;
this.Handle = handle;
}
/// <summary>
/// Creates a new <see cref="ComputeBuffer{T}"/>.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/> used to create the <see cref="ComputeBuffer{T}"/>. </param>
/// <param name="flags"> A bit-field that is used to specify allocation and usage information about the <see cref="ComputeBuffer{T}"/>. </param>
/// <param name="data"> The data for the <see cref="ComputeBuffer{T}"/>. </param>
/// <remarks> Note, that <paramref name="data"/> cannot be an "immediate" parameter, i.e.: <c>new T[100]</c>, because it could be quickly collected by the GC causing Amplifier.OpenCL.Cloo to send and invalid reference to OpenCL. </remarks>
public ComputeBuffer(ComputeContext context, ComputeMemoryFlags flags, T[] data)
: base(context, flags)
{
var size = ComputeTools.SizeOf <T>() * data.Length;
GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
try
{
Handle = CL12.CreateBuffer(context.Handle, flags, new IntPtr(size), dataPtr.AddrOfPinnedObject(), out var error);
ComputeException.ThrowOnError(error);
}
finally
{
dataPtr.Free();
}
Init(size, data.Length);
}
public GenericArrayMemory(ComputeContext context, ComputeMemoryFlags flags, Array array) : base(context, flags)
{
if (array.Length == 0)
{
return;
}
int size = Marshal.SizeOf(array.GetValue(0).GetType()) * array.Length;
var hostPtr = IntPtr.Zero;
if ((flags & (ComputeMemoryFlags.CopyHostPointer | ComputeMemoryFlags.UseHostPointer)) != ComputeMemoryFlags.None)
{
var datagch = GCHandle.Alloc(array, GCHandleType.Pinned);
hostPtr = datagch.AddrOfPinnedObject();
}
ComputeErrorCode error = ComputeErrorCode.Success;
var handle = CL12.CreateBuffer(context.Handle, flags, new IntPtr(size), hostPtr, out error);
this.Size = size;
this.Handle = handle;
}
public GenericArrayMemory(ComputeContext context, ComputeMemoryFlags flags) : base(context, flags)
{
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="flags"></param>
protected ComputeBufferBase(ComputeContext context, ComputeMemoryFlags flags)
: base(context, flags)
{
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="flags"></param>
protected ComputeImage(ComputeContext context, ComputeMemoryFlags flags)
: base(context, flags)
{
}
/// <summary>
/// Gets a collection of supported <see cref="ComputeImage3D"/> <see cref="ComputeImageFormat"/>s in a <see cref="ComputeContext"/>.
/// </summary>
/// <param name="context"> The <see cref="ComputeContext"/> for which the collection of <see cref="ComputeImageFormat"/>s is queried. </param>
/// <param name="flags"> The <c>ComputeMemoryFlags</c> for which the collection of <see cref="ComputeImageFormat"/>s is queried. </param>
/// <returns> The collection of the required <see cref="ComputeImageFormat"/>s. </returns>
public static ICollection <ComputeImageFormat> GetSupportedFormats(ComputeContext context, ComputeMemoryFlags flags)
{
return(GetSupportedFormats(context, flags, ComputeMemoryType.Image3D));
}
private ComputeBuffer(CLMemoryHandle handle, ComputeContext context, ComputeMemoryFlags flags, long size, long count)
: base(context, flags)
{
Handle = handle;
Init(size, count);
}
/// <summary>
/// Creates a new <see cref="ComputeBuffer{T}"/>.
/// </summary>
/// <param name="context"> A <see cref="ComputeContext"/> used to create the <see cref="ComputeBuffer{T}"/>. </param>
/// <param name="flags"> A bit-field that is used to specify allocation and usage information about the <see cref="ComputeBuffer{T}"/>. </param>
/// <param name="count"> The number of elements of the <see cref="ComputeBuffer{T}"/>. </param>
public ComputeBuffer(ComputeContext context, ComputeMemoryFlags flags, long count)
: this(context, flags, count, IntPtr.Zero)
{
}
