evk/evk/evkTypes.h

#pragma once

#include "evkCommon.h"
#include "shaderc/shaderc.h"

TYPEDATA_GEN(VkInstance, INVALID(VK_NULL_HANDLE));
TYPEDATA_GEN(VkDevice, INVALID(VK_NULL_HANDLE));
TYPEDATA_GEN(VkPhysicalDevice);
TYPEDATA_GEN(VkDeviceQueueCreateInfo);
TYPEDATA_GEN(VkQueueFamilyProperties);
TYPEDATA_GEN(VkImage);
TYPEDATA_GEN(VkCommandBufferBeginInfo);
TYPEDATA_GEN(VkCommandBuffer);
TYPEDATA_GEN(VkDynamicState);
TYPEDATA_GEN(VkSurfaceFormatKHR);
TYPEDATA_GEN(VkFormat);
TYPEDATA_GEN(VkClearValue, DEFAULT({{0.f,0.f,0.f,1.f}}));
TYPEDATA_GEN(VkRenderingAttachmentInfoKHR,
    DEFAULT(
      .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,
      .imageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, // Requires VK_KHR_synchronization2
      .loadOp = VK_ATTACHMENT_LOAD_OP_NONE_KHR,
      .storeOp = VK_ATTACHMENT_STORE_OP_NONE,
      .clearValue = (VkClearValue){{{0.f, 0.f, 0.f, 1.f}}},
    )
);
TYPEDATA_GEN(VkViewport, 
  DEFAULT(
    .x = 0,
    .y = 0,
    .maxDepth = 1.0f,
    .minDepth = 0.f,
    .width = 0,
    .height = 0
  )
)

TYPEDATA_GEN(VkRect2D, 
  DEFAULT(0)
)

TYPEDATA_GEN(VkRenderingInfo, 
  DEFAULT(
    .sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
    .flags = 0,
    .renderArea = {{0, 0}, {0, 0}},
    .layerCount = 1,
    .viewMask = 0,
    .colorAttachmentCount = 0,
    .pColorAttachments = VK_NULL_HANDLE,
    .pDepthAttachment = VK_NULL_HANDLE,
    .pStencilAttachment = VK_NULL_HANDLE,
  )
)

TYPEDATA_GEN(VkPipelineInputAssemblyStateCreateInfo,
    DEFAULT(
      .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
      .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
      .primitiveRestartEnable = VK_FALSE,
    )
);

TYPEDATA_GEN(VkPipelineRasterizationStateCreateInfo,
  DEFAULT(
    .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
    .depthClampEnable = VK_FALSE,
    .rasterizerDiscardEnable = VK_FALSE,
    .polygonMode = VK_POLYGON_MODE_FILL,
    .lineWidth = 1.0f,
    .cullMode = VK_CULL_MODE_BACK_BIT,
    .frontFace = VK_FRONT_FACE_CLOCKWISE,
    .depthBiasEnable = VK_FALSE,
  )
);

TYPEDATA_GEN(VkPipelineColorBlendAttachmentState,
  DEFAULT(
    .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
    .blendEnable = VK_FALSE,
  )
);

TYPEDATA_GEN(VkPipelineMultisampleStateCreateInfo,
  DEFAULT(
    .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
    .sampleShadingEnable = VK_FALSE,
    .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
  )
);

TYPEDATA_GEN(VkPipelineShaderStageCreateInfo);

TYPEDATA_GEN(VkDescriptorSetLayout);
TYPEDATA_GEN(VkDescriptorSetLayoutBinding);
TYPEDATA_GEN(VkDescriptorSetLayoutCreateInfo,
  DEFAULT(
    .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
  )
);

TYPEDATA_GEN(VkVertexInputBindingDescription);
TYPEDATA_GEN(VkVertexInputAttributeDescription);

// ========================================================================================================= //
// =================================evk Types=============================================================== //
// ========================================================================================================= //

typedef u32 evkApiVersion;

typedef struct {
  VkInstance vk;
  evkApiVersion apiVersion;
} evkInstance;

typedef struct {
	VkQueueFlags flags;
	u32 count;
} evkDeviceQueueRequirement;

typedef struct {
    VkPhysicalDeviceFeatures         features10;
    VkPhysicalDeviceVulkan11Features features11;
    VkPhysicalDeviceVulkan12Features features12;
    VkPhysicalDeviceVulkan13Features features13;
} evkPhysicalDeviceFeatures;

typedef struct {
  evkInstance instance;
	VkPhysicalDeviceType physicalDeviceType;
	ev_vec(evkDeviceQueueRequirement) queueRequirements;
  ev_vec(evstring) deviceExtensions;
  evkPhysicalDeviceFeatures enabledFeatures;
} evkDeviceCreateInfo;

typedef struct {
	i32 familyIndex;
	u32 allocatedQueueCount;
} evkDeviceQueueFamily;

typedef struct {
  VkPhysicalDeviceLimits limits;
  VkPhysicalDeviceDescriptorBufferPropertiesEXT desc_buf;
} evkDeviceProperties;

#define MAX_QUEUE_FAMILIES ((VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT | VK_QUEUE_SPARSE_BINDING_BIT) + 1)
typedef struct {
	VkDevice vk;
  VkPhysicalDevice _physicalDevice;
  evkInstance _instance;
	evkDeviceQueueFamily queueFamilies[MAX_QUEUE_FAMILIES];
  evkDeviceProperties props;
  evkPhysicalDeviceFeatures enabledFeatures;
} evkDevice;

typedef struct {
  VkCommandPool vk;
  evkDeviceQueueFamily queueFamily;
} evkCommandPool;

typedef struct {
  evkDevice device;
  VkCommandPoolCreateFlags poolFlags;
	VkQueueFlags queueFlags;
} evkCommandPoolCreateInfo;

typedef u32 evkAPIVersion;

typedef struct {
  evkAPIVersion apiVersion;
  u32 applicationVersion;
  u32 engineVersion;
  evstring applicationName;
  evstring engineName;
} evkApplicationInfo;

typedef struct {
  evkApplicationInfo applicationInfo;
  ev_vec(evstring) extensions;
  ev_vec(evstring) layers;
} evkInstanceCreateInfo;

typedef struct {
  VkPipelineLayout vk;
} evkPipelineLayout;

typedef struct {
  VkOffset2D renderOffset;
  VkExtent2D renderExtents;
  u32 layerCount;
  u32 viewMask;
  VkRenderingFlags renderingFlags;

  vec(VkRenderingAttachmentInfoKHR) colorAttachments;
  VkRenderingAttachmentInfoKHR depthAttachment;
  VkRenderingAttachmentInfoKHR stencilAttachment;
} evkRenderingInfo;

typedef union {
  struct {
    VkViewport;
    VkRect2D scissor;
  };
  struct {
    VkViewport vkViewport;
    VkRect2D vkScissor;
  };
} evkViewport;

// typedef union {
//   VkDescriptorSetLayoutBinding vk;
//   struct {
//     VkDescriptorSetLayoutBinding;
//     u32 set;
//   };
// } evkDescriptorBinding;
// typedef VkDescriptorSetLayoutBinding evkDescriptorBinding;

typedef struct {
  evstring name;
  VkDescriptorType descriptorType;
  VkShaderStageFlags stageFlags;
  uint32_t descriptorCount;
  const VkSampler* pImmutableSamplers;
  uint32_t binding;
} evkDescriptorBinding;

// typedef struct {
//   VkDescriptorSetLayout vk;
//   vec(evkDescriptorBinding) bindings;
// } evkDescriptorSetLayout;
// typedef VkDescriptorSetLayout evkDescriptorSetLayout;

typedef struct {
  VkShaderStageFlags stage;
  vec(evkDescriptorBinding) bindings;
} evkShaderReflectionData;

typedef struct {
  VkShaderModule vk;
  evkShaderReflectionData reflect;
} evkShader;

typedef struct {
  shaderc_compiler_t sc;
  shaderc_compile_options_t scopt;
} evkShaderCompiler;

typedef struct {
  u32 dummy;
} evkAllocationUserData;

typedef struct {
  VmaAllocator vma;
} evkGPUAllocator;

typedef struct {
  VmaAllocation vma;
} evkGPUAllocation;

typedef struct {
  VmaAllocationInfo vma;
} evkGPUAllocationInfo;

typedef struct {
  evkGPUAllocator allocator;
  evkGPUAllocation allocation;
  evkGPUAllocationInfo allocationInfo;
} evkGPUAllocationData;

typedef enum {
  EVK_GPU_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT,
  EVK_GPU_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT,
  EVK_GPU_ALLOCATION_CREATE_MAPPED_BIT = VMA_ALLOCATION_CREATE_MAPPED_BIT,
  EVK_GPU_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT,
  EVK_GPU_ALLOCATION_CREATE_DONT_BIND_BIT = VMA_ALLOCATION_CREATE_DONT_BIND_BIT,
  EVK_GPU_ALLOCATION_CREATE_WITHIN_BUDGET_BIT = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT,
  EVK_GPU_ALLOCATION_CREATE_CAN_ALIAS_BIT = VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT,
  EVK_GPU_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
  EVK_GPU_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT,
  EVK_GPU_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT,
  EVK_GPU_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT = VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
} evkGPUAllocationFlags;

typedef enum evkGPUMemoryUsage
{
  EVK_GPU_MEMORY_USAGE_UNKNOWN              = VMA_MEMORY_USAGE_UNKNOWN,
  EVK_GPU_MEMORY_USAGE_GPU_LAZILY_ALLOCATED = VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED,
  EVK_GPU_MEMORY_USAGE_CPU_TO_GPU           = VMA_MEMORY_USAGE_CPU_TO_GPU,
  EVK_GPU_MEMORY_USAGE_AUTO                 = VMA_MEMORY_USAGE_AUTO,
  EVK_GPU_MEMORY_USAGE_AUTO_PREFER_DEVICE   = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE,
  EVK_GPU_MEMORY_USAGE_AUTO_PREFER_HOST     = VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
  EVK_GPU_MEMORY_USAGE_MAX_ENUM             = VMA_MEMORY_USAGE_MAX_ENUM
} evkGPUMemoryUsage;

typedef struct {
  VmaPool vma;
} evkGPUMemoryPool;

typedef struct {
  evkGPUAllocationFlags allocationFlags;
  evkGPUAllocator allocator;
  evkGPUMemoryPool pool;
} evkGPUAllocationCreateInfo;

typedef struct {
  VkImage vk;
  u32 width;
  u32 height;
  VkFormat format;
  evkGPUAllocationData allocData;
} evkImage;

typedef struct {
  VkImageAspectFlags viewAspect;
  u32 mipBase;
  u32 mipCount;
  u32 baseLayer;
  u32 layerCount;
} evkImageViewCreateInfo;

typedef struct {
  VkImageView vk;
} evkImageView;

typedef struct {
  evkGPUAllocationCreateInfo allocationCreateInfo;
  VkBufferCreateFlags    flags;
  VkDeviceSize           sizeInBytes;
  VkBufferUsageFlags     usage;
  bool exclusive;
  vec(u32)               queueFamilyIndices;
} evkBufferCreateInfo;

typedef struct {
  VkBuffer vk;
  evkGPUAllocationData allocData;
  u32 sizeInBytes;
  VkBufferUsageFlags usage;
  VkDeviceAddress address;
} evkBuffer;

typedef struct {
  evkGPUAllocationCreateInfo allocationCreateInfo;
  VkImageCreateFlags flags;
  VkImageType type;
  VkFormat format;
  VkExtent3D extent;
  u32 mipCount;
  u32 layerCount;
  u32 sampleCount;
  VkImageTiling tiling;
  VkImageUsageFlags usage;
  bool exclusive;
  vec(u32) queueFamilyIndices;
  VkImageLayout layout;
} evkImageCreateInfo;

typedef struct {
  VkSurfaceFormatKHR surfaceFormat;
  VkSurfaceKHR surface;
  VkSwapchainKHR vk;
  vec(evkImage) images;
  vec(evkImageView) imageViews;
} evkSwapChain;

typedef struct {
  evkDevice device;
  VkSurfaceKHR surface;
  u32 width;
  u32 height;
  u32 imageCount;
  // Add more stuff when needed
} evkSwapChainCreateInfo;

typedef struct {
  VkFormat format;
  VkPipelineColorBlendAttachmentState blendState;
} evkColorAttachment;

typedef enum {
  EVK_VERTEX_ATTRIBUTE_INVALID = 0,
  EVK_VERTEX_ATTRIBUTE_POSITION,
  EVK_VERTEX_ATTRIBUTE_NORMAL,
  EVK_VERTEX_ATTRIBUTE_TANGENT,
  EVK_VERTEX_ATTRIBUTE_COLOR,
  EVK_VERTEX_ATTRIBUTE_UV0,
  EVK_VERTEX_ATTRIBUTE_UV1,
  EVK_VERTEX_ATTRIBUTE_UV2,
  EVK_VERTEX_ATTRIBUTE_UV3,
  EVK_VERTEX_ATTRIBUTE_UV4,
  EVK_VERTEX_ATTRIBUTE_UV5,
  EVK_VERTEX_ATTRIBUTE_UV6,
  EVK_VERTEX_ATTRIBUTE_UV7,
  EVK_VERTEX_ATTRIBUTE_BLENDWEIGHT,
  EVK_VERTEX_ATTRIBUTE_BLENDINDICES,

  EVK_VERTEX_ATTRIBUTE_TYPE_COUNT
} evkVertexAttributeType;

typedef enum {
  EVK_FMT_INVALID = 0,
  EVK_FMT_FLOAT32,
  EVK_FMT_UINT32,
  EVK_FMT_SINT32,
  EVK_FMT_FLOAT16,
  EVK_FMT_UNORM16,
  EVK_FMT_SNORM16,
  EVK_FMT_UINT16,
  EVK_FMT_SINT16,
  EVK_FMT_UNORM8,
  EVK_FMT_SNORM8,
  EVK_FMT_UINT8,
  EVK_FMT_SINT8,

  EVK_VERTEX_ATTRIBUTE_FORMAT_COUNT
} evkVertexAttributeFormat;

typedef struct {
  evkVertexAttributeType type;
  evkVertexAttributeFormat fmt;
  u32 dim;
} evkVertexAttribute;

typedef struct {
  evkVertexAttribute attributes[EVK_VERTEX_ATTRIBUTE_TYPE_COUNT];
  VkVertexInputRate inputRate;
} evkVertexBufferLayout;
// typedef evkVertexAttribute evkVertexBufferLayout[EVK_VERTEX_ATTRIBUTE_TYPE_COUNT];

typedef struct {
  VkDescriptorSetLayout vk;
  vec(evstring) names;
  vec(VkDescriptorSetLayoutBinding) vkBindings;
  u64 size;
  u64 offset;
} evkDescriptorSetLayout;

typedef struct {
  evkDevice* device;
  evkGPUAllocator* allocator;
  evkDescriptorSetLayout* layout;
} evkDescriptorSetCreateInfo;

typedef struct {
  evkDevice* device;
  evkDescriptorSetLayout layout;
  evkBuffer buffer;
} evkDescriptorSet;

typedef enum {
  EVK_PIPELINE_TYPE_GRAPHICS = VK_PIPELINE_BIND_POINT_GRAPHICS,
  EVK_PIPELINE_TYPE_COMPUTE = VK_PIPELINE_BIND_POINT_COMPUTE,
} evkPipelineType;

typedef struct {
  vec(evkDescriptorSetLayout) setLayouts;
  vec(VkPushConstantRange) pushConstantRanges;
} evkPipelineLayoutCreateInfo;

typedef struct {
  evkPipelineType type;
  vec(VkDynamicState) dynamicStates;
  vec(evkShader) shaderStages;

  vec(evkColorAttachment) colorAttachments;
  VkFormat depthAttachmentFormat;
  VkFormat stencilAttachmentFormat;
  u32 viewMask;

  VkLogicOp blendingOp;
  f32 blendConstants[4];

  u32 viewportCountOverride;
  vec(evkViewport) viewports;

  vec(evkVertexBufferLayout) vertexBufferLayouts;
  vec(evkDescriptorSetLayout) setLayouts;
} evkPipelineCreateInfo;

typedef struct {
  VkPipeline vk;
  evkPipelineLayout layout;
  evkDevice _device;
  evkPipelineType type;
  evkDescriptorSet boundSets[MAX_DESCRIPTOR_SETS];
} evkPipeline;

typedef struct {
  VkCommandBuffer vk;
  bool recording;
  evkPipeline* boundPipeline;
} evkCommandBuffer;

TYPEDATA_GEN(evkInstance, 
  INVALID(
    .vk = VK_NULL_HANDLE,
  )
);

TYPEDATA_GEN(evkShader);

TYPEDATA_GEN(evkPipelineLayoutCreateInfo,
  DEFAULT(
    .setLayouts = EV_VEC_EMPTY,
    .pushConstantRanges = EV_VEC_EMPTY,
  )
);

TYPEDATA_GEN(evkApplicationInfo,
    DEFAULT(
      .apiVersion = VK_API_VERSION_1_1,
      .applicationVersion = 0,
      .engineVersion = 0,
      .applicationName = evstr("Test Application"),
      .engineName = evstr("evk")
    )
);

TYPEDATA_GEN(evkImage);
TYPEDATA_GEN(evkImageView);
TYPEDATA_GEN(evkImageViewCreateInfo,
  DEFAULT(
    .layerCount = 1,
    .baseLayer = 0,
    .mipCount = 1,
    .mipBase = 0,
    .viewAspect = VK_IMAGE_ASPECT_NONE,
  )
);
TYPEDATA_GEN(evkAllocationUserData, INVALID(__EV_VEC_EMPTY_ARRAY));
TYPEDATA_GEN(evkDeviceQueueRequirement);

TYPEDATA_GEN(evkViewport, 
  DEFAULT(
    .x = 0,
    .y = 0,
    .maxDepth = 1.0f,
    .minDepth = 0.f,
    .width = 0,
    .height = 0,
    .scissor.offset.x = 0,
    .scissor.offset.y = 0,
    .scissor.extent.width = 0,
    .scissor.extent.height = 0,
  )
);

TYPEDATA_GEN(evkColorAttachment);

TYPEDATA_GEN(evkPipelineCreateInfo, 
  DEFAULT(
    .type = EVK_PIPELINE_TYPE_GRAPHICS,
    .dynamicStates = EV_VEC_EMPTY,
    .shaderStages = EV_VEC_EMPTY,

    .colorAttachments = EV_VEC_EMPTY,
    .viewMask = 0,

    .blendingOp = VK_LOGIC_OP_NO_OP
  )
);

TYPEDATA_GEN(evkVertexBufferLayout);
TYPEDATA_GEN(evkVertexAttribute);

TYPEDATA_GEN(evkDescriptorBinding);
TYPEDATA_GEN(evkDescriptorSetLayout);
TYPEDATA_GEN(evkDescriptorSet);

TYPEDATA_GEN(evkCommandBuffer);