Core

Vulkan core rendering primitives

UgContext — Top-level Vulkan context holding all core rendering state
UgInstance — Vulkan instance creation and destruction
UgPhysicalDevice — Physical device enumeration and selection utilities
UgQueueFamilies — Queue family query utilities
UgDevice — Logical device creation and queue access
UgBuffer — Generic GPU buffer allocation and upload
UgFrameBuffer — Framebuffer array tied to swapchain images
UgUniformBuffer — Uniform buffer with descriptor set management
UgCommandBuffer — Single-use and reusable command buffer wrapper
UgCommandPool — Vulkan command pool creation and destruction
UgDescriptorPool — Vulkan descriptor pool creation and destruction
UgFence — CPU–GPU synchronization fence
UgSemaphore — GPU–GPU synchronization semaphore
UgImageView — Vulkan image view creation and management
UgImageLayout — Image layout transition utilities
UgWindowSurface — Vulkan window surface creation and destruction
UgSwapchain — Vulkan swapchain creation and frame management
UgShader — SPIR-V shader module loading
UgShaderProgram — Linked vertex and fragment shader program
UgRenderPass — Vulkan render pass management
UgRenderTarget — Off-screen render target backed by a texture
UgRenderer — High-level swapchain renderer managing per-frame synchronization
UgPipeline — Vulkan graphics pipeline creation helpers
UgPipelineLayout — Vulkan pipeline layout management
UgMaterialPipelineEntry — Per-render-pass pipeline cache entry
UgMaterial — Material combining shaders, vertex layout, and per-pass pipeline cache
UgTexture — 2D texture loading and descriptor management
UgSampler — Vulkan sampler creation and destruction
UgTextureArray — Layered texture array for batch rendering
UgVertexAttrib — Single vertex attribute binding description
UgVertexDesc — Vertex buffer layout description
UgVertexSettings — Rasterizer, blending, and depth settings for a pipeline

Header

#include <uhcgraphics.uhh>

Cheat sheet

#define UG_MATERIAL_MAX_RENDER_PASSES 4
#define UG_MATERIAL_MAX_TEXTURES 4

namespace UgContext {
  struct It {
      UgWindow.It window;
      VkInstance instance;
      VkDebugUtilsMessengerEXT logger;
      VkSurfaceKHR surface;
      VkPhysicalDevice physicalDevice;
      UgDevice.It device;
      VkDescriptorPool descriptorPool;
      VkCommandPool cmdPool;
  };
  UgContext.It create(UgWindow.It& window, U8 debug);
  U0 destroy(UgContext.It& ctx);
}

namespace UgInstance {
  VkInstance create(U8 debug);
  U0 destroy(UgContext.It& ctx);
}

namespace UgPhysicalDevice {
  VkPhysicalDeviceProperties getProperties(VkPhysicalDevice device);
  const I8* typeName(VkPhysicalDeviceType type);
  U8 hasExtensions(VkPhysicalDevice device);
  U32 count(VkInstance instance);
  U0 list(VkInstance instance);
  VkPhysicalDevice get(VkInstance instance, VkSurfaceKHR surface, U8 desiredType);
  VkPhysicalDevice create(VkInstance instance, VkSurfaceKHR surface);
}

namespace UgQueueFamilies {
  U32 count(VkPhysicalDevice device);
  U8 hasType(VkPhysicalDevice device, VkQueueFlagBits type);
  U32 getType(VkPhysicalDevice device, VkQueueFlagBits type);
}

namespace UgDevice {
  struct It {
      VkDevice handle;
      VkPhysicalDeviceProperties properties;
      VkQueue graphicQueue;
      VkQueue presentQueue;
  };
  VkQueue getQueue(VkPhysicalDevice device, VkDevice logicalDevice, VkQueueFlagBits queueType);
  VkQueue getPresentationQueue(VkPhysicalDevice device, VkSurfaceKHR surface, VkDevice logicalDevice);
  U32 getSurfaceSupport(VkPhysicalDevice device, VkSurfaceKHR surface);
  U0 destroy(UgDevice.It& device);
  VkDevice make(VkPhysicalDevice device, VkSurfaceKHR surface);
  UgDevice.It create(VkPhysicalDevice device, VkSurfaceKHR surface);
}

namespace UgBuffer {
  struct It {
      VkBuffer handle;
      VkDeviceMemory memory;
  };
  UgBuffer.It create(UgContext.It& ctx, U32 size, VkBufferUsageFlagBits usage);
  U0 upload(UgContext.It& ctx, UgBuffer.It& buffer, U0* data, U32 size);
  U0 destroy(UgContext.It& ctx, UgBuffer.It& buffer);
}

namespace UgFrameBuffer {
  struct It {
      VkFramebuffer* handles;
      VkExtent2D extends;
      U32 bufferCount;
  };
  U0 destroy(UgContext.It& ctx, UgFrameBuffer.It& framebuffers);
  UgFrameBuffer.It create(UgContext.It& ctx, UgSwapchain.It& swapchain, VkRenderPass renderPass);
}

namespace UgUniformBuffer {
  struct It {
      UgBuffer.It buffer;
      VkDescriptorSetLayout setLayout;
      U0* mappedData;
      U32 binding;
      U32 size;
      VkDescriptorSet descriptorSet;
      U32 cursor;
  };
  UgUniformBuffer.It create(UgContext.It& ctx, U32 binding, U32 size);
  U0 bind(UgUniformBuffer.It& uniformBuffer, VkCommandBuffer cmdBuffer, VkPipelineLayout pipelineLayout);
  U0 destroy(UgContext.It& ctx, UgUniformBuffer.It& uniformBuffer);
  U0 reset(UgUniformBuffer.It& uniformBuffer);
  U0 setFloat(UgUniformBuffer.It& buffer, F32 value);
  U0 setVec2f(UgUniformBuffer.It& buffer, VectorF.It vec);
  U0 setVec3f(UgUniformBuffer.It& buffer, VectorF.It vec);
  U0 setVec4f(UgUniformBuffer.It& buffer, VectorF.It vec);
  U0 setMat(UgUniformBuffer.It& buffer, Matrix.It mat);
}

namespace UgCommandBuffer {
  struct It {
      VkCommandBuffer handle;
  };
  U0 begin(UgCommandBuffer.It& cmd);
  U0 end(UgCommandBuffer.It& cmd);
  U0 destroy(UgContext.It& ctx, UgCommandBuffer.It& cmd);
  UgCommandBuffer.It create(UgContext.It& ctx);
}

namespace UgCommandPool {
  U0 destroy(UgContext.It& ctx, VkCommandPool cmdPool);
  VkCommandPool create(UgContext.It& ctx);
}

namespace UgDescriptorPool {
  VkDescriptorPool create(UgContext.It& ctx);
  U0 destroy(UgContext.It& ctx, VkDescriptorPool descriptorPool);
}

namespace UgFence {
  struct It {
      VkFence handle;
  };
  UgFence.It create(UgContext.It& ctx);
  U0 destroy(UgContext.It& ctx, UgFence.It& fence);
  U0 wait(UgContext.It& ctx, UgFence.It& fence);
  U0 reset(UgContext.It& ctx, UgFence.It& fence);
}

namespace UgSemaphore {
  struct It {
      VkSemaphore handle;
  };
  UgSemaphore.It create(UgContext.It& ctx);
  U0 destroy(UgContext.It& ctx, UgSemaphore.It& semaphore);
}

namespace UgImageView {
  struct It {
      VkImage image;
      VkImageView view;
  };
  UgImageView.It create(UgContext.It& ctx, VkImage image, VkFormat format);
  U0 destroy(UgContext.It& ctx, UgImageView.It& imageView);
  VkImageView makeView(UgContext.It& ctx, VkImage image, VkFormat format, VkImageAspectFlags aspectMask);
}

namespace UgImageLayout {
  U0 transition(VkCommandBuffer cmdBuffer, VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout);
}

namespace UgWindowSurface {
  U0 destroy(VkInstance instance, VkSurfaceKHR surface);
  VkSurfaceKHR create(VkInstance instance, UgWindow.It& window);
}

namespace UgSwapchain {
  struct It {
      VkSwapchainKHR handle;
      UgImageView.It* imageViews;
      U32 imageCount;
      U32 currentFrame;
      U32 imageIndex;
      UgSemaphore.It* pSemaphore;
      UgSemaphore.It* rSemaphore;
      VkSurfaceFormatKHR surfaceFormat;
      VkPresentModeKHR presentMode;
      VkSurfaceCapabilitiesKHR capabilities;
      VkImage depthImage;
      VkDeviceMemory depthImageMemory;
      VkImageView depthImageView;
  };
  VkExtent2D extend(UgContext.It& ctx, UgSwapchain.It& swapchain);
  U0 update(UgContext.It& ctx, UgSwapchain.It& swapchain, VkCommandBuffer cmdBuffer);
  U0 destroy(UgContext.It& ctx, UgSwapchain.It& swapchain);
  UgSwapchain.It create(UgContext.It& ctx);
}

namespace UgShader {
  U0 destroy(UgContext.It& ctx, VkShaderModule shader);
  VkShaderModule create(UgContext.It& ctx, const I8* filePath);
}

namespace UgShaderProgram {
  struct It {
      VkPipelineShaderStageCreateInfo handle[2];
      VkShaderModule vertexShader;
      VkShaderModule fragmentShader;
  };
  VkPipelineShaderStageCreateInfo createShaderInfo(VkShaderStageFlagBits stage, VkShaderModule shader);
  UgShaderProgram.It create(UgContext.It& ctx, const I8* vertexSource, const I8* fragmentSource);
  U0 destroy(UgContext.It& ctx, UgShaderProgram.It& shaderProgram);
}

namespace UgRenderPass {
  U0 end(VkCommandBuffer cmdBuffer);
  U0 begin(VkRenderPass renderPass, UgFrameBuffer.It& framebuffers, VkCommandBuffer cmdBuffer, U32 imageIndex);
  U0 destroy(UgContext.It& ctx, VkRenderPass renderPass);
  VkRenderPass create(UgContext.It& ctx, UgSwapchain.It& swapchain);
}

namespace UgRenderTarget {
  struct It {
      VkRenderPass renderPass;
      VkFramebuffer framebuffer;
      UgTexture.It texture;
      U32 width;
      U32 height;
  };
  UgRenderTarget.It create(UgContext.It& ctx, U32 width, U32 height);
  U0 begin(UgRenderTarget.It& rt, UgCommandBuffer.It& cmd);
  U0 end(UgCommandBuffer.It& cmd);
  U0 setViewport(UgRenderTarget.It& rt, UgCommandBuffer.It& cmd);
  U0 destroy(UgContext.It& ctx, UgRenderTarget.It& rt);
}

namespace UgRenderer {
  struct It {
      UgSwapchain.It swapchain;
      UgFrameBuffer.It framebuffers;
      VkRenderPass renderPass;
  };
  UgRenderer.It create(UgContext.It& ctx);
  U0 destroy(UgContext.It& ctx, UgRenderer.It& renderer);
  U0 update(UgContext.It& ctx, UgRenderer.It& renderer);
  U0 begin(UgRenderer.It& renderer, UgCommandBuffer.It& cmd);
  U0 end(UgCommandBuffer.It& cmd);
  U0 setViewport(UgContext.It& ctx, UgRenderer.It& renderer, UgCommandBuffer.It& cmd);
  U0 submit(UgContext.It& ctx, UgRenderer.It& renderer, UgCommandBuffer.It& cmd, UgFence.It& fence);
  VkResult present(UgContext.It& ctx, UgRenderer.It& renderer);
  VkResult aquire(UgContext.It& ctx, UgRenderer.It& renderer);
}

namespace UgPipeline {
  VkPipelineDynamicStateCreateInfo createDynamicState();
  VkPipelineInputAssemblyStateCreateInfo createInputAssembly();
  VkViewport createViewport(UgContext.It& ctx, UgSwapchain.It& swapchain);
  VkRect2D createScissor(UgContext.It& ctx, UgSwapchain.It& swapchain);
  VkPipelineViewportStateCreateInfo createViewportState(VkViewport* viewport, VkRect2D* scissor);
  VkPipelineRasterizationStateCreateInfo createRasterizerState(const UgVertexSettings.It& settings);
  VkPipelineMultisampleStateCreateInfo createMultisamplingState();
  VkPipelineColorBlendAttachmentState createColorBlendAttachmentState(const UgVertexSettings.It& settings);
  VkPipelineColorBlendStateCreateInfo createColorBlendState(VkPipelineColorBlendAttachmentState* colorBlendAttachment);
  U0 destroy(UgContext.It& ctx, VkPipeline graphicsPipeline);
  VkPipeline create(UgContext.It& ctx, VkPipelineLayout layout, UgSwapchain.It& swapchain, UgShaderProgram.It& shaderProgram, VkRenderPass renderPass, VkPipelineVertexInputStateCreateInfo* vertexInput, const UgVertexSettings.It& settings);
  VkPipelineDepthStencilStateCreateInfo createDepthStencil();
}

namespace UgPipelineLayout {
  U0 remove(UgContext.It& ctx, VkPipelineLayout layout);
  U0 destroy(UgContext.It& ctx, VkPipelineLayout pipelineLayout);
  VkPipelineLayout create(UgContext.It& ctx, U32 count, VkDescriptorSetLayout* setLayouts);
}

namespace UgMaterialPipelineEntry {
  struct It {
      VkRenderPass renderPass;
      VkPipeline   pipeline;
  };
}

namespace UgMaterial {
  struct It {
      VkPipelineLayout layout;
      VkDescriptorSetLayout textureSetLayouts[UG_MATERIAL_MAX_TEXTURES];
      UgShaderProgram.It shaderProgram;
      UgVertexDesc.It    vertexDesc;
      UgVertexSettings.It settings;
      U32 textureCount;
      UgMaterialPipelineEntry.It pipelineCache[UG_MATERIAL_MAX_RENDER_PASSES];
      U32 pipelineCacheCount;
      UgContext.It*   ctx;
      UgSwapchain.It* swapchain;
  };
  U0 destroy(UgContext.It& ctx, UgMaterial.It& mat);
}

namespace UgTexture {
  struct It {
      VkImage image;
      VkDeviceMemory memory;
      VkImageView view;
      VkSampler sampler;
      VkDescriptorSetLayout setLayout;
      VkDescriptorSet descriptorSet;
  };
  UgTexture.It create(UgContext.It& ctx, const I8* path);
  VkDescriptorSetLayout createSetLayout(UgContext.It& ctx);
  U0 bind(UgTexture.It& texture, UgCommandBuffer.It& cmd, VkPipelineLayout pipelineLayout, U32 slot);
  U0 destroy(UgContext.It& ctx, UgTexture.It& texture);
}

namespace UgSampler {
  VkSampler create(UgContext.It& ctx);
  U0 destroy(UgContext.It& ctx, VkSampler sampler);
}

namespace UgTextureArray {
  struct It {
      VkImage image;
      VkDeviceMemory memory;
      VkImageView view;
      VkSampler sampler;
      VkDescriptorSetLayout setLayout;
      VkDescriptorSet descriptorSet;
      U32 layerCount;
  };
  UgTextureArray.It create(UgContext.It& ctx, const I8** paths, U32 count);
  U0 bind(UgTextureArray.It& arr, UgCommandBuffer.It& cmd, VkPipelineLayout pipelineLayout, U32 slot);
  U0 destroy(UgContext.It& ctx, UgTextureArray.It& arr);
}

namespace UgVertexAttrib {
  struct It {
      U32 location;
      VkFormat format;
      U32 offset;
  };
}

namespace UgVertexDesc {
  struct It {
      U32 stride;
      UgVertexAttrib.It* attributes;
      U32 attributeCount;
  };
}

namespace UgVertexSettings {
  struct It {
      U8 depthVao;
      I32 colorWriteMask;
      VkBool32 blendEnable;
      VkBlendFactor srcColorBlendFactor;
      VkBlendFactor dstColorBlendFactor;
      VkBlendOp colorBlendOp;
      VkBlendFactor srcAlphaBlendFactor;
      VkBlendFactor dstAlphaBlendFactor;
      VkBlendOp alphaBlendOp;
      VkBool32 depthClampEnable;
      VkBool32 rasterizerDiscardEnable;
      VkPolygonMode polygonMode;
      VkCullModeFlagBits cullMode;
      VkFrontFace frontFace;
      VkBool32 depthBiasEnable;
      F32 depthBiasConstantFactor;
      F32 depthBiasClamp;
      F32 depthBiasSlopeFactor;
      F32 lineWidth;
  };
}