public VkResult Submit(int submitCount, VkSubmitInfo[] pSubmits, VkFence fence) { for (int i = 0; i < submitCount; i++) { var submit = pSubmits[i]; if (submit.waitSemaphoreCount > 0) { SoftwareSemaphore.WaitAll(submit.waitSemaphoreCount, submit.pWaitSemaphores); } for (int cmdIndex = 0; cmdIndex < submit.commandBufferCount; cmdIndex++) { var cmdBuffer = (SoftwareCommandBuffer)submit.pCommandBuffers[cmdIndex]; cmdBuffer.Execute(); } if (submit.signalSemaphoreCount > 0) { SoftwareSemaphore.SignalAll(submit.signalSemaphoreCount, submit.pSignalSemaphores); } } ((SoftwareFence)fence)?.Signal(); return(VkResult.VK_SUCCESS); }
public unsafe Fence(Device device, bool isSignaled = false) { _device = device; var createInfo = new VkFenceCreateInfo { sType = VkStructureType.FenceCreateInfo, flags = ( isSignaled ? VkFenceCreateFlags.Signaled : VkFenceCreateFlags.None ) }; VkFence fence; if (VulkanNative.vkCreateFence( device.Handle, &createInfo, null, &fence ) != VkResult.Success) { throw new Exception("failed to create fence"); } _handle = fence; }
public TransferManager(GraphicsDevice graphics) { Graphics = graphics; Buffer = new((ulong)INITIAL_HOST_SIZE.B); Buffer.CanDestroyImmediately = true; // Safe to do since all operations with this are synchronous // Create command objects VkCommandPoolCreateInfo cpci = new(VkCommandPoolCreateFlags.Transient, Graphics.GraphicsQueue.FamilyIndex); VulkanHandle <VkCommandPool> poolHandle; Graphics.VkDevice.CreateCommandPool(&cpci, null, &poolHandle) .Throw("Failed to create command pool for transfer"); _pool = new(poolHandle, Graphics.VkDevice); VkCommandBufferAllocateInfo cbai = new(_pool, VkCommandBufferLevel.Primary, 1); VulkanHandle <VkCommandBuffer> cmdHandle; Graphics.VkDevice.AllocateCommandBuffers(&cbai, &cmdHandle) .Throw("Failed to allocate command buffer for transfer"); _cmd = new(cmdHandle, _pool); VkFenceCreateInfo fci = new(VkFenceCreateFlags.NoFlags); VulkanHandle <VkFence> fenceHandle; Graphics.VkDevice.CreateFence(&fci, null, &fenceHandle) .Throw("Failed to create fence for transfer"); _fence = new(fenceHandle, Graphics.VkDevice); }
public void Render() { if (!isInitialized) { return; } if (this.submitInfos == null) { InitRenderParams(); } VkDevice device = this.device; VkSwapchainKHR swapchain = this.swapchain; VkSemaphore semaphore = this.vkSemaphore; VkFence fence = this.vkFence; VkQueue queue = this.vkQueue; //uint nextIndex = device.AcquireNextImageKHR(swapchain, ulong.MaxValue, semaphore); UInt32 nextIndex; vkAPI.vkAcquireNextImageKHR(device, swapchain, ulong.MaxValue, semaphore, new VkFence(), &nextIndex).Check(); //device.ResetFence(fence); vkAPI.vkResetFences(device, 1, &fence).Check(); //queue.Submit(ref this.submitInfos[nextIndex], fence); //VkSubmitInfo submitInfo = this.submitInfos[nextIndex]; //vkAPI.vkQueueSubmit(queue, 1, &submitInfo, fence).Check(); vkAPI.vkQueueSubmit(queue, 1, &this.submitInfos[nextIndex], fence).Check(); //device.WaitForFence(fence, true, 100000000); vkAPI.vkWaitForFences(device, 1, &fence, true, 100000000).Check(); //queue.PresentKHR(ref this.presentInfos[nextIndex]); //VkPresentInfoKHR presentInfo = this.presentInfos[nextIndex]; //vkAPI.vkQueuePresentKHR(queue, &presentInfo).Check(); vkAPI.vkQueuePresentKHR(queue, &this.presentInfos[nextIndex]).Check(); }
public static extern VkResult AcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, ulong timeout, VkSemaphore semaphore, VkFence fence, out uint pImageIndex );
public void Submit(CommandBuffer[] buffers, VkSemaphore[] wait, VkPipelineStageFlag[] waitStages, VkSemaphore[] signal, VkFence submit) { unsafe { // ReSharper disable once PossibleNullReferenceException Debug.Assert((waitStages == null && wait == null) || waitStages.Length == wait.Length); var arrayBuffers = buffers.Where(x => !(x is CommandBufferPooledExclusiveUse)).Select(x => { x.AssertBuilt(); return(x.Handle); }).ToArray(); var pooledBuffers = buffers.OfType <CommandBufferPooledExclusiveUse>().ToArray(); Debug.Assert(pooledBuffers.Length == 0 || submit == VkFence.Null, "Can't use custom submit fence on pooled buffers"); fixed(VkSemaphore *waitPtr = wait) fixed(VkPipelineStageFlag * waitStagePtr = waitStages) fixed(VkSemaphore * signalPtr = signal) { if (arrayBuffers.Length > 0) fixed(VkCommandBuffer *buffer = arrayBuffers) { var info = new VkSubmitInfo() { SType = VkStructureType.SubmitInfo, PNext = IntPtr.Zero, CommandBufferCount = (uint)arrayBuffers.Length, PCommandBuffers = buffer, SignalSemaphoreCount = (uint)(signal?.Length ?? 0), PSignalSemaphores = signalPtr, WaitSemaphoreCount = (uint)(wait?.Length ?? 0), PWaitSemaphores = waitPtr, PWaitDstStageMask = waitStagePtr, }; VkException.Check(VkQueue.vkQueueSubmit(Handle, 1, &info, submit)); } foreach (var pooled in pooledBuffers) { var handle = pooled.Handle; var info = new VkSubmitInfo() { SType = VkStructureType.SubmitInfo, PNext = IntPtr.Zero, CommandBufferCount = 1, PCommandBuffers = &handle, SignalSemaphoreCount = (uint)(signal?.Length ?? 0), PSignalSemaphores = signalPtr, WaitSemaphoreCount = (uint)(wait?.Length ?? 0), PWaitSemaphores = waitPtr, PWaitDstStageMask = waitStagePtr, }; pooled.DoSubmit(Handle, info); } } } }
public uint AcquireNextImage(VkSemaphore semaphore, VkFence fence, ulong timeout = ulong.MaxValue) { unsafe { uint index = uint.MaxValue; Device.Handle.AcquireNextImageKHR(Handle, timeout, semaphore, fence, &index); return(index); } }
private void DisposeVulkanFence(VkFence vulkanFence) { AssertDisposing(_state); if (vulkanFence != VK_NULL_HANDLE) { vkDestroyFence(Device.VulkanDevice, vulkanFence, pAllocator: null); } }
protected virtual void Draw(Timer timer) { // Acquire an index of drawing image for this frame. uint nextImageIndex; VkResult result = vkAcquireNextImageKHR(Context.Device, Swapchain, ulong.MaxValue, ImageAvailableSemaphore, VkFence.Null, out nextImageIndex); result.CheckResult(); // Use a fence to wait until the command buffer has finished execution before using it again VkFence fence = SubmitFences[nextImageIndex]; result = vkWaitForFences(Context.Device, 1, &fence, false, ulong.MaxValue); result.CheckResult(); result = vkResetFences(Context.Device, 1, &fence); result.CheckResult(); VkSemaphore signalSemaphore = RenderingFinishedSemaphore; VkSemaphore waitSemaphore = ImageAvailableSemaphore; VkPipelineStageFlags waitStages = VkPipelineStageFlags.ColorAttachmentOutput; VkCommandBuffer commandBuffer = CommandBuffers[nextImageIndex]; VkSubmitInfo submitInfo = new VkSubmitInfo() { sType = VkStructureType.SubmitInfo, waitSemaphoreCount = 1, pWaitSemaphores = &waitSemaphore, pWaitDstStageMask = &waitStages, commandBufferCount = 1, pCommandBuffers = &commandBuffer, signalSemaphoreCount = 1, pSignalSemaphores = &signalSemaphore, }; result = vkQueueSubmit(Context.GraphicsQueue, 1, &submitInfo, SubmitFences[nextImageIndex]); result.CheckResult(); // Present the color output to screen. VkSemaphore waitSemaphoreHandle = RenderingFinishedSemaphore; VkSwapchainKHR swapchainHandle = Swapchain; var nativePresentInfo = new VkPresentInfoKHR { sType = VkStructureType.PresentInfoKHR, pNext = null, waitSemaphoreCount = 1, pWaitSemaphores = &waitSemaphoreHandle, swapchainCount = 1, pSwapchains = &swapchainHandle, pImageIndices = &nextImageIndex }; result = vkQueuePresentKHR(Context.PresentQueue, &nativePresentInfo); result.CheckResult(); }
public void EndOneTimeCommands(VkCommandBuffer cb, VkFence fence) { vkEndCommandBuffer(cb); VkSubmitInfo submitInfo = VkSubmitInfo.New(); submitInfo.commandBufferCount = 1; submitInfo.pCommandBuffers = &cb; vkQueueSubmit(GraphicsQueue, 1, ref submitInfo, fence); vkQueueWaitIdle(GraphicsQueue); vkFreeCommandBuffers(_device, GraphicsCommandPool, 1, ref cb); }
public static void SetDebugMarkerName(this VkFence obj, Device dev, string name) { if (!dev.DebugMarkersEnabled) { return; } VkDebugMarkerObjectNameInfoEXT dmo = new VkDebugMarkerObjectNameInfoEXT(VkDebugReportObjectTypeEXT.FenceEXT, obj.Handle) { pObjectName = name.Pin() }; Utils.CheckResult(vkDebugMarkerSetObjectNameEXT(dev.VkDev, ref dmo)); name.Unpin(); }
public static void SetDebugMarkerName(this VkFence obj, Device dev, string name) { if (!dev.debugUtilsEnabled) { return; } VkDebugUtilsObjectNameInfoEXT dmo = new VkDebugUtilsObjectNameInfoEXT(VkObjectType.Fence, (ulong)obj.Handle) { pObjectName = name.Pin() }; Utils.CheckResult(vkSetDebugUtilsObjectNameEXT(dev.VkDev, ref dmo)); name.Unpin(); }
public VkResult AcquireNextImage(ulong timeout, Semaphore semaphore, Fence fence, out uint index) { VkSemaphore sTemp = VkSemaphore.Null; VkFence fTemp = VkFence.Null; if (semaphore != null) { sTemp = semaphore.Native; } if (fence != null) { fTemp = fence.Native; } var result = Device.Commands.acquireNextImage(Device.Native, swapchain, timeout, sTemp, fTemp, out index); return(result); }
public static VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, long timeout, VkSemaphore semaphore, VkFence fence, out int pImageIndex) { VkPreconditions.CheckNull(device, nameof(device)); VkPreconditions.CheckNull(swapchain, nameof(swapchain)); VkPreconditions.CheckRange(timeout, 1, long.MaxValue, nameof(timeout)); return(GetDevice(device).AcquireNextImage(swapchain, timeout, semaphore, fence, out pImageIndex)); }
public void Submit(CommandBuffer cmd, VkSemaphore wait = default(VkSemaphore), VkSemaphore signal = default(VkSemaphore), VkFence fence = default(VkFence)) { cmd.Submit(handle, wait, signal, fence); }
public static extern VkResult GetFenceStatus( VkDevice device, VkFence fence );
public static extern void DestroyFence( VkDevice device, VkFence fence, IntPtr pAllocator );
public static extern VkResult CreateFence( VkDevice device, ref VkFenceCreateInfo pCreateInfo, IntPtr pAllocator, out VkFence pFence );
public static VkResult vkQueueSubmit(VkQueue queue, VkSubmitInfo submit, VkFence fence) { return(vkQueueSubmit(queue, 1, &submit, fence)); }
public void Init(IntPtr hwnd, IntPtr processHandle) { if (this.isInitialized) { return; } this.instance = InitInstance(); InitDebugCallback(this.instance); this.surface = InitSurface(this.instance, hwnd, processHandle); this.vkPhysicalDevice = InitPhysicalDevice(this.instance); VkSurfaceFormatKHR surfaceFormat = SelectFormat(this.vkPhysicalDevice, this.surface); this.device = CreateDevice(this.vkPhysicalDevice, this.surface); this.vkQueue = this.device.GetQueue(0, 0); VkSurfaceCapabilitiesKHR surfaceCapabilities; //this.vkPhysicalDevice.GetSurfaceCapabilitiesKhr(this.vkSurface, out surfaceCapabilities); vkAPI.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(this.vkPhysicalDevice, this.surface, &surfaceCapabilities).Check(); this.swapchain = CreateSwapchain(this.device, this.surface, surfaceFormat, surfaceCapabilities); this.vkImages = this.device.GetSwapchainImages(this.swapchain); this.renderPass = CreateRenderPass(this.device, surfaceFormat); this.framebuffers = CreateFramebuffers(this.device, this.vkImages, surfaceFormat, this.renderPass, surfaceCapabilities); this.vkFence = this.device.CreateFence(); this.vkSemaphore = this.device.CreateSemaphore(); // buffers for vertex data. VkBuffer vertexBuffer = CreateBuffer(this.vkPhysicalDevice, this.device, Vertices, VkBufferUsageFlagBits.VertexBuffer, typeof(float)); VkBuffer indexBuffer = CreateBuffer(this.vkPhysicalDevice, this.device, Indexes, VkBufferUsageFlagBits.IndexBuffer, typeof(short)); var uniformBufferData = new AreaUniformBuffer(1, 1); this.originalWidth = 1; this.width = this.originalWidth; this.originalHeight = 1; this.height = this.originalHeight; this.uniformBuffer = CreateBuffer(this.vkPhysicalDevice, this.device, uniformBufferData, VkBufferUsageFlagBits.UniformBuffer, typeof(AreaUniformBuffer)); this.descriptorSetLayout = CreateDescriptorSetLayout(this.device); this.vkPipelineLayout = CreatePipelineLayout(this.device, this.descriptorSetLayout); VkPipeline pipeline = CreatePipeline(this.device, surfaceCapabilities, this.renderPass, this.vkPipelineLayout); this.descriptorSet = CreateDescriptorSet(this.device, this.descriptorSetLayout); UpdateDescriptorSets(this.device, this.uniformBuffer, this.descriptorSet); this.commandBuffers = CreateCommandBuffers( this.device, this.renderPass, surfaceCapabilities, this.vkImages, this.framebuffers, pipeline, vertexBuffer, indexBuffer, (uint)Indexes.Length, this.vkPipelineLayout, this.descriptorSet); this.isInitialized = true; }
public static VkResult vkQueueBindSparse(VkQueue queue, VkBindSparseInfo bindInfo, VkFence fence) { return(vkQueueBindSparse(queue, 1, &bindInfo, fence)); }
public override VkResult AcquireNextImage(VkSwapchainKHR swapchain, long timeout, VkSemaphore semaphore, VkFence fence, out int pImageIndex) { throw new NotImplementedException(); }
public static VkResult vkResetFences(VkDevice device, VkFence fence) { return(vkResetFences(device, 1, &fence)); }
public VkResult AcquireNextImage(VkSwapchainKHR swapchain, long timeout, VkSemaphore semaphore, VkFence fence, out int pImageIndex) { pImageIndex = m_NextImageIndex; m_NextImageIndex = (m_NextImageIndex + 1) % m_Images.Count; // semaphore?.Signal(); // fence?.Signal(); return(VkResult.VK_SUCCESS); }
public static VkResult vkQueueSubmit(VkQueue queue, ReadOnlySpan <VkSubmitInfo> submits, VkFence fence) { fixed(VkSubmitInfo *submitsPtr = submits) { return(vkQueueSubmit(queue, submits.Length, submitsPtr, fence)); } }
public static VkResult vkQueueSubmit(VkQueue queue, int submitCount, VkSubmitInfo[] pSubmits, VkFence fence) { VkPreconditions.CheckNull(queue, nameof(queue)); VkPreconditions.CheckNull(pSubmits, nameof(pSubmits)); VkPreconditions.CheckRange(submitCount, 1, int.MaxValue, nameof(submitCount)); VkPreconditions.CheckRange(pSubmits.Length < submitCount, nameof(pSubmits.Length)); return(GetQueue(queue).Submit(submitCount, pSubmits, fence)); }
public static VkResult vkQueueBindSparse(VkQueue queue, ReadOnlySpan <VkBindSparseInfo> bindInfo, VkFence fence) { fixed(VkBindSparseInfo *bindInfoPtr = bindInfo) { return(vkQueueBindSparse(queue, bindInfo.Length, bindInfoPtr, fence)); } }
public static extern VkResult QueueSubmit( VkQueue queue, uint submitCount, IntPtr pSubmits, VkFence fence );
public static extern VkResult QueueBindSparse( VkQueue queue, uint bindInfoCount, ref VkBindSparseInfo pBindInfo, VkFence fence );
public static VkResult vkWaitForFences(VkDevice device, VkFence fence, VkBool32 waitAll, ulong timeout) { return(vkWaitForFences(device, 1, &fence, waitAll, timeout)); }