772 lines
32 KiB
C
772 lines
32 KiB
C
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <vulkan/vulkan.h>
|
|
#include <vulkan/vulkan_core.h>
|
|
|
|
#include "io.h"
|
|
#include "kitty.h"
|
|
#include "paw_allocator.h"
|
|
#include "paw_da.h"
|
|
#include "vulkan_helpers.h"
|
|
|
|
struct Kitty *kitty_make(struct PawMem *mem) {
|
|
struct Kitty *kitty;
|
|
if (mem == NULL) {
|
|
kitty = malloc(sizeof(struct Kitty));
|
|
} else {
|
|
kitty = paw_memmalloc(mem, sizeof(struct Kitty));
|
|
}
|
|
memset(kitty, 0, sizeof(struct Kitty));
|
|
kitty->mem = mem;
|
|
if (kitty->mem == NULL) {
|
|
paw_da_make_inplace(&kitty->attatchments);
|
|
paw_da_make_inplace(&kitty->vertex_buffer.format);
|
|
paw_da_make_inplace(&kitty->instance_buffer.format);
|
|
} else {
|
|
paw_da_make_inplace_mem(&kitty->attatchments, kitty->mem);
|
|
paw_da_make_inplace_mem(&kitty->vertex_buffer.format, kitty->mem);
|
|
paw_da_make_inplace_mem(&kitty->instance_buffer.format, kitty->mem);
|
|
}
|
|
meow("alloced a kitty at %p", kitty);
|
|
return kitty;
|
|
}
|
|
|
|
void kitty_set_push_constant_size(struct Kitty *kitty, uint32_t size) {
|
|
kitty->push_constant_size = size;
|
|
}
|
|
void kitty_set_vertex_shader(struct Kitty *kitty, const char *path) {
|
|
kitty->vertex_path = path;
|
|
meow("vertex path is %s", path);
|
|
}
|
|
void kitty_set_fragment_shader(struct Kitty *kitty, const char *path) {
|
|
kitty->fragment_path = path;
|
|
meow("fragment path is %s", path);
|
|
}
|
|
void kitty_set_vertex_buffer(struct Kitty *kitty, void *data, uint32_t count,
|
|
int vertex_size) {
|
|
kitty->vertex_buffer.data = data;
|
|
kitty->vertex_buffer.count = count;
|
|
kitty->vertex_buffer.vertex_size = vertex_size;
|
|
}
|
|
|
|
void kitty_add_index_buffer(struct Kitty *kitty, void *data, uint32_t count) {
|
|
kitty->index_buffer.data = data;
|
|
kitty->index_buffer.count = count;
|
|
}
|
|
|
|
void kitty_add_instance_buffer(struct Kitty *kitty, void *data, uint32_t count,
|
|
int element_size) {
|
|
kitty->instance_buffer.data = data;
|
|
kitty->instance_buffer.count = count;
|
|
kitty->instance_buffer.element_size = element_size;
|
|
}
|
|
void kitty_add_instance_buffer_format(struct Kitty *kitty,
|
|
enum VkFormat format) {
|
|
paw_da_append(&kitty->instance_buffer.format, format);
|
|
}
|
|
|
|
void kitty_add_vertex_buffer_format(struct Kitty *kitty, enum VkFormat format) {
|
|
paw_da_append(&kitty->vertex_buffer.format, format);
|
|
}
|
|
void kitty_attatch_image(struct Kitty *kitty, const char *path) {
|
|
struct KittyAttatchment attatchment = {0};
|
|
attatchment.type = CAT_ATTATCH_IMAGE;
|
|
attatchment.image.path = path;
|
|
paw_da_append(&kitty->attatchments, attatchment);
|
|
meow("image was attatched");
|
|
}
|
|
int kitty_attatch_ubo(struct Kitty *kitty, uint32_t size) {
|
|
struct KittyAttatchment attatchment = {0};
|
|
attatchment.type = CAT_ATTATCH_UBO;
|
|
attatchment.ubo.size = size;
|
|
paw_da_append(&kitty->attatchments, attatchment);
|
|
meow("ubo of size %d was attatched", size);
|
|
return kitty->attatchments.count - 1;
|
|
}
|
|
int kitty_attatch_ubo_array(struct Kitty *kitty, uint32_t size,
|
|
uint32_t count) {
|
|
struct KittyAttatchment attatchment = {0};
|
|
attatchment.type = CAT_ATTATCH_UBO_ARRAY;
|
|
attatchment.ubo_array.size = size;
|
|
attatchment.ubo_array.count = count;
|
|
paw_da_append(&kitty->attatchments, attatchment);
|
|
return kitty->attatchments.count - 1;
|
|
}
|
|
|
|
void kitty_finalise(struct Vk *state, struct Kitty *kitty) {
|
|
kitty_create_layout_bindings(kitty, state);
|
|
kitty_create_pipeline(kitty, state);
|
|
kitty_create_descriptor_pool(kitty, state);
|
|
kitty_create_image_attatchments(kitty, state);
|
|
kitty_create_ubo_attatchments(kitty, state);
|
|
kitty_create_ubo_array_attatchments(kitty, state);
|
|
kitty_create_descriptor_sets(kitty, state);
|
|
kitty_create_vertex_buffer(kitty, state);
|
|
if (kitty->instance_buffer.count != 0) {
|
|
kitty_create_instance_buffer(kitty, state);
|
|
}
|
|
|
|
paw_da_append(&state->kitties, kitty);
|
|
}
|
|
|
|
void kitty_free(struct Vk *state, struct Kitty *kitty) {
|
|
vkDeviceWaitIdle(state->device);
|
|
vkDestroyBuffer(state->device, kitty->vertex_buffer.buffer, NULL);
|
|
gpu_mem_free(state, state->mem, kitty->vertex_buffer.memory);
|
|
if (kitty->instance_buffer.count != 0) {
|
|
vkDestroyBuffer(state->device, kitty->instance_buffer.buffer, NULL);
|
|
gpu_mem_free(state, state->mem, kitty->instance_buffer.memory);
|
|
}
|
|
vkDestroyDescriptorPool(state->device, kitty->descriptor_pool, NULL);
|
|
vkDestroyDescriptorSetLayout(state->device, kitty->descriptor_set_layout,
|
|
NULL);
|
|
vkDestroyPipelineLayout(state->device, kitty->pipeline_layout, NULL);
|
|
vkDestroyPipeline(state->device, kitty->pipeline, NULL);
|
|
for (int i = 0; i < kitty->attatchments.count; i++) {
|
|
switch (kitty->attatchments.items[i].type) {
|
|
case CAT_ATTATCH_UBO:
|
|
for (int j = 0; j < MAX_FRAMES_IN_FLIGHT; j++) {
|
|
vkDestroyBuffer(state->device,
|
|
kitty->attatchments.items[i].ubo.buffer[j], NULL);
|
|
gpu_mem_free(state, state->mem,
|
|
kitty->attatchments.items[i].ubo.memory[j]);
|
|
}
|
|
break;
|
|
case CAT_ATTATCH_UBO_ARRAY:
|
|
for (int j = 0; j < MAX_FRAMES_IN_FLIGHT; j++) {
|
|
vkDestroyBuffer(state->device,
|
|
kitty->attatchments.items[i].ubo_array.buffer[j], NULL);
|
|
gpu_mem_free(state, state->mem,
|
|
kitty->attatchments.items[i].ubo_array.memory[j]);
|
|
}
|
|
break;
|
|
case CAT_ATTATCH_IMAGE:
|
|
vkDestroyImage(state->device, kitty->attatchments.items[i].image.image,
|
|
NULL);
|
|
gpu_mem_free(state, state->mem,
|
|
kitty->attatchments.items[i].image.memory);
|
|
vkDestroyImageView(state->device, kitty->attatchments.items[i].image.view,
|
|
NULL);
|
|
vkDestroySampler(state->device,
|
|
kitty->attatchments.items[i].image.sampler, NULL);
|
|
break;
|
|
}
|
|
}
|
|
|
|
paw_da_free(&kitty->vertex_buffer.format);
|
|
paw_da_free(&kitty->attatchments);
|
|
|
|
if (kitty->mem == NULL) {
|
|
memset(kitty, 0, sizeof(struct Kitty));
|
|
free(kitty);
|
|
} else {
|
|
paw_memfree(kitty->mem, kitty);
|
|
}
|
|
}
|
|
|
|
void kitty_set_next_push_constant(struct Kitty *kitty, void *data) {
|
|
kitty->next_push_constant = data;
|
|
}
|
|
|
|
void kitty_set_next_ubo(struct Vk *state, struct Kitty *kitty, int index,
|
|
void *data) {
|
|
switch (kitty->attatchments.items[index].type) {
|
|
case CAT_ATTATCH_IMAGE:
|
|
meow("trying to update the contents of an image, not supported");
|
|
break;
|
|
case CAT_ATTATCH_UBO:;
|
|
void *dst = kitty->attatchments.items[index]
|
|
.ubo.memory[state->current_frame]
|
|
.mapped;
|
|
void *src = data;
|
|
int size = kitty->attatchments.items[index].ubo.size;
|
|
memcpy(dst, src, size);
|
|
break;
|
|
case CAT_ATTATCH_UBO_ARRAY:;
|
|
void *dst_array = kitty->attatchments.items[index]
|
|
.ubo_array.memory[state->current_frame]
|
|
.mapped;
|
|
void *src_array = data;
|
|
int size_array = kitty->attatchments.items[index].ubo_array.size *
|
|
kitty->attatchments.items[index].ubo_array.count;
|
|
memcpy(dst_array, src_array, size_array);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void *kitty_get_next_ubo_pointer(struct Vk *state, struct Kitty *kitty,
|
|
int index) {
|
|
switch (kitty->attatchments.items[index].type) {
|
|
case CAT_ATTATCH_IMAGE:
|
|
meow("trying to update the contents of an image, not supported");
|
|
break;
|
|
case CAT_ATTATCH_UBO:;
|
|
return kitty->attatchments.items[index]
|
|
.ubo.memory[state->current_frame]
|
|
.mapped;
|
|
break;
|
|
case CAT_ATTATCH_UBO_ARRAY:;
|
|
return kitty->attatchments.items[index]
|
|
.ubo_array.memory[state->current_frame]
|
|
.mapped;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void kitty_draw(struct Vk *state, uint32_t image_index, struct Kitty *kitty) {
|
|
struct InFlightObjects flight = state->flights[state->current_frame];
|
|
vkCmdBindPipeline(flight.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
|
kitty->pipeline);
|
|
|
|
VkViewport viewport = {0};
|
|
viewport.x = 0.0f;
|
|
viewport.y = 0.0f;
|
|
viewport.width = state->width;
|
|
viewport.height = state->heigh;
|
|
viewport.minDepth = 0.0f;
|
|
viewport.maxDepth = 1.0f;
|
|
vkCmdSetViewport(flight.command_buffer, 0, 1, &viewport);
|
|
|
|
VkRect2D scissor = {0};
|
|
scissor.offset = (VkOffset2D){0, 0};
|
|
scissor.extent = (VkExtent2D){state->width, state->heigh};
|
|
vkCmdSetScissor(flight.command_buffer, 0, 1, &scissor);
|
|
|
|
uint64_t offsets[1] = {0};
|
|
vkCmdBindVertexBuffers(flight.command_buffer, 0, 1,
|
|
&kitty->vertex_buffer.buffer, offsets);
|
|
|
|
if (kitty->instance_buffer.count != 0) {
|
|
vkCmdBindVertexBuffers(flight.command_buffer, 1, 1,
|
|
&kitty->instance_buffer.buffer, offsets);
|
|
}
|
|
|
|
vkCmdBindDescriptorSets(
|
|
flight.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
|
kitty->pipeline_layout, 0, 1,
|
|
&kitty->descriptor_sets[state->current_frame], 0, NULL);
|
|
|
|
if (kitty->instance_buffer.count == 0) {
|
|
vkCmdDraw(flight.command_buffer, kitty->vertex_buffer.count, 1, 0, 0);
|
|
} else {
|
|
vkCmdDraw(flight.command_buffer, kitty->vertex_buffer.count,
|
|
kitty->instance_buffer.count, 0, 0);
|
|
}
|
|
}
|
|
|
|
void kitty_create_layout_bindings(struct Kitty *kitty, struct Vk *state) {
|
|
VkDescriptorSetLayoutBinding
|
|
descriptor_set_layout_binding[kitty->attatchments.count];
|
|
memset(descriptor_set_layout_binding, 0,
|
|
sizeof(VkDescriptorSetLayoutBinding) * kitty->attatchments.count);
|
|
meow("count is %d", kitty->attatchments.items[1].ubo_array.count);
|
|
for (int index = 0; index < kitty->attatchments.count; index++) {
|
|
switch (kitty->attatchments.items[index].type) {
|
|
case CAT_ATTATCH_UBO:
|
|
descriptor_set_layout_binding[index].binding = index;
|
|
descriptor_set_layout_binding[index].descriptorType =
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
descriptor_set_layout_binding[index].descriptorCount = 1;
|
|
descriptor_set_layout_binding[index].stageFlags = VK_SHADER_STAGE_ALL;
|
|
descriptor_set_layout_binding[index].pImmutableSamplers = NULL;
|
|
break;
|
|
case CAT_ATTATCH_UBO_ARRAY:
|
|
meow("count is %d", kitty->attatchments.items[index].ubo_array.count);
|
|
descriptor_set_layout_binding[index].binding = index;
|
|
descriptor_set_layout_binding[index].descriptorType =
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
descriptor_set_layout_binding[index].descriptorCount =
|
|
kitty->attatchments.items[index].ubo_array.count;
|
|
descriptor_set_layout_binding[index].stageFlags = VK_SHADER_STAGE_ALL;
|
|
descriptor_set_layout_binding[index].pImmutableSamplers = NULL;
|
|
break;
|
|
case CAT_ATTATCH_IMAGE:
|
|
descriptor_set_layout_binding[index].binding = index;
|
|
descriptor_set_layout_binding[index].descriptorType =
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
descriptor_set_layout_binding[index].descriptorCount = 1;
|
|
descriptor_set_layout_binding[index].stageFlags = VK_SHADER_STAGE_ALL;
|
|
descriptor_set_layout_binding[index].pImmutableSamplers = NULL;
|
|
break;
|
|
}
|
|
}
|
|
VkDescriptorSetLayoutCreateInfo layout_info = {0};
|
|
layout_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
|
layout_info.bindingCount = kitty->attatchments.count;
|
|
layout_info.pBindings = descriptor_set_layout_binding;
|
|
CHECK_VK_RESULT(vkCreateDescriptorSetLayout(state->device, &layout_info, NULL,
|
|
&kitty->descriptor_set_layout));
|
|
}
|
|
|
|
void kitty_create_pipeline(struct Kitty *kitty, struct Vk *state) {
|
|
int vert_size, frag_size;
|
|
uint32_t *vert_shader =
|
|
read_binary_file((char *)kitty->vertex_path, &vert_size);
|
|
uint32_t *frag_shader =
|
|
read_binary_file((char *)kitty->fragment_path, &frag_size);
|
|
|
|
VkShaderModule vert_module =
|
|
create_shader_module(state, vert_shader, vert_size);
|
|
VkShaderModule frag_module =
|
|
create_shader_module(state, frag_shader, frag_size);
|
|
|
|
VkPipelineShaderStageCreateInfo vert_stage_info = {0};
|
|
vert_stage_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
|
vert_stage_info.stage = VK_SHADER_STAGE_VERTEX_BIT;
|
|
vert_stage_info.module = vert_module;
|
|
vert_stage_info.pName = "main";
|
|
|
|
VkPipelineShaderStageCreateInfo frag_stage_info = {0};
|
|
frag_stage_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
|
frag_stage_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
frag_stage_info.module = frag_module;
|
|
frag_stage_info.pName = "main";
|
|
|
|
VkPipelineShaderStageCreateInfo shader_stage_info[] = {vert_stage_info,
|
|
frag_stage_info};
|
|
|
|
VkPipelineVertexInputStateCreateInfo vertex_input_info = {0};
|
|
if (kitty->instance_buffer.count == 0) {
|
|
meow("single instance kitty");
|
|
VkVertexInputBindingDescription vertex_binding_description = {0};
|
|
vertex_binding_description.binding = 0;
|
|
vertex_binding_description.stride = kitty->vertex_buffer.vertex_size;
|
|
vertex_binding_description.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
|
|
|
VkVertexInputAttributeDescription *vertex_attribute_descriptions =
|
|
alloca(sizeof(VkVertexInputAttributeDescription) *
|
|
kitty->vertex_buffer.format.count);
|
|
int offset = 0;
|
|
for (int i = 0; i < kitty->vertex_buffer.format.count; i++) {
|
|
vertex_attribute_descriptions[i].binding = 0;
|
|
vertex_attribute_descriptions[i].location = i;
|
|
vertex_attribute_descriptions[i].format =
|
|
kitty->vertex_buffer.format.items[i];
|
|
vertex_attribute_descriptions[i].offset = offset;
|
|
offset += get_size_of_format(kitty->vertex_buffer.format.items[i]);
|
|
}
|
|
|
|
vertex_input_info.sType =
|
|
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
|
vertex_input_info.vertexBindingDescriptionCount = 1;
|
|
vertex_input_info.pVertexBindingDescriptions = &vertex_binding_description;
|
|
vertex_input_info.vertexAttributeDescriptionCount =
|
|
kitty->vertex_buffer.format.count;
|
|
vertex_input_info.pVertexAttributeDescriptions =
|
|
vertex_attribute_descriptions;
|
|
} else {
|
|
meow("multi instance kitty");
|
|
VkVertexInputBindingDescription binding_descriptions[2] = {0};
|
|
binding_descriptions[0].binding = 0;
|
|
binding_descriptions[0].stride = kitty->vertex_buffer.vertex_size;
|
|
binding_descriptions[0].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
|
binding_descriptions[1].binding = 1;
|
|
binding_descriptions[1].stride = kitty->instance_buffer.element_size;
|
|
binding_descriptions[1].inputRate = VK_VERTEX_INPUT_RATE_INSTANCE;
|
|
|
|
VkVertexInputAttributeDescription *attribute_descriptions =
|
|
alloca(sizeof(VkVertexInputAttributeDescription) *
|
|
kitty->vertex_buffer.format.count +
|
|
sizeof(VkVertexInputAttributeDescription) *
|
|
kitty->instance_buffer.format.count);
|
|
int offset = 0;
|
|
for (int i = 0; i < kitty->vertex_buffer.format.count; i++) {
|
|
attribute_descriptions[i].binding = 0;
|
|
attribute_descriptions[i].location = i;
|
|
attribute_descriptions[i].format = kitty->vertex_buffer.format.items[i];
|
|
attribute_descriptions[i].offset = offset;
|
|
offset += get_size_of_format(kitty->vertex_buffer.format.items[i]);
|
|
}
|
|
offset = 0;
|
|
for (int i = 0; i < kitty->instance_buffer.format.count; i++) {
|
|
attribute_descriptions[i + kitty->vertex_buffer.format.count].binding = 1;
|
|
attribute_descriptions[i + kitty->vertex_buffer.format.count].location =
|
|
i + kitty->vertex_buffer.format.count;
|
|
attribute_descriptions[i + kitty->vertex_buffer.format.count].format =
|
|
kitty->instance_buffer.format.items[i];
|
|
attribute_descriptions[i + kitty->vertex_buffer.format.count].offset =
|
|
offset;
|
|
offset += get_size_of_format(kitty->instance_buffer.format.items[i]);
|
|
}
|
|
|
|
vertex_input_info.sType =
|
|
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
|
vertex_input_info.vertexBindingDescriptionCount = 2;
|
|
vertex_input_info.pVertexBindingDescriptions = binding_descriptions;
|
|
vertex_input_info.vertexAttributeDescriptionCount =
|
|
kitty->vertex_buffer.format.count + kitty->instance_buffer.format.count;
|
|
vertex_input_info.pVertexAttributeDescriptions = attribute_descriptions;
|
|
}
|
|
|
|
VkPipelineInputAssemblyStateCreateInfo input_assembly_info = {0};
|
|
input_assembly_info.sType =
|
|
VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
|
input_assembly_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
|
input_assembly_info.primitiveRestartEnable = VK_FALSE;
|
|
|
|
VkPipelineViewportStateCreateInfo viewport_state_info = {0};
|
|
viewport_state_info.sType =
|
|
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
|
|
viewport_state_info.viewportCount = 1;
|
|
viewport_state_info.scissorCount = 1;
|
|
|
|
VkPipelineRasterizationStateCreateInfo rasterizer_info = {0};
|
|
rasterizer_info.sType =
|
|
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
|
|
rasterizer_info.depthClampEnable = VK_FALSE;
|
|
rasterizer_info.rasterizerDiscardEnable = VK_FALSE;
|
|
rasterizer_info.polygonMode = VK_POLYGON_MODE_FILL;
|
|
rasterizer_info.lineWidth = 1.0f;
|
|
rasterizer_info.cullMode = VK_CULL_MODE_BACK_BIT;
|
|
rasterizer_info.frontFace = VK_FRONT_FACE_CLOCKWISE;
|
|
rasterizer_info.depthBiasEnable = VK_FALSE;
|
|
|
|
VkPipelineMultisampleStateCreateInfo multisampling_info = {0};
|
|
multisampling_info.sType =
|
|
VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
|
multisampling_info.sampleShadingEnable = VK_FALSE;
|
|
multisampling_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
|
|
|
|
VkPipelineColorBlendAttachmentState color_blend_attachment = {0};
|
|
color_blend_attachment.colorWriteMask =
|
|
VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
|
|
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
|
color_blend_attachment.blendEnable = VK_TRUE;
|
|
color_blend_attachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
|
color_blend_attachment.dstColorBlendFactor =
|
|
VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
color_blend_attachment.colorBlendOp = VK_BLEND_OP_ADD;
|
|
color_blend_attachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
|
|
color_blend_attachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
|
|
color_blend_attachment.alphaBlendOp = VK_BLEND_OP_ADD;
|
|
|
|
VkPipelineColorBlendStateCreateInfo color_blend_info = {0};
|
|
color_blend_info.sType =
|
|
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
|
color_blend_info.logicOpEnable = VK_FALSE;
|
|
color_blend_info.logicOp = VK_LOGIC_OP_COPY;
|
|
color_blend_info.attachmentCount = 1;
|
|
color_blend_info.pAttachments = &color_blend_attachment;
|
|
|
|
/* VkPushConstantRange push_constant_range = {0}; */
|
|
/* push_constant_range.offset = 0; */
|
|
/* push_constant_range.size = kitty->push_constant_size; */
|
|
/* push_constant_range.stageFlags = VK_SHADER_STAGE_ALL; */
|
|
|
|
VkPipelineLayoutCreateInfo pipeline_layout_info = {0};
|
|
pipeline_layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
|
pipeline_layout_info.setLayoutCount = 1;
|
|
pipeline_layout_info.pSetLayouts = &kitty->descriptor_set_layout;
|
|
pipeline_layout_info.pushConstantRangeCount = 0; // TODO
|
|
pipeline_layout_info.pPushConstantRanges = NULL;
|
|
CHECK_VK_RESULT(vkCreatePipelineLayout(state->device, &pipeline_layout_info,
|
|
NULL, &kitty->pipeline_layout));
|
|
|
|
VkDynamicState dynamic_states[] = {VK_DYNAMIC_STATE_VIEWPORT,
|
|
VK_DYNAMIC_STATE_SCISSOR};
|
|
|
|
VkPipelineDynamicStateCreateInfo dynamic_state_info = {0};
|
|
dynamic_state_info.sType =
|
|
VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
|
dynamic_state_info.pDynamicStates = dynamic_states;
|
|
dynamic_state_info.dynamicStateCount =
|
|
sizeof(dynamic_states) / sizeof(dynamic_states[0]);
|
|
|
|
VkGraphicsPipelineCreateInfo pipeline_info = {0};
|
|
pipeline_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
|
|
pipeline_info.stageCount = 2;
|
|
pipeline_info.pStages = shader_stage_info;
|
|
pipeline_info.pVertexInputState = &vertex_input_info;
|
|
pipeline_info.pInputAssemblyState = &input_assembly_info;
|
|
pipeline_info.pViewportState = &viewport_state_info;
|
|
pipeline_info.pRasterizationState = &rasterizer_info;
|
|
pipeline_info.pMultisampleState = &multisampling_info;
|
|
pipeline_info.pDepthStencilState = NULL;
|
|
pipeline_info.pColorBlendState = &color_blend_info;
|
|
pipeline_info.pDynamicState = &dynamic_state_info;
|
|
pipeline_info.layout = kitty->pipeline_layout;
|
|
pipeline_info.renderPass = state->render_pass;
|
|
pipeline_info.subpass = 0;
|
|
pipeline_info.basePipelineHandle = NULL;
|
|
pipeline_info.basePipelineIndex = -1;
|
|
|
|
CHECK_VK_RESULT(vkCreateGraphicsPipelines(
|
|
state->device, NULL, 1, &pipeline_info, NULL, &kitty->pipeline));
|
|
|
|
vkDestroyShaderModule(state->device, vert_module, NULL);
|
|
vkDestroyShaderModule(state->device, frag_module, NULL);
|
|
|
|
free(vert_shader);
|
|
free(frag_shader);
|
|
}
|
|
|
|
void kitty_create_descriptor_pool(struct Kitty *kitty, struct Vk *state) {
|
|
int ubo_count = 0;
|
|
int image_count = 0;
|
|
for (int i = 0; i < kitty->attatchments.count; i++) {
|
|
switch (kitty->attatchments.items[i].type) {
|
|
case CAT_ATTATCH_UBO:
|
|
case CAT_ATTATCH_UBO_ARRAY:
|
|
ubo_count++;
|
|
break;
|
|
case CAT_ATTATCH_IMAGE:
|
|
image_count++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
VkDescriptorPoolSize pool_sizes[2] = {0};
|
|
pool_sizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
pool_sizes[0].descriptorCount = MAX_FRAMES_IN_FLIGHT;
|
|
pool_sizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
pool_sizes[1].descriptorCount = MAX_FRAMES_IN_FLIGHT;
|
|
|
|
VkDescriptorPoolCreateInfo pool_info = {0};
|
|
pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
|
|
pool_info.poolSizeCount = 2;
|
|
pool_info.pPoolSizes = pool_sizes;
|
|
pool_info.maxSets = 10;
|
|
|
|
CHECK_VK_RESULT(vkCreateDescriptorPool(state->device, &pool_info, NULL,
|
|
&kitty->descriptor_pool));
|
|
}
|
|
|
|
void kitty_create_image_attatchments(struct Kitty *kitty, struct Vk *state) {
|
|
for (int index = 0; index < kitty->attatchments.count; index++) {
|
|
if (kitty->attatchments.items[index].type != CAT_ATTATCH_IMAGE) {
|
|
continue;
|
|
}
|
|
struct KittyAttatchment *atch = &kitty->attatchments.items[index];
|
|
atch->image.pixels = load_image(atch->image.path, &atch->image.dims);
|
|
atch->image.size = atch->image.dims.x * atch->image.dims.y * 4;
|
|
|
|
VkBuffer staging_buffer;
|
|
struct GpuPointer staging_buffer_memory;
|
|
create_buffer(state, atch->image.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
|
|
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
&staging_buffer, &staging_buffer_memory);
|
|
|
|
memcpy(staging_buffer_memory.mapped, atch->image.pixels, atch->image.size);
|
|
|
|
create_image(state, atch->image.dims, VK_FORMAT_R8G8B8A8_SRGB,
|
|
VK_IMAGE_TILING_OPTIMAL,
|
|
VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
|
|
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &atch->image.image,
|
|
&atch->image.memory);
|
|
|
|
transition_image_layout(state, atch->image.image, VK_FORMAT_R8G8B8A8_SRGB,
|
|
VK_IMAGE_LAYOUT_UNDEFINED,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
|
copy_buffer_to_image(state, staging_buffer, atch->image.image,
|
|
atch->image.dims);
|
|
transition_image_layout(state, atch->image.image, VK_FORMAT_R8G8B8A8_SRGB,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
|
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
|
|
|
|
vkDestroyBuffer(state->device, staging_buffer, NULL);
|
|
gpu_mem_free(state, state->mem, staging_buffer_memory);
|
|
|
|
VkImageViewCreateInfo view_info = {0};
|
|
view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
view_info.image = atch->image.image;
|
|
view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
view_info.format = VK_FORMAT_R8G8B8A8_SRGB;
|
|
view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
view_info.subresourceRange.baseMipLevel = 0;
|
|
view_info.subresourceRange.levelCount = 1;
|
|
view_info.subresourceRange.baseArrayLayer = 0;
|
|
view_info.subresourceRange.layerCount = 1;
|
|
CHECK_VK_RESULT(
|
|
vkCreateImageView(state->device, &view_info, NULL, &atch->image.view));
|
|
|
|
VkSamplerCreateInfo sampler_info = {0};
|
|
sampler_info.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
|
sampler_info.magFilter = VK_FILTER_NEAREST;
|
|
sampler_info.minFilter = VK_FILTER_NEAREST;
|
|
sampler_info.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
sampler_info.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
sampler_info.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
sampler_info.anisotropyEnable = VK_FALSE;
|
|
sampler_info.maxAnisotropy = 1.0f;
|
|
sampler_info.borderColor = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
|
|
sampler_info.unnormalizedCoordinates = VK_FALSE;
|
|
sampler_info.compareEnable = VK_FALSE;
|
|
sampler_info.compareOp = VK_COMPARE_OP_ALWAYS;
|
|
sampler_info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
|
|
sampler_info.mipLodBias = 0.0f;
|
|
sampler_info.minLod = 0.0;
|
|
sampler_info.maxLod = 0.0;
|
|
CHECK_VK_RESULT(vkCreateSampler(state->device, &sampler_info, NULL,
|
|
&atch->image.sampler));
|
|
free(atch->image.pixels);
|
|
}
|
|
}
|
|
|
|
void kitty_create_ubo_attatchments(struct Kitty *kitty, struct Vk *state) {
|
|
for (int index = 0; index < kitty->attatchments.count; index++) {
|
|
if (kitty->attatchments.items[index].type != CAT_ATTATCH_UBO) {
|
|
continue;
|
|
}
|
|
for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
|
create_buffer(state, kitty->attatchments.items[index].ubo.size,
|
|
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
|
|
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
&kitty->attatchments.items[index].ubo.buffer[i],
|
|
&kitty->attatchments.items[index].ubo.memory[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void kitty_create_ubo_array_attatchments(struct Kitty *kitty,
|
|
struct Vk *state) {
|
|
for (int index = 0; index < kitty->attatchments.count; index++) {
|
|
if (kitty->attatchments.items[index].type != CAT_ATTATCH_UBO_ARRAY) {
|
|
continue;
|
|
}
|
|
for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
|
create_buffer(state,
|
|
kitty->attatchments.items[index].ubo_array.size *
|
|
kitty->attatchments.items[index].ubo_array.count,
|
|
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
|
|
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
&kitty->attatchments.items[index].ubo_array.buffer[i],
|
|
&kitty->attatchments.items[index].ubo_array.memory[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void kitty_create_descriptor_sets(struct Kitty *kitty, struct Vk *state) {
|
|
VkDescriptorSetLayout set_layouts[MAX_FRAMES_IN_FLIGHT];
|
|
for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
|
set_layouts[i] = kitty->descriptor_set_layout;
|
|
}
|
|
|
|
VkDescriptorSetAllocateInfo alloc_info = {0};
|
|
alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
|
|
alloc_info.descriptorPool = kitty->descriptor_pool;
|
|
alloc_info.descriptorSetCount = MAX_FRAMES_IN_FLIGHT;
|
|
alloc_info.pSetLayouts = set_layouts;
|
|
CHECK_VK_RESULT(vkAllocateDescriptorSets(state->device, &alloc_info,
|
|
kitty->descriptor_sets));
|
|
|
|
for (int index = 0; index < kitty->attatchments.count; index++) {
|
|
for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
|
|
switch (kitty->attatchments.items[index].type) {
|
|
case CAT_ATTATCH_UBO:;
|
|
VkDescriptorBufferInfo buffer_info = {0};
|
|
buffer_info.buffer = kitty->attatchments.items[index].ubo.buffer[i];
|
|
buffer_info.offset = 0;
|
|
buffer_info.range = kitty->attatchments.items[index].ubo.size;
|
|
|
|
VkWriteDescriptorSet write_buffer = {0};
|
|
write_buffer.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
|
write_buffer.dstSet = kitty->descriptor_sets[i];
|
|
write_buffer.dstBinding = index;
|
|
write_buffer.dstArrayElement = 0;
|
|
write_buffer.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
write_buffer.descriptorCount = 1;
|
|
write_buffer.pBufferInfo = &buffer_info;
|
|
vkUpdateDescriptorSets(state->device, 1, &write_buffer, 0, NULL);
|
|
break;
|
|
case CAT_ATTATCH_UBO_ARRAY:;
|
|
for (int j = 0; j < kitty->attatchments.items[index].ubo_array.count;
|
|
j++) {
|
|
VkDescriptorBufferInfo array_buffer_info = {0};
|
|
array_buffer_info.buffer =
|
|
kitty->attatchments.items[index].ubo_array.buffer[i];
|
|
array_buffer_info.offset = 0;
|
|
array_buffer_info.range =
|
|
kitty->attatchments.items[index].ubo_array.size *
|
|
kitty->attatchments.items[index].ubo_array.count;
|
|
|
|
VkWriteDescriptorSet write_array_buffer = {0};
|
|
write_array_buffer.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
|
write_array_buffer.dstSet = kitty->descriptor_sets[i];
|
|
write_array_buffer.dstBinding = index;
|
|
write_array_buffer.dstArrayElement = j;
|
|
write_array_buffer.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
write_array_buffer.descriptorCount = 1;
|
|
write_array_buffer.pBufferInfo = &array_buffer_info;
|
|
vkUpdateDescriptorSets(state->device, 1, &write_array_buffer, 0,
|
|
NULL);
|
|
}
|
|
break;
|
|
case CAT_ATTATCH_IMAGE:;
|
|
VkDescriptorImageInfo image_info = {0};
|
|
image_info.imageLayout = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL;
|
|
image_info.imageView = kitty->attatchments.items[index].image.view;
|
|
image_info.sampler = kitty->attatchments.items[index].image.sampler;
|
|
|
|
VkWriteDescriptorSet write_image = {0};
|
|
write_image.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
|
write_image.dstSet = kitty->descriptor_sets[i];
|
|
write_image.dstBinding = index;
|
|
write_image.dstArrayElement = 0;
|
|
write_image.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
write_image.descriptorCount = 1;
|
|
write_image.pImageInfo = &image_info;
|
|
vkUpdateDescriptorSets(state->device, 1, &write_image, 0, NULL);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void kitty_create_vertex_buffer(struct Kitty *kitty, struct Vk *state) {
|
|
VkDeviceSize size =
|
|
kitty->vertex_buffer.count * kitty->vertex_buffer.vertex_size;
|
|
VkBuffer staging_buffer;
|
|
struct GpuPointer staging_buffer_memory;
|
|
|
|
create_buffer(state, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
|
|
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
&staging_buffer, &staging_buffer_memory);
|
|
|
|
memcpy(staging_buffer_memory.mapped, kitty->vertex_buffer.data, size);
|
|
|
|
create_buffer(state, size,
|
|
VK_BUFFER_USAGE_TRANSFER_DST_BIT |
|
|
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
|
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
|
|
&kitty->vertex_buffer.buffer, &kitty->vertex_buffer.memory);
|
|
|
|
copy_buffer(state, staging_buffer, kitty->vertex_buffer.buffer, size);
|
|
|
|
vkDestroyBuffer(state->device, staging_buffer, NULL);
|
|
gpu_mem_free(state, state->mem, staging_buffer_memory);
|
|
kitty->vertex_buffer.data = NULL;
|
|
}
|
|
|
|
void kitty_create_instance_buffer(struct Kitty *kitty, struct Vk *state) {
|
|
if (kitty->instance_buffer.count == 0) {
|
|
crash("trying to create an instance buffer for a kitty that is not "
|
|
"instanced :o");
|
|
}
|
|
VkDeviceSize size =
|
|
kitty->instance_buffer.count * kitty->instance_buffer.element_size;
|
|
VkBuffer staging_buffer;
|
|
struct GpuPointer staging_buffer_memory;
|
|
|
|
create_buffer(state, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
|
|
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
&staging_buffer, &staging_buffer_memory);
|
|
|
|
memcpy(staging_buffer_memory.mapped, kitty->instance_buffer.data, size);
|
|
|
|
create_buffer(state, size,
|
|
VK_BUFFER_USAGE_TRANSFER_DST_BIT |
|
|
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
|
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
|
|
&kitty->instance_buffer.buffer, &kitty->instance_buffer.memory);
|
|
|
|
copy_buffer(state, staging_buffer, kitty->instance_buffer.buffer, size);
|
|
|
|
vkDestroyBuffer(state->device, staging_buffer, NULL);
|
|
gpu_mem_free(state, state->mem, staging_buffer_memory);
|
|
kitty->instance_buffer.data = NULL;
|
|
}
|