quick/Quake-III-Arena-VS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Minor cleanup.

Browse Source
This commit is contained in:
Artem Kharytoniuk 2017-04-24 17:08:51 +03:00
parent f2f0cea494
commit e73ff2f88e
3 changed files with 326 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/engine/platform/win_glimp.c
View File

@ -563,20 +563,23 @@ static bool GLW_SetMode(int mode, qboolean fullscreen) {
if (r_renderAPICompareWindow->integer) { if (r_renderAPICompareWindow->integer) {
HWND hwnd2 = create_api_compare_window(glConfig.vidWidth, glConfig.vidHeight); HWND hwnd2 = create_api_compare_window(glConfig.vidWidth, glConfig.vidHeight);
if (!vk_initialize(hwnd2)) { vk_initialize(hwnd2);
g_wv.hWnd_vulkan = hwnd2;
/*if (!vk_initialize(hwnd2)) {
ShowWindow(hwnd2, SW_HIDE); ShowWindow(hwnd2, SW_HIDE);
DestroyWindow(hwnd2); DestroyWindow(hwnd2);
ri.Printf(PRINT_WARNING, "GLW_SetMode: could not create API compare window"); ri.Printf(PRINT_WARNING, "GLW_SetMode: could not create API compare window");
} else { } else {
g_wv.hWnd_vulkan = hwnd2; g_wv.hWnd_vulkan = hwnd2;
} }*/
} }
} else { // vulkan } else { // vulkan
if (!vk_initialize(hwnd)) { vk_initialize(hwnd);
/*if (!vk_initialize(hwnd)) {
ShowWindow(hwnd, SW_HIDE); ShowWindow(hwnd, SW_HIDE);
DestroyWindow(hwnd); DestroyWindow(hwnd);
return false; return false;
} }*/
g_wv.hWnd = hwnd; g_wv.hWnd = hwnd;
g_wv.hWnd_vulkan = hwnd; g_wv.hWnd_vulkan = hwnd;

644
src/engine/renderer/vk.cpp
View File

@ -543,341 +543,333 @@ static void deallocate_image_chunks() {
VkPipeline create_pipeline(const Vk_Pipeline_Desc&); VkPipeline create_pipeline(const Vk_Pipeline_Desc&);
bool vk_initialize(HWND hwnd) { void vk_initialize(HWND hwnd) {
vk_log_file = fopen("vk_dev.log", "w"); vk_log_file = fopen("vk_dev.log", "w");
try { vk.instance = create_instance();
auto& g = vk; vk.physical_device = select_physical_device(vk.instance);
vk.surface = create_surface(vk.instance, hwnd);
vk.surface_format = select_surface_format(vk.physical_device, vk.surface);
g.instance = create_instance(); vk.queue_family_index = select_queue_family(vk.physical_device, vk.surface);
g.physical_device = select_physical_device(g.instance); vk.device = create_device(vk.physical_device, vk.queue_family_index);
g.surface = create_surface(g.instance, hwnd); vkGetDeviceQueue(vk.device, vk.queue_family_index, 0, &vk.queue);
g.surface_format = select_surface_format(g.physical_device, g.surface);
g.queue_family_index = select_queue_family(g.physical_device, g.surface); vk.swapchain = create_swapchain(vk.physical_device, vk.device, vk.surface, vk.surface_format);
g.device = create_device(g.physical_device, g.queue_family_index);
vkGetDeviceQueue(g.device, g.queue_family_index, 0, &g.queue);
g.swapchain = create_swapchain(g.physical_device, g.device, g.surface, g.surface_format); VK_CHECK(vkGetSwapchainImagesKHR(vk.device, vk.swapchain, &vk.swapchain_image_count, nullptr));
VK_CHECK(vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk.swapchain_image_count, nullptr)); if (vk.swapchain_image_count > MAX_SWAPCHAIN_IMAGES)
ri.Error( ERR_FATAL, "initialize_vulkan: swapchain image count (%d) exceeded limit (%d)", vk.swapchain_image_count, MAX_SWAPCHAIN_IMAGES );
if (vk.swapchain_image_count > MAX_SWAPCHAIN_IMAGES) VK_CHECK(vkGetSwapchainImagesKHR(vk.device, vk.swapchain, &vk.swapchain_image_count, vk.swapchain_images));
ri.Error( ERR_FATAL, "initialize_vulkan: swapchain image count (%d) exceeded limit (%d)", vk.swapchain_image_count, MAX_SWAPCHAIN_IMAGES );
VK_CHECK(vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk.swapchain_image_count, g.swapchain_images)); for (std::size_t i = 0; i < vk.swapchain_image_count; i++) {
VkImageViewCreateInfo desc;
for (std::size_t i = 0; i < vk.swapchain_image_count; i++) { desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
VkImageViewCreateInfo desc; desc.pNext = nullptr;
desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; desc.flags = 0;
desc.pNext = nullptr; desc.image = vk.swapchain_images[i];
desc.flags = 0; desc.viewType = VK_IMAGE_VIEW_TYPE_2D;
desc.image = g.swapchain_images[i]; desc.format = vk.surface_format.format;
desc.viewType = VK_IMAGE_VIEW_TYPE_2D; desc.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
desc.format = g.surface_format.format; desc.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
desc.components.r = VK_COMPONENT_SWIZZLE_IDENTITY; desc.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
desc.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; desc.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
desc.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; desc.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
desc.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; desc.subresourceRange.baseMipLevel = 0;
desc.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; desc.subresourceRange.levelCount = 1;
desc.subresourceRange.baseMipLevel = 0; desc.subresourceRange.baseArrayLayer = 0;
desc.subresourceRange.levelCount = 1; desc.subresourceRange.layerCount = 1;
desc.subresourceRange.baseArrayLayer = 0; VK_CHECK(vkCreateImageView(vk.device, &desc, nullptr, &vk.swapchain_image_views[i]));
desc.subresourceRange.layerCount = 1; }
VK_CHECK(vkCreateImageView(g.device, &desc, nullptr, &g.swapchain_image_views[i]));
} {
VkCommandPoolCreateInfo desc;
{ desc.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
VkCommandPoolCreateInfo desc; desc.pNext = nullptr;
desc.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; desc.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
desc.pNext = nullptr; desc.queueFamilyIndex = vk.queue_family_index;
desc.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
desc.queueFamilyIndex = vk.queue_family_index; VK_CHECK(vkCreateCommandPool(vk.device, &desc, nullptr, &vk.command_pool));
}
VK_CHECK(vkCreateCommandPool(g.device, &desc, nullptr, &vk.command_pool));
} {
VkCommandBufferAllocateInfo alloc_info;
{ alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
VkCommandBufferAllocateInfo alloc_info; alloc_info.pNext = nullptr;
alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; alloc_info.commandPool = vk.command_pool;
alloc_info.pNext = nullptr; alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
alloc_info.commandPool = vk.command_pool; alloc_info.commandBufferCount = 1;
alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; VK_CHECK(vkAllocateCommandBuffers(vk.device, &alloc_info, &vk.command_buffer));
alloc_info.commandBufferCount = 1; }
VK_CHECK(vkAllocateCommandBuffers(vk.device, &alloc_info, &g.command_buffer));
} //
// Depth attachment image.
// //
// Depth attachment image. {
// VkFormat depth_format = find_depth_format(vk.physical_device);
{
VkFormat depth_format = find_depth_format(vk.physical_device); VkImageCreateInfo desc;
desc.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
VkImageCreateInfo desc; desc.pNext = nullptr;
desc.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; desc.flags = 0;
desc.pNext = nullptr; desc.imageType = VK_IMAGE_TYPE_2D;
desc.flags = 0; desc.format = depth_format;
desc.imageType = VK_IMAGE_TYPE_2D; desc.extent.width = glConfig.vidWidth;
desc.format = depth_format; desc.extent.height = glConfig.vidHeight;
desc.extent.width = glConfig.vidWidth; desc.extent.depth = 1;
desc.extent.height = glConfig.vidHeight; desc.mipLevels = 1;
desc.extent.depth = 1; desc.arrayLayers = 1;
desc.mipLevels = 1; desc.samples = VK_SAMPLE_COUNT_1_BIT;
desc.arrayLayers = 1; desc.tiling = VK_IMAGE_TILING_OPTIMAL;
desc.samples = VK_SAMPLE_COUNT_1_BIT; desc.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
desc.tiling = VK_IMAGE_TILING_OPTIMAL; desc.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
desc.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; desc.queueFamilyIndexCount = 0;
desc.sharingMode = VK_SHARING_MODE_EXCLUSIVE; desc.pQueueFamilyIndices = nullptr;
desc.queueFamilyIndexCount = 0; desc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
desc.pQueueFamilyIndices = nullptr;
desc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; VK_CHECK(vkCreateImage(vk.device, &desc, nullptr, &vk.depth_image));
VK_CHECK(vkCreateImage(vk.device, &desc, nullptr, &vk.depth_image)); VkMemoryRequirements memory_requirements;
vkGetImageMemoryRequirements(vk.device, vk.depth_image, &memory_requirements);
VkMemoryRequirements memory_requirements;
vkGetImageMemoryRequirements(vk.device, vk.depth_image, &memory_requirements); VkMemoryAllocateInfo alloc_info;
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
VkMemoryAllocateInfo alloc_info; alloc_info.pNext = nullptr;
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; alloc_info.allocationSize = memory_requirements.size;
alloc_info.pNext = nullptr; alloc_info.memoryTypeIndex = find_memory_type(vk.physical_device, memory_requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
alloc_info.allocationSize = memory_requirements.size;
alloc_info.memoryTypeIndex = find_memory_type(vk.physical_device, memory_requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); VK_CHECK(vkAllocateMemory(vk.device, &alloc_info, nullptr, &vk.depth_image_memory));
VK_CHECK(vkBindImageMemory(vk.device, vk.depth_image, vk.depth_image_memory, 0));
VK_CHECK(vkAllocateMemory(vk.device, &alloc_info, nullptr, &vk.depth_image_memory)); vk.depth_image_view = create_image_view(vk.depth_image, depth_format, VK_IMAGE_ASPECT_DEPTH_BIT);
VK_CHECK(vkBindImageMemory(vk.device, vk.depth_image, vk.depth_image_memory, 0));
vk.depth_image_view = create_image_view(vk.depth_image, depth_format, VK_IMAGE_ASPECT_DEPTH_BIT); record_and_run_commands(vk.command_pool, vk.queue, [&depth_format](VkCommandBuffer command_buffer) {
record_image_layout_transition(command_buffer, vk.depth_image, depth_format, 0, VK_IMAGE_LAYOUT_UNDEFINED,
record_and_run_commands(vk.command_pool, vk.queue, [&depth_format](VkCommandBuffer command_buffer) { VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
record_image_layout_transition(command_buffer, vk.depth_image, depth_format, 0, VK_IMAGE_LAYOUT_UNDEFINED, });
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); }
});
} VkFormat depth_format = find_depth_format(vk.physical_device);
VkFormat depth_format = find_depth_format(vk.physical_device); vk.render_pass = create_render_pass(vk.device, vk.surface_format.format, depth_format);
vk.render_pass = create_render_pass(vk.device, vk.surface_format.format, depth_format); {
VkImageView attachments[2] = {VK_NULL_HANDLE, vk.depth_image_view};
{
VkImageView attachments[2] = {VK_NULL_HANDLE, vk.depth_image_view}; VkFramebufferCreateInfo desc;
desc.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
VkFramebufferCreateInfo desc; desc.pNext = nullptr;
desc.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; desc.flags = 0;
desc.pNext = nullptr; desc.renderPass = vk.render_pass;
desc.flags = 0; desc.attachmentCount = 2;
desc.renderPass = vk.render_pass; desc.pAttachments = attachments;
desc.attachmentCount = 2; desc.width = glConfig.vidWidth;
desc.pAttachments = attachments; desc.height = glConfig.vidHeight;
desc.width = glConfig.vidWidth; desc.layers = 1;
desc.height = glConfig.vidHeight;
desc.layers = 1; for (uint32_t i = 0; i < vk.swapchain_image_count; i++) {
attachments[0] = vk.swapchain_image_views[i]; // set color attachment
for (uint32_t i = 0; i < vk.swapchain_image_count; i++) { VK_CHECK(vkCreateFramebuffer(vk.device, &desc, nullptr, &vk.framebuffers[i]));
attachments[0] = vk.swapchain_image_views[i]; // set color attachment }
VK_CHECK(vkCreateFramebuffer(vk.device, &desc, nullptr, &vk.framebuffers[i])); }
}
} //
// Descriptor pool.
// //
// Descriptor pool. {
// VkDescriptorPoolSize pool_size;
{ pool_size.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
VkDescriptorPoolSize pool_size; pool_size.descriptorCount = MAX_DRAWIMAGES;
pool_size.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
pool_size.descriptorCount = MAX_DRAWIMAGES; VkDescriptorPoolCreateInfo desc;
desc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
VkDescriptorPoolCreateInfo desc; desc.pNext = nullptr;
desc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; desc.flags = 0;
desc.pNext = nullptr; desc.maxSets = MAX_DRAWIMAGES;
desc.flags = 0; desc.poolSizeCount = 1;
desc.maxSets = MAX_DRAWIMAGES; desc.pPoolSizes = &pool_size;
desc.poolSizeCount = 1;
desc.pPoolSizes = &pool_size; VK_CHECK(vkCreateDescriptorPool(vk.device, &desc, nullptr, &vk.descriptor_pool));
}
VK_CHECK(vkCreateDescriptorPool(vk.device, &desc, nullptr, &vk.descriptor_pool));
} //
// Descriptor set layout.
// //
// Descriptor set layout. {
// VkDescriptorSetLayoutBinding descriptor_binding;
{ descriptor_binding.binding = 0;
VkDescriptorSetLayoutBinding descriptor_binding; descriptor_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
descriptor_binding.binding = 0; descriptor_binding.descriptorCount = 1;
descriptor_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; descriptor_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
descriptor_binding.descriptorCount = 1; descriptor_binding.pImmutableSamplers = nullptr;
descriptor_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
descriptor_binding.pImmutableSamplers = nullptr; VkDescriptorSetLayoutCreateInfo desc;
desc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
VkDescriptorSetLayoutCreateInfo desc; desc.pNext = nullptr;
desc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; desc.flags = 0;
desc.pNext = nullptr; desc.bindingCount = 1;
desc.flags = 0; desc.pBindings = &descriptor_binding;
desc.bindingCount = 1;
desc.pBindings = &descriptor_binding; VK_CHECK(vkCreateDescriptorSetLayout(vk.device, &desc, nullptr, &vk.set_layout));
}
VK_CHECK(vkCreateDescriptorSetLayout(vk.device, &desc, nullptr, &vk.set_layout));
} //
// Pipeline layout.
// //
// Pipeline layout. {
// VkPushConstantRange push_range;
{ push_range.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
VkPushConstantRange push_range; push_range.offset = 0;
push_range.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; push_range.size = 64; // sizeof(float[16])
push_range.offset = 0;
push_range.size = 64; // sizeof(float[16]) VkDescriptorSetLayout set_layouts[2] = {vk.set_layout, vk.set_layout};
VkDescriptorSetLayout set_layouts[2] = {vk.set_layout, vk.set_layout}; VkPipelineLayoutCreateInfo desc;
desc.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
VkPipelineLayoutCreateInfo desc; desc.pNext = nullptr;
desc.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; desc.flags = 0;
desc.pNext = nullptr; desc.setLayoutCount = 2;
desc.flags = 0; desc.pSetLayouts = set_layouts;
desc.setLayoutCount = 2; desc.pushConstantRangeCount = 1;
desc.pSetLayouts = set_layouts; desc.pPushConstantRanges = &push_range;
desc.pushConstantRangeCount = 1;
desc.pPushConstantRanges = &push_range; VK_CHECK(vkCreatePipelineLayout(vk.device, &desc, nullptr, &vk.pipeline_layout));
}
VK_CHECK(vkCreatePipelineLayout(vk.device, &desc, nullptr, &vk.pipeline_layout));
} //
// Geometry buffers.
// //
// Geometry buffers. {
// VkBufferCreateInfo desc;
{ desc.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
VkBufferCreateInfo desc; desc.pNext = nullptr;
desc.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; desc.flags = 0;
desc.pNext = nullptr; desc.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
desc.flags = 0; desc.queueFamilyIndexCount = 0;
desc.sharingMode = VK_SHARING_MODE_EXCLUSIVE; desc.pQueueFamilyIndices = nullptr;
desc.queueFamilyIndexCount = 0;
desc.pQueueFamilyIndices = nullptr; desc.size = VERTEX_BUFFER_SIZE;
desc.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
desc.size = VERTEX_BUFFER_SIZE; VK_CHECK(vkCreateBuffer(vk.device, &desc, nullptr, &vk.vertex_buffer));
desc.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
VK_CHECK(vkCreateBuffer(vk.device, &desc, nullptr, &vk.vertex_buffer)); desc.size = INDEX_BUFFER_SIZE;
desc.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
desc.size = INDEX_BUFFER_SIZE; VK_CHECK(vkCreateBuffer(vk.device, &desc, nullptr, &vk.index_buffer));
desc.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
VK_CHECK(vkCreateBuffer(vk.device, &desc, nullptr, &vk.index_buffer)); VkMemoryRequirements vb_memory_requirements;
vkGetBufferMemoryRequirements(vk.device, vk.vertex_buffer, &vb_memory_requirements);
VkMemoryRequirements vb_memory_requirements;
vkGetBufferMemoryRequirements(vk.device, vk.vertex_buffer, &vb_memory_requirements); VkMemoryRequirements ib_memory_requirements;
vkGetBufferMemoryRequirements(vk.device, vk.index_buffer, &ib_memory_requirements);
VkMemoryRequirements ib_memory_requirements;
vkGetBufferMemoryRequirements(vk.device, vk.index_buffer, &ib_memory_requirements); VkDeviceSize mask = ~(ib_memory_requirements.alignment - 1);
VkDeviceSize index_buffer_offset = (vb_memory_requirements.size + ib_memory_requirements.alignment - 1) & mask;
VkDeviceSize mask = ~(ib_memory_requirements.alignment - 1);
VkDeviceSize index_buffer_offset = (vb_memory_requirements.size + ib_memory_requirements.alignment - 1) & mask; uint32_t memory_type_bits = vb_memory_requirements.memoryTypeBits & ib_memory_requirements.memoryTypeBits;
uint32_t memory_type = find_memory_type(vk.physical_device, memory_type_bits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
uint32_t memory_type_bits = vb_memory_requirements.memoryTypeBits & ib_memory_requirements.memoryTypeBits;
uint32_t memory_type = find_memory_type(vk.physical_device, memory_type_bits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); VkMemoryAllocateInfo alloc_info;
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
VkMemoryAllocateInfo alloc_info; alloc_info.pNext = nullptr;
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; alloc_info.allocationSize = index_buffer_offset + ib_memory_requirements.size;
alloc_info.pNext = nullptr; alloc_info.memoryTypeIndex = memory_type;
alloc_info.allocationSize = index_buffer_offset + ib_memory_requirements.size; VK_CHECK(vkAllocateMemory(vk.device, &alloc_info, nullptr, &vk.geometry_buffer_memory));
alloc_info.memoryTypeIndex = memory_type;
VK_CHECK(vkAllocateMemory(vk.device, &alloc_info, nullptr, &vk.geometry_buffer_memory)); vkBindBufferMemory(vk.device, vk.vertex_buffer, vk.geometry_buffer_memory, 0);
vkBindBufferMemory(vk.device, vk.index_buffer, vk.geometry_buffer_memory, index_buffer_offset);
vkBindBufferMemory(vk.device, vk.vertex_buffer, vk.geometry_buffer_memory, 0);
vkBindBufferMemory(vk.device, vk.index_buffer, vk.geometry_buffer_memory, index_buffer_offset); void* data;
VK_CHECK(vkMapMemory(vk.device, vk.geometry_buffer_memory, 0, VK_WHOLE_SIZE, 0, &data));
void* data; vk.vertex_buffer_ptr = (byte*)data;
VK_CHECK(vkMapMemory(vk.device, vk.geometry_buffer_memory, 0, VK_WHOLE_SIZE, 0, &data)); vk.index_buffer_ptr = (byte*)data + index_buffer_offset;
vk.vertex_buffer_ptr = (byte*)data; }
vk.index_buffer_ptr = (byte*)data + index_buffer_offset;
} //
// Sync primitives.
// //
// Sync primitives. {
// VkSemaphoreCreateInfo desc;
{ desc.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
VkSemaphoreCreateInfo desc; desc.pNext = nullptr;
desc.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; desc.flags = 0;
desc.pNext = nullptr;
desc.flags = 0; VK_CHECK(vkCreateSemaphore(vk.device, &desc, nullptr, &vk.image_acquired));
VK_CHECK(vkCreateSemaphore(vk.device, &desc, nullptr, &vk.rendering_finished));
VK_CHECK(vkCreateSemaphore(vk.device, &desc, nullptr, &vk.image_acquired));
VK_CHECK(vkCreateSemaphore(vk.device, &desc, nullptr, &vk.rendering_finished)); VkFenceCreateInfo fence_desc;
fence_desc.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
VkFenceCreateInfo fence_desc; fence_desc.pNext = nullptr;
fence_desc.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; fence_desc.flags = VK_FENCE_CREATE_SIGNALED_BIT;
fence_desc.pNext = nullptr; VK_CHECK(vkCreateFence(vk.device, &fence_desc, nullptr, &vk.rendering_finished_fence));
fence_desc.flags = VK_FENCE_CREATE_SIGNALED_BIT; }
VK_CHECK(vkCreateFence(vk.device, &fence_desc, nullptr, &vk.rendering_finished_fence));
} //
// Shader modules.
// //
// Shader modules. {
// auto create_shader_module = [](uint8_t* bytes, int count) {
{ if (count % 4 != 0) {
auto create_shader_module = [](uint8_t* bytes, int count) { ri.Error(ERR_FATAL, "Vulkan error: SPIR-V binary buffer size is not multiple of 4");
if (count % 4 != 0) { }
ri.Error(ERR_FATAL, "Vulkan error: SPIR-V binary buffer size is not multiple of 4"); VkShaderModuleCreateInfo desc;
} desc.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
VkShaderModuleCreateInfo desc; desc.pNext = nullptr;
desc.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; desc.flags = 0;
desc.pNext = nullptr; desc.codeSize = count;
desc.flags = 0; desc.pCode = reinterpret_cast<const uint32_t*>(bytes);
desc.codeSize = count;
desc.pCode = reinterpret_cast<const uint32_t*>(bytes); VkShaderModule module;
VK_CHECK(vkCreateShaderModule(vk.device, &desc, nullptr, &module));
VkShaderModule module; return module;
VK_CHECK(vkCreateShaderModule(vk.device, &desc, nullptr, &module)); };
return module;
}; vk.single_texture_vs = create_shader_module(single_texture_vert_spv, single_texture_vert_spv_size);
vk.single_texture_fs = create_shader_module(single_texture_frag_spv, single_texture_frag_spv_size);
vk.single_texture_vs = create_shader_module(single_texture_vert_spv, single_texture_vert_spv_size); vk.multi_texture_vs = create_shader_module(multi_texture_vert_spv, multi_texture_vert_spv_size);
vk.single_texture_fs = create_shader_module(single_texture_frag_spv, single_texture_frag_spv_size); vk.multi_texture_mul_fs = create_shader_module(multi_texture_mul_frag_spv, multi_texture_mul_frag_spv_size);
vk.multi_texture_vs = create_shader_module(multi_texture_vert_spv, multi_texture_vert_spv_size); vk.multi_texture_add_fs = create_shader_module(multi_texture_add_frag_spv, multi_texture_add_frag_spv_size);
vk.multi_texture_mul_fs = create_shader_module(multi_texture_mul_frag_spv, multi_texture_mul_frag_spv_size); }
vk.multi_texture_add_fs = create_shader_module(multi_texture_add_frag_spv, multi_texture_add_frag_spv_size);
} //
// Samplers.
// //
// Samplers. {
// VkSamplerCreateInfo desc;
{ desc.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
VkSamplerCreateInfo desc; desc.pNext = nullptr;
desc.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; desc.flags = 0;
desc.pNext = nullptr; desc.magFilter = VK_FILTER_LINEAR;
desc.flags = 0; desc.minFilter = VK_FILTER_LINEAR;
desc.magFilter = VK_FILTER_LINEAR; desc.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
desc.minFilter = VK_FILTER_LINEAR; desc.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
desc.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST; desc.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
desc.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT; desc.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
desc.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT; desc.mipLodBias = 0.0f;
desc.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT; desc.anisotropyEnable = VK_TRUE;
desc.mipLodBias = 0.0f; desc.maxAnisotropy = 1;
desc.anisotropyEnable = VK_TRUE; desc.compareEnable = VK_FALSE;
desc.maxAnisotropy = 1; desc.compareOp = VK_COMPARE_OP_ALWAYS;
desc.compareEnable = VK_FALSE; desc.minLod = 0.0f;
desc.compareOp = VK_COMPARE_OP_ALWAYS; desc.maxLod = 0.0f;
desc.minLod = 0.0f; desc.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
desc.maxLod = 0.0f; desc.unnormalizedCoordinates = VK_FALSE;
desc.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
desc.unnormalizedCoordinates = VK_FALSE; VK_CHECK(vkCreateSampler(vk.device, &desc, nullptr, &vk.sampler));
}
VK_CHECK(vkCreateSampler(vk.device, &desc, nullptr, &vk.sampler));
} //
// Skybox pipeline.
// //
// Skybox pipeline. {
// Vk_Pipeline_Desc desc;
{ desc.shader_type = Vk_Shader_Type::single_texture;
Vk_Pipeline_Desc desc; desc.state_bits = 0;
desc.shader_type = Vk_Shader_Type::single_texture; desc.face_culling = CT_FRONT_SIDED;
desc.state_bits = 0; desc.polygon_offset = false;
desc.face_culling = CT_FRONT_SIDED;
desc.polygon_offset = false; vk.skybox_pipeline = create_pipeline(desc);
vk.skybox_pipeline = create_pipeline(desc);
}
} catch (const std::exception&) {
return false;
} }
return true;
} }
void vk_deinitialize() { void vk_deinitialize() {

2
src/engine/renderer/vk.h
View File

@ -50,7 +50,7 @@ struct Vk_Image {
VkDescriptorSet descriptor_set; VkDescriptorSet descriptor_set;
}; };
bool vk_initialize(HWND hwnd); void vk_initialize(HWND hwnd);
void vk_deinitialize(); void vk_deinitialize();
void vk_destroy_resources(); void vk_destroy_resources();