/// <summary>
/// Creates the CL image from GL texture. This can be a platfor specific operation.
/// On some platforms, some of the parameters may be ignored.
/// </summary>
/// <returns>The CL image from GL texture.</returns>
/// <param name="context">Context.</param>
/// <param name="memFlags">Mem flags.</param>
/// <param name="target">Target.</param>
/// <param name="mipLevel">Mip level.</param>
/// <param name="texturePointer">Texture pointer.</param>
/// <param name="error">Error.</param>
public static IMem CreateCLImageFromGLTexture(Context context, MemFlags memFlags, TextureTarget target, int mipLevel, IntPtr texturePointer, out ErrorCode error){
#if UNITY_STANDALONE_OSX || UNITY_IPHONE
//here, we use a function from apple (gcl) headers
var ret = new Mem(gcl_gl_create_image_from_texture(target,new IntPtr(mipLevel),texturePointer));
error = ErrorCode.Success;
return ret;
#endif
#if UNITY_STANDALONE_WIN || UNITY_STANDALONE_LINUX || UNITY_ANDROID
//here we use the GL sharing extensions.
return new Mem(clCreateFromGLTexture2D((context as IHandleData).Handle,memFlags,target,new IntPtr(mipLevel),texturePointer,out error));
#endif
}
public static IMemoryObject CreateImage2D(ContextHandle context,
MemFlags flags,
ImageFormat imageFormat,
IntPtr imageWidth,
IntPtr imageHeight,
IntPtr imageRowPitch,
IntPtr hostPtr,
out OpenCLErrorCode errorcodeRet)
{
using (var imageFormatPtr = imageFormat.Pin())
return new MemoryObject(clCreateImage2D((context as IHandleData).Handle, flags, imageFormatPtr, imageWidth, imageHeight, imageRowPitch, hostPtr, out errorcodeRet));
}
internal extern static unsafe IntPtr CreateBuffer(IntPtr context, MemFlags flags, IntPtr size, IntPtr host_ptr, [OutAttribute] OpenTK.Compute.CL10.ErrorCode* errcode_ret);
public static IMem <T> CreateBuffer <T>(Context context, MemFlags flags, int length, out ErrorCode errcodeRet)
where T : struct
{
return(new Mem <T>(CreateBuffer(context, flags, (IntPtr)(TypeSize <T> .SizeInt * length), null, out errcodeRet)));
}
public static IMem CreateBuffer(Context context, MemFlags flags, IntPtr size, out ErrorCode errcodeRet)
{
return(CreateBuffer(context, flags, size, null, out errcodeRet));
}
internal extern static unsafe IntPtr CreateBuffer(IntPtr context, MemFlags flags, IntPtr size, IntPtr host_ptr, [OutAttribute] osuTK.Compute.CL10.ErrorCode *errcode_ret);
/// <summary>
/// Convenience function. Checks if a context supports a specific image format
/// </summary>
/// <param name="flags"></param>
/// <param name="type"></param>
/// <param name="channelOrder"></param>
/// <param name="channelType"></param>
/// <returns>true if the image format is supported, false otherwise</returns>
public bool SupportsImageFormat(MemFlags flags, MemObjectType type, ChannelOrder channelOrder, ChannelType channelType)
{
ImageFormat[] imageFormats = GetSupportedImageFormats(flags, type);
foreach (ImageFormat imageFormat in imageFormats)
{
if (imageFormat.ChannelOrder == channelOrder && imageFormat.ChannelType == channelType)
return true;
}
return false;
}
public Image CreateImage2D(MemFlags flags, ImageFormat imageFormat, long imageWidth, long imageHeight, long imageRowPitch, IntPtr pHost)
{
return CreateImage2D(flags, imageFormat, (IntPtr)imageWidth, (IntPtr)imageHeight, (IntPtr)imageRowPitch, pHost);
}
public Mem CreateBuffer( MemFlags flags, long size, void* pHost )
{
IntPtr memID;
ErrorCode result;
memID = (IntPtr)OpenCL.CreateBuffer( ContextID, (ulong)flags, new IntPtr(size), pHost, out result );
if( result!=ErrorCode.SUCCESS )
throw new OpenCLException( "CreateBuffer failed with error code "+result, result);
return new Mem( this, memID );
}
public Buffer CreateBuffer(MemFlags flags, int size)
{
return(Buffer.Create(this, flags, size));
}
public static IntPtr CreateSubBuffer(IntPtr memobj, MemFlags flags, BufferRegion buffer_create_info, out ErrorCode errcode_ret)
{
return(OpenCLAPI.clCreateSubBuffer(memobj, (cl_mem_flags)flags, BufferCreateType.REGION, &buffer_create_info, out errcode_ret));
}
public static IMemoryObject CreateBuffer(ContextHandle context, MemFlags flags, IntPtr size, object hostData, out OpenCLErrorCode errcodeRet)
{
using (var hostPtr = hostData.Pin())
return CreateBuffer(context, flags, size, hostPtr, out errcodeRet);
}
private static extern OpenCLErrorCode clGetSupportedImageFormats(IntPtr context,
MemFlags flags,
MemObjectType imageType,
uint numEntries,
[Out] [MarshalAs(UnmanagedType.LPArray)] ImageFormat[] imageFormats,
out uint numImageFormats);
public CLBuffer <T> CreateBuffer <T>(MemFlags memFlags, T[] data) where T : struct
{
return(new CLBuffer <T>(ContextId, CommandQueueId, memFlags, data));
}
internal extern static unsafe IntPtr CreateImage3D(IntPtr context, MemFlags flags, ImageFormat *image_format, IntPtr image_width, IntPtr image_height, IntPtr image_depth, IntPtr image_row_pitch, IntPtr image_slice_pitch, IntPtr host_ptr, [OutAttribute] int *errcode_ret);
public static IntPtr CreateSubBuffer(IntPtr memobj, MemFlags flags, BufferRegion buffer_create_info, out ErrorCode errcode_ret)
{
return OpenCLAPI.clCreateSubBuffer(memobj, (cl_mem_flags)flags, BufferCreateType.REGION, &buffer_create_info, out errcode_ret);
}
public Mem CreateBuffer(MemFlags flags, long size)
{
return CreateBuffer(flags, size, IntPtr.Zero);
}
public Image2D CreateImage2D(MemFlags flags, ImageFormat format, int width, int height)
{
return(Image2D.Create(this, flags, format, width, height));
}
public Mem CreateFromGLTexture3D(MemFlags flags, int target, int mipLevel, int texture)
{
IntPtr memID;
ErrorCode result;
memID = OpenCL.CreateFromGLTexture3D(ContextID, (ulong)flags, target, mipLevel, (uint)texture, out result);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("CreateFromGLTexture3D failed with error code " + result, result);
return new Mem(this, memID);
}
private static extern IntPtr clCreateFromGLTexture2D(IntPtr context, MemFlags memflags, TextureTarget target, IntPtr mip_level, IntPtr texture, out ErrorCode error);
public Image CreateImage3D(MemFlags flags, ImageFormat imageFormat, IntPtr imageWidth, IntPtr imageHeight, IntPtr imageDepth, IntPtr imageRowPitch, IntPtr imageSlicePitch, IntPtr pHost)
{
IntPtr memID;
ErrorCode result;
memID = (IntPtr)OpenCL.CreateImage3D(ContextID, (ulong)flags, imageFormat, imageWidth, imageHeight, imageDepth, imageRowPitch, imageSlicePitch, pHost.ToPointer(), out result);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("CreateImage3D failed with error code " + result, result);
return new Image(this, memID);
}
public static extern Error clGetSupportedImageFormats(OpenCLContext context, MemFlags flags, MemObjectType image_type, Int32 num_entries, [Out] ImageFormat[] image_formats, Int32 num_image_formats);
private static extern IntPtr clCreateFromGLTexture3D(IntPtr context, MemFlags memflags, TextureTarget target, IntPtr mip_level, IntPtr texture, out ErrorCode error);
public static OpenCLMem clCreateBuffer(OpenCLContext context, MemFlags flags, IntPtr size, [In] Byte[] bytes, out Error error)
{
error = default(Error);
Console.WriteLine("Calling OpenCLMem clCreateBuffer(OpenCLContext context, MemFlags flags, IntPtr size, [In] Byte[] bytes, out Error error)");
return default(OpenCLMem);
}
public void SetArgumentValue <T>(int argumentIndex, T *item, MemFlags flags, long count)
where T : unmanaged
{
SetArgumentValue(argumentIndex, item, flags, sizeof(T) * count);
}
public static OpenCLMem clCreateBuffer(OpenCLContext context, MemFlags flags, IntPtr size, IntPtr host_ptr, Error error)
{
Console.WriteLine("Calling OpenCLMem clCreateBuffer(OpenCLContext context, MemFlags flags, IntPtr size, IntPtr host_ptr, Error error)");
return default(OpenCLMem);
}
public static IMem <T> CreateBuffer <T>(Context context, MemFlags flags, T[] hostData, out ErrorCode errcodeRet)
where T : struct
{
return(new Mem <T>(CreateBuffer(context, flags, (IntPtr)(TypeSize <T> .SizeInt * hostData.Length), hostData, out errcodeRet)));
}
public static Error clGetSupportedImageFormats(OpenCLContext context, MemFlags flags, MemObjectType image_type, Int32 num_entries, [Out] ImageFormat[] image_formats, Int32 num_image_formats)
{
Console.WriteLine("Calling Error clGetSupportedImageFormats(OpenCLContext context, MemFlags flags, MemObjectType image_type, Int32 num_entries, [Out] ImageFormat[] image_formats, Int32 num_image_formats)");
return default(Error);
}
internal extern static unsafe int GetSupportedImageFormats(IntPtr context, MemFlags flags, MemObjectType image_type, uint num_entries, ImageFormat* image_formats, uint* num_image_formats);
public static extern OpenCLMem clCreateBuffer(OpenCLContext context, MemFlags flags, IntPtr size, [In] Byte[] bytes, out Error error);
internal extern static unsafe IntPtr CreateImage3D(IntPtr context, MemFlags flags, ImageFormat* image_format, IntPtr image_width, IntPtr image_height, IntPtr image_depth, IntPtr image_row_pitch, IntPtr image_slice_pitch, IntPtr host_ptr, [OutAttribute] int* errcode_ret);
public static extern OpenCLMem clCreateBuffer(OpenCLContext context, MemFlags flags, IntPtr size, IntPtr host_ptr, Error error);
public static ImageFormat[] GetSupportedImageFormats(Context context, MemFlags flags, MemObjectType imageType, out ErrorCode error)
{
uint imageFormatCount;
error = GetSupportedImageFormats(context, flags, imageType, 0, null, out imageFormatCount);
if (error != ErrorCode.Success)
return new ImageFormat[0];
var imageFormats = new ImageFormat[imageFormatCount];
error = GetSupportedImageFormats(context, flags, imageType, imageFormatCount, imageFormats, out imageFormatCount);
if (error != ErrorCode.Success)
return new ImageFormat[0];
return imageFormats;
}
public static extern OpenCLMem clCreateImage3D(OpenCLContext context, MemFlags flags, ref ImageFormat image_format, IntPtr image_width, IntPtr image_height, IntPtr image_depth, IntPtr image_row_pitch, IntPtr image_slice_pitch, IntPtr host_ptr, Error error);
public Mem CreateBuffer(MemFlags flags, long size, IntPtr pHost)
{
return CreateBuffer(flags, size, pHost.ToPointer());
}
public static OpenCLMem clCreateImage2D(OpenCLContext context, MemFlags flags, ref ImageFormat image_format, IntPtr image_width, IntPtr image_height, IntPtr image_row_pitch, IntPtr host_ptr, Error error)
{
Console.WriteLine("Calling OpenCLMem clCreateImage2D(OpenCLContext context, MemFlags flags, ref ImageFormat image_format, IntPtr image_width, IntPtr image_height, IntPtr image_row_pitch, IntPtr host_ptr, Error error)");
return default(OpenCLMem);
}
public Mem CreateFromGLRenderbuffer(MemFlags flags, IntPtr renderbuffer)
{
IntPtr memID;
ErrorCode result;
memID = OpenCL.CreateFromGLRenderbuffer(ContextID, (ulong)flags, (uint)renderbuffer, out result);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("CreateFromGLTexture3D failed with error code " + result, result);
return new Mem(this, memID);
}
internal static extern IntPtr clCreateBuffer(IntPtr context, MemFlags flags, IntPtr size, IntPtr hostPtr, [Out][MarshalAs(UnmanagedType.I4)] out ErrorCode errcodeRet);
public Image CreateImage2D(MemFlags flags, ImageFormat imageFormat, long imageWidth, long imageHeight)
{
return CreateImage2D(flags, imageFormat, (IntPtr)imageWidth, (IntPtr)imageHeight, IntPtr.Zero, IntPtr.Zero);
}
internal static extern IntPtr clCreateImage3D(IntPtr context, MemFlags flags, IntPtr imageFormat, IntPtr imageWidth, IntPtr imageHeight, IntPtr imageDepth, IntPtr imageRowPitch, IntPtr imageSlicePitch, IntPtr hostPtr, out ErrorCode errcodeRet);
public Image CreateImage3D(MemFlags flags, ImageFormat imageFormat, int imageWidth, int imageHeight, int imageDepth, int imageRowPitch, int imageSlicePitch, IntPtr pHost)
{
return CreateImage3D(flags, imageFormat, (IntPtr)imageWidth, (IntPtr)imageHeight, (IntPtr)imageDepth, (IntPtr)imageRowPitch, (IntPtr)imageSlicePitch, pHost);
}
/// <summary>
/// OpenCL 1.1
/// </summary>
/// <param name="buffer"></param>
/// <param name="flags"></param>
/// <param name="buffer_create_info"></param>
/// <param name="errcode_ret"></param>
/// <returns></returns>
public Mem CreateSubBuffer(Mem buffer, MemFlags flags, BufferRegion buffer_create_info, out ErrorCode errcode_ret)
{
var memID = OpenCL.CreateSubBuffer(buffer.MemID, flags, buffer_create_info, out errcode_ret);
return(new Mem(buffer.Context, memID));
}
/// <summary>
/// Query which ImageFormats are supported by this context
/// </summary>
/// <param name="flags"></param>
/// <param name="type"></param>
/// <returns></returns>
public ImageFormat[] GetSupportedImageFormats(MemFlags flags, MemObjectType type)
{
uint numImageFormats;
ImageFormat[] imageFormats;
ErrorCode result;
result = OpenCL.GetSupportedImageFormats(ContextID, (ulong)flags, (uint)type, (uint)0, null, out numImageFormats);
if( result!=ErrorCode.SUCCESS )
throw new OpenCLException("GetSupportedImageFormats failed with error code " + result, result);
imageFormats = new ImageFormat[numImageFormats];
result = OpenCL.GetSupportedImageFormats(ContextID, (ulong)flags, (uint)type, numImageFormats, imageFormats, out numImageFormats);
if (result != ErrorCode.SUCCESS)
throw new OpenCLException("GetSupportedImageFormats failed with error code " + result, result);
return imageFormats;
}
private KernelImage(int index, MemFlags flags, int width, int height, SystemGDI.PixelFormat format)
: this(index, flags, width, height, format.ToGPU())
{
}
public KernelImage(int index, MemFlags flags, byte[] bytes, int width, int height, SystemGDI.PixelFormat pixelFormat)
: this(index, flags, bytes, width, height, pixelFormat.ToGPU())
{
}
public static extern Mem CreateBuffer(IntPtr context,
MemFlags flags,
long size,
IntPtr hostPtr,
[Out][MarshalAs(UnmanagedType.I4)] out ErrorCode errcodeRet);
/// <summary>
/// OpenCL 1.1
/// </summary>
/// <param name="buffer"></param>
/// <param name="flags"></param>
/// <param name="buffer_create_info"></param>
/// <param name="errcode_ret"></param>
/// <returns></returns>
public Mem CreateSubBuffer(Mem buffer, MemFlags flags, BufferRegion buffer_create_info, out ErrorCode errcode_ret)
{
IntPtr memID = OpenCL.CreateSubBuffer(buffer.MemID, flags, buffer_create_info, out errcode_ret);
return new Mem(buffer.Context, memID);
}
internal extern static unsafe int GetSupportedImageFormats(IntPtr context, MemFlags flags, MemObjectType image_type, uint num_entries, ImageFormat *image_formats, uint *num_image_formats);
