Examples: Vulkan: Coding style tweaks.
This commit is contained in:
ocornut
parent
9c513d4443
commit
0e7b9b8284
@ -80,3 +80,7 @@ allegro5_example/
|
||||
marmalade_example/
|
||||
Marmalade example using IwGx
|
||||
|
||||
vulkan_example/
|
||||
Vulkan example.
|
||||
This is quite long and tedious, because: Vulkan.
|
||||
|
||||
|
||||
4
examples/vulkan_example/build_win32.bat
Normal file
4
examples/vulkan_example/build_win32.bat
Normal file
@ -0,0 +1,4 @@
|
||||
@REM Build for Visual Studio compiler. Run your copy of vcvars32.bat or vcvarsall.bat to setup command-line compiler.
|
||||
mkdir Debug
|
||||
cl /nologo /Zi /MD /I ..\.. /I ..\libs\glfw\include /I %VULKAN_SDK%\include *.cpp ..\..\*.cpp /FeDebug/vulkan_example.exe /FoDebug/ /link /LIBPATH:..\libs\glfw\lib-vc2010-32 /libpath:%VULKAN_SDK%\bin32 glfw3.lib opengl32.lib gdi32.lib shell32.lib vulkan-1.lib
|
||||
|
||||
@ -59,7 +59,8 @@ static VkBuffer g_IndexBuffer[IMGUI_VK_QUEUED_FRAMES] = {};
|
||||
static VkDeviceMemory g_UploadBufferMemory = VK_NULL_HANDLE;
|
||||
static VkBuffer g_UploadBuffer = VK_NULL_HANDLE;
|
||||
|
||||
static unsigned char __glsl_shader_vert_spv[] = {
|
||||
static unsigned char __glsl_shader_vert_spv[] =
|
||||
{
|
||||
0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00,
|
||||
0x6c, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
|
||||
0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00, 0x20, 0x00, 0x00, 0x00,
|
||||
@ -161,7 +162,8 @@ static unsigned char __glsl_shader_vert_spv[] = {
|
||||
};
|
||||
static unsigned int __glsl_shader_vert_spv_len = 1172;
|
||||
|
||||
static unsigned char __glsl_shader_frag_spv[] = {
|
||||
static unsigned char __glsl_shader_frag_spv[] =
|
||||
{
|
||||
0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x08, 0x00,
|
||||
0x6c, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
|
||||
0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00,
|
||||
@ -224,15 +226,15 @@ static uint32_t ImGui_ImplGlfwVulkan_MemoryType(VkMemoryPropertyFlags properties
|
||||
{
|
||||
VkPhysicalDeviceMemoryProperties prop;
|
||||
vkGetPhysicalDeviceMemoryProperties(g_Gpu, &prop);
|
||||
for(uint32_t i=0; i < prop.memoryTypeCount; ++i)
|
||||
if((prop.memoryTypes[i].propertyFlags & properties) == properties &&
|
||||
type_bits & (1<<i))
|
||||
for (uint32_t i = 0; i < prop.memoryTypeCount; i++)
|
||||
if ((prop.memoryTypes[i].propertyFlags & properties) == properties && type_bits & (1<<i))
|
||||
return i;
|
||||
return 0xffffffff; // Unable to find memoryType
|
||||
}
|
||||
|
||||
static void ImGui_ImplGlfwVulkan_VkResult(VkResult err)
|
||||
{
|
||||
if(g_CheckVkResult)
|
||||
if (g_CheckVkResult)
|
||||
g_CheckVkResult(err);
|
||||
}
|
||||
|
||||
@ -244,22 +246,19 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
|
||||
|
||||
// Create the Vertex Buffer:
|
||||
size_t vertex_size = draw_data->TotalVtxCount * sizeof(ImDrawVert);
|
||||
if(!g_VertexBuffer[g_FrameIndex] ||
|
||||
g_VertexBufferSize[g_FrameIndex] < vertex_size){
|
||||
if(g_VertexBuffer[g_FrameIndex])
|
||||
if (!g_VertexBuffer[g_FrameIndex] || g_VertexBufferSize[g_FrameIndex] < vertex_size)
|
||||
{
|
||||
if (g_VertexBuffer[g_FrameIndex])
|
||||
vkDestroyBuffer(g_Device, g_VertexBuffer[g_FrameIndex], g_Allocator);
|
||||
if(g_VertexBufferMemory[g_FrameIndex])
|
||||
if (g_VertexBufferMemory[g_FrameIndex])
|
||||
vkFreeMemory(g_Device, g_VertexBufferMemory[g_FrameIndex], g_Allocator);
|
||||
size_t vertex_buffer_size = ((vertex_size-1)/g_BufferMemoryAlignment+1)*g_BufferMemoryAlignment;
|
||||
size_t vertex_buffer_size = ((vertex_size-1) / g_BufferMemoryAlignment+1) * g_BufferMemoryAlignment;
|
||||
VkBufferCreateInfo buffer_info = {};
|
||||
buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
||||
buffer_info.size = vertex_buffer_size;
|
||||
buffer_info.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
|
||||
buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||||
err = vkCreateBuffer(g_Device,
|
||||
&buffer_info,
|
||||
g_Allocator,
|
||||
&g_VertexBuffer[g_FrameIndex]);
|
||||
err = vkCreateBuffer(g_Device, &buffer_info, g_Allocator, &g_VertexBuffer[g_FrameIndex]);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
VkMemoryRequirements req;
|
||||
vkGetBufferMemoryRequirements(g_Device, g_VertexBuffer[g_FrameIndex], &req);
|
||||
@ -267,38 +266,29 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
|
||||
VkMemoryAllocateInfo alloc_info = {};
|
||||
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
alloc_info.allocationSize = req.size;
|
||||
alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
|
||||
req.memoryTypeBits);
|
||||
err = vkAllocateMemory(g_Device,
|
||||
&alloc_info,
|
||||
g_Allocator,
|
||||
&g_VertexBufferMemory[g_FrameIndex]);
|
||||
alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, req.memoryTypeBits);
|
||||
err = vkAllocateMemory(g_Device, &alloc_info, g_Allocator, &g_VertexBufferMemory[g_FrameIndex]);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
err = vkBindBufferMemory(g_Device,
|
||||
g_VertexBuffer[g_FrameIndex],
|
||||
g_VertexBufferMemory[g_FrameIndex], 0);
|
||||
err = vkBindBufferMemory(g_Device, g_VertexBuffer[g_FrameIndex], g_VertexBufferMemory[g_FrameIndex], 0);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
g_VertexBufferSize[g_FrameIndex] = vertex_buffer_size;
|
||||
}
|
||||
|
||||
// Create the Index Buffer:
|
||||
size_t index_size = draw_data->TotalIdxCount * sizeof(ImDrawIdx);
|
||||
if(!g_IndexBuffer[g_FrameIndex] ||
|
||||
g_IndexBufferSize[g_FrameIndex] < index_size){
|
||||
if(g_IndexBuffer[g_FrameIndex])
|
||||
if (!g_IndexBuffer[g_FrameIndex] || g_IndexBufferSize[g_FrameIndex] < index_size)
|
||||
{
|
||||
if (g_IndexBuffer[g_FrameIndex])
|
||||
vkDestroyBuffer(g_Device, g_IndexBuffer[g_FrameIndex], g_Allocator);
|
||||
if(g_IndexBufferMemory[g_FrameIndex])
|
||||
if (g_IndexBufferMemory[g_FrameIndex])
|
||||
vkFreeMemory(g_Device, g_IndexBufferMemory[g_FrameIndex], g_Allocator);
|
||||
size_t index_buffer_size = ((index_size-1)/g_BufferMemoryAlignment+1)*g_BufferMemoryAlignment;
|
||||
size_t index_buffer_size = ((index_size-1) / g_BufferMemoryAlignment+1) * g_BufferMemoryAlignment;
|
||||
VkBufferCreateInfo buffer_info = {};
|
||||
buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
||||
buffer_info.size = index_buffer_size;
|
||||
buffer_info.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
|
||||
buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||||
err = vkCreateBuffer(g_Device,
|
||||
&buffer_info,
|
||||
g_Allocator,
|
||||
&g_IndexBuffer[g_FrameIndex]);
|
||||
err = vkCreateBuffer(g_Device, &buffer_info, g_Allocator, &g_IndexBuffer[g_FrameIndex]);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
VkMemoryRequirements req;
|
||||
vkGetBufferMemoryRequirements(g_Device, g_IndexBuffer[g_FrameIndex], &req);
|
||||
@ -306,38 +296,27 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
|
||||
VkMemoryAllocateInfo alloc_info = {};
|
||||
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
alloc_info.allocationSize = req.size;
|
||||
alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
|
||||
req.memoryTypeBits);
|
||||
err = vkAllocateMemory(g_Device,
|
||||
&alloc_info,
|
||||
g_Allocator,
|
||||
&g_IndexBufferMemory[g_FrameIndex]);
|
||||
alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, req.memoryTypeBits);
|
||||
err = vkAllocateMemory(g_Device, &alloc_info, g_Allocator, &g_IndexBufferMemory[g_FrameIndex]);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
err = vkBindBufferMemory(g_Device,
|
||||
g_IndexBuffer[g_FrameIndex],
|
||||
g_IndexBufferMemory[g_FrameIndex], 0);
|
||||
err = vkBindBufferMemory(g_Device, g_IndexBuffer[g_FrameIndex], g_IndexBufferMemory[g_FrameIndex], 0);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
g_IndexBufferSize[g_FrameIndex] = index_buffer_size;
|
||||
}
|
||||
|
||||
// Upload Vertex and index Data:
|
||||
{
|
||||
ImDrawVert* vtx_dst;
|
||||
ImDrawIdx* idx_dst;
|
||||
err = vkMapMemory(g_Device, g_VertexBufferMemory[g_FrameIndex],
|
||||
0, vertex_size, 0,
|
||||
reinterpret_cast<void**>(&vtx_dst));
|
||||
err = vkMapMemory(g_Device, g_VertexBufferMemory[g_FrameIndex], 0, vertex_size, 0, (void**)(&vtx_dst));
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
err = vkMapMemory(g_Device, g_IndexBufferMemory[g_FrameIndex],
|
||||
0, index_size, 0,
|
||||
reinterpret_cast<void**>(&idx_dst));
|
||||
err = vkMapMemory(g_Device, g_IndexBufferMemory[g_FrameIndex], 0, index_size, 0, (void**)(&idx_dst));
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
for(int n = 0; n < draw_data->CmdListsCount; n++){
|
||||
for (int n = 0; n < draw_data->CmdListsCount; n++)
|
||||
{
|
||||
const ImDrawList* cmd_list = draw_data->CmdLists[n];
|
||||
memcpy(vtx_dst, &cmd_list->VtxBuffer[0],
|
||||
cmd_list->VtxBuffer.size() * sizeof(ImDrawVert));
|
||||
memcpy(idx_dst, &cmd_list->IdxBuffer[0],
|
||||
cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx));
|
||||
memcpy(vtx_dst, &cmd_list->VtxBuffer[0], cmd_list->VtxBuffer.size() * sizeof(ImDrawVert));
|
||||
memcpy(idx_dst, &cmd_list->IdxBuffer[0], cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx));
|
||||
vtx_dst += cmd_list->VtxBuffer.size();
|
||||
idx_dst += cmd_list->IdxBuffer.size();
|
||||
}
|
||||
@ -353,29 +332,22 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
|
||||
vkUnmapMemory(g_Device, g_VertexBufferMemory[g_FrameIndex]);
|
||||
vkUnmapMemory(g_Device, g_IndexBufferMemory[g_FrameIndex]);
|
||||
}
|
||||
|
||||
// Bind pipeline and descriptor sets:
|
||||
{
|
||||
vkCmdBindPipeline(g_CommandBuffer,
|
||||
VK_PIPELINE_BIND_POINT_GRAPHICS,
|
||||
g_Pipeline);
|
||||
vkCmdBindPipeline(g_CommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, g_Pipeline);
|
||||
VkDescriptorSet desc_set[1] = {g_DescriptorSet};
|
||||
vkCmdBindDescriptorSets(g_CommandBuffer,
|
||||
VK_PIPELINE_BIND_POINT_GRAPHICS,
|
||||
g_PipelineLayout,
|
||||
0, 1, desc_set,
|
||||
0, NULL);
|
||||
vkCmdBindDescriptorSets(g_CommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, g_PipelineLayout, 0, 1, desc_set, 0, NULL);
|
||||
}
|
||||
|
||||
// Bind Vertex And Index Buffer:
|
||||
{
|
||||
VkBuffer vertex_buffers[1] = {g_VertexBuffer[g_FrameIndex]};
|
||||
VkDeviceSize vertex_offset[1] = {0};
|
||||
vkCmdBindVertexBuffers(g_CommandBuffer,
|
||||
0, 1,
|
||||
vertex_buffers, vertex_offset);
|
||||
vkCmdBindIndexBuffer(g_CommandBuffer,
|
||||
g_IndexBuffer[g_FrameIndex],
|
||||
0, VK_INDEX_TYPE_UINT16);
|
||||
vkCmdBindVertexBuffers(g_CommandBuffer, 0, 1, vertex_buffers, vertex_offset);
|
||||
vkCmdBindIndexBuffer(g_CommandBuffer, g_IndexBuffer[g_FrameIndex], 0, VK_INDEX_TYPE_UINT16);
|
||||
}
|
||||
|
||||
// Setup viewport:
|
||||
{
|
||||
VkViewport viewport;
|
||||
@ -387,6 +359,7 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
|
||||
viewport.maxDepth = 1.0f;
|
||||
vkCmdSetViewport(g_CommandBuffer, 0, 1, &viewport);
|
||||
}
|
||||
|
||||
// Setup scale and translation:
|
||||
{
|
||||
float scale[2];
|
||||
@ -395,39 +368,32 @@ void ImGui_ImplGlfwVulkan_RenderDrawLists(ImDrawData* draw_data)
|
||||
float translate[2];
|
||||
translate[0] = -1.0f;
|
||||
translate[1] = -1.0f;
|
||||
vkCmdPushConstants(g_CommandBuffer,
|
||||
g_PipelineLayout,
|
||||
VK_SHADER_STAGE_VERTEX_BIT,
|
||||
sizeof(float) * 0,
|
||||
sizeof(float) * 2,
|
||||
scale);
|
||||
vkCmdPushConstants(g_CommandBuffer,
|
||||
g_PipelineLayout,
|
||||
VK_SHADER_STAGE_VERTEX_BIT,
|
||||
sizeof(float) * 2,
|
||||
sizeof(float) * 2,
|
||||
translate);
|
||||
vkCmdPushConstants(g_CommandBuffer, g_PipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, sizeof(float) * 0, sizeof(float) * 2, scale);
|
||||
vkCmdPushConstants(g_CommandBuffer, g_PipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, sizeof(float) * 2, sizeof(float) * 2, translate);
|
||||
}
|
||||
|
||||
// Render the command lists:
|
||||
int vtx_offset = 0;
|
||||
int idx_offset = 0;
|
||||
for(int n = 0; n < draw_data->CmdListsCount; n++){
|
||||
for (int n = 0; n < draw_data->CmdListsCount; n++)
|
||||
{
|
||||
const ImDrawList* cmd_list = draw_data->CmdLists[n];
|
||||
for(int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++){
|
||||
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.size(); cmd_i++)
|
||||
{
|
||||
const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
|
||||
if(pcmd->UserCallback){
|
||||
if (pcmd->UserCallback)
|
||||
{
|
||||
pcmd->UserCallback(cmd_list, pcmd);
|
||||
}
|
||||
else{
|
||||
else
|
||||
{
|
||||
VkRect2D scissor;
|
||||
scissor.offset.x = static_cast<int32_t>(pcmd->ClipRect.x);
|
||||
scissor.offset.y = static_cast<int32_t>(pcmd->ClipRect.y);
|
||||
scissor.extent.width = static_cast<uint32_t>(pcmd->ClipRect.z - pcmd->ClipRect.x);
|
||||
scissor.extent.height = static_cast<uint32_t>(pcmd->ClipRect.w - pcmd->ClipRect.y + 1); // TODO: + 1??????
|
||||
vkCmdSetScissor(g_CommandBuffer, 0, 1, &scissor);
|
||||
vkCmdDrawIndexed(g_CommandBuffer,
|
||||
pcmd->ElemCount, 1,
|
||||
idx_offset, vtx_offset, 0);
|
||||
vkCmdDrawIndexed(g_CommandBuffer, pcmd->ElemCount, 1, idx_offset, vtx_offset, 0);
|
||||
}
|
||||
idx_offset += pcmd->ElemCount;
|
||||
}
|
||||
@ -468,6 +434,7 @@ void ImGui_ImplGlfwVulkan_KeyCallback(GLFWwindow*, int key, int, int action, int
|
||||
io.KeyCtrl = io.KeysDown[GLFW_KEY_LEFT_CONTROL] || io.KeysDown[GLFW_KEY_RIGHT_CONTROL];
|
||||
io.KeyShift = io.KeysDown[GLFW_KEY_LEFT_SHIFT] || io.KeysDown[GLFW_KEY_RIGHT_SHIFT];
|
||||
io.KeyAlt = io.KeysDown[GLFW_KEY_LEFT_ALT] || io.KeysDown[GLFW_KEY_RIGHT_ALT];
|
||||
io.KeySuper = io.KeysDown[GLFW_KEY_LEFT_SUPER] || io.KeysDown[GLFW_KEY_RIGHT_SUPER];
|
||||
}
|
||||
|
||||
void ImGui_ImplGlfwVulkan_CharCallback(GLFWwindow*, unsigned int c)
|
||||
@ -487,6 +454,7 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
|
||||
size_t upload_size = width*height*4*sizeof(char);
|
||||
|
||||
VkResult err;
|
||||
|
||||
// Create the Image:
|
||||
{
|
||||
VkImageCreateInfo info = {};
|
||||
@ -500,32 +468,23 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
|
||||
info.arrayLayers = 1;
|
||||
info.samples = VK_SAMPLE_COUNT_1_BIT;
|
||||
info.tiling = VK_IMAGE_TILING_OPTIMAL;
|
||||
info.usage =
|
||||
VK_IMAGE_USAGE_SAMPLED_BIT |
|
||||
VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
||||
info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
||||
info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||||
info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
err = vkCreateImage(g_Device,
|
||||
&info,
|
||||
g_Allocator,
|
||||
&g_FontImage);
|
||||
err = vkCreateImage(g_Device, &info, g_Allocator, &g_FontImage);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
VkMemoryRequirements req;
|
||||
vkGetImageMemoryRequirements(g_Device, g_FontImage, &req);
|
||||
VkMemoryAllocateInfo alloc_info = {};
|
||||
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
alloc_info.allocationSize = req.size;
|
||||
alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(
|
||||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
|
||||
req.memoryTypeBits);
|
||||
err = vkAllocateMemory(g_Device,
|
||||
&alloc_info,
|
||||
g_Allocator,
|
||||
&g_FontMemory);
|
||||
alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, req.memoryTypeBits);
|
||||
err = vkAllocateMemory(g_Device, &alloc_info, g_Allocator, &g_FontMemory);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
err = vkBindImageMemory(g_Device, g_FontImage, g_FontMemory, 0);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
}
|
||||
|
||||
// Create the Image View:
|
||||
{
|
||||
VkResult err;
|
||||
@ -537,12 +496,10 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
|
||||
info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
info.subresourceRange.levelCount = 1;
|
||||
info.subresourceRange.layerCount = 1;
|
||||
err = vkCreateImageView(g_Device,
|
||||
&info,
|
||||
g_Allocator,
|
||||
&g_FontView);
|
||||
err = vkCreateImageView(g_Device, &info, g_Allocator, &g_FontView);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
}
|
||||
|
||||
// Update the Descriptor Set:
|
||||
{
|
||||
VkDescriptorImageInfo desc_image[1] = {};
|
||||
@ -555,10 +512,9 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
|
||||
write_desc[0].descriptorCount = 1;
|
||||
write_desc[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
||||
write_desc[0].pImageInfo = desc_image;
|
||||
vkUpdateDescriptorSets(g_Device,
|
||||
1, write_desc,
|
||||
0, NULL);
|
||||
vkUpdateDescriptorSets(g_Device, 1, write_desc, 0, NULL);
|
||||
}
|
||||
|
||||
// Create the Upload Buffer:
|
||||
{
|
||||
VkBufferCreateInfo buffer_info = {};
|
||||
@ -566,10 +522,7 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
|
||||
buffer_info.size = upload_size;
|
||||
buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
||||
buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||||
err = vkCreateBuffer(g_Device,
|
||||
&buffer_info,
|
||||
g_Allocator,
|
||||
&g_UploadBuffer);
|
||||
err = vkCreateBuffer(g_Device, &buffer_info, g_Allocator, &g_UploadBuffer);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
VkMemoryRequirements req;
|
||||
vkGetBufferMemoryRequirements(g_Device, g_UploadBuffer, &req);
|
||||
@ -577,22 +530,17 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
|
||||
VkMemoryAllocateInfo alloc_info = {};
|
||||
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
alloc_info.allocationSize = req.size;
|
||||
alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
|
||||
req.memoryTypeBits);
|
||||
err = vkAllocateMemory(g_Device,
|
||||
&alloc_info,
|
||||
g_Allocator,
|
||||
&g_UploadBufferMemory);
|
||||
alloc_info.memoryTypeIndex = ImGui_ImplGlfwVulkan_MemoryType(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, req.memoryTypeBits);
|
||||
err = vkAllocateMemory(g_Device, &alloc_info, g_Allocator, &g_UploadBufferMemory);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
err = vkBindBufferMemory(g_Device, g_UploadBuffer, g_UploadBufferMemory, 0);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
}
|
||||
|
||||
// Upload to Buffer:
|
||||
{
|
||||
char *map;
|
||||
err = vkMapMemory(g_Device, g_UploadBufferMemory, 0, upload_size, 0,
|
||||
reinterpret_cast<void**>(&map));
|
||||
char* map = NULL;
|
||||
err = vkMapMemory(g_Device, g_UploadBufferMemory, 0, upload_size, 0, (void**)(&map));
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
memcpy(map, pixels, upload_size);
|
||||
VkMappedMemoryRange range[1] = {};
|
||||
@ -616,21 +564,15 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
|
||||
copy_barrier[0].subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
copy_barrier[0].subresourceRange.levelCount = 1;
|
||||
copy_barrier[0].subresourceRange.layerCount = 1;
|
||||
vkCmdPipelineBarrier(command_buffer,
|
||||
VK_PIPELINE_STAGE_HOST_BIT,
|
||||
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||||
0,
|
||||
0, NULL, 0, NULL, 1, copy_barrier);
|
||||
vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1, copy_barrier);
|
||||
|
||||
VkBufferImageCopy region = {};
|
||||
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
region.imageSubresource.layerCount = 1;
|
||||
region.imageExtent.width = width;
|
||||
region.imageExtent.height = height;
|
||||
vkCmdCopyBufferToImage(command_buffer,
|
||||
g_UploadBuffer,
|
||||
g_FontImage,
|
||||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||||
1, ®ion);
|
||||
vkCmdCopyBufferToImage(command_buffer, g_UploadBuffer, g_FontImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion);
|
||||
|
||||
VkImageMemoryBarrier use_barrier[1] = {};
|
||||
use_barrier[0].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
||||
use_barrier[0].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
||||
@ -643,16 +585,11 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
|
||||
use_barrier[0].subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
use_barrier[0].subresourceRange.levelCount = 1;
|
||||
use_barrier[0].subresourceRange.layerCount = 1;
|
||||
vkCmdPipelineBarrier(command_buffer,
|
||||
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||||
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
|
||||
0,
|
||||
0, NULL, 0, NULL, 1, use_barrier);
|
||||
vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, NULL, 0, NULL, 1, use_barrier);
|
||||
}
|
||||
io.Fonts->TexID = (void *)(intptr_t)g_FontImage;
|
||||
|
||||
io.Fonts->ClearInputData();
|
||||
io.Fonts->ClearTexData();
|
||||
// Store our identifier
|
||||
io.Fonts->TexID = (void *)(intptr_t)g_FontImage;
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -660,7 +597,6 @@ bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
|
||||
bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
|
||||
{
|
||||
VkResult err;
|
||||
|
||||
VkShaderModule vert_module;
|
||||
VkShaderModule frag_module;
|
||||
|
||||
@ -679,7 +615,9 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
|
||||
err = vkCreateShaderModule(g_Device, &frag_info, g_Allocator, &frag_module);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
}
|
||||
if(!g_FontSampler){
|
||||
|
||||
if (!g_FontSampler)
|
||||
{
|
||||
VkSamplerCreateInfo info = {};
|
||||
info.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
||||
info.magFilter = VK_FILTER_LINEAR;
|
||||
@ -690,13 +628,12 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
|
||||
info.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
||||
info.minLod = -1000;
|
||||
info.maxLod = 1000;
|
||||
err = vkCreateSampler(g_Device,
|
||||
&info,
|
||||
g_Allocator,
|
||||
&g_FontSampler);
|
||||
err = vkCreateSampler(g_Device, &info, g_Allocator, &g_FontSampler);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
}
|
||||
if(!g_DescriptorSetLayout){
|
||||
|
||||
if (!g_DescriptorSetLayout)
|
||||
{
|
||||
VkSampler sampler[1] = {g_FontSampler};
|
||||
VkDescriptorSetLayoutBinding binding[1] = {};
|
||||
binding[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
||||
@ -707,12 +644,10 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
|
||||
info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
||||
info.bindingCount = 1;
|
||||
info.pBindings = binding;
|
||||
err = vkCreateDescriptorSetLayout(g_Device,
|
||||
&info,
|
||||
g_Allocator,
|
||||
&g_DescriptorSetLayout);
|
||||
err = vkCreateDescriptorSetLayout(g_Device, &info, g_Allocator, &g_DescriptorSetLayout);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
}
|
||||
|
||||
// Create Descriptor Set:
|
||||
{
|
||||
VkDescriptorSetAllocateInfo alloc_info = {};
|
||||
@ -723,7 +658,9 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
|
||||
err = vkAllocateDescriptorSets(g_Device, &alloc_info, &g_DescriptorSet);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
}
|
||||
if(!g_PipelineLayout){
|
||||
|
||||
if (!g_PipelineLayout)
|
||||
{
|
||||
VkPushConstantRange push_constants[2] = {};
|
||||
push_constants[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
|
||||
push_constants[0].offset = sizeof(float) * 0;
|
||||
@ -738,8 +675,7 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
|
||||
layout_info.pSetLayouts = set_layout;
|
||||
layout_info.pushConstantRangeCount = 2;
|
||||
layout_info.pPushConstantRanges = push_constants;
|
||||
err = vkCreatePipelineLayout(g_Device, &layout_info,
|
||||
g_Allocator, &g_PipelineLayout);
|
||||
err = vkCreatePipelineLayout(g_Device, &layout_info, g_Allocator, &g_PipelineLayout);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
}
|
||||
|
||||
@ -805,17 +741,14 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
|
||||
color_attachment[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
||||
color_attachment[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
|
||||
color_attachment[0].alphaBlendOp = VK_BLEND_OP_ADD;
|
||||
color_attachment[0].colorWriteMask =
|
||||
VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
|
||||
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
||||
color_attachment[0].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
||||
|
||||
VkPipelineColorBlendStateCreateInfo blend_info = {};
|
||||
blend_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
||||
blend_info.attachmentCount = 1;
|
||||
blend_info.pAttachments = color_attachment;
|
||||
|
||||
VkDynamicState dynamic_states[2] = {VK_DYNAMIC_STATE_VIEWPORT,
|
||||
VK_DYNAMIC_STATE_SCISSOR};
|
||||
VkDynamicState dynamic_states[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
|
||||
VkPipelineDynamicStateCreateInfo dynamic_state = {};
|
||||
dynamic_state.dynamicStateCount = 2;
|
||||
dynamic_state.pDynamicStates = dynamic_states;
|
||||
@ -834,11 +767,7 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
|
||||
info.pDynamicState = &dynamic_state;
|
||||
info.layout = g_PipelineLayout;
|
||||
info.renderPass = g_RenderPass;
|
||||
err = vkCreateGraphicsPipelines(g_Device,
|
||||
g_PipelineCache,
|
||||
1, &info,
|
||||
g_Allocator,
|
||||
&g_Pipeline);
|
||||
err = vkCreateGraphicsPipelines(g_Device, g_PipelineCache, 1, &info, g_Allocator, &g_Pipeline);
|
||||
ImGui_ImplGlfwVulkan_VkResult(err);
|
||||
|
||||
vkDestroyShaderModule(g_Device, vert_module, g_Allocator);
|
||||
@ -849,43 +778,47 @@ bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
|
||||
|
||||
void ImGui_ImplGlfwVulkan_InvalidateFontUploadObjects()
|
||||
{
|
||||
if(g_UploadBuffer){
|
||||
if (g_UploadBuffer)
|
||||
{
|
||||
vkDestroyBuffer(g_Device, g_UploadBuffer, g_Allocator);
|
||||
g_UploadBuffer = VK_NULL_HANDLE;
|
||||
}
|
||||
if(g_UploadBufferMemory){
|
||||
if (g_UploadBufferMemory)
|
||||
{
|
||||
vkFreeMemory(g_Device, g_UploadBufferMemory, g_Allocator);
|
||||
g_UploadBufferMemory = VK_NULL_HANDLE;
|
||||
}
|
||||
}
|
||||
|
||||
void ImGui_ImplGlfwVulkan_InvalidateDeviceObjects()
|
||||
{
|
||||
ImGui_ImplGlfwVulkan_InvalidateFontUploadObjects();
|
||||
for(int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++){
|
||||
if(g_VertexBuffer[i])
|
||||
for (int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++)
|
||||
{
|
||||
if (g_VertexBuffer[i])
|
||||
vkDestroyBuffer(g_Device, g_VertexBuffer[i], g_Allocator);
|
||||
if(g_VertexBufferMemory[i])
|
||||
if (g_VertexBufferMemory[i])
|
||||
vkFreeMemory(g_Device, g_VertexBufferMemory[i], g_Allocator);
|
||||
if(g_IndexBuffer[i])
|
||||
if (g_IndexBuffer[i])
|
||||
vkDestroyBuffer(g_Device, g_IndexBuffer[i], g_Allocator);
|
||||
if(g_IndexBufferMemory[i])
|
||||
if (g_IndexBufferMemory[i])
|
||||
vkFreeMemory(g_Device, g_IndexBufferMemory[i], g_Allocator);
|
||||
}
|
||||
|
||||
if(g_FontView)
|
||||
if (g_FontView)
|
||||
vkDestroyImageView(g_Device, g_FontView, g_Allocator);
|
||||
if(g_FontImage)
|
||||
if (g_FontImage)
|
||||
vkDestroyImage(g_Device, g_FontImage, g_Allocator);
|
||||
if(g_FontMemory)
|
||||
if (g_FontMemory)
|
||||
vkFreeMemory(g_Device, g_FontMemory, g_Allocator);
|
||||
if(g_FontSampler)
|
||||
if (g_FontSampler)
|
||||
vkDestroySampler(g_Device, g_FontSampler, g_Allocator);
|
||||
|
||||
if(g_DescriptorSetLayout)
|
||||
if (g_DescriptorSetLayout)
|
||||
vkDestroyDescriptorSetLayout(g_Device, g_DescriptorSetLayout, g_Allocator);
|
||||
if(g_PipelineLayout)
|
||||
if (g_PipelineLayout)
|
||||
vkDestroyPipelineLayout(g_Device, g_PipelineLayout, g_Allocator);
|
||||
if(g_Pipeline)
|
||||
if (g_Pipeline)
|
||||
vkDestroyPipeline(g_Device, g_Pipeline, g_Allocator);
|
||||
}
|
||||
|
||||
@ -998,5 +931,5 @@ void ImGui_ImplGlfwVulkan_Render(VkCommandBuffer command_buffer)
|
||||
g_CommandBuffer = command_buffer;
|
||||
ImGui::Render();
|
||||
g_CommandBuffer = VK_NULL_HANDLE;
|
||||
g_FrameIndex = (g_FrameIndex+1)%IMGUI_VK_QUEUED_FRAMES;
|
||||
g_FrameIndex = (g_FrameIndex + 1) % IMGUI_VK_QUEUED_FRAMES;
|
||||
}
|
||||
|
||||
@ -4,11 +4,12 @@
|
||||
// If you are new to ImGui, see examples/README.txt and documentation at the top of imgui.cpp.
|
||||
// https://github.com/ocornut/imgui
|
||||
|
||||
#define IMGUI_VK_QUEUED_FRAMES 2
|
||||
|
||||
struct GLFWwindow;
|
||||
|
||||
struct ImGui_ImplGlfwVulkan_Init_Data{
|
||||
#define IMGUI_VK_QUEUED_FRAMES 2
|
||||
|
||||
struct ImGui_ImplGlfwVulkan_Init_Data
|
||||
{
|
||||
VkAllocationCallbacks* allocator;
|
||||
VkPhysicalDevice gpu;
|
||||
VkDevice device;
|
||||
@ -29,7 +30,6 @@ IMGUI_API void ImGui_ImplGlfwVulkan_InvalidateDeviceObjects();
|
||||
IMGUI_API bool ImGui_ImplGlfwVulkan_CreateFontsTexture(VkCommandBuffer command_buffer);
|
||||
IMGUI_API bool ImGui_ImplGlfwVulkan_CreateDeviceObjects();
|
||||
|
||||
|
||||
// GLFW callbacks (installed by default if you enable 'install_callbacks' during initialization)
|
||||
// Provided here if you want to chain callbacks.
|
||||
// You can also handle inputs yourself and use those as a reference.
|
||||
@ -38,4 +38,3 @@ IMGUI_API void ImGui_ImplGlfwVulkan_ScrollCallback(GLFWwindow* window, do
|
||||
IMGUI_API void ImGui_ImplGlfwVulkan_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
|
||||
IMGUI_API void ImGui_ImplGlfwVulkan_CharCallback(GLFWwindow* window, unsigned int c);
|
||||
|
||||
|
||||
|
||||
@ -3,8 +3,8 @@
|
||||
|
||||
#include <imgui.h>
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h> // printf, fprintf
|
||||
#include <stdlib.h> // abort
|
||||
#define GLFW_INCLUDE_NONE
|
||||
#define GLFW_INCLUDE_VULKAN
|
||||
#include <GLFW/glfw3.h>
|
||||
@ -47,9 +47,10 @@ static VkClearValue g_ClearValue = {};
|
||||
|
||||
static void check_vk_result(VkResult err)
|
||||
{
|
||||
if(err == 0) return;
|
||||
if (err == 0) return;
|
||||
printf("VkResult %d\n", err);
|
||||
if(err < 0) abort();
|
||||
if (err < 0)
|
||||
abort();
|
||||
}
|
||||
|
||||
static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
|
||||
@ -58,15 +59,17 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
|
||||
VkSwapchainKHR old_swapchain = g_Swapchain;
|
||||
err = vkDeviceWaitIdle(g_Device);
|
||||
check_vk_result(err);
|
||||
|
||||
// Destroy old Framebuffer:
|
||||
for(uint32_t i=0; i<g_BackBufferCount; i++)
|
||||
if(g_BackBufferView[i])
|
||||
for (uint32_t i=0; i<g_BackBufferCount; i++)
|
||||
if (g_BackBufferView[i])
|
||||
vkDestroyImageView(g_Device, g_BackBufferView[i], g_Allocator);
|
||||
for(uint32_t i=0; i<g_BackBufferCount; i++)
|
||||
if(g_Framebuffer[i])
|
||||
for(uint32_t i=0; i<g_BackBufferCount; i++)
|
||||
if (g_Framebuffer[i])
|
||||
vkDestroyFramebuffer(g_Device, g_Framebuffer[i], g_Allocator);
|
||||
if(g_RenderPass)
|
||||
if (g_RenderPass)
|
||||
vkDestroyRenderPass(g_Device, g_RenderPass, g_Allocator);
|
||||
|
||||
// Create Swapchain:
|
||||
{
|
||||
VkSwapchainCreateInfoKHR info = {};
|
||||
@ -86,13 +89,15 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
|
||||
err = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(g_Gpu, g_Surface, &cap);
|
||||
check_vk_result(err);
|
||||
info.minImageCount = (cap.minImageCount + 2 < cap.maxImageCount) ? (cap.minImageCount + 2) : cap.maxImageCount;
|
||||
if(cap.currentExtent.width == 0xffffffff){
|
||||
if (cap.currentExtent.width == 0xffffffff)
|
||||
{
|
||||
fb_width = w;
|
||||
fb_height = h;
|
||||
info.imageExtent.width = fb_width;
|
||||
info.imageExtent.height = fb_height;
|
||||
}
|
||||
else{
|
||||
else
|
||||
{
|
||||
fb_width = cap.currentExtent.width;
|
||||
fb_height = cap.currentExtent.height;
|
||||
info.imageExtent.width = fb_width;
|
||||
@ -105,8 +110,9 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
|
||||
err = vkGetSwapchainImagesKHR(g_Device, g_Swapchain, &g_BackBufferCount, g_BackBuffer);
|
||||
check_vk_result(err);
|
||||
}
|
||||
if(old_swapchain)
|
||||
if (old_swapchain)
|
||||
vkDestroySwapchainKHR(g_Device, old_swapchain, g_Allocator);
|
||||
|
||||
// Create the Render Pass:
|
||||
{
|
||||
VkAttachmentDescription attachment = {};
|
||||
@ -134,6 +140,7 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
|
||||
err = vkCreateRenderPass(g_Device, &info, g_Allocator, &g_RenderPass);
|
||||
check_vk_result(err);
|
||||
}
|
||||
|
||||
// Create The Image Views
|
||||
{
|
||||
VkImageViewCreateInfo info = {};
|
||||
@ -145,12 +152,14 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
|
||||
info.components.b = VK_COMPONENT_SWIZZLE_B;
|
||||
info.components.a = VK_COMPONENT_SWIZZLE_A;
|
||||
info.subresourceRange = g_ImageRange;
|
||||
for(uint32_t i=0; i<g_BackBufferCount; i++){
|
||||
for (uint32_t i = 0; i<g_BackBufferCount; i++)
|
||||
{
|
||||
info.image = g_BackBuffer[i];
|
||||
err = vkCreateImageView(g_Device, &info, g_Allocator, &g_BackBufferView[i]);
|
||||
check_vk_result(err);
|
||||
}
|
||||
}
|
||||
|
||||
// Create Framebuffer:
|
||||
{
|
||||
VkImageView attachment[1];
|
||||
@ -162,7 +171,8 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
|
||||
info.width = fb_width;
|
||||
info.height = fb_height;
|
||||
info.layers = 1;
|
||||
for(uint32_t i=0; i<g_BackBufferCount; i++){
|
||||
for (uint32_t i = 0; i<g_BackBufferCount; i++)
|
||||
{
|
||||
attachment[0] = g_BackBufferView[i];
|
||||
err = vkCreateFramebuffer(g_Device, &info, g_Allocator, &g_Framebuffer[i]);
|
||||
check_vk_result(err);
|
||||
@ -173,9 +183,10 @@ static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
|
||||
static void setup_vulkan(GLFWwindow* window)
|
||||
{
|
||||
VkResult err;
|
||||
|
||||
// Create Vulkan Instance
|
||||
{
|
||||
int glfw_extensions_count;
|
||||
uint32_t glfw_extensions_count;
|
||||
const char** glfw_extensions = glfwGetRequiredInstanceExtensions(&glfw_extensions_count);
|
||||
VkInstanceCreateInfo create_info = {};
|
||||
create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
||||
@ -184,17 +195,20 @@ static void setup_vulkan(GLFWwindow* window)
|
||||
err = vkCreateInstance(&create_info, g_Allocator, &g_Instance);
|
||||
check_vk_result(err);
|
||||
}
|
||||
|
||||
// Create Window Surface
|
||||
{
|
||||
err = glfwCreateWindowSurface(g_Instance, window, g_Allocator, &g_Surface);
|
||||
check_vk_result(err);
|
||||
}
|
||||
// Get Gpu
|
||||
|
||||
// Get GPU
|
||||
{
|
||||
uint32_t count = 1;
|
||||
err = vkEnumeratePhysicalDevices(g_Instance, &count, &g_Gpu);
|
||||
check_vk_result(err);
|
||||
}
|
||||
|
||||
// Create Logical Device
|
||||
{
|
||||
int device_extension_count = 1;
|
||||
@ -217,6 +231,7 @@ static void setup_vulkan(GLFWwindow* window)
|
||||
check_vk_result(err);
|
||||
vkGetDeviceQueue(g_Device, g_QueueFamily, queue_index, &g_Queue);
|
||||
}
|
||||
|
||||
// Create Framebuffers
|
||||
{
|
||||
int w, h;
|
||||
@ -224,8 +239,10 @@ static void setup_vulkan(GLFWwindow* window)
|
||||
resize_vulkan(window, w, h);
|
||||
glfwSetFramebufferSizeCallback(window, resize_vulkan);
|
||||
}
|
||||
|
||||
// Create Command Buffers
|
||||
for(int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++){
|
||||
for (int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++)
|
||||
{
|
||||
{
|
||||
VkCommandPoolCreateInfo info = {};
|
||||
info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
||||
@ -257,20 +274,23 @@ static void setup_vulkan(GLFWwindow* window)
|
||||
check_vk_result(err);
|
||||
}
|
||||
}
|
||||
|
||||
// Create Descriptor Pool
|
||||
{
|
||||
VkDescriptorPoolSize pool_size[11] = {
|
||||
{VK_DESCRIPTOR_TYPE_SAMPLER, 1000},
|
||||
{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000},
|
||||
{VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1000},
|
||||
{VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1000},
|
||||
{VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1000},
|
||||
{VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1000},
|
||||
{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1000},
|
||||
{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1000},
|
||||
{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1000},
|
||||
{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1000},
|
||||
{VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1000}};
|
||||
VkDescriptorPoolSize pool_size[11] =
|
||||
{
|
||||
{ VK_DESCRIPTOR_TYPE_SAMPLER, 1000 },
|
||||
{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1000 },
|
||||
{ VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1000 },
|
||||
{ VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1000 },
|
||||
{ VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1000 },
|
||||
{ VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1000 },
|
||||
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1000 },
|
||||
{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1000 },
|
||||
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1000 },
|
||||
{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1000 },
|
||||
{ VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1000 }
|
||||
};
|
||||
VkDescriptorPoolCreateInfo pool_info = {};
|
||||
pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
|
||||
pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
|
||||
@ -285,13 +305,15 @@ static void setup_vulkan(GLFWwindow* window)
|
||||
static void cleanup_vulkan()
|
||||
{
|
||||
vkDestroyDescriptorPool(g_Device, g_DescriptorPool, g_Allocator);
|
||||
for(int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++){
|
||||
for (int i = 0; i < IMGUI_VK_QUEUED_FRAMES; i++)
|
||||
{
|
||||
vkDestroyFence(g_Device, g_Fence[i], g_Allocator);
|
||||
vkFreeCommandBuffers(g_Device, g_CommandPool[i], 1, &g_CommandBuffer[i]);
|
||||
vkDestroyCommandPool(g_Device, g_CommandPool[i], g_Allocator);
|
||||
vkDestroySemaphore(g_Device, g_Semaphore[i], g_Allocator);
|
||||
}
|
||||
for(uint32_t i=0; i<g_BackBufferCount; i++){
|
||||
for (uint32_t i = 0; i < g_BackBufferCount; i++)
|
||||
{
|
||||
vkDestroyImageView(g_Device, g_BackBufferView[i], g_Allocator);
|
||||
vkDestroyFramebuffer(g_Device, g_Framebuffer[i], g_Allocator);
|
||||
}
|
||||
@ -305,18 +327,15 @@ static void cleanup_vulkan()
|
||||
static void frame_begin()
|
||||
{
|
||||
VkResult err;
|
||||
while(true){
|
||||
while (true)
|
||||
{
|
||||
err = vkWaitForFences(g_Device, 1, &g_Fence[g_FrameIndex], VK_TRUE, 100);
|
||||
if(err == VK_SUCCESS) break;
|
||||
if(err == VK_TIMEOUT) continue;
|
||||
if (err == VK_SUCCESS) break;
|
||||
if (err == VK_TIMEOUT) continue;
|
||||
check_vk_result(err);
|
||||
}
|
||||
{
|
||||
err = vkAcquireNextImageKHR(
|
||||
g_Device, g_Swapchain,
|
||||
UINT64_MAX,
|
||||
g_Semaphore[g_FrameIndex], VK_NULL_HANDLE,
|
||||
&g_BackBufferIndex);
|
||||
err = vkAcquireNextImageKHR(g_Device, g_Swapchain, UINT64_MAX, g_Semaphore[g_FrameIndex], VK_NULL_HANDLE, &g_BackBufferIndex);
|
||||
check_vk_result(err);
|
||||
}
|
||||
{
|
||||
@ -356,11 +375,7 @@ static void frame_end()
|
||||
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
||||
barrier.image = g_BackBuffer[g_BackBufferIndex];
|
||||
barrier.subresourceRange = g_ImageRange;
|
||||
vkCmdPipelineBarrier(g_CommandBuffer[g_FrameIndex],
|
||||
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
|
||||
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
|
||||
0,
|
||||
0, NULL, 0, NULL, 1, &barrier);
|
||||
vkCmdPipelineBarrier(g_CommandBuffer[g_FrameIndex], VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0, NULL, 1, &barrier);
|
||||
}
|
||||
{
|
||||
VkSubmitInfo info = {};
|
||||
@ -391,7 +406,7 @@ static void frame_end()
|
||||
check_vk_result(err);
|
||||
check_vk_result(res);
|
||||
}
|
||||
g_FrameIndex = (g_FrameIndex)%IMGUI_VK_QUEUED_FRAMES;
|
||||
g_FrameIndex = (g_FrameIndex) % IMGUI_VK_QUEUED_FRAMES;
|
||||
}
|
||||
|
||||
static void error_callback(int error, const char* description)
|
||||
@ -410,7 +425,8 @@ int main(int, char**)
|
||||
GLFWwindow* window = glfwCreateWindow(1280, 720, "ImGui Vulkan example", NULL, NULL);
|
||||
|
||||
// Setup Vulkan
|
||||
if(!glfwVulkanSupported()){
|
||||
if (!glfwVulkanSupported())
|
||||
{
|
||||
printf("GLFW: Vulkan Not Supported\n");
|
||||
return 1;
|
||||
}
|
||||
@ -508,9 +524,7 @@ int main(int, char**)
|
||||
g_ClearValue.color.float32[3] = clear_color.w;
|
||||
|
||||
frame_begin();
|
||||
|
||||
ImGui_ImplGlfwVulkan_Render(g_CommandBuffer[g_FrameIndex]);
|
||||
|
||||
frame_end();
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user