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

Rename.

Browse Source
This commit is contained in:
Artem Kharytoniuk 2017-04-12 18:31:29 +03:00
parent 11791b47a3
commit c208817246
7 changed files with 131 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/engine/renderer/tr_backend.c
View File

@ -465,7 +465,7 @@ void RB_BeginDrawingView (void) {
clear_rect.baseArrayLayer = 0;
clear_rect.layerCount = 1;
vkCmdClearAttachments(vk_instance.command_buffer, attachment_count, attachments, 1, &clear_rect);
vkCmdClearAttachments(vk.command_buffer, attachment_count, attachments, 1, &clear_rect);
}
if ( ( backEnd.refdef.rdflags & RDF_HYPERSPACE ) )
@ -722,8 +722,8 @@ void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
// VULKAN
vkDestroyImage(vk_instance.device, tr.scratchImage[client]->vk_image, nullptr);
vkDestroyImageView(vk_instance.device, tr.scratchImage[client]->vk_image_view, nullptr);
vkDestroyImage(vk.device, tr.scratchImage[client]->vk_image, nullptr);
vkDestroyImageView(vk.device, tr.scratchImage[client]->vk_image_view, nullptr);
tr.scratchImage[client]->vk_image = vk_create_cinematic_image(cols, rows, tr.scratchImage[client]->vk_staging_buffer);
tr.scratchImage[client]->vk_image_view = create_image_view(tr.scratchImage[client]->vk_image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT);
vk_update_cinematic_image(tr.scratchImage[client]->vk_image, tr.scratchImage[client]->vk_staging_buffer, cols, rows, data);
@ -745,7 +745,7 @@ void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *
descriptor_writes[0].pBufferInfo = nullptr;
descriptor_writes[0].pTexelBufferView = nullptr;
vkUpdateDescriptorSets(vk_instance.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr);
vkUpdateDescriptorSets(vk.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr);
} else {
if (dirty) {
// otherwise, just subimage upload it so that drivers can tell we are going to be changing
@ -929,12 +929,12 @@ const void *RB_DrawBuffer( const void *data ) {
}
// VULKAN
VkResult result = vkAcquireNextImageKHR(vk_instance.device, vk_instance.swapchain, UINT64_MAX, vulkan_demo->image_acquired, VK_NULL_HANDLE, &vulkan_demo->swapchain_image_index);
VkResult result = vkAcquireNextImageKHR(vk.device, vk.swapchain, UINT64_MAX, vulkan_demo->image_acquired, VK_NULL_HANDLE, &vulkan_demo->swapchain_image_index);
check_vk_result(result, "vkAcquireNextImageKHR");
result = vkWaitForFences(vk_instance.device, 1, &vulkan_demo->rendering_finished_fence, VK_FALSE, 1e9);
result = vkWaitForFences(vk.device, 1, &vulkan_demo->rendering_finished_fence, VK_FALSE, 1e9);
check_vk_result(result, "vkWaitForFences");
result = vkResetFences(vk_instance.device, 1, &vulkan_demo->rendering_finished_fence);
result = vkResetFences(vk.device, 1, &vulkan_demo->rendering_finished_fence);
check_vk_result(result, "vkResetFences");
VkCommandBufferBeginInfo begin_info;
@ -947,7 +947,7 @@ const void *RB_DrawBuffer( const void *data ) {
fprintf(logfile, "begin\n");
fflush(logfile);
result = vkBeginCommandBuffer(vk_instance.command_buffer, &begin_info);
result = vkBeginCommandBuffer(vk.command_buffer, &begin_info);
check_vk_result(result, "vkBeginCommandBuffer");
vulkan_demo->begin_frame();
@ -1064,7 +1064,7 @@ const void *RB_SwapBuffers( const void *data ) {
extern FILE* logfile;
vulkan_demo->end_frame();
VkResult result = vkEndCommandBuffer(vk_instance.command_buffer);
VkResult result = vkEndCommandBuffer(vk.command_buffer);
check_vk_result(result, "vkEndCommandBuffer");
fprintf(logfile, "present\n");
@ -1078,11 +1078,11 @@ const void *RB_SwapBuffers( const void *data ) {
submit_info.pWaitSemaphores = &vulkan_demo->image_acquired;
submit_info.pWaitDstStageMask = &wait_dst_stage_mask;
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &vk_instance.command_buffer;
submit_info.pCommandBuffers = &vk.command_buffer;
submit_info.signalSemaphoreCount = 1;
submit_info.pSignalSemaphores = &vulkan_demo->rendering_finished;
result = vkQueueSubmit(vk_instance.queue, 1, &submit_info, vulkan_demo->rendering_finished_fence);
result = vkQueueSubmit(vk.queue, 1, &submit_info, vulkan_demo->rendering_finished_fence);
check_vk_result(result, "vkQueueSubmit");
VkPresentInfoKHR present_info;
@ -1091,10 +1091,10 @@ const void *RB_SwapBuffers( const void *data ) {
present_info.waitSemaphoreCount = 1;
present_info.pWaitSemaphores = &vulkan_demo->rendering_finished;
present_info.swapchainCount = 1;
present_info.pSwapchains = &vk_instance.swapchain;
present_info.pSwapchains = &vk.swapchain;
present_info.pImageIndices = &vulkan_demo->swapchain_image_index;
present_info.pResults = nullptr;
result = vkQueuePresentKHR(vk_instance.queue, &present_info);
result = vkQueuePresentKHR(vk.queue, &present_info);
check_vk_result(result, "vkQueuePresentKHR");
return (const void *)(cmd + 1);

8
src/engine/renderer/tr_image.c
View File

@ -1846,16 +1846,16 @@ void R_DeleteTextures( void ) {
int i;
// VULKAN
vkDeviceWaitIdle(vk_instance.device);
vkDeviceWaitIdle(vk.device);
for ( i=0; i<tr.numImages ; i++ ) {
qglDeleteTextures( 1, &tr.images[i]->texnum );
// VULKAN
vkDestroyImage(vk_instance.device, tr.images[i]->vk_image, nullptr);
vkDestroyImageView(vk_instance.device, tr.images[i]->vk_image_view, nullptr);
vkDestroyImage(vk.device, tr.images[i]->vk_image, nullptr);
vkDestroyImageView(vk.device, tr.images[i]->vk_image_view, nullptr);
if (tr.images[i]->vk_staging_buffer.handle != VK_NULL_HANDLE)
vkDestroyBuffer(vk_instance.device, tr.images[i]->vk_staging_buffer.handle, nullptr);
vkDestroyBuffer(vk.device, tr.images[i]->vk_staging_buffer.handle, nullptr);
}
Com_Memset( tr.images, 0, sizeof( tr.images ) );

2
src/engine/renderer/tr_init.c
View File

@ -27,7 +27,7 @@ glconfig_t glConfig;
glstate_t glState;
// VULKAN
Vulkan_Instance vk_instance;
Vulkan_Instance vk;
static void GfxInfo_f( void );

4
src/engine/renderer/tr_local.h
View File

@ -945,7 +945,7 @@ typedef struct {
float fogTable[FOG_TABLE_SIZE];
// VULKAN
Vulkan_Resources vk;
Vulkan_Resources vk_resources;
} trGlobals_t;
@ -955,7 +955,7 @@ extern glconfig_t glConfig; // outside of TR since it shouldn't be cleared duri
extern glstate_t glState; // outside of TR since it shouldn't be cleared during ref re-init
// VULKAN
extern Vulkan_Instance vk_instance; // same as above - shouldn't be cleared during ref re-init
extern Vulkan_Instance vk; // same as above - shouldn't be cleared during ref re-init
// VULKAN
class Vulkan_Demo;

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

@ -259,7 +259,7 @@ static VkSwapchainKHR create_swapchain(VkPhysicalDevice physical_device, VkDevic
static VkRenderPass create_render_pass(VkPhysicalDevice physical_device, VkDevice device) {
VkAttachmentDescription color_attachment;
color_attachment.flags = 0;
color_attachment.format = vk_instance.surface_format.format;
color_attachment.format = vk.surface_format.format;
color_attachment.samples = VK_SAMPLE_COUNT_1_BIT;
color_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
color_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
@ -319,7 +319,7 @@ static VkRenderPass create_render_pass(VkPhysicalDevice physical_device, VkDevic
bool vk_initialize(HWND hwnd) {
try {
auto& g = vk_instance;
auto& g = vk;
g.instance = create_instance();
g.physical_device = select_physical_device(g.instance);
@ -332,16 +332,16 @@ bool vk_initialize(HWND hwnd) {
g.swapchain = create_swapchain(g.physical_device, g.device, g.surface, g.surface_format);
VkResult result = vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk_instance.swapchain_image_count, nullptr);
VkResult result = vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk.swapchain_image_count, nullptr);
check_vk_result(result, "vkGetSwapchainImagesKHR");
if (vk_instance.swapchain_image_count > MAX_SWAPCHAIN_IMAGES)
ri.Error( ERR_FATAL, "initialize_vulkan: swapchain image count (%d) exceeded limit (%d)", vk_instance.swapchain_image_count, MAX_SWAPCHAIN_IMAGES );
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 );
result = vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk_instance.swapchain_image_count, g.swapchain_images);
result = vkGetSwapchainImagesKHR(g.device, g.swapchain, &vk.swapchain_image_count, g.swapchain_images);
check_vk_result(result, "vkGetSwapchainImagesKHR");
for (std::size_t i = 0; i < vk_instance.swapchain_image_count; i++) {
for (std::size_t i = 0; i < vk.swapchain_image_count; i++) {
VkImageViewCreateInfo desc;
desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
desc.pNext = nullptr;
@ -367,9 +367,9 @@ bool vk_initialize(HWND hwnd) {
desc.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
desc.pNext = nullptr;
desc.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
desc.queueFamilyIndex = vk_instance.queue_family_index;
desc.queueFamilyIndex = vk.queue_family_index;
result = vkCreateCommandPool(g.device, &desc, nullptr, &vk_instance.command_pool);
result = vkCreateCommandPool(g.device, &desc, nullptr, &vk.command_pool);
check_vk_result(result, "vkCreateCommandPool");
}
@ -377,23 +377,23 @@ bool vk_initialize(HWND hwnd) {
VkCommandBufferAllocateInfo alloc_info;
alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
alloc_info.pNext = nullptr;
alloc_info.commandPool = vk_instance.command_pool;
alloc_info.commandPool = vk.command_pool;
alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
alloc_info.commandBufferCount = 1;
result = vkAllocateCommandBuffers(vk_instance.device, &alloc_info, &g.command_buffer);
result = vkAllocateCommandBuffers(vk.device, &alloc_info, &g.command_buffer);
check_vk_result(result, "vkAllocateCommandBuffers");
}
get_allocator()->initialize(vk_instance.physical_device, vk_instance.device);
get_resource_manager()->initialize(vk_instance.device);
get_allocator()->initialize(vk.physical_device, vk.device);
get_resource_manager()->initialize(vk.device);
{
VkFormat depth_format = find_depth_format(vk_instance.physical_device);
vk_instance.depth_image = create_depth_attachment_image(glConfig.vidWidth, glConfig.vidHeight, depth_format);
vk_instance.depth_image_view = create_image_view(vk_instance.depth_image, depth_format, VK_IMAGE_ASPECT_DEPTH_BIT);
VkFormat depth_format = find_depth_format(vk.physical_device);
vk.depth_image = create_depth_attachment_image(glConfig.vidWidth, glConfig.vidHeight, depth_format);
vk.depth_image_view = create_image_view(vk.depth_image, depth_format, VK_IMAGE_ASPECT_DEPTH_BIT);
record_and_run_commands(vk_instance.command_pool, vk_instance.queue, [&depth_format](VkCommandBuffer command_buffer) {
record_image_layout_transition(command_buffer, vk_instance.depth_image, depth_format, 0, VK_IMAGE_LAYOUT_UNDEFINED,
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,
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
});
}
@ -401,22 +401,22 @@ bool vk_initialize(HWND hwnd) {
g.render_pass = create_render_pass(g.physical_device, g.device);
{
std::array<VkImageView, 2> attachments = {VK_NULL_HANDLE, vk_instance.depth_image_view};
std::array<VkImageView, 2> attachments = {VK_NULL_HANDLE, vk.depth_image_view};
VkFramebufferCreateInfo desc;
desc.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
desc.pNext = nullptr;
desc.flags = 0;
desc.renderPass = vk_instance.render_pass;
desc.renderPass = vk.render_pass;
desc.attachmentCount = static_cast<uint32_t>(attachments.size());
desc.pAttachments = attachments.data();
desc.width = glConfig.vidWidth;
desc.height = glConfig.vidHeight;
desc.layers = 1;
for (uint32_t i = 0; i < vk_instance.swapchain_image_count; i++) {
attachments[0] = vk_instance.swapchain_image_views[i]; // set color attachment
VkResult result = vkCreateFramebuffer(vk_instance.device, &desc, nullptr, &vk_instance.framebuffers[i]);
for (uint32_t i = 0; i < vk.swapchain_image_count; i++) {
attachments[0] = vk.swapchain_image_views[i]; // set color attachment
VkResult result = vkCreateFramebuffer(vk.device, &desc, nullptr, &vk.framebuffers[i]);
check_vk_result(result, "vkCreateFramebuffer");
}
}
@ -428,20 +428,20 @@ bool vk_initialize(HWND hwnd) {
}
void vk_deinitialize() {
auto& g = vk_instance;
auto& g = vk;
get_resource_manager()->release_resources();
get_allocator()->deallocate_all();
vkDestroyFence(vk_instance.device, vulkan_demo->rendering_finished_fence, nullptr);
vkDestroyImage(vk_instance.device, vk_instance.depth_image, nullptr);
vkDestroyImageView(vk_instance.device, vk_instance.depth_image_view, nullptr);
vkDestroyFence(vk.device, vulkan_demo->rendering_finished_fence, nullptr);
vkDestroyImage(vk.device, vk.depth_image, nullptr);
vkDestroyImageView(vk.device, vk.depth_image_view, nullptr);
for (uint32_t i = 0; i < vk_instance.swapchain_image_count; i++) {
vkDestroyFramebuffer(vk_instance.device, vk_instance.framebuffers[i], nullptr);
for (uint32_t i = 0; i < vk.swapchain_image_count; i++) {
vkDestroyFramebuffer(vk.device, vk.framebuffers[i], nullptr);
}
vkDestroyRenderPass(vk_instance.device, vk_instance.render_pass, nullptr);
vkDestroyRenderPass(vk.device, vk.render_pass, nullptr);
vkDestroyCommandPool(g.device, g.command_pool, nullptr);
@ -469,11 +469,11 @@ VkImage vk_create_cinematic_image(int width, int height, Vk_Staging_Buffer& stag
buffer_desc.pQueueFamilyIndices = nullptr;
VkBuffer buffer;
VkResult result = vkCreateBuffer(vk_instance.device, &buffer_desc, nullptr, &buffer);
VkResult result = vkCreateBuffer(vk.device, &buffer_desc, nullptr, &buffer);
check_vk_result(result, "vkCreateBuffer");
VkDeviceMemory buffer_memory = get_allocator()->allocate_staging_memory(buffer);
result = vkBindBufferMemory(vk_instance.device, buffer, buffer_memory, 0);
result = vkBindBufferMemory(vk.device, buffer, buffer_memory, 0);
check_vk_result(result, "vkBindBufferMemory");
VkImageCreateInfo image_desc;
@ -496,11 +496,11 @@ VkImage vk_create_cinematic_image(int width, int height, Vk_Staging_Buffer& stag
image_desc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VkImage image;
result = vkCreateImage(vk_instance.device, &image_desc, nullptr, &image);
result = vkCreateImage(vk.device, &image_desc, nullptr, &image);
check_vk_result(result, "vkCreateImage");
VkDeviceMemory image_memory = get_allocator()->allocate_memory(image);
result = vkBindImageMemory(vk_instance.device, image, image_memory, 0);
result = vkBindImageMemory(vk.device, image, image_memory, 0);
check_vk_result(result, "vkBindImageMemory");
staging_buffer.handle = buffer;
@ -512,12 +512,12 @@ VkImage vk_create_cinematic_image(int width, int height, Vk_Staging_Buffer& stag
void vk_update_cinematic_image(VkImage image, const Vk_Staging_Buffer& staging_buffer, int width, int height, const uint8_t* rgba_pixels) {
void* buffer_data;
VkResult result = vkMapMemory(vk_instance.device, staging_buffer.memory, staging_buffer.offset, staging_buffer.size, 0, &buffer_data);
VkResult result = vkMapMemory(vk.device, staging_buffer.memory, staging_buffer.offset, staging_buffer.size, 0, &buffer_data);
check_vk_result(result, "vkMapMemory");
memcpy(buffer_data, rgba_pixels, staging_buffer.size);
vkUnmapMemory(vk_instance.device, staging_buffer.memory);
vkUnmapMemory(vk.device, staging_buffer.memory);
record_and_run_commands(vk_instance.command_pool, vk_instance.queue,
record_and_run_commands(vk.command_pool, vk.queue,
[&image, &staging_buffer, &width, &height](VkCommandBuffer command_buffer) {
record_image_layout_transition(command_buffer, image, VK_FORMAT_R8G8B8A8_UNORM,
@ -799,13 +799,13 @@ static VkPipeline create_pipeline(const Vk_Pipeline_Desc& desc) {
create_info.pColorBlendState = &blend_state;
create_info.pDynamicState = &dynamic_state;
create_info.layout = vulkan_demo->pipeline_layout;
create_info.renderPass = vk_instance.render_pass;
create_info.renderPass = vk.render_pass;
create_info.subpass = 0;
create_info.basePipelineHandle = VK_NULL_HANDLE;
create_info.basePipelineIndex = -1;
VkPipeline pipeline;
VkResult result = vkCreateGraphicsPipelines(vk_instance.device, VK_NULL_HANDLE, 1, &create_info, nullptr, &pipeline);
VkResult result = vkCreateGraphicsPipelines(vk.device, VK_NULL_HANDLE, 1, &create_info, nullptr, &pipeline);
check_vk_result(result, "vkCreateGraphicsPipelines");
return pipeline;
}
@ -825,13 +825,13 @@ struct Timer {
};
VkPipeline vk_find_pipeline(const Vk_Pipeline_Desc& desc) {
for (int i = 0; i < tr.vk.num_pipelines; i++) {
if (tr.vk.pipeline_desc[i] == desc) {
return tr.vk.pipelines[i];
for (int i = 0; i < tr.vk_resources.num_pipelines; i++) {
if (tr.vk_resources.pipeline_desc[i] == desc) {
return tr.vk_resources.pipelines[i];
}
}
if (tr.vk.num_pipelines == MAX_VK_PIPELINES) {
if (tr.vk_resources.num_pipelines == MAX_VK_PIPELINES) {
ri.Error( ERR_DROP, "vk_find_pipeline: MAX_VK_PIPELINES hit\n");
}
@ -839,26 +839,26 @@ VkPipeline vk_find_pipeline(const Vk_Pipeline_Desc& desc) {
VkPipeline pipeline = create_pipeline(desc);
pipeline_create_time += t.Elapsed_Seconds();
tr.vk.pipeline_desc[tr.vk.num_pipelines] = desc;
tr.vk.pipelines[tr.vk.num_pipelines] = pipeline;
tr.vk.num_pipelines++;
tr.vk_resources.pipeline_desc[tr.vk_resources.num_pipelines] = desc;
tr.vk_resources.pipelines[tr.vk_resources.num_pipelines] = pipeline;
tr.vk_resources.num_pipelines++;
return pipeline;
}
static void vk_destroy_pipelines() {
for (int i = 0; i < tr.vk.num_pipelines; i++) {
vkDestroyPipeline(vk_instance.device, tr.vk.pipelines[i], nullptr);
for (int i = 0; i < tr.vk_resources.num_pipelines; i++) {
vkDestroyPipeline(vk.device, tr.vk_resources.pipelines[i], nullptr);
}
tr.vk.num_pipelines = 0;
Com_Memset(tr.vk.pipelines, 0, sizeof(tr.vk.pipelines));
Com_Memset(tr.vk.pipeline_desc, 0, sizeof(tr.vk.pipeline_desc));
tr.vk_resources.num_pipelines = 0;
Com_Memset(tr.vk_resources.pipelines, 0, sizeof(tr.vk_resources.pipelines));
Com_Memset(tr.vk_resources.pipeline_desc, 0, sizeof(tr.vk_resources.pipeline_desc));
pipeline_create_time = 0.0f;
}
void vk_destroy_resources() {
vkDeviceWaitIdle(vk_instance.device);
vkDeviceWaitIdle(vk.device);
vk_destroy_pipelines();
}

86
src/engine/renderer/vk_demo.cpp
View File

@ -33,7 +33,7 @@ Vulkan_Demo::Vulkan_Demo(int window_width, int window_height)
fence_desc.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fence_desc.pNext = nullptr;
fence_desc.flags = VK_FENCE_CREATE_SIGNALED_BIT;
VkResult result = vkCreateFence(vk_instance.device, &fence_desc, nullptr, &rendering_finished_fence);
VkResult result = vkCreateFence(vk.device, &fence_desc, nullptr, &rendering_finished_fence);
check_vk_result(result, "vkCreateFence");
create_descriptor_pool();
@ -72,7 +72,7 @@ void Vulkan_Demo::create_uniform_buffer() {
uniform_buffer = create_buffer(size, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
VkPhysicalDeviceProperties props;
vkGetPhysicalDeviceProperties(vk_instance.physical_device, &props);
vkGetPhysicalDeviceProperties(vk.physical_device, &props);
VkDeviceSize offset_align = props.limits.minUniformBufferOffsetAlignment;
tess_ubo_offset_step = (uint32_t)((sizeof(Uniform_Buffer_Object) + offset_align - 1) / offset_align * offset_align);
}
@ -82,13 +82,13 @@ VkImage Vulkan_Demo::create_texture(const uint8_t* pixels, int bytes_per_pixel,
bytes_per_pixel == 3 ? VK_FORMAT_R8G8B8_UNORM : VK_FORMAT_R8G8B8A8_UNORM, pixels, bytes_per_pixel);
Defer_Action destroy_staging_image([this, &staging_image]() {
vkDestroyImage(vk_instance.device, staging_image, nullptr);
vkDestroyImage(vk.device, staging_image, nullptr);
});
VkImage texture_image = ::create_texture(image_width, image_height,
bytes_per_pixel == 3 ? VK_FORMAT_R8G8B8_UNORM : VK_FORMAT_R8G8B8A8_UNORM);
record_and_run_commands(vk_instance.command_pool, vk_instance.queue,
record_and_run_commands(vk.command_pool, vk.queue,
[&texture_image, &staging_image, &image_width, &image_height, this](VkCommandBuffer command_buffer) {
record_image_layout_transition(command_buffer, staging_image, VK_FORMAT_R8G8B8A8_UNORM,
@ -188,7 +188,7 @@ void Vulkan_Demo::create_image_descriptor_set(const image_t* image) {
desc.pSetLayouts = &descriptor_set_layout;
VkDescriptorSet set;
VkResult result = vkAllocateDescriptorSets(vk_instance.device, &desc, &set);
VkResult result = vkAllocateDescriptorSets(vk.device, &desc, &set);
check_vk_result(result, "vkAllocateDescriptorSets");
VkDescriptorImageInfo image_info;
@ -208,7 +208,7 @@ void Vulkan_Demo::create_image_descriptor_set(const image_t* image) {
descriptor_writes[0].pBufferInfo = nullptr;
descriptor_writes[0].pTexelBufferView = nullptr;
vkUpdateDescriptorSets(vk_instance.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr);
vkUpdateDescriptorSets(vk.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr);
update_ubo_descriptor(set);
@ -224,7 +224,7 @@ void Vulkan_Demo::create_multitexture_descriptor_set(const image_t* image, const
desc.pSetLayouts = &descriptor_set_layout;
VkDescriptorSet set;
VkResult result = vkAllocateDescriptorSets(vk_instance.device, &desc, &set);
VkResult result = vkAllocateDescriptorSets(vk.device, &desc, &set);
check_vk_result(result, "vkAllocateDescriptorSets");
VkDescriptorImageInfo image_info[2];
@ -259,7 +259,7 @@ void Vulkan_Demo::create_multitexture_descriptor_set(const image_t* image, const
descriptor_writes[1].pBufferInfo = nullptr;
descriptor_writes[1].pTexelBufferView = nullptr;
vkUpdateDescriptorSets(vk_instance.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr);
vkUpdateDescriptorSets(vk.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr);
update_ubo_descriptor(set);
@ -295,7 +295,7 @@ void Vulkan_Demo::upload_geometry() {
tess_vertex_buffer = get_resource_manager()->create_buffer(desc);
tess_vertex_buffer_memory = get_allocator()->allocate_staging_memory(tess_vertex_buffer);
VkResult result = vkBindBufferMemory(vk_instance.device, tess_vertex_buffer, tess_vertex_buffer_memory, 0);
VkResult result = vkBindBufferMemory(vk.device, tess_vertex_buffer, tess_vertex_buffer_memory, 0);
check_vk_result(result, "vkBindBufferMemory");
}
@ -312,7 +312,7 @@ void Vulkan_Demo::upload_geometry() {
tess_index_buffer = get_resource_manager()->create_buffer(desc);
tess_index_buffer_memory = get_allocator()->allocate_staging_memory(tess_index_buffer);
VkResult result = vkBindBufferMemory(vk_instance.device, tess_index_buffer, tess_index_buffer_memory, 0);
VkResult result = vkBindBufferMemory(vk.device, tess_index_buffer, tess_index_buffer_memory, 0);
check_vk_result(result, "vkBindBufferMemory");
}
}
@ -335,7 +335,7 @@ void Vulkan_Demo::update_ubo_descriptor(VkDescriptorSet set) {
descriptor_writes[0].pBufferInfo = &buffer_info;
descriptor_writes[0].pTexelBufferView = nullptr;
vkUpdateDescriptorSets(vk_instance.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr);
vkUpdateDescriptorSets(vk.device, (uint32_t)descriptor_writes.size(), descriptor_writes.data(), 0, nullptr);
}
void Vulkan_Demo::update_uniform_buffer() {
@ -372,10 +372,10 @@ void Vulkan_Demo::update_uniform_buffer() {
}
void* data;
VkResult result = vkMapMemory(vk_instance.device, uniform_staging_buffer_memory, tess_ubo_offset, sizeof(ubo), 0, &data);
VkResult result = vkMapMemory(vk.device, uniform_staging_buffer_memory, tess_ubo_offset, sizeof(ubo), 0, &data);
check_vk_result(result, "vkMapMemory");
memcpy(data, &ubo, sizeof(ubo));
vkUnmapMemory(vk_instance.device, uniform_staging_buffer_memory);
vkUnmapMemory(vk.device, uniform_staging_buffer_memory);
}
void Vulkan_Demo::begin_frame() {
@ -386,7 +386,7 @@ void Vulkan_Demo::begin_frame() {
region.srcOffset = 0;
region.dstOffset = 0;
region.size = sizeof(Uniform_Buffer_Object) * 1024;
vkCmdCopyBuffer(vk_instance.command_buffer, uniform_staging_buffer, uniform_buffer, 1, &region);
vkCmdCopyBuffer(vk.command_buffer, uniform_staging_buffer, uniform_buffer, 1, &region);
VkBufferMemoryBarrier barrier;
barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
@ -399,7 +399,7 @@ void Vulkan_Demo::begin_frame() {
barrier.offset = 0;
barrier.size = sizeof(Uniform_Buffer_Object) * 1024;
vkCmdPipelineBarrier(vk_instance.command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, 0,
vkCmdPipelineBarrier(vk.command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, 0,
0, nullptr, 1, &barrier, 0, nullptr);
std::array<VkClearValue, 2> clear_values;
@ -409,14 +409,14 @@ void Vulkan_Demo::begin_frame() {
VkRenderPassBeginInfo render_pass_begin_info;
render_pass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
render_pass_begin_info.pNext = nullptr;
render_pass_begin_info.renderPass = vk_instance.render_pass;
render_pass_begin_info.framebuffer = vk_instance.framebuffers[swapchain_image_index];
render_pass_begin_info.renderPass = vk.render_pass;
render_pass_begin_info.framebuffer = vk.framebuffers[swapchain_image_index];
render_pass_begin_info.renderArea.offset = {0, 0};
render_pass_begin_info.renderArea.extent = {(uint32_t)window_width, (uint32_t)window_height};
render_pass_begin_info.clearValueCount = static_cast<uint32_t>(clear_values.size());
render_pass_begin_info.pClearValues = clear_values.data();
vkCmdBeginRenderPass(vk_instance.command_buffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBeginRenderPass(vk.command_buffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);
tess_vertex_buffer_offset = 0;
tess_index_buffer_offset = 0;
@ -428,7 +428,7 @@ void Vulkan_Demo::begin_frame() {
void Vulkan_Demo::end_frame() {
fprintf(logfile, "end_frame (vb_size %d, ib_size %d, ubo_size %d)\n", (int)tess_vertex_buffer_offset, (int)tess_index_buffer_offset, (int)tess_ubo_offset);
fflush(logfile);
vkCmdEndRenderPass(vk_instance.command_buffer);
vkCmdEndRenderPass(vk.command_buffer);
}
void Vulkan_Demo::render_tess(const shaderStage_t* stage) {
@ -436,7 +436,7 @@ void Vulkan_Demo::render_tess(const shaderStage_t* stage) {
fflush(logfile);
void* data;
VkResult result = vkMapMemory(vk_instance.device, tess_vertex_buffer_memory, tess_vertex_buffer_offset, tess.numVertexes * sizeof(Vk_Vertex), 0, &data);
VkResult result = vkMapMemory(vk.device, tess_vertex_buffer_memory, tess_vertex_buffer_offset, tess.numVertexes * sizeof(Vk_Vertex), 0, &data);
check_vk_result(result, "vkMapMemory");
Vk_Vertex* v = (Vk_Vertex*)data;
for (int i = 0; i < tess.numVertexes; i++, v++) {
@ -450,31 +450,31 @@ void Vulkan_Demo::render_tess(const shaderStage_t* stage) {
v->st[0] = tess.svars.texcoords[0][i][0];
v->st[1] = tess.svars.texcoords[0][i][1];
}
vkUnmapMemory(vk_instance.device, tess_vertex_buffer_memory);
vkUnmapMemory(vk.device, tess_vertex_buffer_memory);
result = vkMapMemory(vk_instance.device, tess_index_buffer_memory, tess_index_buffer_offset, tess.numIndexes * sizeof(uint32_t), 0, &data);
result = vkMapMemory(vk.device, tess_index_buffer_memory, tess_index_buffer_offset, tess.numIndexes * sizeof(uint32_t), 0, &data);
check_vk_result(result, "vkMapMemory");
uint32_t* ind = (uint32_t*)data;
for (int i = 0; i < tess.numIndexes; i++, ind++) {
*ind = tess.indexes[i];
}
vkUnmapMemory(vk_instance.device, tess_index_buffer_memory);
vkUnmapMemory(vk.device, tess_index_buffer_memory);
const VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(vk_instance.command_buffer, 0, 1, &tess_vertex_buffer, &tess_vertex_buffer_offset);
vkCmdBindIndexBuffer(vk_instance.command_buffer, tess_index_buffer, tess_index_buffer_offset, VK_INDEX_TYPE_UINT32);
vkCmdBindVertexBuffers(vk.command_buffer, 0, 1, &tess_vertex_buffer, &tess_vertex_buffer_offset);
vkCmdBindIndexBuffer(vk.command_buffer, tess_index_buffer, tess_index_buffer_offset, VK_INDEX_TYPE_UINT32);
image_t* image = glState.vk_current_images[0];
VkDescriptorSet set = image_descriptor_sets[image];
update_uniform_buffer();
vkCmdBindDescriptorSets(vk_instance.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &set, 1, &tess_ubo_offset);
vkCmdBindDescriptorSets(vk.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &set, 1, &tess_ubo_offset);
tess_ubo_offset += tess_ubo_offset_step;
vkCmdBindPipeline(vk_instance.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, stage->vk_pipeline);
vkCmdBindPipeline(vk.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, stage->vk_pipeline);
VkRect2D r = vk_get_viewport_rect();
vkCmdSetScissor(vk_instance.command_buffer, 0, 1, &r);
vkCmdSetScissor(vk.command_buffer, 0, 1, &r);
VkViewport viewport;
viewport.x = (float)r.offset.x;
@ -483,13 +483,13 @@ void Vulkan_Demo::render_tess(const shaderStage_t* stage) {
viewport.height = (float)r.extent.height;
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
vkCmdSetViewport(vk_instance.command_buffer, 0, 1, &viewport);
vkCmdSetViewport(vk.command_buffer, 0, 1, &viewport);
if (tess.shader->polygonOffset) {
vkCmdSetDepthBias(vk_instance.command_buffer, r_offsetUnits->value, 0.0f, r_offsetFactor->value);
vkCmdSetDepthBias(vk.command_buffer, r_offsetUnits->value, 0.0f, r_offsetFactor->value);
}
vkCmdDrawIndexed(vk_instance.command_buffer, tess.numIndexes, 1, 0, 0, 0);
vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
tess_vertex_buffer_offset += tess.numVertexes * sizeof(Vk_Vertex);
tess_index_buffer_offset += tess.numIndexes * sizeof(uint32_t);
@ -501,7 +501,7 @@ void Vulkan_Demo::render_tess_multi(const shaderStage_t* stage) {
fflush(logfile);
void* data;
VkResult result = vkMapMemory(vk_instance.device, tess_vertex_buffer_memory, tess_vertex_buffer_offset, tess.numVertexes * sizeof(Vk_Vertex2), 0, &data);
VkResult result = vkMapMemory(vk.device, tess_vertex_buffer_memory, tess_vertex_buffer_offset, tess.numVertexes * sizeof(Vk_Vertex2), 0, &data);
check_vk_result(result, "vkMapMemory");
Vk_Vertex2* v = (Vk_Vertex2*)data;
for (int i = 0; i < tess.numVertexes; i++, v++) {
@ -517,19 +517,19 @@ void Vulkan_Demo::render_tess_multi(const shaderStage_t* stage) {
v->st2[0] = tess.svars.texcoords[1][i][0];
v->st2[1] = tess.svars.texcoords[1][i][1];
}
vkUnmapMemory(vk_instance.device, tess_vertex_buffer_memory);
vkUnmapMemory(vk.device, tess_vertex_buffer_memory);
result = vkMapMemory(vk_instance.device, tess_index_buffer_memory, tess_index_buffer_offset, tess.numIndexes * sizeof(uint32_t), 0, &data);
result = vkMapMemory(vk.device, tess_index_buffer_memory, tess_index_buffer_offset, tess.numIndexes * sizeof(uint32_t), 0, &data);
check_vk_result(result, "vkMapMemory");
uint32_t* ind = (uint32_t*)data;
for (int i = 0; i < tess.numIndexes; i++, ind++) {
*ind = tess.indexes[i];
}
vkUnmapMemory(vk_instance.device, tess_index_buffer_memory);
vkUnmapMemory(vk.device, tess_index_buffer_memory);
const VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(vk_instance.command_buffer, 0, 1, &tess_vertex_buffer, &tess_vertex_buffer_offset);
vkCmdBindIndexBuffer(vk_instance.command_buffer, tess_index_buffer, tess_index_buffer_offset, VK_INDEX_TYPE_UINT32);
vkCmdBindVertexBuffers(vk.command_buffer, 0, 1, &tess_vertex_buffer, &tess_vertex_buffer_offset);
vkCmdBindIndexBuffer(vk.command_buffer, tess_index_buffer, tess_index_buffer_offset, VK_INDEX_TYPE_UINT32);
image_t* image = glState.vk_current_images[0];
image_t* image2 = glState.vk_current_images[1];
@ -542,13 +542,13 @@ void Vulkan_Demo::render_tess_multi(const shaderStage_t* stage) {
auto set = it->second;
update_uniform_buffer();
vkCmdBindDescriptorSets(vk_instance.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &set, 1, &tess_ubo_offset);
vkCmdBindDescriptorSets(vk.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &set, 1, &tess_ubo_offset);
tess_ubo_offset += tess_ubo_offset_step;
vkCmdBindPipeline(vk_instance.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, stage->vk_pipeline);
vkCmdBindPipeline(vk.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, stage->vk_pipeline);
VkRect2D r = vk_get_viewport_rect();
vkCmdSetScissor(vk_instance.command_buffer, 0, 1, &r);
vkCmdSetScissor(vk.command_buffer, 0, 1, &r);
VkViewport viewport;
viewport.x = (float)r.offset.x;
@ -557,13 +557,13 @@ void Vulkan_Demo::render_tess_multi(const shaderStage_t* stage) {
viewport.height = (float)r.extent.height;
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
vkCmdSetViewport(vk_instance.command_buffer, 0, 1, &viewport);
vkCmdSetViewport(vk.command_buffer, 0, 1, &viewport);
if (tess.shader->polygonOffset) {
vkCmdSetDepthBias(vk_instance.command_buffer, r_offsetUnits->value, 0.0f, r_offsetFactor->value);
vkCmdSetDepthBias(vk.command_buffer, r_offsetUnits->value, 0.0f, r_offsetFactor->value);
}
vkCmdDrawIndexed(vk_instance.command_buffer, tess.numIndexes, 1, 0, 0, 0);
vkCmdDrawIndexed(vk.command_buffer, tess.numIndexes, 1, 0, 0, 0);
tess_vertex_buffer_offset += tess.numVertexes * sizeof(Vk_Vertex2);
tess_index_buffer_offset += tess.numIndexes * sizeof(uint32_t);

32
src/engine/renderer/vk_utils.cpp
View File

@ -30,12 +30,12 @@ Shader_Module::Shader_Module(uint8_t bytes[], int size) {
desc.codeSize = data.size();
desc.pCode = reinterpret_cast<const uint32_t*>(data.data());
VkResult result = vkCreateShaderModule(vk_instance.device, &desc, nullptr, &handle);
VkResult result = vkCreateShaderModule(vk.device, &desc, nullptr, &handle);
check_vk_result(result, "vkCreateShaderModule");
}
Shader_Module::~Shader_Module() {
vkDestroyShaderModule(vk_instance.device, handle, nullptr);
vkDestroyShaderModule(vk.device, handle, nullptr);
}
void record_and_run_commands(VkCommandPool command_pool, VkQueue queue, std::function<void(VkCommandBuffer)> recorder) {
@ -48,7 +48,7 @@ void record_and_run_commands(VkCommandPool command_pool, VkQueue queue, std::fun
alloc_info.commandBufferCount = 1;
VkCommandBuffer command_buffer;
VkResult result = vkAllocateCommandBuffers(vk_instance.device, &alloc_info, &command_buffer);
VkResult result = vkAllocateCommandBuffers(vk.device, &alloc_info, &command_buffer);
check_vk_result(result, "vkAllocateCommandBuffers");
VkCommandBufferBeginInfo begin_info;
@ -78,7 +78,7 @@ void record_and_run_commands(VkCommandPool command_pool, VkQueue queue, std::fun
check_vk_result(result, "vkQueueSubmit");
result = vkQueueWaitIdle(queue);
check_vk_result(result, "vkQueueWaitIdle");
vkFreeCommandBuffers(vk_instance.device, command_pool, 1, &command_buffer);
vkFreeCommandBuffers(vk.device, command_pool, 1, &command_buffer);
}
static bool has_depth_component(VkFormat format) {
@ -162,11 +162,11 @@ VkImage create_texture(int image_width, int image_height, VkFormat format) {
desc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VkImage image;
VkResult result = vkCreateImage(vk_instance.device, &desc, nullptr, &image);
VkResult result = vkCreateImage(vk.device, &desc, nullptr, &image);
check_vk_result(result, "vkCreateImage");
VkDeviceMemory memory = get_allocator()->allocate_memory(image);
result = vkBindImageMemory(vk_instance.device, image, memory, 0);
result = vkBindImageMemory(vk.device, image, memory, 0);
check_vk_result(result, "vkBindImageMemory");
return image;
}
@ -192,12 +192,12 @@ VkImage create_staging_texture(int image_width, int image_height, VkFormat forma
desc.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
VkImage image;
VkResult result = vkCreateImage(vk_instance.device, &desc, nullptr, &image);
VkResult result = vkCreateImage(vk.device, &desc, nullptr, &image);
check_vk_result(result, "vkCreateImage");
get_allocator()->get_shared_staging_memory().ensure_allocation_for_object(image);
VkDeviceMemory memory = get_allocator()->get_shared_staging_memory().get_handle();
result = vkBindImageMemory(vk_instance.device, image, memory, 0);
result = vkBindImageMemory(vk.device, image, memory, 0);
check_vk_result(result, "vkBindImageMemory");
VkImageSubresource staging_image_subresource;
@ -205,10 +205,10 @@ VkImage create_staging_texture(int image_width, int image_height, VkFormat forma
staging_image_subresource.mipLevel = 0;
staging_image_subresource.arrayLayer = 0;
VkSubresourceLayout staging_image_layout;
vkGetImageSubresourceLayout(vk_instance.device, image, &staging_image_subresource, &staging_image_layout);
vkGetImageSubresourceLayout(vk.device, image, &staging_image_subresource, &staging_image_layout);
void* data;
result = vkMapMemory(vk_instance.device, memory, 0, staging_image_layout.size, 0, &data);
result = vkMapMemory(vk.device, memory, 0, staging_image_layout.size, 0, &data);
check_vk_result(result, "vkMapMemory");
const int bytes_per_row = image_width * bytes_per_pixel;
@ -220,7 +220,7 @@ VkImage create_staging_texture(int image_width, int image_height, VkFormat forma
memcpy(&bytes[i * staging_image_layout.rowPitch], &pixels[i * bytes_per_row], bytes_per_row);
}
}
vkUnmapMemory(vk_instance.device, memory);
vkUnmapMemory(vk.device, memory);
return image;
}
@ -245,11 +245,11 @@ VkImage create_depth_attachment_image(int image_width, int image_height, VkForma
desc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VkImage image;
VkResult result = vkCreateImage(vk_instance.device, &desc, nullptr, &image);
VkResult result = vkCreateImage(vk.device, &desc, nullptr, &image);
check_vk_result(result, "vkCreateImage");
VkDeviceMemory memory = get_allocator()->allocate_memory(image);
result = vkBindImageMemory(vk_instance.device, image, memory, 0);
result = vkBindImageMemory(vk.device, image, memory, 0);
check_vk_result(result, "vkBindImageMemory");
return image;
}
@ -273,7 +273,7 @@ VkImageView create_image_view(VkImage image, VkFormat format, VkImageAspectFlags
desc.subresourceRange.layerCount = 1;
VkImageView image_view;
VkResult result = vkCreateImageView(vk_instance.device, &desc, nullptr, &image_view);
VkResult result = vkCreateImageView(vk.device, &desc, nullptr, &image_view);
check_vk_result(result, "vkCreateImageView");
return image_view;
}
@ -292,7 +292,7 @@ VkBuffer create_buffer(VkDeviceSize size, VkBufferUsageFlags usage) {
VkBuffer buffer = get_resource_manager()->create_buffer(desc);
VkDeviceMemory memory = get_allocator()->allocate_memory(buffer);
VkResult result = vkBindBufferMemory(vk_instance.device, buffer, memory, 0);
VkResult result = vkBindBufferMemory(vk.device, buffer, memory, 0);
check_vk_result(result, "vkBindBufferMemory");
return buffer;
}
@ -311,7 +311,7 @@ VkBuffer create_permanent_staging_buffer(VkDeviceSize size, VkDeviceMemory& memo
VkBuffer buffer = get_resource_manager()->create_buffer(desc);
memory = get_allocator()->allocate_staging_memory(buffer);
VkResult result = vkBindBufferMemory(vk_instance.device, buffer, memory, 0);
VkResult result = vkBindBufferMemory(vk.device, buffer, memory, 0);
check_vk_result(result, "vkBindBufferMemory");
return buffer;
}