Beispiel #1
0
        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);
        }
Beispiel #4
0
 /// <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));
 }
Beispiel #5
0
 /// <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;
 }
Beispiel #6
0
 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);
     }
 }
Beispiel #7
0
 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;
         });
     }
 }