/// <summary> /// Submit an executable command buffer with optional wait and signal semaphores, and an optional fence to be signaled when the commands have been completed. /// </summary> /// <param name="queue">Queue.</param> /// <param name="wait">Wait.</param> /// <param name="signal">Signal.</param> /// <param name="fence">Fence.</param> public void Submit(VkQueue queue, VkSemaphore wait = default, VkSemaphore signal = default, Fence fence = null) { VkSubmitInfo submit_info = VkSubmitInfo.New(); IntPtr dstStageMask = Marshal.AllocHGlobal(sizeof(uint)); Marshal.WriteInt32(dstStageMask, (int)VkPipelineStageFlags.ColorAttachmentOutput); using (PinnedObjects pctx = new PinnedObjects()) { submit_info.pWaitDstStageMask = dstStageMask; if (signal != VkSemaphore.Null) { submit_info.signalSemaphoreCount = 1; submit_info.pSignalSemaphores = signal.Pin(pctx); } if (wait != VkSemaphore.Null) { submit_info.waitSemaphoreCount = 1; submit_info.pWaitSemaphores = wait.Pin(pctx); } submit_info.commandBufferCount = 1; submit_info.pCommandBuffers = handle.Pin(pctx); Utils.CheckResult(vkQueueSubmit(queue, 1, ref submit_info, fence)); } Marshal.FreeHGlobal(dstStageMask); }
protected override void PlatformSwapBuffers() { // First, ensure all pending draws are submitted to the proper render passes, and are completed. FlushFrameDrawCommands(); // Then, present the swapchain. VkPresentInfoKHR presentInfo = VkPresentInfoKHR.New(); presentInfo.waitSemaphoreCount = 1; // Wait on the last render pass to complete before presenting. VkSemaphore signalSemaphore = _renderPassSemaphores[_renderPassStates.Count - 1]; presentInfo.pWaitSemaphores = &signalSemaphore; VkSwapchainKHR swapchain = _scInfo.Swapchain; presentInfo.swapchainCount = 1; presentInfo.pSwapchains = &swapchain; uint imageIndex = _scInfo.ImageIndex; presentInfo.pImageIndices = &imageIndex; vkQueuePresentKHR(_presentQueue, ref presentInfo); ClearFrameObjects(); _framebufferChanged = true; }
public DeferredPbrRenderer(Queue gQueue, string cubemapPath, uint width, uint height, float nearPlane, float farPlane) { this.gQueue = gQueue; this.dev = gQueue.Dev; this.cubemapPath = cubemapPath; this.width = width; this.height = height; DrawComplete = dev.CreateSemaphore(); pipelineCache = new PipelineCache(dev); descriptorPool = new DescriptorPool(dev, 5, new VkDescriptorPoolSize(VkDescriptorType.UniformBuffer, 3), new VkDescriptorPoolSize(VkDescriptorType.CombinedImageSampler, 6), new VkDescriptorPoolSize(VkDescriptorType.InputAttachment, 5), new VkDescriptorPoolSize(VkDescriptorType.StorageImage, 4) ); uboMatrices = new HostBuffer(dev, VkBufferUsageFlags.UniformBuffer, matrices, true); uboLights = new HostBuffer <Light> (dev, VkBufferUsageFlags.UniformBuffer, lights, true); #if WITH_SHADOWS shadowMapRenderer = new ShadowMapRenderer(gQueue, this); #endif init(nearPlane, farPlane); }
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 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 extern VkResult AcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, ulong timeout, VkSemaphore semaphore, VkFence fence, out uint pImageIndex );
public override void Activate() { if (state != ActivableState.Activated) { presentComplete = Dev.CreateSemaphore(); presentComplete.SetDebugMarkerName(Dev, "Semaphore PresentComplete"); } base.Activate(); }
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); } }
/** * Acquires the next image in the swap chain * * @param presentCompleteSemaphore (Optional) Semaphore that is signaled when the image is ready for use * @param imageIndex Pointer to the image index that will be increased if the next image could be acquired * * @note The function will always wait until the next image has been acquired by setting timeout to UINT64_MAX * * @return VkResult of the image acquisition */ public VkResult AcquireNextImage(VkSemaphore presentCompleteSemaphore, ref uint imageIndex) { // By setting timeout to UINT64_MAX we will always wait until the next image has been acquired or an actual error is thrown // With that we don't have to handle VK_NOT_READY uint index = 0; VkResult result = vkAcquireNextImageKHR(Device, Swapchain, ulong.MaxValue, presentCompleteSemaphore, new VkFence(), &index); imageIndex = index; return(result); }
public static VkResult vkCreateSemaphore(VkDevice device, out VkSemaphore semaphore) { VkSemaphoreCreateInfo createInfo = new VkSemaphoreCreateInfo { sType = VkStructureType.SemaphoreCreateInfo, pNext = null, flags = VkSemaphoreCreateFlags.None }; return(vkCreateSemaphore(device, &createInfo, null, out semaphore)); }
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(); }
/** * Queue an image for presentation * * @param queue Presentation queue for presenting the image * @param imageIndex Index of the swapchain image to queue for presentation * @param waitSemaphore (Optional) Semaphore that is waited on before the image is presented (only used if != VK_NULL_HANDLE) * * @return VkResult of the queue presentation */ public VkResult QueuePresent(VkQueue queue, uint imageIndex, VkSemaphore waitSemaphore = new VkSemaphore()) { var presentInfo = VkPresentInfoKHR.Alloc(); presentInfo->swapchainsImages.Set(Swapchain); presentInfo->swapchainsImages.Set(imageIndex); // Check if a wait semaphore has been specified to wait for before presenting the image if (waitSemaphore != 0ul) { presentInfo->waitSemaphores = waitSemaphore; } return(vkQueuePresentKHR(queue, presentInfo)); }
void drawFrame() { int imageIndex; Vulkan.vkAcquireNextImageKHR(device, swapChain, long.MaxValue, imageAvailableSemaphore, null, out imageIndex); VkSubmitInfo submitInfo = new VkSubmitInfo(); submitInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_SUBMIT_INFO; VkSemaphore[] waitSemaphores = new VkSemaphore[] { imageAvailableSemaphore }; VkPipelineStageFlagBits[] waitStages = new VkPipelineStageFlagBits[] { VkPipelineStageFlagBits.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT }; submitInfo.waitSemaphoreCount = 1; submitInfo.pWaitSemaphores = waitSemaphores; submitInfo.pWaitDstStageMask = waitStages; submitInfo.commandBufferCount = 1; submitInfo.pCommandBuffers = new VkCommandBuffer[] { commandBuffers[imageIndex] }; VkSemaphore[] signalSemaphores = new VkSemaphore[] { renderFinishedSemaphore }; submitInfo.signalSemaphoreCount = 1; submitInfo.pSignalSemaphores = signalSemaphores; fpsSubmitQueue.Begin(); VkResult result = Vulkan.vkQueueSubmit(graphicsQueue, 1, new VkSubmitInfo[] { submitInfo }, null); fpsSubmitQueue.End(); fpsSubmitQueue.DebugPeriodicReport(); if (result != VkResult.VK_SUCCESS) { throw Program.Throw("failed to submit draw command buffer!"); } VkPresentInfoKHR presentInfo = new VkPresentInfoKHR(); presentInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; presentInfo.waitSemaphoreCount = 1; presentInfo.pWaitSemaphores = signalSemaphores; VkSwapchainKHR[] swapChains = new VkSwapchainKHR[] { swapChain }; presentInfo.swapchainCount = 1; presentInfo.pSwapchains = swapChains; presentInfo.pImageIndices = new int[] { imageIndex }; fpsPresentQueue.Begin(); Vulkan.vkQueuePresentKHR(presentQueue, presentInfo); fpsPresentQueue.End(); fpsPresentQueue.DebugPeriodicReport(); Vulkan.vkQueueWaitIdle(presentQueue); }
public static void SetDebugMarkerName(this VkSemaphore obj, Device dev, string name) { if (!dev.DebugMarkersEnabled) { return; } VkDebugMarkerObjectNameInfoEXT dmo = new VkDebugMarkerObjectNameInfoEXT(VkDebugReportObjectTypeEXT.SemaphoreEXT, obj.Handle) { pObjectName = name.Pin() }; Utils.CheckResult(vkDebugMarkerSetObjectNameEXT(dev.VkDev, ref dmo)); name.Unpin(); }
private void CreateSemaphores() { var semaphoreInfo = new VkSemaphoreCreateInfo() { sType = VkStructureType.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, }; VkSemaphore vkSemaphore; var result = VulkanNative.vkCreateSemaphore(vkDevice, &semaphoreInfo, null, &vkSemaphore); vkImageAvailableSemaphore = vkSemaphore; Helpers.CheckErrors(result); result = VulkanNative.vkCreateSemaphore(vkDevice, &semaphoreInfo, null, &vkSemaphore); vkRenderFinishedSemaphore = vkSemaphore; Helpers.CheckErrors(result); }
private VkResult AcquireNextImage(out uint imageIndex) { VkSemaphore acquireSemaphore; if (_recycledSemaphores.Count == 0) { vkCreateSemaphore(VkDevice, out acquireSemaphore).CheckResult(); } else { acquireSemaphore = _recycledSemaphores[_recycledSemaphores.Count - 1]; _recycledSemaphores.RemoveAt(_recycledSemaphores.Count - 1); } VkResult result = vkAcquireNextImageKHR(VkDevice, Swapchain.Handle, ulong.MaxValue, acquireSemaphore, VkFence.Null, out imageIndex); if (result != VkResult.Success) { _recycledSemaphores.Add(acquireSemaphore); return(result); } if (_perFrame[imageIndex].QueueSubmitFence != VkFence.Null) { vkWaitForFences(VkDevice, _perFrame[imageIndex].QueueSubmitFence, true, ulong.MaxValue); vkResetFences(VkDevice, _perFrame[imageIndex].QueueSubmitFence); } if (_perFrame[imageIndex].PrimaryCommandPool != VkCommandPool.Null) { vkResetCommandPool(VkDevice, _perFrame[imageIndex].PrimaryCommandPool, VkCommandPoolResetFlags.None); } // Recycle the old semaphore back into the semaphore manager. VkSemaphore old_semaphore = _perFrame[imageIndex].SwapchainAcquireSemaphore; if (old_semaphore != VkSemaphore.Null) { _recycledSemaphores.Add(old_semaphore); } _perFrame[imageIndex].SwapchainAcquireSemaphore = acquireSemaphore; return(VkResult.Success); }
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); }
/** * Queue an image for presentation * * @param queue Presentation queue for presenting the image * @param imageIndex Index of the swapchain image to queue for presentation * @param waitSemaphore (Optional) Semaphore that is waited on before the image is presented (only used if != VK_NULL_HANDLE) * * @return VkResult of the queue presentation */ public VkResult QueuePresent(VkQueue queue, uint imageIndex, VkSemaphore waitSemaphore = new VkSemaphore()) { VkPresentInfoKHR presentInfo = VkPresentInfoKHR.New(); presentInfo.pNext = null; presentInfo.swapchainCount = 1; var sc = Swapchain; presentInfo.pSwapchains = ≻ presentInfo.pImageIndices = &imageIndex; // Check if a wait semaphore has been specified to wait for before presenting the image if (waitSemaphore.Handle != 0) { presentInfo.pWaitSemaphores = &waitSemaphore; presentInfo.waitSemaphoreCount = 1; } return(vkQueuePresentKHR(queue, &presentInfo)); }
public void Present(SwapChain swapChain, VkSemaphore wait) { VkPresentInfoKHR present = VkPresentInfoKHR.New(); uint idx = swapChain.currentImageIndex; VkSwapchainKHR sc = swapChain.handle; present.swapchainCount = 1; present.pSwapchains = sc.Pin(); present.waitSemaphoreCount = 1; present.pWaitSemaphores = wait.Pin(); present.pImageIndices = idx.Pin(); Utils.CheckResult(vkQueuePresentKHR(handle, ref present)); sc.Unpin(); wait.Unpin(); idx.Unpin(); }
public void AcquireNextImage(VkDevice device, VkSemaphore semaphore, VkFence fence) { VkResult result = vkAcquireNextImageKHR( device, _swapchain, ulong.MaxValue, semaphore, fence, ref _currentImageIndex); if (result == VkResult.ErrorOutOfDateKHR || result == VkResult.SuboptimalKHR) { // RecreateSwapChain(); } else if (result != VkResult.Success) { throw new VeldridException("Could not acquire next image from the Vulkan swapchain."); } }
public void Present() { VkSemaphore Semaphore = NativeDevice.RenderFinishedSemaphore; VkSwapchainKHR swapchain = SwapChain; CommandList commandList = NativeDevice.NativeCommandList; VkPresentInfoKHR presentInfo = new VkPresentInfoKHR() { sType = VkStructureType.PresentInfoKHR, waitSemaphoreCount = 1, pWaitSemaphores = &Semaphore, swapchainCount = 1, pSwapchains = &swapchain, pImageIndices = Interop.AllocToPointer(ref commandList.imageIndex), }; vkQueuePresentKHR(NativeDevice.NativeCommandQueue, &presentInfo); }
private void InitRenderParams() { VkSwapchainKHR swapchain = this.swapchain; VkSemaphore semaphore = this.vkSemaphore; VkCommandBuffer[] commandBuffers = this.commandBuffers; submitInfos = VkSubmitInfo.Alloc(2); presentInfos = VkPresentInfoKHR.Alloc(2); for (uint index = 0; index < 2; index++) { //submitInfos[index].waitSemaphoresDstStageMasks.Set(semaphore); submitInfos[index].waitSemaphores = semaphore; submitInfos[index].waitSemaphoresDstStageMasks.Set(VkPipelineStageFlagBits.AllGraphics); submitInfos[index].commandBuffers = commandBuffers[index]; presentInfos[index].swapchains = swapchain; //presentInfo->swapchainsImages.Set(swapchain); presentInfos[index].swapchainsImages.Set(index); } }
public unsafe Semaphore(Device device) { _device = device; var createInfo = new VkSemaphoreCreateInfo { sType = VkStructureType.SemaphoreCreateInfo }; VkSemaphore semaphore; if (VulkanNative.vkCreateSemaphore( _device.Handle, &createInfo, null, &semaphore ) != VkResult.Success) { throw new Exception("failed to create semaphore"); } _handle = semaphore; }
public void Submit() { VkSemaphore signalSemaphore = NativeDevice.RenderFinishedSemaphore; VkSemaphore waitSemaphore = NativeDevice.ImageAvailableSemaphore; VkPipelineStageFlags waitStages = VkPipelineStageFlags.ColorAttachmentOutput; VkCommandBuffer commandBuffer = CommandBuffer; VkSubmitInfo submitInfo = new VkSubmitInfo() { sType = VkStructureType.SubmitInfo, waitSemaphoreCount = 1, pWaitSemaphores = &waitSemaphore, pWaitDstStageMask = &waitStages, commandBufferCount = 1, pCommandBuffers = &commandBuffer, signalSemaphoreCount = 1, pSignalSemaphores = &signalSemaphore, }; vkQueueSubmit(NativeDevice.NativeCommandQueue, 1, &submitInfo, VkFence.Null); }
public void InitializePlatformDevice() { // Features should be checked by the examples before using them CreateFeatures(); // Memory properties are used regularly for creating all kinds of buffers CreateMemoryProperties(); // Queue family properties, used for setting up requested queues upon device creation CreateQueueFamilyProperties(); // Get list of supported extensions CreateExtensionProperties(); // Desired queues need to be requested upon logical device creation // Due to differing queue family configurations of Vulkan implementations this can be a bit tricky, especially if the application // requests different queue types CreateDevice(); // Create CommandQueues CreateCommandQueues(); // Create Semaphores ImageAvailableSemaphore = CreateSemaphore(); RenderFinishedSemaphore = CreateSemaphore(); }
public static VkResult vkQueuePresentKHR(VkQueue queue, VkSemaphore waitSemaphore, VkSwapchainKHR swapchain, uint imageIndex) { var presentInfo = new VkPresentInfoKHR { sType = VkStructureType.PresentInfoKHR, pNext = null }; if (waitSemaphore != VkSemaphore.Null) { presentInfo.waitSemaphoreCount = 1u; presentInfo.pWaitSemaphores = &waitSemaphore; } if (swapchain != VkSwapchainKHR.Null) { presentInfo.swapchainCount = 1u; presentInfo.pSwapchains = &swapchain; presentInfo.pImageIndices = &imageIndex; } return(vkQueuePresentKHR(queue, &presentInfo)); }
void draw() { prepareFrame(); // Offscreen rendering // Wait for swap chain presentation to finish submitInfo[0].waitSemaphoresDstStageMasks.Set(((Semaphores *)semaphores.header)->PresentComplete); // Signal ready with offscreen semaphore var signalSemaphore = offscreenPass.semaphore; submitInfo[0].signalSemaphores = signalSemaphore; // Submit work var commandBuffer = offscreenPass.commandBuffer; submitInfo[0].commandBuffers = commandBuffer; vkQueueSubmit(queue, 1, submitInfo, new VkFence()); // Scene rendering // Wait for offscreen semaphore VkSemaphore semaphore = offscreenPass.semaphore; submitInfo->waitSemaphoresDstStageMasks.Set(semaphore); // Signal ready with render complete semaphpre submitInfo->signalSemaphores = ((Semaphores *)semaphores.header)->RenderComplete; // Submit work VkCommandBuffer cmdBuffer = drawCmdBuffers[currentBuffer]; submitInfo->commandBuffers = cmdBuffer; vkQueueSubmit(queue, 1, submitInfo, new VkFence()); submitFrame(); }
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; }
void CreateSemaphores() { imageAvailableSemaphore = new VkSemaphore(device); renderFinishedSemaphore = new VkSemaphore(device); }
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)); }