X-Git-Url: http://git.mutantstargoat.com?a=blobdiff_plain;f=src%2Fvulkan%2Fvkutil.cc;h=1a33fa710afebac13b111b8dc99598a933413ad0;hb=dbce2a319517c09fcf1a9be60ae46a0ff20c423e;hp=35a85dd0e3a378d52ae8cdf43a910bcecc0e54f6;hpb=22347bb45e427ea763295d77da0de0d2ef9c2395;p=demo diff --git a/src/vulkan/vkutil.cc b/src/vulkan/vkutil.cc index 35a85dd..1a33fa7 100644 --- a/src/vulkan/vkutil.cc +++ b/src/vulkan/vkutil.cc @@ -13,24 +13,14 @@ /* global variables */ VkPhysicalDevice vk_physical; VkDevice vk_device; -VkCommandPool vk_pool; +VkInstance vk_instance; VkQueue vk_queue; +int vk_qfamily; +VkCommandPool vk_pool; VkSurfaceKHR vk_surface; VkSwapchainKHR vk_swapchain; - -VkPipeline *vkgparent_pipeline; -VkFramebuffer *vkfbufs; -VkRenderPass vkrpass; -VkInstance vkinst; -VkCommandBuffer vkcmdbuf; /* primary command buffer */ -int vkqfamily; - -VkSemaphore vk_img_avail_sema; -VkSemaphore vk_rend_done_sema; -VkImage *vkswapchain_images; -VkImageView *vkswapchain_views; -int vknum_swapchain_images; -int vk_curr_swapchain_image; +VkRenderPass vk_renderpass; +VkDescriptorPool vk_dpool; /* static functions */ static const char *get_device_name_str(VkPhysicalDeviceType type); @@ -132,17 +122,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; } @@ -234,7 +224,7 @@ bool vku_create_device() printf("created device %d\n", sel_dev); vk_physical = phys_devices[sel_dev]; - vkqfamily = sel_qfamily; + vk_qfamily = sel_qfamily; vkGetDeviceQueue(vk_device, sel_qfamily, 0, &vk_queue); @@ -259,41 +249,19 @@ bool vku_create_device() void vku_cleanup() { - if(vkinst) { + if(vk_instance) { vkDeviceWaitIdle(vk_device); vkDestroyCommandPool(vk_device, vk_pool, 0); - vkDestroySemaphore(vk_device, vk_img_avail_sema, 0); - vkDestroySemaphore(vk_device, vk_rend_done_sema, 0); - vkDestroyDevice(vk_device, 0); - vkDestroyInstance(vkinst, 0); - vkinst = 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(vk_device, &sinf, 0, &vk_img_avail_sema) != VK_SUCCESS) { - fprintf(stderr, "Failed to create semaphore\n"); - return false; - } - - if(vkCreateSemaphore(vk_device, &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; @@ -468,6 +436,19 @@ void vku_destroy_buffer(struct vku_buffer *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) { @@ -641,3 +622,192 @@ 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); +} + +bool vku_update_descriptor_sets(VkDescriptorSet *sets, int num_sets) +{ +// std::vector + return true; +} + +VkPipelineCache vku_create_pipeline_cache() +{ + VkPipelineCacheCreateInfo cinf; + memset(&cinf, 0, sizeof cinf); + cinf.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; + + VkPipelineCache cache; + if(vkCreatePipelineCache(vk_device, &cinf, 0, &cache) != VK_SUCCESS) { + fprintf(stderr, "Failed to create pipeline cache.\n"); + return 0; + } + return cache; +} + +void vku_destroy_pipeline_cache(VkPipelineCache cache) +{ + vkDestroyPipelineCache(vk_device, cache, 0); +} + +void vku_pl_init_shader_stage_state_info(VkPipelineShaderStageCreateInfo *ssinf, + VkShaderStageFlagBits stage, VkShaderModule sm) +{ + memset(ssinf, 0, sizeof *ssinf); + ssinf->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + ssinf->stage = stage; + ssinf->module = sm; + ssinf->pName = "main"; +} + +void vku_pl_init_input_asm_state_info(VkPipelineInputAssemblyStateCreateInfo *iasinf) +{ + memset(iasinf, 0, sizeof *iasinf); + iasinf->sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + iasinf->topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; +} + +void vku_pl_init_viewport_state_info(VkPipelineViewportStateCreateInfo *vsinf, + VkViewport *viewports, int num_viewports, VkRect2D *scissors, + int num_scissors) +{ + memset(vsinf, 0, sizeof *vsinf); + vsinf->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + vsinf->viewportCount = num_viewports; + vsinf->scissorCount = num_scissors; + vsinf->pViewports = viewports; + vsinf->pScissors = scissors; +} + +void vku_pl_init_rasterization_state_info(VkPipelineRasterizationStateCreateInfo *rsinf) +{ + memset(rsinf, 0, sizeof *rsinf); + rsinf->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rsinf->polygonMode = VK_POLYGON_MODE_FILL; + rsinf->cullMode = VK_CULL_MODE_FRONT_BIT; + rsinf->frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; +} + +void vku_pl_init_multisample_state_info(VkPipelineMultisampleStateCreateInfo *msinf) +{ + memset(msinf, 0, sizeof *msinf); + msinf->sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + msinf->rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; +} + +void vku_pl_init_depth_stencil_state_info(VkPipelineDepthStencilStateCreateInfo *dsinf, + bool enable) +{ + memset(dsinf, 0, sizeof *dsinf); + dsinf->sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + dsinf->depthTestEnable = enable ? VK_TRUE : VK_FALSE; +} + +void vku_pl_init_color_blend_state_info(VkPipelineColorBlendStateCreateInfo *cbsinf, + bool enable) +{ + memset(cbsinf, 0, sizeof *cbsinf); + cbsinf->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + //TODO +}