예제 #1
0
 /// <summary>
 /// Copy results of queries in a query pool to a host memory region.
 /// </summary>
 public Result GetResults(uint firstQuery, uint queryCount, ArrayProxy <byte> data, DeviceSize stride, QueryResultFlags flags)
 {
     unsafe
     {
         try
         {
             Result   result         = default(Result);
             GCHandle dataHandle     = default(GCHandle);
             byte *   marshalledData = null;
             if (data.Contents != ProxyContents.Null)
             {
                 if (data.Contents == ProxyContents.Single)
                 {
                     byte *dataPointer = stackalloc byte[1];
                     *     dataPointer = data.GetSingleValue();
                     marshalledData = dataPointer;
                 }
                 else
                 {
                     var arrayValue = data.GetArrayValue();
                     dataHandle     = GCHandle.Alloc(arrayValue.Array, GCHandleType.Pinned);
                     marshalledData = (byte *)(dataHandle.AddrOfPinnedObject() + (int)(MemUtil.SizeOf <byte>() * arrayValue.Offset)).ToPointer();
                 }
             }
             else
             {
                 marshalledData = null;
             }
             result = Interop.Commands.vkGetQueryPoolResults(this.parent.handle, this.handle, firstQuery, queryCount, (Size)(data.Length), marshalledData, stride, flags);
             if (SharpVkException.IsError(result))
             {
                 throw SharpVkException.Create(result);
             }
             if (dataHandle.IsAllocated)
             {
                 dataHandle.Free();
             }
             return(result);
         }
         finally
         {
             Interop.HeapUtil.FreeLog();
         }
     }
 }
예제 #2
0
 /// <summary>
 /// Submits a sequence of semaphores or command buffers to a queue.
 /// </summary>
 public void Submit(ArrayProxy <SubmitInfo> submits, Fence fence)
 {
     unsafe
     {
         try
         {
             Result commandResult;
             Interop.SubmitInfo *marshalledSubmits = null;
             if (submits.Contents != ProxyContents.Null)
             {
                 Interop.SubmitInfo *arrayPointer = stackalloc Interop.SubmitInfo[submits.Length];
                 if (submits.Contents == ProxyContents.Single)
                 {
                     submits.GetSingleValue().MarshalTo(arrayPointer);
                 }
                 else
                 {
                     var arrayValue = submits.GetArrayValue();
                     for (int index = 0; index < submits.Length; index++)
                     {
                         arrayValue.Array[arrayValue.Offset + index].MarshalTo(&arrayPointer[index]);
                     }
                 }
                 marshalledSubmits = arrayPointer;
             }
             else
             {
                 marshalledSubmits = null;
             }
             Interop.Fence marshalledFence = default(Interop.Fence);
             fence?.MarshalTo(&marshalledFence);
             commandResult = Interop.Commands.vkQueueSubmit(this.handle, (uint)(submits.Length), marshalledSubmits, marshalledFence);
             if (SharpVkException.IsError(commandResult))
             {
                 throw SharpVkException.Create(commandResult);
             }
         }
         finally
         {
             Interop.HeapUtil.FreeLog();
         }
     }
 }
예제 #3
0
 /// <summary>
 /// Combine the data stores of pipeline caches.
 /// </summary>
 public void MergePipelineCaches(ArrayProxy <PipelineCache> sourceCaches)
 {
     unsafe
     {
         try
         {
             Result commandResult;
             Interop.PipelineCache *marshalledSourceCaches = null;
             if (sourceCaches.Contents != ProxyContents.Null)
             {
                 Interop.PipelineCache *arrayPointer = stackalloc Interop.PipelineCache[sourceCaches.Length];
                 if (sourceCaches.Contents == ProxyContents.Single)
                 {
                     sourceCaches.GetSingleValue().MarshalTo(arrayPointer);
                 }
                 else
                 {
                     var arrayValue = sourceCaches.GetArrayValue();
                     for (int index = 0; index < sourceCaches.Length; index++)
                     {
                         arrayValue.Array[arrayValue.Offset + index].MarshalTo(&arrayPointer[index]);
                     }
                 }
                 marshalledSourceCaches = arrayPointer;
             }
             else
             {
                 marshalledSourceCaches = null;
             }
             commandResult = Interop.Commands.vkMergePipelineCaches(this.parent.handle, this.handle, (uint)(sourceCaches.Length), marshalledSourceCaches);
             if (SharpVkException.IsError(commandResult))
             {
                 throw SharpVkException.Create(commandResult);
             }
         }
         finally
         {
             Interop.HeapUtil.FreeLog();
         }
     }
 }
예제 #4
0
 /// <summary>
 /// Free one or more descriptor sets.
 /// </summary>
 public void FreeDescriptorSets(ArrayProxy <DescriptorSet> descriptorSets)
 {
     unsafe
     {
         try
         {
             Result commandResult;
             Interop.DescriptorSet *marshalledDescriptorSets = null;
             if (descriptorSets.Contents != ProxyContents.Null)
             {
                 Interop.DescriptorSet *arrayPointer = stackalloc Interop.DescriptorSet[descriptorSets.Length];
                 if (descriptorSets.Contents == ProxyContents.Single)
                 {
                     descriptorSets.GetSingleValue().MarshalTo(arrayPointer);
                 }
                 else
                 {
                     var arrayValue = descriptorSets.GetArrayValue();
                     for (int index = 0; index < descriptorSets.Length; index++)
                     {
                         arrayValue.Array[arrayValue.Offset + index].MarshalTo(&arrayPointer[index]);
                     }
                 }
                 marshalledDescriptorSets = arrayPointer;
             }
             else
             {
                 marshalledDescriptorSets = null;
             }
             commandResult = Interop.Commands.vkFreeDescriptorSets(this.parent.handle, this.handle, (uint)(descriptorSets.Length), marshalledDescriptorSets);
             if (SharpVkException.IsError(commandResult))
             {
                 throw SharpVkException.Create(commandResult);
             }
         }
         finally
         {
             Interop.HeapUtil.FreeLog();
         }
     }
 }
예제 #5
0
 /// <summary>
 /// Free command buffers.
 /// </summary>
 public void FreeCommandBuffers(ArrayProxy <CommandBuffer> commandBuffers)
 {
     unsafe
     {
         try
         {
             Interop.CommandBuffer *marshalledCommandBuffers = null;
             if (commandBuffers.Contents != ProxyContents.Null)
             {
                 Interop.CommandBuffer *arrayPointer = stackalloc Interop.CommandBuffer[commandBuffers.Length];
                 if (commandBuffers.Contents == ProxyContents.Single)
                 {
                     commandBuffers.GetSingleValue().MarshalTo(arrayPointer);
                 }
                 else
                 {
                     var arrayValue = commandBuffers.GetArrayValue();
                     for (int index = 0; index < commandBuffers.Length; index++)
                     {
                         arrayValue.Array[arrayValue.Offset + index].MarshalTo(&arrayPointer[index]);
                     }
                 }
                 marshalledCommandBuffers = arrayPointer;
             }
             else
             {
                 marshalledCommandBuffers = null;
             }
             Interop.Commands.vkFreeCommandBuffers(this.parent.handle, this.handle, (uint)(commandBuffers.Length), marshalledCommandBuffers);
         }
         finally
         {
             Interop.HeapUtil.FreeLog();
         }
     }
 }
예제 #6
0
 /// <summary>
 /// -
 /// </summary>
 public void RegisterObjects(ArrayProxy <ObjectTableEntry> objectTableEntries, ArrayProxy <uint> objectIndices)
 {
     unsafe
     {
         try
         {
             var                commandDelegate = this.commandCache.GetCommandDelegate <Interop.vkRegisterObjectsNVX>("vkRegisterObjectsNVX", "device");
             Result             commandResult;
             GCHandle           objectTableEntriesHandle           = default(GCHandle);
             ObjectTableEntry * marshalledObjectTableEntries       = null;
             ObjectTableEntry **doubleMarshalledObjectTableEntries = null;
             if (objectTableEntries.Contents != ProxyContents.Null)
             {
                 if (objectTableEntries.Contents == ProxyContents.Single)
                 {
                     ObjectTableEntry *dataPointer = stackalloc ObjectTableEntry[1];
                     *dataPointer = objectTableEntries.GetSingleValue();
                     marshalledObjectTableEntries       = dataPointer;
                     doubleMarshalledObjectTableEntries = &marshalledObjectTableEntries;
                 }
                 else
                 {
                     var arrayValue = objectTableEntries.GetArrayValue();
                     objectTableEntriesHandle     = GCHandle.Alloc(arrayValue.Array, GCHandleType.Pinned);
                     marshalledObjectTableEntries = (ObjectTableEntry *)(objectTableEntriesHandle.AddrOfPinnedObject() + (int)(MemUtil.SizeOf <ObjectTableEntry>() * arrayValue.Offset)).ToPointer();
                     ObjectTableEntry **dataPointer = stackalloc ObjectTableEntry *[objectTableEntries.Length];
                     doubleMarshalledObjectTableEntries = dataPointer;
                     for (int marshalIndex = 0; marshalIndex < objectTableEntries.Length; marshalIndex++)
                     {
                         doubleMarshalledObjectTableEntries[marshalIndex] = &marshalledObjectTableEntries[marshalIndex];
                     }
                 }
             }
             else
             {
                 marshalledObjectTableEntries = null;
             }
             GCHandle objectIndicesHandle     = default(GCHandle);
             uint *   marshalledObjectIndices = null;
             if (objectIndices.Contents != ProxyContents.Null)
             {
                 if (objectIndices.Contents == ProxyContents.Single)
                 {
                     uint *dataPointer = stackalloc uint[1];
                     *     dataPointer = objectIndices.GetSingleValue();
                     marshalledObjectIndices = dataPointer;
                 }
                 else
                 {
                     var arrayValue = objectIndices.GetArrayValue();
                     objectIndicesHandle     = GCHandle.Alloc(arrayValue.Array, GCHandleType.Pinned);
                     marshalledObjectIndices = (uint *)(objectIndicesHandle.AddrOfPinnedObject() + (int)(MemUtil.SizeOf <uint>() * arrayValue.Offset)).ToPointer();
                 }
             }
             else
             {
                 marshalledObjectIndices = null;
             }
             commandResult = commandDelegate(this.parent.handle, this.handle, (uint)(objectIndices.Length), doubleMarshalledObjectTableEntries, marshalledObjectIndices);
             if (SharpVkException.IsError(commandResult))
             {
                 throw SharpVkException.Create(commandResult);
             }
             if (objectTableEntriesHandle.IsAllocated)
             {
                 objectTableEntriesHandle.Free();
             }
             if (objectIndicesHandle.IsAllocated)
             {
                 objectIndicesHandle.Free();
             }
         }
         finally
         {
             Interop.HeapUtil.FreeLog();
         }
     }
 }