protected OpenCLMemory(OpenCLContext context, ComputeMemory computeMemory) { Contract.Requires(context != null); Contract.Requires(computeMemory != null); Context = context; ComputeMemory = computeMemory; }
/// <summary> /// Enqueues a command to unmap a buffer or a <see cref="ComputeImage"/> from the host address space. /// </summary> /// <param name="memory"> The <see cref="ComputeMemory"/>. </param> /// <param name="mappedPtr"> The host address returned by a previous call to <see cref="ComputeCommandQueue.Map"/>. This pointer is <c>IntPtr.Zero</c> after this method returns. </param> /// <param name="events"> A collection of events that need to complete before this particular command can be executed. If <paramref name="events"/> is not <c>null</c> or read-only a new <see cref="ComputeEvent"/> identifying this command is created and attached to the end of the collection. </param> public void Unmap(ComputeMemory memory, ref IntPtr mappedPtr, ICollection <ComputeEventBase> events) { int eventWaitListSize; CLEventHandle[] eventHandles = ComputeTools.ExtractHandles(events, out eventWaitListSize); bool eventsWritable = (events != null && !events.IsReadOnly); CLEventHandle[] newEventHandle = (eventsWritable) ? new CLEventHandle[1] : null; ComputeErrorCode error = CL10.EnqueueUnmapMemObject(Handle, memory.Handle, mappedPtr, eventWaitListSize, eventHandles, newEventHandle); ComputeException.ThrowOnError(error); mappedPtr = IntPtr.Zero; if (eventsWritable) { events.Add(new ComputeEvent(newEventHandle[0], this)); } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Sets a <c>T*</c>, <c>image2d_t</c> or <c>image3d_t</c> argument of the /// <see cref="ComputeKernel"/>. /// </summary> /// /// <remarks> /// This method will automatically track <paramref name="memObj"/> to prevent it from being /// collected by the GC.<br/> Arguments to the kernel are referred by indices that go from 0 for /// the leftmost argument to n-1, where n is the total number of arguments declared by the kernel. /// </remarks> /// /// <param name="index"> The argument index. </param> /// <param name="memObj"> The <see cref="ComputeMemory"/> that is passed as the argument. </param> //////////////////////////////////////////////////////////////////////////////////////////////////// public void SetMemoryArgument(int index, ComputeMemory memObj) { SetValueArgument <CLMemoryHandle>(index, memObj.Handle); }
/// <summary> /// Creates a new ComputeBuffer from an ComputeMemory. Because the memory is retained the cloned buffer as well as the clone have to be disposed /// </summary> /// <param name="memory"></param> /// <returns></returns> public static ComputeBuffer <T> From(ComputeMemory memory) { CL10.RetainMemObject(memory.Handle); return(new ComputeBuffer <T>(memory.Handle, memory.Context, memory.Flags, memory.Size)); }
/// <summary>Creates a OpenCLTemplate variable from a Cloo ComputeBuffer</summary> /// <param name="ClooMemoryObject">Cloo computebuffer to create from</param> /// <param name="Size">ClooMemoryObject.Size</param> /// <param name="Count">ClooMemoryObject.Count</param> public Variable(ComputeMemory ClooMemoryObject, int Size, int Count) { VarSize = Size; OriginalVarLength = Count; this.VarPointer = ClooMemoryObject; }
private static void CoreRender(ComputeMemory buffer, ComputeCommandQueue queue, IEnumerable<ComputeKernel> kernels, Vector4 position, Vector4 lookat, Vector4 up, int frame, float fov, int slowRenderCount, float focalDistance, int width, int height, long[] globalSize, long[] localSize) { foreach (var kernel in kernels) { kernel.SetMemoryArgument(0, buffer); kernel.SetValueArgument(1, width); kernel.SetValueArgument(2, height); kernel.SetValueArgument(3, position); kernel.SetValueArgument(4, lookat); kernel.SetValueArgument(5, up); kernel.SetValueArgument(6, frame); kernel.SetValueArgument(7, fov); kernel.SetValueArgument(8, slowRenderCount); kernel.SetValueArgument(9, focalDistance); queue.Execute(kernel, LaunchSize, globalSize, localSize, null); } }
public void Render(ComputeMemory buffer, ComputeCommandQueue queue) { if (_doingScreenshot || _kernels == null) return; if (VideoRenderer.CheckForVideo(this)) return; CoreRender(buffer, queue, _kernels, new Vector4((Vector3)_input.Camera.Position), new Vector4((Vector3)_input.Camera.Lookat), new Vector4((Vector3)_input.Camera.Up), _input.Camera.Frame, _input.Camera.Fov, 1, _input.Camera.FocalDistance, _width, _height, _globalSize, _localSize); _input.Frame++; if (_input.CheckForScreenshot()) { _doingScreenshot = true; ThreadPool.QueueUserWorkItem(o => { Screenshot(); _doingScreenshot = false; }); } if (_input.CheckForGif()) { _doingScreenshot = true; ThreadPool.QueueUserWorkItem(o => { GifRenderer.RenderGif(this); _doingScreenshot = false; }); } }