// Sets up the command buffer that renders the scene to the offscreen frame buffer void buildOffscreenCommandBuffer() { if (offscreenPass.commandBuffer == NullHandle) { offscreenPass.commandBuffer = createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, false); } if (offscreenPass.semaphore == 0) { VkSemaphoreCreateInfo semaphoreCreateInfo = Initializers.semaphoreCreateInfo(); Util.CheckResult(vkCreateSemaphore(device, &semaphoreCreateInfo, null, out offscreenPass.semaphore)); } VkCommandBufferBeginInfo cmdBufInfo = Initializers.commandBufferBeginInfo(); FixedArray2 <VkClearValue> clearValues = new FixedArray2 <VkClearValue>(); clearValues.First.color = new VkClearColorValue(0.0f, 0.0f, 0.0f, 0.0f); clearValues.Second.depthStencil = new VkClearDepthStencilValue { depth = 1.0f, stencil = 0 }; VkRenderPassBeginInfo renderPassBeginInfo = Initializers.renderPassBeginInfo(); renderPassBeginInfo.renderPass = offscreenPass.renderPass; renderPassBeginInfo.framebuffer = offscreenPass.frameBuffer; renderPassBeginInfo.renderArea.extent.width = offscreenPass.width; renderPassBeginInfo.renderArea.extent.height = offscreenPass.height; renderPassBeginInfo.clearValueCount = 2; renderPassBeginInfo.pClearValues = &clearValues.First; Util.CheckResult(vkBeginCommandBuffer(offscreenPass.commandBuffer, &cmdBufInfo)); VkViewport viewport = Initializers.viewport((float)offscreenPass.width, (float)offscreenPass.height, 0.0f, 1.0f); vkCmdSetViewport(offscreenPass.commandBuffer, 0, 1, &viewport); VkRect2D scissor = Initializers.rect2D(offscreenPass.width, offscreenPass.height, 0, 0); vkCmdSetScissor(offscreenPass.commandBuffer, 0, 1, &scissor); vkCmdBeginRenderPass(offscreenPass.commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); vkCmdBindDescriptorSets(offscreenPass.commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts_scene, 0, 1, ref descriptorSets_scene, 0, null); vkCmdBindPipeline(offscreenPass.commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines_colorPass); ulong offsets = 0; vkCmdBindVertexBuffers(offscreenPass.commandBuffer, VERTEX_BUFFER_BIND_ID, 1, ref models_example.vertices.buffer, &offsets); vkCmdBindIndexBuffer(offscreenPass.commandBuffer, models_example.indices.buffer, 0, VK_INDEX_TYPE_UINT32); vkCmdDrawIndexed(offscreenPass.commandBuffer, models_example.indexCount, 1, 0, 0, 0); vkCmdEndRenderPass(offscreenPass.commandBuffer); Util.CheckResult(vkEndCommandBuffer(offscreenPass.commandBuffer)); }
private void CreateSyncPrimitives() { var semaphoreInfo = new VkSemaphoreCreateInfo { sType = VkStructureType.SemaphoreCreateInfo }; vkCreateSemaphore(device, &semaphoreInfo, null, out imageAvailableSemaphore).CheckResult(); vkCreateSemaphore(device, &semaphoreInfo, null, out renderFinishedSemaphore).CheckResult(); }
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)); }
void createSemaphores() { VkSemaphoreCreateInfo semaphoreInfo = new VkSemaphoreCreateInfo(); semaphoreInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; if (Vulkan.vkCreateSemaphore(device, semaphoreInfo, null, out imageAvailableSemaphore) != VkResult.VK_SUCCESS || Vulkan.vkCreateSemaphore(device, semaphoreInfo, null, out renderFinishedSemaphore) != VkResult.VK_SUCCESS) { throw Program.Throw("failed to create semaphores!"); } }
public Semaphore(Device dev) { Device = dev; unsafe { var info = new VkSemaphoreCreateInfo() { SType = VkStructureType.SemaphoreCreateInfo, Flags = 0 }; Handle = dev.Handle.CreateSemaphore(&info, Instance.AllocationCallbacks); } }
private void CreateSemaphores() { VkSemaphoreCreateInfo semaphoreCI = VkSemaphoreCreateInfo.New(); vkCreateSemaphore(_device, ref semaphoreCI, null, out _imageAvailableSemaphore); const int MaxRenderPasses = 10; _renderPassSemaphores.Resize(MaxRenderPasses); for (int i = 0; i < MaxRenderPasses; i++) { vkCreateSemaphore(_device, ref semaphoreCI, null, out _renderPassSemaphores[i]); } }
internal VkSemaphore CreateSemaphore() { VkSemaphoreCreateInfo vkSemaphoreCreate = new VkSemaphoreCreateInfo() { sType = VkStructureType.SemaphoreCreateInfo, pNext = null, flags = 0 }; vkCreateSemaphore(Device, &vkSemaphoreCreate, null, out var Semaphore); return(Semaphore); }
void CreateSemaphore() { VkSemaphoreCreateInfo info = new VkSemaphoreCreateInfo(); info.sType = VkStructureType.SemaphoreCreateInfo; var result = Device.Commands.createSemaphore(Device.Native, ref info, Device.Instance.AllocationCallbacks, out semaphore); if (result != VkResult.Success) { throw new SemaphoreException(string.Format("Error creating semaphore: {0}", result)); } }
private VkSemaphore CreateSemaphore(VkDevice device) { VkSemaphoreCreateInfo createInfo = new VkSemaphoreCreateInfo { sType = VkStructureType.SemaphoreCreateInfo, pNext = null }; VkSemaphore semaphore; VkResult result = vkCreateSemaphore(device, &createInfo, null, out semaphore); result.CheckResult(); return(semaphore); }
// Command: 136 /// <summary>vkCreateSemaphore - Create a new queue semaphore object /// </summary> /// <param name="pCreateInfo"> pCreateInfo is a pointer to an instance of the /// VkSemaphoreCreateInfo structure which contains information about /// how the semaphore is to be created.</param> /// <param name="pAllocator"> pAllocator controls host memory allocation as described in the /// Memory Allocation chapter.</param> public VkSemaphore CreateSemaphore(VkSemaphoreCreateInfo *pCreateInfo = null, VkAllocationCallbacks *pAllocator = null) { VkSemaphore semaphore; if (pCreateInfo == null) { var info = new VkSemaphoreCreateInfo { sType = VkStructureType.SemaphoreCreateInfo }; pCreateInfo = &info; } vkAPI.vkCreateSemaphore(this, pCreateInfo, pAllocator, &semaphore); return(semaphore); }
private void CreateSemaphores() { VkSemaphoreCreateInfo semaphoreInfo = new VkSemaphoreCreateInfo() { sType = VkStructureType.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, }; fixed(VkSemaphore *imageAvailableSemaphorePtr = &this.imageAvailableSemaphore) { Helpers.CheckErrors(VulkanNative.vkCreateSemaphore(this.device, &semaphoreInfo, null, imageAvailableSemaphorePtr)); } fixed(VkSemaphore *renderFinishedSemaphorePtr = &this.renderFinishedSemaphore) { Helpers.CheckErrors(VulkanNative.vkCreateSemaphore(this.device, &semaphoreInfo, null, renderFinishedSemaphorePtr)); } }
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); }
public static VkResult vkCreateTypedSemaphore(VkDevice device, VkSemaphoreType type, ulong initialValue, out VkSemaphore semaphore) { VkSemaphoreTypeCreateInfo typeCreateiInfo = new VkSemaphoreTypeCreateInfo { sType = VkStructureType.SemaphoreTypeCreateInfo, pNext = null, semaphoreType = type, initialValue = initialValue }; VkSemaphoreCreateInfo createInfo = new VkSemaphoreCreateInfo { sType = VkStructureType.SemaphoreCreateInfo, pNext = &typeCreateiInfo, flags = VkSemaphoreCreateFlags.None }; return(vkCreateSemaphore(device, &createInfo, null, out semaphore)); }
private ulong CreateQueueSubmitSemaphore() { ulong queueSubmitSemaphore; var queueSubmitSemaphoreCreateInfo = new VkSemaphoreCreateInfo { sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, pNext = null, flags = 0, }; var result = vkCreateSemaphore(Device, &queueSubmitSemaphoreCreateInfo, pAllocator: null, &queueSubmitSemaphore); if (result != VK_SUCCESS) { ThrowExternalException(nameof(vkCreateSemaphore), (int)result); } return(queueSubmitSemaphore); }
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 DummySemaphore(DummyDevice device, VkSemaphoreCreateInfo createInfo) { this.m_device = device; this.m_createInfo = createInfo; }
public void InitVulkan() { VkResult err; err = CreateInstance(false); if (err != VkResult.Success) { throw new InvalidOperationException("Could not create Vulkan instance. Error: " + err); } if (Settings.Validation) { } // Physical Device uint gpuCount = 0; Util.CheckResult(vkEnumeratePhysicalDevices(Instance, &gpuCount, null)); Debug.Assert(gpuCount > 0); // Enumerate devices IntPtr *physicalDevices = stackalloc IntPtr[(int)gpuCount]; err = vkEnumeratePhysicalDevices(Instance, &gpuCount, (VkPhysicalDevice *)physicalDevices); if (err != VkResult.Success) { throw new InvalidOperationException("Could not enumerate physical devices."); } // GPU selection // Select physical Device to be used for the Vulkan example // Defaults to the first Device unless specified by command line uint selectedDevice = 0; // TODO: Implement arg parsing, etc. physicalDevice = ((VkPhysicalDevice *)physicalDevices)[selectedDevice]; // Store properties (including limits) and features of the phyiscal Device // So examples can check against them and see if a feature is actually supported VkPhysicalDeviceProperties deviceProperties; vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties); DeviceProperties = deviceProperties; VkPhysicalDeviceFeatures deviceFeatures; vkGetPhysicalDeviceFeatures(physicalDevice, &deviceFeatures); DeviceFeatures = deviceFeatures; // Gather physical Device memory properties VkPhysicalDeviceMemoryProperties deviceMemoryProperties; vkGetPhysicalDeviceMemoryProperties(physicalDevice, &deviceMemoryProperties); DeviceMemoryProperties = deviceMemoryProperties; // Derived examples can override this to set actual features (based on above readings) to enable for logical device creation getEnabledFeatures(); // Vulkan Device creation // This is handled by a separate class that gets a logical Device representation // and encapsulates functions related to a Device vulkanDevice = new vksVulkanDevice(physicalDevice); VkResult res = vulkanDevice.CreateLogicalDevice(enabledFeatures, EnabledExtensions); if (res != VkResult.Success) { throw new InvalidOperationException("Could not create Vulkan Device."); } device = vulkanDevice.LogicalDevice; // Get a graphics queue from the Device VkQueue queue; vkGetDeviceQueue(device, vulkanDevice.QFIndices.Graphics, 0, &queue); this.queue = queue; // Find a suitable depth format VkFormat depthFormat; uint validDepthFormat = Tools.getSupportedDepthFormat(physicalDevice, &depthFormat); Debug.Assert(validDepthFormat == True); DepthFormat = depthFormat; Swapchain.Connect(Instance, physicalDevice, device); // Create synchronization objects VkSemaphoreCreateInfo semaphoreCreateInfo = Initializers.semaphoreCreateInfo(); // Create a semaphore used to synchronize image presentation // Ensures that the image is displayed before we start submitting new commands to the queu Util.CheckResult(vkCreateSemaphore(device, &semaphoreCreateInfo, null, &GetSemaphoresPtr()->PresentComplete)); // Create a semaphore used to synchronize command submission // Ensures that the image is not presented until all commands have been sumbitted and executed Util.CheckResult(vkCreateSemaphore(device, &semaphoreCreateInfo, null, &GetSemaphoresPtr()->RenderComplete)); // Create a semaphore used to synchronize command submission // Ensures that the image is not presented until all commands for the text overlay have been sumbitted and executed // Will be inserted after the render complete semaphore if the text overlay is enabled Util.CheckResult(vkCreateSemaphore(device, &semaphoreCreateInfo, null, &GetSemaphoresPtr()->TextOverlayComplete)); // Set up submit info structure // Semaphores will stay the same during application lifetime // Command buffer submission info is set by each example submitInfo = Initializers.SubmitInfo(); submitInfo.pWaitDstStageMask = (VkPipelineStageFlags *)submitPipelineStages.Data; submitInfo.waitSemaphoreCount = 1; submitInfo.pWaitSemaphores = &GetSemaphoresPtr()->PresentComplete; submitInfo.signalSemaphoreCount = 1; submitInfo.pSignalSemaphores = &GetSemaphoresPtr()->RenderComplete; }
public static extern VkResult CreateSemaphore( VkDevice device, ref VkSemaphoreCreateInfo pCreateInfo, IntPtr pAllocator, out VkSemaphore pSemaphore );
public override VkResult CreateSemaphore(VkSemaphoreCreateInfo semaphoreCreateInfo, out VkSemaphore semaphore) { semaphore = new DummySemaphore(this, semaphoreCreateInfo); return(VkResult.VK_SUCCESS); }
public void Build(int deviceIndex, bool timeline, ulong value) { if (!locked) { unsafe { IntPtr semaphorePtr_l = IntPtr.Zero; this.timeline = timeline; if (timeline) { var semaphoreTypeInfo = new VkSemaphoreTypeCreateInfo() { sType = VkStructureType.StructureTypeSemaphoreTypeCreateInfo, semaphoreType = VkSemaphoreType.SemaphoreTypeTimeline, initialValue = value }; var semaphoreTypeInfo_ptr = semaphoreTypeInfo.Pointer(); var semaphoreInfo = new VkSemaphoreCreateInfo() { sType = VkStructureType.StructureTypeSemaphoreCreateInfo, pNext = semaphoreTypeInfo_ptr }; if (vkCreateSemaphore(GraphicsDevice.GetDeviceInfo(deviceIndex).Device, semaphoreInfo.Pointer(), null, &semaphorePtr_l) != VkResult.Success) { throw new Exception("Failed to create semaphore."); } } else { var semaphoreInfo = new VkSemaphoreCreateInfo() { sType = VkStructureType.StructureTypeSemaphoreCreateInfo, }; if (vkCreateSemaphore(GraphicsDevice.GetDeviceInfo(deviceIndex).Device, semaphoreInfo.Pointer(), null, &semaphorePtr_l) != VkResult.Success) { throw new Exception("Failed to create semaphore."); } } hndl = semaphorePtr_l; devID = deviceIndex; if (GraphicsDevice.EnableValidation && Name != null) { var objName = new VkDebugUtilsObjectNameInfoEXT() { sType = VkStructureType.StructureTypeDebugUtilsObjectNameInfoExt, pObjectName = Name, objectType = VkObjectType.ObjectTypeSemaphore, objectHandle = (ulong)hndl }; GraphicsDevice.SetDebugUtilsObjectNameEXT(GraphicsDevice.GetDeviceInfo(deviceIndex).Device, objName.Pointer()); } } locked = true; } else { throw new Exception("GpuSemaphore is locked."); } }
public override VkResult CreateSemaphore(VkSemaphoreCreateInfo semaphoreCreateInfo, out VkSemaphore semaphore) { return(SoftwareSemaphore.Create(this, semaphoreCreateInfo, out semaphore)); }
public static VkResult Create(SoftwareDevice device, VkSemaphoreCreateInfo semaphoreCreateInfo, out VkSemaphore semaphore) { semaphore = new SoftwareSemaphore(device, semaphoreCreateInfo); return(VkResult.VK_SUCCESS); }
public SoftwareSemaphore(SoftwareDevice device, VkSemaphoreCreateInfo semaphoreCreateInfo) { this.m_Event = new AutoResetEvent(false); this.m_device = device; this.m_semaphoreCreateInfo = semaphoreCreateInfo; }
// Sets up the command buffer that renders the scene to the offscreen frame buffer void buildOffscreenCommandBuffer() { if (offscreenPass.commandBuffer.handle == 0) { offscreenPass.commandBuffer = createCommandBuffer( VkCommandBufferLevel.Primary //VK_COMMAND_BUFFER_LEVEL_PRIMARY , false); } if (offscreenPass.semaphore.handle == 0) { var semaphoreCreateInfo = VkSemaphoreCreateInfo.Alloc(); VkSemaphore semaphore; vkCreateSemaphore(device, semaphoreCreateInfo, null, &semaphore); offscreenPass.semaphore = semaphore; } var cmdBufInfo = VkCommandBufferBeginInfo.Alloc(); var clearValues = new VkClearValue[2]; clearValues[0].color = defaultClearColor; clearValues[1].depthStencil = new VkClearDepthStencilValue { depth = 1.0f, stencil = 0 }; var renderPassBeginInfo = VkRenderPassBeginInfo.Alloc(); renderPassBeginInfo->renderPass = offscreenPass.renderPass; renderPassBeginInfo->framebuffer = offscreenPass.framebuffer; renderPassBeginInfo->renderArea.extent.width = offscreenPass.width; renderPassBeginInfo->renderArea.extent.height = offscreenPass.height; renderPassBeginInfo->clearValues = clearValues; vkBeginCommandBuffer(offscreenPass.commandBuffer, cmdBufInfo); VkViewport viewport = new VkViewport(offscreenPass.width, offscreenPass.height, 0.0f, 1.0f); vkCmdSetViewport(offscreenPass.commandBuffer, 0, 1, &viewport); VkRect2D scissor = new VkRect2D(0, 0, offscreenPass.width, offscreenPass.height); vkCmdSetScissor(offscreenPass.commandBuffer, 0, 1, &scissor); vkCmdBeginRenderPass(offscreenPass.commandBuffer, renderPassBeginInfo, VkSubpassContents.Inline);// VK_SUBPASS_CONTENTS_INLINE); { VkDescriptorSet set = setScene; vkCmdBindDescriptorSets(offscreenPass.commandBuffer, VkPipelineBindPoint.Graphics,// VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayoutScene, 0, 1, &set, 0, null); } vkCmdBindPipeline(offscreenPass.commandBuffer, VkPipelineBindPoint.Graphics, // VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineColorPass); { VkBuffer buffer = model.vertices.buffer; VkDeviceSize offset = 0; vkCmdBindVertexBuffers(offscreenPass.commandBuffer, VERTEX_BUFFER_BIND_ID, 1, &buffer, &offset); } vkCmdBindIndexBuffer(offscreenPass.commandBuffer, model.indices.buffer, 0, VkIndexType.Uint32);// VK_INDEX_TYPE_UINT32); vkCmdDrawIndexed(offscreenPass.commandBuffer, model.indexCount, 1, 0, 0, 0); vkCmdEndRenderPass(offscreenPass.commandBuffer); vkEndCommandBuffer(offscreenPass.commandBuffer); }
static void Main(string[] args) { Console.WriteLine(AppContext.GetData("NATIVE_DLL_SEARCH_DIRECTORIES").ToString()); Console.WriteLine($"Hello Vulkan!"); Init(); if (!GLFW.Vulkan.IsSupported) { Console.Error.WriteLine("GLFW says that vulkan is not supported."); return; } WindowHint(Hint.ClientApi, ClientApi.None); NativeWindow window = new GLFW.NativeWindow(width, height, "Fabricor"); Glfw.SetKeyCallback(window, (a, b, c, d, e) => { GLFWInput.KeyCallback(a, b, c, d, e); }); FInstance finst = new FInstance(); VkSurfaceKHR surface = CreateSurface(finst.instance, window); VkDevice device = CreateDevice(finst.instance, out var physicalDevice, surface, out var queueFamilyIndex); VkSwapchainKHR swapchain = CreateSwapchain(VkSwapchainKHR.Null, finst.instance, device, physicalDevice, surface, queueFamilyIndex); VkRenderPass renderPass = CreateRenderPass(device); uint swapchainImageCount = 0; Assert(vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, null));////////////IMAGES VkImage[] swapchainImages = new VkImage[swapchainImageCount]; fixed(VkImage *ptr = &swapchainImages[0]) Assert(vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount, ptr)); CommandPoolManager.Init(device, queueFamilyIndex); int poolId = CommandPoolManager.CreateCommandPool(VkCommandPoolCreateFlags.ResetCommandBuffer); VkSemaphoreCreateInfo pCreateInfo = VkSemaphoreCreateInfo.New(); VkSemaphore acquireSemaphore = new VkSemaphore(); vkCreateSemaphore(device, &pCreateInfo, null, &acquireSemaphore); VkSemaphore releaseSemaphore = new VkSemaphore(); vkCreateSemaphore(device, &pCreateInfo, null, &releaseSemaphore); VkQueue graphicsQueue = VkQueue.Null; vkGetDeviceQueue(device, queueFamilyIndex, 0, &graphicsQueue); string[] textures = new string[] { "res/Linus.png", "res/Alex.png", "res/Victor.png", "res/Alex2.png", //"res/Cyan.png", "res/Alex3.png", //"res/Red.png", }; FTexture texture = new FTexture(device, physicalDevice, poolId, graphicsQueue, textures, VkFormat.R8g8b8a8Unorm, 512, 512, (uint)(Math.Log(512) / Math.Log(2)) + 1); VkPipelineCache pipelineCache = VkPipelineCache.Null;//This is critcal for performance. FGraphicsPipeline voxelPipeline = new FGraphicsPipeline(device, physicalDevice, pipelineCache, renderPass, "shaders/voxel", swapchainImageCount, texture); voxelPipeline.CreateDepthBuffer(physicalDevice, (uint)width, (uint)height); VkImageView[] swapchainImageViews = new VkImageView[swapchainImageCount]; for (int i = 0; i < swapchainImageCount; i++) { swapchainImageViews[i] = FTexture.CreateColourImageView(device, swapchainImages[i], surfaceFormat.format); } VkFramebuffer[] frambuffers = new VkFramebuffer[swapchainImageCount]; for (int i = 0; i < swapchainImageCount; i++) { frambuffers[i] = CreateFramebuffer(device, renderPass, swapchainImageViews[i], voxelPipeline.depthImageView); } MeshWrapper <VoxelVertex> mesh = VoxelMeshFactory.GenerateMesh(device, physicalDevice); Action updateMesh = delegate { VoxelMeshFactory.UpdateMesh(device, physicalDevice, mesh); }; GLFWInput.Subscribe(Keys.U, updateMesh, InputState.Press); Action changeTexture = delegate { Span <VoxelVertex> span = mesh.Mesh.vertices.Map(); for (int j = 0; j < span.Length; j++) { span[j].textureId++; } span = mesh.Mesh.vertices.UnMap(); }; GLFWInput.Subscribe(Keys.F, changeTexture, InputState.Press); FCommandBuffer[] cmdBuffers = new FCommandBuffer[swapchainImageCount]; VkFence[] fences = new VkFence[swapchainImageCount]; for (int i = 0; i < swapchainImageCount; i++) { cmdBuffers[i] = new FCommandBuffer(device, poolId); VkFenceCreateInfo createInfo = VkFenceCreateInfo.New(); createInfo.flags = VkFenceCreateFlags.Signaled; VkFence fence = VkFence.Null; Assert(vkCreateFence(device, &createInfo, null, &fence)); fences[i] = fence; } FCamera camera = new FCamera(); camera.AspectWidth = width; camera.AspectHeight = height; camera.position.Z = -1f; //camera.rotation=Quaternion.CreateFromYawPitchRoll(MathF.PI,0,0); double lastTime = Glfw.Time; int nbFrames = 0; while (!WindowShouldClose(window)) { PollEvents(); GLFWInput.Update(); // Measure speed double currentTime = Glfw.Time; nbFrames++; if (currentTime - lastTime >= 1.0) { // If last prinf() was more than 1 sec ago // printf and reset timer Console.WriteLine($"ms/frame: {1000.0 / nbFrames}"); nbFrames = 0; lastTime += 1.0; } if (GLFWInput.TimeKeyPressed(Keys.D) > 0) { camera.position += Vector3.Transform(Vector3.UnitX * 0.00015f, camera.rotation); } if (GLFWInput.TimeKeyPressed(Keys.A) > 0) { camera.position -= Vector3.Transform(Vector3.UnitX * 0.00015f, camera.rotation); } if (GLFWInput.TimeKeyPressed(Keys.W) > 0) { camera.position += Vector3.Transform(Vector3.UnitZ * 0.00015f, camera.rotation); } if (GLFWInput.TimeKeyPressed(Keys.S) > 0) { camera.position -= Vector3.Transform(Vector3.UnitZ * 0.00015f, camera.rotation); } if (GLFWInput.TimeKeyPressed(Keys.Space) > 0) { camera.position += Vector3.Transform(Vector3.UnitY * 0.00015f, camera.rotation); } if (GLFWInput.TimeKeyPressed(Keys.LeftShift) > 0) { camera.position -= Vector3.Transform(Vector3.UnitY * 0.00015f, camera.rotation); } if (GLFWInput.TimeKeyPressed(Keys.Right) > 0) { camera.rotation *= Quaternion.CreateFromAxisAngle(Vector3.UnitY, 0.00015f); } if (GLFWInput.TimeKeyPressed(Keys.Left) > 0) { camera.rotation *= Quaternion.CreateFromAxisAngle(Vector3.UnitY, -0.00015f); } uint imageIndex = 0; Assert(vkAcquireNextImageKHR(device, swapchain, ulong.MaxValue, acquireSemaphore, VkFence.Null, &imageIndex)); VkCommandBufferBeginInfo beginInfo = VkCommandBufferBeginInfo.New(); beginInfo.flags = VkCommandBufferUsageFlags.OneTimeSubmit; voxelPipeline.swapchainFramebuffer = frambuffers[imageIndex]; voxelPipeline.swapchainImage = swapchainImages[imageIndex]; voxelPipeline.swapchainImageIndex = imageIndex; voxelPipeline.mesh = mesh; voxelPipeline.camera = camera; fixed(VkFence *ptr = &(fences[imageIndex])) { vkWaitForFences(device, 1, ptr, VkBool32.False, ulong.MaxValue); vkResetFences(device, 1, ptr); } cmdBuffers[imageIndex].RecordCommandBuffer(new Action <VkCommandBuffer>[] { voxelPipeline.Execute, }); VkPipelineStageFlags submitStageMask = VkPipelineStageFlags.ColorAttachmentOutput; VkSubmitInfo submitInfo = VkSubmitInfo.New(); submitInfo.waitSemaphoreCount = 1; submitInfo.pWaitSemaphores = &acquireSemaphore; submitInfo.pWaitDstStageMask = &submitStageMask; submitInfo.commandBufferCount = 1; fixed(VkCommandBuffer *ptr = &(cmdBuffers[imageIndex].buffer)) submitInfo.pCommandBuffers = ptr; submitInfo.signalSemaphoreCount = 1; submitInfo.pSignalSemaphores = &releaseSemaphore; Assert(vkQueueSubmit(graphicsQueue, 1, &submitInfo, fences[imageIndex])); VkPresentInfoKHR presentInfoKHR = VkPresentInfoKHR.New(); presentInfoKHR.swapchainCount = 1; presentInfoKHR.pSwapchains = &swapchain; presentInfoKHR.pImageIndices = &imageIndex; presentInfoKHR.waitSemaphoreCount = 1; presentInfoKHR.pWaitSemaphores = &releaseSemaphore; Assert(vkQueuePresentKHR(graphicsQueue, &presentInfoKHR)); vkDeviceWaitIdle(device); } finst.Destroy(); DestroyWindow(window); Terminate(); }
public abstract VkResult CreateSemaphore(VkSemaphoreCreateInfo semaphoreCreateInfo, out VkSemaphore semaphore);