X-Git-Url: http://git.mutantstargoat.com?a=blobdiff_plain;f=src%2Fvulkan%2Fvkutil.cc;h=c1ca1d56d856e6e2bef5ae63660a777683c9d3da;hb=86c912d603be75ac8b2fdb2229f1696e9c0c01d9;hp=25f3ad37996178a09ab42bc244262901a4719196;hpb=32feb79dc3b9ddeeab84a0329d53b8aaff86bb80;p=demo diff --git a/src/vulkan/vkutil.cc b/src/vulkan/vkutil.cc index 25f3ad3..c1ca1d5 100644 --- a/src/vulkan/vkutil.cc +++ b/src/vulkan/vkutil.cc @@ -7,29 +7,19 @@ #include #include +#include "allocator.h" #include "vkutil.h" /* global variables */ - -VkPipeline *vkgparent_pipeline; -VkFramebuffer *vkfbufs; -VkRenderPass vkrpass; -VkSurfaceKHR vksurface; -VkInstance vkinst; -VkPhysicalDevice vkpdev; -VkDevice vkdev; -VkQueue vkq; -VkCommandPool vkcmdpool; -VkCommandBuffer vkcmdbuf; /* primary command buffer */ -int vkqfamily; - -VkSemaphore vk_img_avail_sema; -VkSemaphore vk_rend_done_sema; -VkSwapchainKHR vkswapchain; -VkImage *vkswapchain_images; -VkImageView *vkswapchain_views; -int vknum_swapchain_images; -int vk_curr_swapchain_image; +VkPhysicalDevice vk_physical; +VkDevice vk_device; +VkInstance vk_instance; +VkQueue vk_queue; +int vk_qfamily; +VkCommandPool vk_pool; +VkSurfaceKHR vk_surface; +VkSwapchainKHR vk_swapchain; +VkDescriptorPool vk_dpool; /* static functions */ static const char *get_device_name_str(VkPhysicalDeviceType type); @@ -131,17 +121,17 @@ bool vku_create_device() inst_info.ppEnabledExtensionNames = ext_names; inst_info.enabledExtensionCount = sizeof ext_names / sizeof *ext_names; - if(vkCreateInstance(&inst_info, 0, &vkinst) != 0) { + if(vkCreateInstance(&inst_info, 0, &vk_instance) != 0) { fprintf(stderr, "failed to create vulkan instance\n"); return false; } printf("created vulkan instance\n"); - if(vkEnumeratePhysicalDevices(vkinst, &num_devices, 0) != 0) { + if(vkEnumeratePhysicalDevices(vk_instance, &num_devices, 0) != 0) { fprintf(stderr, "failed to enumerate vulkan physical devices\n"); return false; } phys_devices = new VkPhysicalDevice[num_devices]; - if(vkEnumeratePhysicalDevices(vkinst, &num_devices, phys_devices) != 0) { + if(vkEnumeratePhysicalDevices(vk_instance, &num_devices, phys_devices) != 0) { fprintf(stderr, "failed to enumerate vulkan physical devices\n"); return false; } @@ -200,7 +190,7 @@ bool vku_create_device() if(sel_dev < 0 || sel_qfamily < 0) { fprintf(stderr, "failed to find any device with a graphics-capable command queue\n"); - vkDestroyDevice(vkdev, 0); + vkDestroyDevice(vk_device, 0); return false; } @@ -226,16 +216,16 @@ bool vku_create_device() dev_info.enabledExtensionCount = sizeof devext_names / sizeof *devext_names; dev_info.ppEnabledExtensionNames = devext_names; - if(vkCreateDevice(phys_devices[sel_dev], &dev_info, 0, &vkdev) != 0) { + if(vkCreateDevice(phys_devices[sel_dev], &dev_info, 0, &vk_device) != 0) { fprintf(stderr, "failed to create device %d\n", sel_dev); return false; } printf("created device %d\n", sel_dev); - vkpdev = phys_devices[sel_dev]; - vkqfamily = sel_qfamily; + vk_physical = phys_devices[sel_dev]; + vk_qfamily = sel_qfamily; - vkGetDeviceQueue(vkdev, sel_qfamily, 0, &vkq); + vkGetDeviceQueue(vk_device, sel_qfamily, 0, &vk_queue); /* create command buffer pool */ memset(&cmdpool_info, 0, sizeof cmdpool_info); @@ -243,56 +233,34 @@ bool vku_create_device() cmdpool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; cmdpool_info.queueFamilyIndex = sel_qfamily; - if(vkCreateCommandPool(vkdev, &cmdpool_info, 0, &vkcmdpool) != 0) { - fprintf(stderr, "failed to get command quque!\n"); + if(vkCreateCommandPool(vk_device, &cmdpool_info, 0, &vk_pool) != 0) { + fprintf(stderr, "failed to get command queue!\n"); return false; } - if(!(vkcmdbuf = vku_alloc_cmdbuf(vkcmdpool, VK_COMMAND_BUFFER_LEVEL_PRIMARY))) { - fprintf(stderr, "failed to create primary command buffer\n"); - return false; - } + /* if(!(vkcmdbuf = vku_alloc_cmdbuf(vk_pool, VK_COMMAND_BUFFER_LEVEL_PRIMARY))) { + fprintf(stderr, "failed to create primary command buffer\n"); + return false; + } */ return true; } void vku_cleanup() { - if(vkinst) { - vkDeviceWaitIdle(vkdev); - vkDestroyCommandPool(vkdev, vkcmdpool, 0); - - vkDestroySemaphore(vkdev, vk_img_avail_sema, 0); - vkDestroySemaphore(vkdev, vk_rend_done_sema, 0); + if(vk_instance) { + vkDeviceWaitIdle(vk_device); + vkDestroyCommandPool(vk_device, vk_pool, 0); - vkDestroyDevice(vkdev, 0); - vkDestroyInstance(vkinst, 0); - vkinst = 0; + vkDestroyDevice(vk_device, 0); + vkDestroyInstance(vk_instance, 0); + vk_instance = 0; } delete [] phys_devices; phys_devices = 0; } -bool vku_create_semaphores() -{ - VkSemaphoreCreateInfo sinf; - memset(&sinf, 0, sizeof sinf); - - sinf.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; - if(vkCreateSemaphore(vkdev, &sinf, 0, &vk_img_avail_sema) != VK_SUCCESS) { - fprintf(stderr, "Failed to create semaphore\n"); - return false; - } - - if(vkCreateSemaphore(vkdev, &sinf, 0, &vk_rend_done_sema) != VK_SUCCESS) { - fprintf(stderr, "Failed to create semaphore\n"); - return false; - } - - return true; -} - VkCommandBuffer vku_alloc_cmdbuf(VkCommandPool pool, VkCommandBufferLevel level) { VkCommandBuffer cmdbuf; @@ -304,15 +272,33 @@ VkCommandBuffer vku_alloc_cmdbuf(VkCommandPool pool, VkCommandBufferLevel level) inf.level = level; inf.commandBufferCount = 1; - if(vkAllocateCommandBuffers(vkdev, &inf, &cmdbuf) != 0) { + if(vkAllocateCommandBuffers(vk_device, &inf, &cmdbuf) != 0) { return 0; } return cmdbuf; } +bool vku_alloc_cmdbufs(VkCommandPool pool, VkCommandBufferLevel level, unsigned int count, VkCommandBuffer *buf_array) +{ + VkCommandBufferAllocateInfo cinf; + memset(&cinf, 0, sizeof cinf); + + cinf.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + cinf.commandPool = vk_pool; + cinf.level = level; + cinf.commandBufferCount = count; + + if(vkAllocateCommandBuffers(vk_device, &cinf, buf_array) != VK_SUCCESS) { + fprintf(stderr, "Failed to allocate command buffer\n"); + return false; + } + + return true; +} + void vku_free_cmdbuf(VkCommandPool pool, VkCommandBuffer buf) { - vkFreeCommandBuffers(vkdev, pool, 1, &buf); + vkFreeCommandBuffers(vk_device, pool, 1, &buf); } void vku_begin_cmdbuf(VkCommandBuffer buf, unsigned int flags) @@ -349,83 +335,44 @@ void vku_submit_cmdbuf(VkQueue q, VkCommandBuffer buf, VkFence done_fence) vkQueueSubmit(q, 1, &info, done_fence); } -VkSwapchainKHR vku_create_swapchain(VkSurfaceKHR surf, int xsz, int ysz, int n, - VkPresentModeKHR pmode, VkSwapchainKHR prev) +bool vku_get_surface_format(VkPhysicalDevice gpu, VkSurfaceKHR surface, VkSurfaceFormatKHR *sformat) { - VkSwapchainKHR sc; - VkSwapchainCreateInfoKHR inf; + uint32_t fcount; - memset(&inf, 0, sizeof inf); - inf.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; - inf.surface = surf; - inf.minImageCount = n; - inf.imageFormat = VK_FORMAT_B8G8R8A8_UNORM; /* TODO enumerate and choose */ - inf.imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR; - inf.imageExtent.width = xsz; - inf.imageExtent.height = ysz; - inf.imageArrayLayers = 1; - inf.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; - inf.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; /* XXX make this an option? */ - inf.preTransform = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR; - inf.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; - inf.presentMode = pmode; - inf.oldSwapchain = prev; - - if(vkCreateSwapchainKHR(vkdev, &inf, 0, &sc) != 0) { - return 0; + if(vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical, + vk_surface, &fcount, 0) != VK_SUCCESS) { + fprintf(stderr, "Failed to get format count for physical device.\n"); + return false; } - return sc; -} - -VkImage *vku_get_swapchain_images(VkSwapchainKHR sc, int *count) -{ - uint32_t nimg; - VkImage *images; - - if(vkGetSwapchainImagesKHR(vkdev, sc, &nimg, 0) != 0) { - return 0; + if(fcount == 0) { + fprintf(stderr, "No color formats were found.\n"); + return false; } - images = new VkImage[nimg]; - vkGetSwapchainImagesKHR(vkdev, sc, &nimg, images); - if(count) *count = (int)nimg; - return images; -} - -VkImageView *vku_create_image_views(VkImage *images, int count) -{ - VkImageView *iviews; - - iviews = new VkImageView[count]; - for(int i=0; iformat = VK_FORMAT_B8G8R8_UNORM; } - return iviews; + delete [] formats; + return true; } + int vku_get_next_image(VkSwapchainKHR sc) { uint32_t next; - if(vkAcquireNextImageKHR(vkdev, sc, UINT64_MAX, 0, 0, &next) != 0) { + if(vkAcquireNextImageKHR(vk_device, sc, UINT64_MAX, 0, 0, &next) != 0) { return -1; } return (int)next; @@ -444,90 +391,7 @@ void vku_present(VkSwapchainKHR sc, int img_idx) inf.pImageIndices = &index; inf.pResults = &res; - vkQueuePresentKHR(vkq, &inf); -} - -bool vku_create_renderpass() -{ - VkAttachmentDescription attachments[2]; - memset(&attachments, 0, 2 * sizeof *attachments); - - /* color */ - attachments[0].format = VK_FORMAT_B8G8R8A8_UNORM; - attachments[0].samples = VK_SAMPLE_COUNT_1_BIT; - attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE; - attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - attachments[0].initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - attachments[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - - /* depth */ - attachments[1].format = VK_FORMAT_D32_SFLOAT_S8_UINT; //TODO - attachments[1].samples = VK_SAMPLE_COUNT_1_BIT; - attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; - attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - attachments[1].initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - attachments[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - - VkAttachmentReference color_ref; - color_ref.attachment = 0; - color_ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - - VkAttachmentReference depth_ref; - depth_ref.attachment = 1; - depth_ref.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - - VkSubpassDescription subpass_desc; - memset(&subpass_desc, 0, sizeof subpass_desc); - - subpass_desc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; - subpass_desc.colorAttachmentCount = 1; - subpass_desc.pColorAttachments = &color_ref; - subpass_desc.pDepthStencilAttachment = &depth_ref; - - VkRenderPassCreateInfo inf; - memset(&inf, 0, sizeof inf); - - inf.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; - inf.attachmentCount = 2; - inf.pAttachments = attachments; - inf.subpassCount = 1; - inf.pSubpasses = &subpass_desc; - - if(vkCreateRenderPass(vkdev, &inf, 0, &vkrpass) != VK_SUCCESS) { - return false; - } - - return true; -} - -bool vku_create_framebuffers(VkImageView *image_views, int count, int w, int h) -{ - delete vkfbufs; - vkfbufs = new VkFramebuffer[count]; - - VkFramebufferCreateInfo inf; - memset(&inf, 0, sizeof inf); - - inf.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; - inf.renderPass = vkrpass; - inf.attachmentCount = count; - inf.pAttachments = image_views; - inf.width = w; - inf.height = h; - inf.layers = 1; - - for(int i=0; ibuf) != 0) { + if(vkCreateBuffer(vk_device, &binfo, 0, &buf->buf) != 0) { fprintf(stderr, "failed to create %d byte buffer (usage: %x)\n", sz, usage); return 0; } - // TODO back with memory + + VkMemoryRequirements mr; + vkGetBufferMemoryRequirements(vk_device, buf->buf, &mr); + + DevMemBlock block; + if(!vku_allocate(mr.size, &block)) + return 0; + + buf->mem_pool = block.dev_mem; + return buf; } void vku_destroy_buffer(struct vku_buffer *buf) { if(buf) { - vkDestroyBuffer(vkdev, buf->buf, 0); + //TODO change when the allocator changes + vku_free(buf->mem_pool); + + vkDestroyBuffer(vk_device, buf->buf, 0); delete buf; } } +bool vku_update_buffer(vku_buffer *buf, int size, void *data) +{ + uint8_t *pdata; + if(vkMapMemory(vk_device, buf->mem_pool, 0, size, 0, (void**)&pdata) != VK_SUCCESS) { + fprintf(stderr, "Failed to map memory.\n"); + return false; + } + memcpy(pdata, data, size); + vkUnmapMemory(vk_device, buf->mem_pool); + + return true; +} + void vku_cmd_copybuf(VkCommandBuffer cmdbuf, VkBuffer dest, int doffs, VkBuffer src, int soffs, int size) { @@ -635,89 +524,6 @@ const char *vku_get_vulkan_error_str(VkResult error) return errmsg.c_str(); } -bool vku_create_graphics_pipeline(VkPipelineLayout *layout) -{ - VkGraphicsPipelineCreateInfo inf; - memset(&inf, 0, sizeof inf); - - inf.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; - inf.layout = *layout; - inf.renderPass = vkrpass; - - /* states */ - - /* how primitives are assembled */ - VkPipelineInputAssemblyStateCreateInfo ias; - memset(&ias, 0, sizeof ias); - ias.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - ias.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; - - /* rasterisation */ - VkPipelineRasterizationStateCreateInfo rsi; - memset(&rsi, 0, sizeof rsi); - rsi.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - rsi.polygonMode = VK_POLYGON_MODE_FILL; - rsi.cullMode = VK_CULL_MODE_BACK_BIT; - rsi.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; - rsi.lineWidth = 1.0f; - - /* blend factors */ - VkPipelineColorBlendAttachmentState bas[1]; - memset(&bas[0], 0, sizeof bas[0]); - - VkPipelineColorBlendStateCreateInfo cbs; - memset(&cbs, 0, sizeof cbs); - cbs.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; - cbs.attachmentCount = 1; - cbs.pAttachments = bas; - - /* number of viewport and scissors in this pipeline */ - VkPipelineViewportStateCreateInfo vs; - memset(&vs, 0, sizeof vs); - vs.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; - vs.viewportCount = 1; - vs.scissorCount = 1; - - /* dynamic states: that can be changed later */ - std::vector ds_enabled; - ds_enabled.push_back(VK_DYNAMIC_STATE_VIEWPORT); - //ds_enabled.push_back(VK_DYNAMIC_STATE_SCISSOR); - VkPipelineDynamicStateCreateInfo ds; - ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; - ds.pDynamicStates = ds_enabled.data(); - ds.dynamicStateCount = static_cast(ds_enabled.size()); - - /* depth tests */ - VkPipelineDepthStencilStateCreateInfo dsi; - memset(&dsi, 0, sizeof dsi); - dsi.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - dsi.depthTestEnable = VK_TRUE; - dsi.depthWriteEnable = VK_TRUE; - dsi.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL; - dsi.back.failOp = VK_STENCIL_OP_KEEP; - dsi.back.passOp = VK_STENCIL_OP_KEEP; - dsi.back.compareOp = VK_COMPARE_OP_ALWAYS; - dsi.front = dsi.back; - - /* multisampling - must be set even if not used */ - VkPipelineMultisampleStateCreateInfo msi; - memset(&msi, 0, sizeof msi); - msi.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - msi.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; - - /* vertex input descriptions */ - VkVertexInputBindingDescription vib; - memset(&vib, 0, sizeof vib); - vib.stride = sizeof(Vec3); - vib.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; - - /* input attr bindings */ - VkVertexInputAttributeDescription via[2]; - memset(&via, 0, sizeof via); - via[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; - - return true; -} static const char *get_device_name_str(VkPhysicalDeviceType type) { @@ -815,3 +621,108 @@ static const char *get_mem_size_str(long sz) sprintf(str, "%ld.%ld %s", sz / 10, sz % 10, unitstr[uidx]); return str; } + +vku_descriptor *vku_create_descriptor(VkDescriptorType type, + VkFlags stage, int binding_point, + int size, int num_desc) +{ + vku_descriptor *desc = new vku_descriptor; + + desc->type = type; + desc->size = size; + desc->stage_flags = stage; + desc->binding_point = binding_point; + + VkDescriptorSetLayoutBinding dslb; + memset(&dslb, 0, sizeof dslb); + + dslb.binding = binding_point; + dslb.descriptorType = type; + dslb.descriptorCount = num_desc; + dslb.stageFlags = stage; + + VkDescriptorSetLayoutCreateInfo dslinf; + memset(&dslinf, 0, sizeof dslinf); + + dslinf.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + dslinf.bindingCount = 1; + dslinf.pBindings = &dslb; + + if(vkCreateDescriptorSetLayout(vk_device, &dslinf, 0, &desc->layout) != VK_SUCCESS) { + fprintf(stderr, "Failed to create vku_descriptor.\n"); + return 0; + } + + return desc; +} + +void vku_destroy_descriptor(vku_descriptor *desc) +{ + vkDestroyDescriptorSetLayout(vk_device, desc->layout, 0); + delete desc; +} + +bool vku_create_descriptor_pool(vku_descriptor **descriptors, int num_desc) +{ + if(vk_dpool) + vkDestroyDescriptorPool(vk_device, vk_dpool, 0); + + VkDescriptorPoolCreateInfo dpinf; + memset(&dpinf, 0, sizeof dpinf); + dpinf.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + dpinf.maxSets = 1; + + dpinf.poolSizeCount = num_desc; + + std::vector sizes; + for(int i=0; itype; + psz.descriptorCount = 1; + sizes.push_back(psz); + } + + dpinf.pPoolSizes = sizes.data(); + + if(vkCreateDescriptorPool(vk_device, &dpinf, 0, &vk_dpool) != VK_SUCCESS) { + fprintf(stderr, "Failed to create descriptor pool.\n"); + return false; + } + + return true; +} + +void vku_destroy_descriptor_pool() +{ + vkDestroyDescriptorPool(vk_device, vk_dpool, 0); +} + +bool vku_allocate_descriptor_sets(vku_descriptor **desc, int num_desc, VkDescriptorSet set) +{ + VkDescriptorSetAllocateInfo dainf; + memset(&dainf, 0, sizeof dainf); + + dainf.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + dainf.descriptorPool = vk_dpool; + dainf.descriptorSetCount = num_desc; + + std::vector layouts; + for(int i=0; ilayout); + } + + dainf.pSetLayouts = layouts.data(); + + if(vkAllocateDescriptorSets(vk_device, &dainf, &set) != VK_SUCCESS) { + fprintf(stderr, "Failed to allocate descriptor sets.\n"); + return false; + } + return true; +} + +void vku_free_descriptor_sets(VkDescriptorSet *sets, int num) +{ + vkFreeDescriptorSets(vk_device, vk_dpool, num, sets); +} + +