Kataglyphis-Renderer documentation

Contents:

• About The Project
  • Key Features
  • Built With
  • Useful tools (you might also considering :) )
• Getting Started
  • Prerequisites
  • Installation
• Shaders
• Tests
  • Static Analyzers
• Format cmake files
• Format code files
• Docs
  • Roadmap
  • Contributing
  • License
  • Contact
  • Acknowledgements
  • Literature
  • Common issues

Doxygen API Documentation

class Allocator

#include <Allocator.hpp>

Public Functions

Allocator()

Allocator(const VkDevice &device, const VkPhysicalDevice &physicalDevice, const VkInstance &instance)

void cleanUp()

~Allocator()

Private Members

VmaAllocator vmaAllocator

class App

#include <App.hpp>

Public Functions

App()

int run()

~App()

class ASManager

#include <ASManager.hpp>

Public Functions

ASManager()

inline VkAccelerationStructureKHR &getTLAS()

void createASForScene(VulkanDevice *device, VkCommandPool commandPool, Scene *scene)

void createBLAS(VulkanDevice *device, VkCommandPool commandPool, Scene *scene)

void createTLAS(VulkanDevice *device, VkCommandPool commandPool, Scene *scene)

void cleanUp()

~ASManager()

Private Functions

void createSingleBlas(VulkanDevice *device, VkCommandBuffer command_buffer, BuildAccelerationStructure &build_as_structure, VkDeviceAddress scratch_device_or_host_address)

void createAccelerationStructureInfosBLAS(VulkanDevice *device, BuildAccelerationStructure &build_as_structure, BlasInput &blas_input, VkDeviceSize &current_scretch_size, VkDeviceSize &current_size)

void objectToVkGeometryKHR(VulkanDevice *device, Mesh *mesh, VkAccelerationStructureGeometryKHR &acceleration_structure_geometry, VkAccelerationStructureBuildRangeInfoKHR &acceleration_structure_build_range_info)

Private Members

VulkanDevice *vulkanDevice = {VK_NULL_HANDLE}

CommandBufferManager commandBufferManager

VulkanBufferManager vulkanBufferManager

std::vector<BottomLevelAccelerationStructure> blas

TopLevelAccelerationStructure tlas

struct BlasInput

#include <ASManager.hpp>

Public Members

std::vector<VkAccelerationStructureGeometryKHR> as_geometry

std::vector<VkAccelerationStructureBuildRangeInfoKHR> as_build_offset_info

struct BottomLevelAccelerationStructure

#include <BottomLevelAccelerationStructure.hpp>

Public Members

VkAccelerationStructureKHR vulkanAS

VulkanBuffer vulkanBuffer

struct BuildAccelerationStructure

#include <ASManager.hpp>

Public Members

VkAccelerationStructureBuildGeometryInfoKHR build_info

VkAccelerationStructureBuildSizesInfoKHR size_info

const VkAccelerationStructureBuildRangeInfoKHR *range_info

BottomLevelAccelerationStructure single_blas

class Camera

#include <Camera.hpp>

Public Functions

Camera()

void key_control(bool *keys, float delta_time)

void mouse_control(float x_change, float y_change)

inline glm::vec3 get_camera_position() const

inline glm::vec3 get_camera_direction() const

inline glm::vec3 get_up_axis() const

inline glm::vec3 get_right_axis() const

inline float get_near_plane() const

inline float get_far_plane() const

inline float get_fov() const

inline float get_yaw() const

glm::mat4 calculate_viewmatrix()

void set_near_plane(float near_plane)

void set_far_plane(float far_plane)

void set_fov(float fov)

void set_camera_position(glm::vec3 new_camera_position)

~Camera()

Private Functions

void update()

Private Members

glm::vec3 position

glm::vec3 front

glm::vec3 world_up

glm::vec3 right

glm::vec3 up

float yaw

float pitch

float movement_speed

float turn_speed

float near_plane

float far_plane

float fov

class CommandBufferManager

#include <CommandBufferManager.hpp>

Public Functions

CommandBufferManager()

VkCommandBuffer beginCommandBuffer(VkDevice device, VkCommandPool command_pool)

void endAndSubmitCommandBuffer(VkDevice device, VkCommandPool command_pool, VkQueue queue, VkCommandBuffer &command_buffer)

~CommandBufferManager()

class File

#include <File.hpp>

Public Functions

explicit File(const std::string &file_location)

std::string read()

std::vector<char> readCharSequence()

std::string getBaseDir()

~File()

Private Members

std::string file_location

struct GlobalUBO

#include <GlobalUBO.hpp>

Public Members

mat4 projection

mat4 view

class GUI

#include <GUI.hpp>

Public Functions

GUI(Window *window)

void initializeVulkanContext(VulkanDevice *device, const VkInstance &instance, const VkRenderPass &post_render_pass, const VkCommandPool &graphics_command_pool)

inline GUISceneSharedVars getGuiSceneSharedVars()

inline GUIRendererSharedVars &getGuiRendererSharedVars()

void setUserSelectionForRRT(bool rrtCapabilitiesAvailable)

void render()

void cleanUp()

~GUI()

Private Functions

void create_gui_context(Window *window, const VkInstance &instance, const VkRenderPass &post_render_pass)

void create_fonts_and_upload(const VkCommandPool &graphics_command_pool)

Private Members

VulkanDevice *device = {VK_NULL_HANDLE}

Window *window = {VK_NULL_HANDLE}

VkDescriptorPool gui_descriptor_pool = {VK_NULL_HANDLE}

CommandBufferManager commandBufferManager

GUISceneSharedVars guiSceneSharedVars

GUIRendererSharedVars guiRendererSharedVars

bool renderUserSelectionForRRT = true

struct GUIRendererSharedVars

#include <GUIRendererSharedVars.hpp>

Public Members

bool raytracing = false

bool pathTracing = false

bool shader_hot_reload_triggered = false

struct GUISceneSharedVars

#include <GUISceneSharedVars.hpp>

Public Members

float direcional_light_radiance = 10.f

float directional_light_color[3] = {1.f, 1.f, 1.f}

float directional_light_direction[3] = {0.075f, -1.f, 0.118f}

class Mesh

#include <Mesh.hpp>

Public Functions

Mesh(VulkanDevice *device, VkQueue transfer_queue, VkCommandPool transfer_command_pool, std::vector<Vertex> &vertices, std::vector<uint32_t> &indices, std::vector<unsigned int> &materialIndex, std::vector<ObjMaterial> &materials)

Mesh()

void cleanUp()

inline ObjectDescription &getObjectDescription()

inline glm::mat4 getModel()

inline uint32_t getVertexCount()

inline uint32_t getIndexCount()

inline VkBuffer &getVertexBuffer()

inline VkBuffer &getMaterialIDBuffer()

inline VkBuffer &getIndexBuffer()

void setModel(glm::mat4 new_model)

~Mesh()

Private Functions

void createVertexBuffer(VkQueue transfer_queue, VkCommandPool transfer_command_pool, std::vector<Vertex> &vertices)

void createIndexBuffer(VkQueue transfer_queue, VkCommandPool transfer_command_pool, std::vector<uint32_t> &indices)

void createMaterialIDBuffer(VkQueue transfer_queue, VkCommandPool transfer_command_pool, std::vector<unsigned int> &materialIndex)

void createMaterialBuffer(VkQueue transfer_queue, VkCommandPool transfer_command_pool, std::vector<ObjMaterial> &materials)

Private Members

VulkanBufferManager vulkanBufferManager

ObjectDescription object_description = {static_cast<uint64_t>(-1), static_cast<uint64_t>(-1), static_cast<uint64_t>(-1), static_cast<uint64_t>(-1)}

VulkanBuffer vertexBuffer

VulkanBuffer indexBuffer

VulkanBuffer objectDescriptionBuffer

VulkanBuffer materialIdsBuffer

VulkanBuffer materialsBuffer

glm::mat4 model

uint32_t vertex_count = {static_cast<uint32_t>(-1)}

uint32_t index_count = {static_cast<uint32_t>(-1)}

VulkanDevice *device = {VK_NULL_HANDLE}

class Model

#include <Model.hpp>

Public Functions

Model()

Model(VulkanDevice *device)

void cleanUp()

void add_new_mesh(VulkanDevice *device, VkQueue transfer_queue, VkCommandPool command_pool, std::vector<Vertex> &vertices, std::vector<unsigned int> &indices, std::vector<unsigned int> &materialIndex, std::vector<ObjMaterial> &materials)

inline uint32_t getTextureCount()

inline std::vector<Texture> &getTextures()

inline std::vector<VkSampler> &getTextureSamplers()

inline std::vector<std::string> getTextureList()

inline uint32_t getMeshCount()

inline Mesh *getMesh(size_t index)

inline glm::mat4 getModel()

inline uint32_t getCustomInstanceIndex()

uint32_t getPrimitiveCount()

inline ObjectDescription getObjectDescription()

void set_model(glm::mat4 model)

void addTexture(Texture newTexture)

~Model()

Private Functions

void addSampler(Texture newTexture)

Private Members

VulkanDevice *device = {VK_NULL_HANDLE}

uint32_t mesh_model_index = {static_cast<uint32_t>(-1)}

Mesh mesh

glm::mat4 model

std::vector<std::string> texture_list

std::vector<Texture> modelTextures

std::vector<VkSampler> modelTextureSamplers

struct ObjectDescription

#include <ObjectDescription.hpp>

Public Members

uint64_t vertex_address

uint64_t index_address

uint64_t material_index_address

uint64_t material_address

class ObjLoader

#include <ObjLoader.hpp>

Public Functions

ObjLoader(VulkanDevice *device, VkQueue transfer_queue, VkCommandPool command_pool)

std::shared_ptr<Model> loadModel(const std::string &modelFile)

Private Functions

std::vector<std::string> loadTexturesAndMaterials(const std::string &modelFile)

void loadVertices(const std::string &fileName)

Private Members

VulkanDevice *device

VkQueue transfer_queue

VkCommandPool command_pool

std::vector<Vertex> vertices

std::vector<unsigned int> indices

std::vector<ObjMaterial> materials

std::vector<unsigned int> materialIndex

std::vector<std::string> textures

struct ObjMaterial

#include <ObjMaterial.hpp>

Public Members

vec3 ambient

vec3 diffuse

vec3 specular

vec3 transmittance

vec3 emission

float shininess

float ior

float dissolve

int illum

int textureID

class PathTracing

#include <PathTracing.hpp>

Public Functions

PathTracing()

void init(VulkanDevice *device, const std::vector<VkDescriptorSetLayout> &descriptorSetLayouts)

void shaderHotReload(const std::vector<VkDescriptorSetLayout> &descriptor_set_layouts)

void recordCommands(VkCommandBuffer &commandBuffer, uint32_t image_index, VulkanImage &vulkanImage, VulkanSwapChain *vulkanSwapChain, const std::vector<VkDescriptorSet> &descriptorSets)

void cleanUp()

~PathTracing()

Public Members

uint32_t maxComputeWorkGroupCount[3] = {static_cast<uint32_t>(-1), static_cast<uint32_t>(-1), static_cast<uint32_t>(-1)}

uint32_t maxComputeWorkGroupInvocations = -1

uint32_t maxComputeWorkGroupSize[3] = {static_cast<uint32_t>(-1), static_cast<uint32_t>(-1), static_cast<uint32_t>(-1)}

Private Functions

void createQueryPool()

void createPipeline(const std::vector<VkDescriptorSetLayout> &descriptorSetLayouts)

Private Members

VulkanDevice *device = {VK_NULL_HANDLE}

VkPipelineLayout pipeline_layout = {VK_NULL_HANDLE}

VkPipeline pipeline = {VK_NULL_HANDLE}

VkPushConstantRange pc_range = {VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM, 0, 0}

PushConstantPathTracing push_constant = {glm::vec4(0.f), 0, 0}

float timeStampPeriod = {0}

uint64_t pathTracingTiming = {static_cast<uint64_t>(-1.f)}

uint32_t query_count = {2}

std::vector<uint64_t> queryResults

VkQueryPool queryPool = {VK_NULL_HANDLE}

struct PathTracing computeLimits

SpecializationData specializationData

class PostStage

#include <PostStage.hpp>

Public Functions

PostStage()

void init(VulkanDevice *device, VulkanSwapChain *vulkanSwapChain, const std::vector<VkDescriptorSetLayout> &descriptorSetLayouts)

void shaderHotReload(const std::vector<VkDescriptorSetLayout> &descriptor_set_layouts)

inline VkRenderPass &getRenderPass()

inline VkSampler &getOffscreenSampler()

void recordCommands(VkCommandBuffer &commandBuffer, uint32_t image_index, const std::vector<VkDescriptorSet> &descriptorSets)

void cleanUp()

~PostStage()

Private Functions

void createDepthbufferImage()

void createOffscreenTextureSampler()

void createPushConstantRange()

void createRenderpass()

void createGraphicsPipeline(const std::vector<VkDescriptorSetLayout> &descriptorSetLayouts)

void createFramebuffer()

Private Members

VulkanDevice *device = {VK_NULL_HANDLE}

VulkanSwapChain *vulkanSwapChain = {VK_NULL_HANDLE}

std::vector<VkFramebuffer> framebuffers

Texture depthBufferImage

VkFormat depth_format = {VK_FORMAT_UNDEFINED}

VkSampler offscreenTextureSampler

VkPushConstantRange push_constant_range = {VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM, 0, 0}

VkRenderPass render_pass = {VK_NULL_HANDLE}

VkPipeline graphics_pipeline = {VK_NULL_HANDLE}

VkPipelineLayout pipeline_layout = {VK_NULL_HANDLE}

struct PushConstantPathTracing

#include <PushConstantPathTracing.hpp>

Public Members

vec4 clearColor

uint width

uint height

struct PushConstantPost

#include <PushConstantPost.hpp>

Public Members

float aspect_ratio

struct PushConstantRasterizer

#include <PushConstantRasterizer.hpp>

Public Members

mat4 model

struct PushConstantRaytracing

#include <PushConstantRayTracing.hpp>

Public Members

vec4 clear_color

struct QueueFamilyIndices

#include <QueueFamilyIndices.hpp>

Public Functions

inline bool is_valid()

Public Members

int graphics_family = -1

int presentation_family = -1

int compute_family = -1

class Rasterizer

#include <Rasterizer.hpp>

Public Functions

Rasterizer()

void init(VulkanDevice *device, VulkanSwapChain *vulkanSwapChain, const std::vector<VkDescriptorSetLayout> &descriptorSetLayouts, VkCommandPool &commandPool)

void shaderHotReload(const std::vector<VkDescriptorSetLayout> &descriptor_set_layouts)

Texture &getOffscreenTexture(uint32_t index)

void setPushConstant(PushConstantRasterizer pushConstant)

void recordCommands(VkCommandBuffer &commandBuffer, uint32_t image_index, Scene *scene, const std::vector<VkDescriptorSet> &descriptorSets)

void cleanUp()

~Rasterizer()

Private Functions

void createTextures(VkCommandPool &commandPool)

void createGraphicsPipeline(const std::vector<VkDescriptorSetLayout> &descriptorSetLayouts)

void createRenderPass()

void createFramebuffer()

void createPushConstantRange()

Private Members

VulkanDevice *device = {VK_NULL_HANDLE}

VulkanSwapChain *vulkanSwapChain = {VK_NULL_HANDLE}

CommandBufferManager commandBufferManager

std::vector<VkFramebuffer> framebuffer

std::vector<Texture> offscreenTextures

Texture depthBufferImage

VkPushConstantRange push_constant_range = {VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM, 0, 0}

PushConstantRasterizer pushConstant = {glm::mat4(1.f)}

VkPipeline graphics_pipeline = {VK_NULL_HANDLE}

VkPipelineLayout pipeline_layout = {VK_NULL_HANDLE}

VkRenderPass render_pass = {VK_NULL_HANDLE}

class Raytracing

#include <Raytracing.hpp>

Public Functions

Raytracing()

void init(VulkanDevice *device, const std::vector<VkDescriptorSetLayout> &descriptorSetLayouts)

void shaderHotReload(const std::vector<VkDescriptorSetLayout> &descriptor_set_layouts)

void recordCommands(VkCommandBuffer &commandBuffer, VulkanSwapChain *vulkanSwapChain, const std::vector<VkDescriptorSet> &descriptorSets)

void cleanUp()

~Raytracing()

Private Functions

void createPCRange()

void createGraphicsPipeline(const std::vector<VkDescriptorSetLayout> &descriptorSetLayouts)

void createSBT()

Private Members

VulkanDevice *device = {VK_NULL_HANDLE}

VulkanSwapChain *vulkanSwapChain = {VK_NULL_HANDLE}

VkPipeline graphicsPipeline = {VK_NULL_HANDLE}

VkPipelineLayout pipeline_layout = {VK_NULL_HANDLE}

PushConstantRaytracing pc = {glm::vec4(0.f)}

VkPushConstantRange pc_ranges = {VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM, 0, 0}

std::vector<VkRayTracingShaderGroupCreateInfoKHR> shader_groups

VulkanBuffer shaderBindingTableBuffer

VulkanBuffer raygenShaderBindingTableBuffer

VulkanBuffer missShaderBindingTableBuffer

VulkanBuffer hitShaderBindingTableBuffer

VkStridedDeviceAddressRegionKHR rgen_region = {}

VkStridedDeviceAddressRegionKHR miss_region = {}

VkStridedDeviceAddressRegionKHR hit_region = {}

VkStridedDeviceAddressRegionKHR call_region = {}

VkPhysicalDeviceRayTracingPipelinePropertiesKHR raytracing_properties = {}

class Scene

#include <Scene.hpp>

Public Functions

Scene()

void update_user_input(GUI *gui)

void update_model_matrix(glm::mat4 model_matrix, int model_id)

inline const GUISceneSharedVars &getGuiSceneSharedVars()

inline std::vector<Texture> &getTextures(int model_index)

inline std::vector<VkSampler> &getTextureSampler(int model_index)

inline uint32_t getTextureCount(int model_index)

inline uint32_t getModelCount()

inline glm::mat4 getModelMatrix(int model_index)

inline uint32_t getMeshCount(int model_index)

inline VkBuffer getVertexBuffer(int model_index, int mesh_index)

inline VkBuffer getIndexBuffer(int model_index, int mesh_index)

inline uint32_t getIndexCount(int model_index, int mesh_index)

inline uint32_t getNumberObjectDescriptions()

uint32_t getNumberMeshes()

inline std::vector<ObjectDescription> getObjectDescriptions()

inline std::vector<std::shared_ptr<Model>> const &get_model_list()

void loadModel(VulkanDevice *device, VkCommandPool commandPool)

void add_model(std::shared_ptr<Model> model)

void add_object_description(ObjectDescription object_description)

void cleanUp()

~Scene()

Private Members

std::vector<ObjectDescription> object_descriptions

std::vector<std::shared_ptr<Model>> model_list

GUISceneSharedVars guiSceneSharedVars

struct SceneUBO

#include <SceneUBO.hpp>

Public Members

vec4 light_dir

vec4 view_dir

vec4 cam_pos

class ShaderHelper

#include <ShaderHelper.hpp>

Public Functions

ShaderHelper()

void compileShader(const std::string &shader_src_dir, const std::string &shader_name)

std::string getShaderSpvDir(const std::string &shader_src_dir, const std::string &shader_name)

VkShaderModule createShaderModule(VulkanDevice *device, const std::vector<char> &code)

~ShaderHelper()

Private Members

std::string target = " --target-env=vulkan1.3 "

struct SpecializationData

Public Members

uint32_t specWorkGroupSizeX = 16

uint32_t specWorkGroupSizeY = 8

uint32_t specWorkGroupSizeZ = 0

struct SwapChainDetails

#include <SwapChainDetails.hpp>

Public Members

VkSurfaceCapabilitiesKHR surface_capabilities

std::vector<VkSurfaceFormatKHR> formats

std::vector<VkPresentModeKHR> presentation_mode

class Texture

#include <Texture.hpp>

Public Functions

Texture()

void createFromFile(VulkanDevice *device, VkCommandPool commandPool, const std::string &fileName)

void setImage(VkImage image)

void setImageView(VkImageView imageView)

inline uint32_t getMipLevel()

inline VulkanImage &getVulkanImage()

inline VulkanImageView &getVulkanImageView()

inline VkImage &getImage()

inline VkImageView &getImageView()

void createImage(VulkanDevice *device, uint32_t width, uint32_t height, uint32_t mip_levels, VkFormat format, VkImageTiling tiling, VkImageUsageFlags use_flags, VkMemoryPropertyFlags prop_flags)

void createImageView(VulkanDevice *device, VkFormat format, VkImageAspectFlags aspect_flags, uint32_t mip_levels)

void cleanUp()

~Texture()

Private Functions

stbi_uc *loadTextureData(const std::string &file_name, int *width, int *height, VkDeviceSize *image_size)

void generateMipMaps(VkPhysicalDevice physical_device, VkDevice device, VkCommandPool command_pool, VkQueue queue, VkImage image, VkFormat image_format, int32_t width, int32_t height, uint32_t mip_levels)

Private Members

uint32_t mip_levels = 0

CommandBufferManager commandBufferManager

VulkanBufferManager vulkanBufferManager

VulkanImage vulkanImage

VulkanImageView vulkanImageView

struct TopLevelAccelerationStructure

#include <TopLevelAccelerationStructure.hpp>

Public Members

VkAccelerationStructureKHR vulkanAS

VulkanBuffer vulkanBuffer

struct Vertex

#include <Vertex.hpp>

Public Members

vec3 pos

vec3 normal

vec3 color

vec2 texture_coords

class VulkanBuffer

#include <VulkanBuffer.hpp>

Public Functions

VulkanBuffer()

void create(VulkanDevice *vulkanDevice, VkDeviceSize buffer_size, VkBufferUsageFlags buffer_usage_flags, VkMemoryPropertyFlags buffer_propertiy_flags)

void cleanUp()

inline VkBuffer &getBuffer()

inline VkDeviceMemory &getBufferMemory()

~VulkanBuffer()

Private Members

VulkanDevice *device = {VK_NULL_HANDLE}

VkBuffer buffer = {VK_NULL_HANDLE}

VkDeviceMemory bufferMemory = {VK_NULL_HANDLE}

bool created = {false}

class VulkanBufferManager

#include <VulkanBufferManager.hpp>

Public Functions

VulkanBufferManager()

void copyBuffer(VkDevice device, VkQueue transfer_queue, VkCommandPool transfer_command_pool, VulkanBuffer src_buffer, VulkanBuffer dst_buffer, VkDeviceSize buffer_size)

void copyImageBuffer(VkDevice device, VkQueue transfer_queue, VkCommandPool transfer_command_pool, VkBuffer src_buffer, VkImage image, uint32_t width, uint32_t height)

template<typename T>
inline void createBufferAndUploadVectorOnDevice(VulkanDevice *device, VkCommandPool commandPool, VulkanBuffer &vulkanBuffer, VkBufferUsageFlags dstBufferUsageFlags, VkMemoryPropertyFlags dstBufferMemoryPropertyFlags, std::vector<T> &data)

~VulkanBufferManager()

Private Members

CommandBufferManager commandBufferManager

class VulkanDevice

#include <VulkanDevice.hpp>

Public Functions

VulkanDevice(VulkanInstance *instance, VkSurfaceKHR *surface)

inline VkPhysicalDeviceProperties getPhysicalDeviceProperties()

inline VkPhysicalDevice getPhysicalDevice() const

inline VkDevice getLogicalDevice() const

QueueFamilyIndices getQueueFamilies()

inline VkQueue getGraphicsQueue() const

inline VkQueue getComputeQueue() const

inline VkQueue getPresentationQueue() const

SwapChainDetails getSwapchainDetails()

inline bool supportsHardwareAcceleratedRRT()

void cleanUp()

~VulkanDevice()

Private Functions

void get_physical_device()

void create_logical_device()

QueueFamilyIndices getQueueFamilies(VkPhysicalDevice physical_device)

SwapChainDetails getSwapchainDetails(VkPhysicalDevice device)

bool check_device_suitable(VkPhysicalDevice device)

bool check_device_extension_support(VkPhysicalDevice device)

Private Members

VkPhysicalDevice physical_device

VkPhysicalDeviceProperties device_properties

VkDevice logical_device

VulkanInstance *instance

VkSurfaceKHR *surface

VkQueue graphics_queue

VkQueue presentation_queue

VkQueue compute_queue

bool deviceSupportsHardwareAcceleratedRRT = true

const std::vector<const char*> device_extensions = {VK_KHR_SWAPCHAIN_EXTENSION_NAME}

const std::vector<const char*> device_extensions_for_raytracing = {VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME, VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME, VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_KHR_SPIRV_1_4_EXTENSION_NAME, VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME, VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME, VK_KHR_RAY_QUERY_EXTENSION_NAME}

class VulkanImage

#include <VulkanImage.hpp>

Public Functions

VulkanImage()

void create(VulkanDevice *device, uint32_t width, uint32_t height, uint32_t mip_levels, VkFormat format, VkImageTiling tiling, VkImageUsageFlags use_flags, VkMemoryPropertyFlags prop_flags)

void transitionImageLayout(VkDevice device, VkQueue queue, VkCommandPool command_pool, VkImageLayout old_layout, VkImageLayout new_layout, VkImageAspectFlags aspectMask, uint32_t mip_levels)

void transitionImageLayout(VkCommandBuffer command_buffer, VkImageLayout old_layout, VkImageLayout new_layout, uint32_t mip_levels, VkImageAspectFlags aspectMask)

void setImage(VkImage image)

inline VkImage &getImage()

void cleanUp()

~VulkanImage()

Private Functions

VkAccessFlags accessFlagsForImageLayout(VkImageLayout layout)

VkPipelineStageFlags pipelineStageForLayout(VkImageLayout oldImageLayout)

Private Members

VulkanDevice *device = {VK_NULL_HANDLE}

CommandBufferManager commandBufferManager

VkImage image

VkDeviceMemory imageMemory

class VulkanImageView

#include <VulkanImageView.hpp>

Public Functions

VulkanImageView()

void setImageView(VkImageView imageView)

inline VkImageView &getImageView()

void create(VulkanDevice *device, VkImage image, VkFormat format, VkImageAspectFlags aspect_flags, uint32_t mip_levels)

void cleanUp()

~VulkanImageView()

Private Members

VulkanDevice *device = {VK_NULL_HANDLE}

VkImageView imageView

class VulkanInstance

#include <VulkanInstance.hpp>

Public Functions

VulkanInstance()

inline VkInstance &getVulkanInstance()

void cleanUp()

~VulkanInstance()

Private Functions

bool check_validation_layer_support()

bool check_instance_extension_support(std::vector<const char*> *check_extensions)

Private Members

VkInstance instance

std::vector<const char*> validationLayers = {"VK_LAYER_KHRONOS_validation"}

class VulkanRenderer

#include <VulkanRenderer.hpp>

Public Functions

VulkanRenderer(Window *window, Scene *scene, GUI *gui, Camera *camera)

void drawFrame()

void updateUniforms(Scene *scene, Camera *camera, Window *window)

void updateStateDueToUserInput(GUI *gui)

void finishAllRenderCommands()

void update_raytracing_descriptor_set(uint32_t image_index)

void cleanUp()

~VulkanRenderer()

Private Functions

void shaderHotReload()

void create_surface()

void record_commands(uint32_t image_index)

void create_command_pool()

void cleanUpCommandPools()

void create_uniform_buffers()

void update_uniform_buffers(uint32_t image_index)

void cleanUpUBOs()

void create_command_buffers()

void createSynchronization()

void cleanUpSync()

void create_object_description_buffer()

void createDescriptorPoolSharedRenderStages()

void createSharedRenderDescriptorSetLayouts()

void createSharedRenderDescriptorSet()

void updateTexturesInSharedRenderDescriptorSet()

void create_post_descriptor_layout()

void updatePostDescriptorSets()

void createRaytracingDescriptorSetLayouts()

void createRaytracingDescriptorSets()

void updateRaytracingDescriptorSets()

void createRaytracingDescriptorPool()

bool checkChangedFramebufferSize()

Private Members

VulkanBufferManager vulkanBufferManager

VulkanInstance instance

VkSurfaceKHR surface

std::unique_ptr<VulkanDevice> device

VulkanSwapChain vulkanSwapChain

Window *window

Scene *scene

GUI *gui

VkCommandPool graphics_command_pool

VkCommandPool compute_command_pool

GlobalUBO globalUBO

std::vector<VulkanBuffer> globalUBOBuffer

SceneUBO sceneUBO

std::vector<VulkanBuffer> sceneUBOBuffer

std::vector<VkCommandBuffer> command_buffers

CommandBufferManager commandBufferManager

Raytracing raytracingStage

Rasterizer rasterizer

PathTracing pathTracing

PostStage postStage

Allocator allocator

uint32_t current_frame = {0}

std::vector<VkSemaphore> image_available

std::vector<VkSemaphore> render_finished

std::vector<VkFence> in_flight_fences

std::vector<VkFence> images_in_flight_fences

ASManager asManager

VulkanBuffer objectDescriptionBuffer

VkDescriptorPool descriptorPoolSharedRenderStages

VkDescriptorSetLayout sharedRenderDescriptorSetLayout

std::vector<VkDescriptorSet> sharedRenderDescriptorSet

VkDescriptorPool post_descriptor_pool = {VK_NULL_HANDLE}

VkDescriptorSetLayout post_descriptor_set_layout = {VK_NULL_HANDLE}

std::vector<VkDescriptorSet> post_descriptor_set

VkDescriptorPool raytracingDescriptorPool = {VK_NULL_HANDLE}

std::vector<VkDescriptorSet> raytracingDescriptorSet

VkDescriptorSetLayout raytracingDescriptorSetLayout = {VK_NULL_HANDLE}

class VulkanSwapChain

#include <VulkanSwapChain.hpp>

Public Functions

VulkanSwapChain()

void initVulkanContext(VulkanDevice *device, Window *window, const VkSurfaceKHR &surface)

inline const VkSwapchainKHR &getSwapChain() const

inline uint32_t getNumberSwapChainImages() const

inline const VkExtent2D &getSwapChainExtent() const

inline const VkFormat &getSwapChainFormat() const

inline Texture &getSwapChainImage(uint32_t index)

void cleanUp()

~VulkanSwapChain()

Private Functions

VkSurfaceFormatKHR choose_best_surface_format(const std::vector<VkSurfaceFormatKHR> &formats)

VkPresentModeKHR choose_best_presentation_mode(const std::vector<VkPresentModeKHR> &presentation_modes)

VkExtent2D choose_swap_extent(const VkSurfaceCapabilitiesKHR &surface_capabilities)

Private Members

VulkanDevice *device = {VK_NULL_HANDLE}

Window *window = {VK_NULL_HANDLE}

VkSwapchainKHR swapchain = {VK_NULL_HANDLE}

std::vector<Texture> swap_chain_images

VkFormat swap_chain_image_format = {VK_FORMAT_B8G8R8A8_UNORM}

VkExtent2D swap_chain_extent = {0, 0}

class Window

#include <Window.hpp>

Public Functions

Window()

Window(uint32_t window_width, uint32_t window_height)

int initialize()

void cleanUp()

inline bool get_should_close()

inline float get_buffer_width() const

inline float get_buffer_height() const

float get_x_change()

float get_y_change()

inline GLFWwindow *get_window()

float get_height()

float get_width()

inline bool *get_keys()

bool framebuffer_size_has_changed()

void reset_framebuffer_has_changed()

void update_viewport()

void set_buffer_size(float window_buffer_width, float window_buffer_height)

~Window()

Private Functions

void init_callbacks()

Private Members

GLFWwindow *main_window

uint32_t window_width

uint32_t window_height

bool keys[1024]

float last_x

float last_y

float x_change

float y_change

bool mouse_first_moved

bool framebuffer_resized

int window_buffer_width

int window_buffer_height

Private Static Functions

static void framebuffer_size_callback(GLFWwindow *window, int width, int height)

static void key_callback(GLFWwindow *window, int key, int code, int action, int mode)

static void mouse_callback(GLFWwindow *window, double x_pos, double y_pos)

static void mouse_button_callback(GLFWwindow *window, int button, int action, int mods)

namespace debug

Functions

VKAPI_ATTR VkBool32 VKAPI_CALL debugUtilsMessengerCallback (VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData, void *pUserData)

void setupDebugging(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportCallbackEXT callBack)

void freeDebugCallback(VkInstance instance)

VKAPI_ATTR VkBool32 VKAPI_CALL messageCallback (VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t srcObject, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg, void *pUserData)

Variables

PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT

PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT

VkDebugUtilsMessengerEXT debugUtilsMessenger

int validationLayerCount

const char *validationLayerNames[]

namespace sceneConfig

Functions

std::string getModelFile()

glm::mat4 getModelMatrix()

namespace ShaderIncludes

Functions

std::string getShaderIncludes()

namespace vertex

Functions

std::array<VkVertexInputAttributeDescription, 4> getVertexInputAttributeDesc()

file Cache.cmake

file CompilerWarnings.cmake

file CPackOptions.cmake

file Doxygen.cmake

file Hardening.cmake

file InterproceduralOptimization.cmake

file PreventInSourceBuilds.cmake

file ProjectOptions.cmake

file Sanitizers.cmake

file Speedup.cmake

file StandardProjectSettings.cmake

file StaticAnalyzers.cmake

file SystemLibDependencies.cmake

file Tests.cmake

file clouds.glsl

file CloudsRectangle.frag

file CloudsRectangle.vert

file noise_texture_128_res.comp

file noise_texture_32_res.comp

file directional_light.glsl

file grad_noise.glsl

file light.glsl

file material.glsl

file Matlib.glsl

file point_light.glsl

file raycommon.glsl

file ShadingLibrary.glsl

file worley_noise.glsl

file bindings.hpp

#include “GlobalValues.hpp”

#include “host_device_shared.hpp”

Defines

MODEL_TEXTURES_SLOT

SKYBOX_TEXTURES_SLOT

GBUFFER_TEXTURES_SLOT

D_LIGHT_SHADOW_TEXTURES_SLOT

P_LIGHT_SHADOW_TEXTURES_SLOT

NOISE_128D_TEXTURES_SLOT

NOISE_32D_TEXTURES_SLOT

NOISE_CELL_POSITIONS_SLOT

RANDOM_NUMBERS_SLOT

NOISE_128D_IMAGE_SLOT

NOISE_32D_IMAGE_SLOT

STORAGE_BUFFER_MATERIAL_ID_BINDING

UNIFORM_LIGHT_MATRICES_BINDING

file GlobalValues.hpp

Defines

NUM_MIN_CASCADES

MAX_RESOLUTION_X

MAX_RESOLUTION_Y

Variables

const int G_BUFFER_SIZE = 4

const int NUM_FRUSTUM_PLANES = 6

const int NUM_CLOUDS = 1

file host_device_shared.hpp

Defines

PI_DEF

Variables

const int NUM_CASCADES = 3

const int MAX_POINT_LIGHTS = 1

const int MAX_MATERIALS = 35

const int SKYBOX_MATERIAL_ID = MAX_MATERIALS

const int CLOUDS_MATERIAL_ID = MAX_MATERIALS + 1

const int MAX_TEXTURE_COUNT = 30

const float PI = 3.14159265359f

const int NUM_CELL_POSITIONS = 5

file host_device_shared_vars.hpp

Defines

globalUBO_BINDING

sceneUBO_BINDING

OBJECT_DESCRIPTION_BINDING

TEXTURES_BINDING

SAMPLER_BINDING

TLAS_BINDING

OUT_IMAGE_BINDING

Variables

const int MAX_TEXTURE_COUNT = 1

file loading_screen.frag

file loading_screen.vert

file path_tracing.comp

file disney.glsl

file frostbite.glsl

file pbrBook.glsl

file phong.glsl

file unreal4.glsl

file microfacet.glsl

file post.frag

file post.frag.log.txt

file post.vert

file post.vert.log.txt

file g_buffer_geometry_pass.frag

file g_buffer_geometry_pass.vert

file g_buffer_lighting_pass.frag

file g_buffer_lighting_pass.vert

file shader.frag

file shader.frag.log.txt

file shader.vert

file shader.vert.log.txt

file directional_shadow_map.frag

file directional_shadow_map.vert

file omni_shadow_map.frag

file omni_shadow_map.vert

file raytrace.rchit

file raytrace.rchit.log.txt

file raytrace.rgen

file raytrace.rgen.log.txt

file raytrace.rmiss

file raytrace.rmiss.log.txt

file shadow.rmiss

file shadow.rmiss.log.txt

file SkyBox.frag

file SkyBox.vert

file App.cpp

#include “App.hpp”

#include <vulkan/vulkan.h>

#include <GLFW/glfw3.h>

#include <glm/glm.hpp>

#include <glm/mat4x4.hpp>

#include <iostream>

#include <memory>

#include <stdexcept>

#include <vector>

#include “GUI.hpp”

#include “VulkanRenderer.hpp”

#include “Window.hpp”

Defines

GLFW_INCLUDE_NONE

GLFW_INCLUDE_VULKAN

GLM_FORCE_RADIANS

GLM_FORCE_DEPTH_ZERO_TO_ONE

file App.hpp

file CompileShadersToSPV.cmake

file SetExternalLibsFilters.cmake

file SetProjectFilters.cmake

file SetShaderFilters.cmake

file SetSourceGroups.cmake

file CMakeLists.txt

Functions

set (PROJECT_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/) set(PROJECT_INCLUDE_DIR $

set (EXTERNAL_LIB_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}../../ExternalLib/) set(SHADER_SRC_DIR $

Resources Shaders include (cmake/filters/SetShaderFilters.cmake) include(cmake/filters/SetProjectFilters.cmake) include(cmake/SetSourceGroups.cmake) include(cmake/filters/SetExternalLibsFilters.cmake) file(GLOB_RECURSE VULKANRENDERER_SOURCES "*.hpp" "*.cpp") if(RUST_FEATURES) corrosion_import_crate(MANIFEST_PATH rusty_code/Cargo.toml) corrosion_add_cxxbridge(rusty_bridge CRATE rusty_code MANIFEST_PATH rusty_code FILES lib.rs) endif() add_executable($

file CMakeLists.txt

file CMakeLists.txt

Functions

set (WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../../../) set(PROJECT_SRC_DIR $

Src GraphicsEngineOpenGL set (PROJECT_INCLUDE_DIR ${WORKING_DIRECTORY}Src/GraphicsEngineOpenGL/) set(EXTERNAL_LIB_SRC_DIR $

ExternalLib set (SHADER_SRC_DIR ${WORKING_DIRECTORY}Resources/Shaders/) include($

cmake filters SetShaderFilters cmake include (${PROJECT_SRC_DIR}cmake/filters/SetProjectFilters.cmake) include($

cmake filters SetExternalLibsFilters cmake include (cmake/SetTestFilters.cmake) set(COMMIT_TEST_SUITE_OPENGL commitTestSuiteOpenGL) add_executable($

file CMakeLists.txt

Functions

include (GoogleTest) set(WORKING_DIRECTORY $

set (PROJECT_SRC_DIR ${WORKING_DIRECTORY}Src/GraphicsEngineVulkan/) set(PROJECT_INCLUDE_DIR $

Src GraphicsEngineVulkan set (EXTERNAL_LIB_SRC_DIR ${WORKING_DIRECTORY}ExternalLib/) set(SHADER_SRC_DIR $

Resources Shaders include (${PROJECT_SRC_DIR}cmake/filters/SetShaderFilters.cmake) include($

file CMakeLists.txt

Functions

include (GoogleTest) set(WORKING_DIRECTORY $

set (PROJECT_SRC_DIR ${WORKING_DIRECTORY}Src/GraphicsEngineVulkan/) set(PROJECT_INCLUDE_DIR $

Src GraphicsEngineVulkan set (EXTERNAL_LIB_SRC_DIR ${WORKING_DIRECTORY}ExternalLib/) set(SHADER_SRC_DIR $

Resources Shaders include (${WORKING_DIRECTORY}Src/GraphicsEngineVulkan/cmake/filters/SetShaderFilters.cmake) include($

file CMakeLists.txt

file CMakeLists.txt

Functions

set (WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../../) set(PROJECT_SRC_DIR $

Src GraphicsEngineVulkan set (PROJECT_INCLUDE_DIR ${WORKING_DIRECTORY}Src/GraphicsEngineVulkan/) set(EXTERNAL_LIB_SRC_DIR $

ExternalLib set (SHADER_SRC_DIR ${WORKING_DIRECTORY}Resources/Shaders/) include($

Src GraphicsEngineVulkan cmake filters SetShaderFilters cmake include (${WORKING_DIRECTORY}Src/GraphicsEngineVulkan/cmake/filters/SetProjectFilters.cmake) include($

Src GraphicsEngineVulkan cmake filters SetExternalLibsFilters cmake include (cmake/SetTestFilters.cmake) set(PERF_TEST_SUITE perfTestSuite) add_executable($

file FormatHelper.hpp

#include <vulkan/vulkan.h>

#include <stdexcept>

#include <vector>

#include “spdlog/spdlog.h”

Functions

static VkFormat choose_supported_format(VkPhysicalDevice physical_device, const std::vector<VkFormat> &formats, VkImageTiling tiling, VkFormatFeatureFlags feature_flags)

file Globals.hpp

Variables

const int MAX_FRAME_DRAWS = 3

const int MAX_OBJECTS = 40

file MemoryHelper.hpp

#include <vulkan/vulkan.h>

Functions

static uint32_t align_up(uint32_t memory, uint32_t alignment)

static uint32_t find_memory_type_index(VkPhysicalDevice physical_device, uint32_t allowed_types, VkMemoryPropertyFlags properties)

file Utilities.hpp

#include <stdexcept>

#include “spdlog/spdlog.h”

#include “host_device_shared_vars.hpp”

Defines

ASSERT_VULKAN(val, error_string)

NOT_YET_IMPLEMENTED

Variables

const bool ENABLE_VALIDATION_LAYERS = true

file GUI.cpp

#include “GUI.hpp”

#include “QueueFamilyIndices.hpp”

#include “Utilities.hpp”

#include “VulkanDevice.hpp”

#include “VulkanRendererConfig.hpp”

#include <filesystem>

#include <imgui.h>

#include <imgui_impl_glfw.h>

#include <imgui_impl_vulkan.h>

file GUI.hpp

#include <memory>

#include “CommandBufferManager.hpp”

#include “GUIRendererSharedVars.hpp”

#include “GUISceneSharedVars.hpp”

#include “Globals.hpp”

#include “VulkanDevice.hpp”

#include “Window.hpp”

file Main.cpp

#include “App.hpp”

#include “rusty_bridge/lib.h”

#include <iostream>

Functions

int32_t rusty_extern_c_integer()

int main()

file Allocator.cpp

#include “Allocator.hpp”

#include “Utilities.hpp”

file Allocator.hpp

#include <vk_mem_alloc.h>

#include <vulkan/vulkan.h>

#include <stdexcept>

file ASManager.cpp

#include “ASManager.hpp”

file ASManager.hpp

#include <vulkan/vulkan.h>

#include “BottomLevelAccelerationStructure.hpp”

#include “CommandBufferManager.hpp”

#include “Scene.hpp”

#include “TopLevelAccelerationStructure.hpp”

#include “VulkanDevice.hpp”

file BottomLevelAccelerationStructure.hpp

#include <vulkan/vulkan.h>

#include “VulkanBuffer.hpp”

file TopLevelAccelerationStructure.hpp

#include <vulkan/vulkan.h>

#include “VulkanBuffer.hpp”

file CommandBufferManager.cpp

#include “CommandBufferManager.hpp”

#include “Utilities.hpp”

file CommandBufferManager.hpp

#include <vulkan/vulkan.h>

file GlobalUBO.hpp

file GUIRendererSharedVars.hpp

file PathTracing.cpp

#include “PathTracing.hpp”

#include <algorithm>

#include <array>

#include <filesystem>

#include “File.hpp”

#include “ShaderHelper.hpp”

#include “VulkanRendererConfig.hpp”

#include <Utilities.hpp>

file PathTracing.hpp

#include <vulkan/vulkan.h>

#include “PushConstantPathTracing.hpp”

#include “VulkanDevice.hpp”

#include “VulkanSwapChain.hpp”

file PostStage.cpp

#include “PostStage.hpp”

#include <array>

#include <filesystem>

#include <vector>

#include “File.hpp”

#include “FormatHelper.hpp”

#include “GUI.hpp”

#include “PushConstantPost.hpp”

#include “ShaderHelper.hpp”

#include “Vertex.hpp”

#include “VulkanRendererConfig.hpp”

#include <Utilities.hpp>

#include <imgui.h>

#include <imgui_impl_glfw.h>

#include <imgui_impl_vulkan.h>

file PostStage.hpp

#include “VulkanDevice.hpp”

#include “VulkanSwapChain.hpp”

#include <vulkan/vulkan.h>

file PushConstantPathTracing.hpp

file PushConstantPost.hpp

file PushConstantRasterizer.hpp

file PushConstantRayTracing.hpp

file QueueFamilyIndices.hpp

file Rasterizer.cpp

#include “Rasterizer.hpp”

#include <array>

#include <filesystem>

#include <vector>

#include “File.hpp”

#include “FormatHelper.hpp”

#include “ShaderHelper.hpp”

#include “Vertex.hpp”

#include “VulkanRendererConfig.hpp”

#include <Utilities.hpp>

file Rasterizer.hpp

#include <vulkan/vulkan.h>

#include “PushConstantRasterizer.hpp”

#include “Scene.hpp”

#include “Texture.hpp”

#include “VulkanDevice.hpp”

#include “VulkanSwapChain.hpp”

file Raytracing.cpp

#include “Raytracing.hpp”

#include <array>

#include <filesystem>

#include <sstream>

#include <vector>

#include “File.hpp”

#include “MemoryHelper.hpp”

#include “ShaderHelper.hpp”

#include “VulkanRendererConfig.hpp”

#include <Utilities.hpp>

file Raytracing.hpp

#include <vulkan/vulkan.h>

#include “PushConstantRayTracing.hpp”

#include “VulkanBuffer.hpp”

#include “VulkanSwapChain.hpp”

file SceneUBO.hpp

file SwapChainDetails.hpp

#include <vulkan/vulkan.h>

#include <vector>

file VulkanRenderer.cpp

#include “VulkanRenderer.hpp”

#include “GUISceneSharedVars.hpp”

#include “PushConstantRasterizer.hpp”

#include “PushConstantRayTracing.hpp”

#include “QueueFamilyIndices.hpp”

#include “Utilities.hpp”

#include <GLFW/glfw3.h>

#include <stdio.h>

#include <stdlib.h>

#include <algorithm>

#include <array>

#include <cstring>

#include <glm/glm.hpp>

#include <glm/gtc/matrix_transform.hpp>

#include <iostream>

#include <memory>

#include <set>

#include <sstream>

#include <stdexcept>

#include <vector>

#include <vk_mem_alloc.h>

#include <stb_image.h>

#include <gsl/gsl>

#include “File.hpp”

#include “Globals.hpp”

#include “PushConstantPost.hpp”

#include “ShaderHelper.hpp”

#include “VulkanRendererConfig.hpp”

#include <VulkanDebug.hpp>

Defines

GLFW_INCLUDE_NONE

GLFW_INCLUDE_VULKAN

VMA_IMPLEMENTATION

STB_IMAGE_IMPLEMENTATION

file VulkanRenderer.hpp

#include “ASManager.hpp”

#include “Allocator.hpp”

#include “CommandBufferManager.hpp”

#include “GUI.hpp”

#include “GlobalUBO.hpp”

#include “PathTracing.hpp”

#include “PostStage.hpp”

#include “Rasterizer.hpp”

#include “Raytracing.hpp”

#include “Scene.hpp”

#include “SceneUBO.hpp”

#include “Texture.hpp”

#include “Camera.hpp”

#include “VulkanBuffer.hpp”

#include “VulkanBufferManager.hpp”

#include “VulkanDevice.hpp”

#include “VulkanInstance.hpp”

#include “VulkanSwapChain.hpp”

#include “Window.hpp”

file VulkanRendererConfig.h

Defines

VulkanRenderer_VERSION_MAJOR

VulkanRenderer_VERSION_MINOR

VULKAN_VERSION_MAJOR

VULKAN_VERSION_MINOR

GLSLC_EXE

RELATIVE_RESOURCE_PATH

RELATIVE_IMGUI_FONTS_PATH

file VulkanRendererConfig.hpp

Defines

VulkanRenderer_VERSION_MAJOR

VulkanRenderer_VERSION_MINOR

VULKAN_VERSION_MAJOR

VULKAN_VERSION_MINOR

GLSLC_EXE

file Camera.cpp

#include “Camera.hpp”

#include <GLFW/glfw3.h>

Defines

GLFW_INCLUDE_NONE

GLFW_INCLUDE_VULKAN

file Camera.hpp

#include <glm/glm.hpp>

#include <glm/gtc/matrix_transform.hpp>

file GUISceneSharedVars.hpp

file Mesh.cpp

#include “Mesh.hpp”

#include <cstring>

#include <memory>

#include “Utilities.hpp”

#include “VulkanBuffer.hpp”

file Mesh.hpp

#include <glm/glm.hpp>

#include <vector>

#include “ObjMaterial.hpp”

#include “ObjectDescription.hpp”

#include “Vertex.hpp”

#include “VulkanBufferManager.hpp”

file Model.cpp

#include “Model.hpp”

#include <Utilities.hpp>

#include <iostream>

#include <unordered_map>

file Model.hpp

#include <memory>

#include <vector>

#include “Mesh.hpp”

#include “Texture.hpp”

file ObjectDescription.hpp

file ObjLoader.cpp

#include “ObjLoader.hpp”

#include <tiny_obj_loader.h>

#include “File.hpp”

#include <iostream>

#include <unordered_map>

Defines

TINYOBJLOADER_IMPLEMENTATION

file ObjLoader.hpp

#include <vulkan/vulkan.h>

#include <memory>

#include “Model.hpp”

#include “ObjMaterial.hpp”

#include “Vertex.hpp”

file ObjMaterial.hpp

file Scene.cpp

#include “Scene.hpp”

#include “ObjLoader.hpp”

#include “Utilities.hpp”

#include “spdlog/spdlog.h”

file Scene.hpp

#include <stdio.h>

#include <stdlib.h>

#include <algorithm>

#include <glm/glm.hpp>

#include <glm/gtc/matrix_transform.hpp>

#include <iostream>

#include <memory>

#include <set>

#include <stdexcept>

#include <vector>

#include “GUI.hpp”

#include “GUISceneSharedVars.hpp”

#include “Mesh.hpp”

#include “Model.hpp”

#include “SceneConfig.hpp”

file SceneConfig.cpp

#include “SceneConfig.hpp”

#include “VulkanRendererConfig.hpp”

#include <filesystem>

#include <sstream>

file SceneConfig.hpp

#include <glm/glm.hpp>

#include <glm/gtc/matrix_transform.hpp>

#include <string>

file Texture.cpp

#include “Texture.hpp”

#include “Utilities.hpp”

#include <cmath>

#include <stdexcept>

#include “spdlog/spdlog.h”

file Texture.hpp

#include <stb_image.h>

#include <vulkan/vulkan.h>

#include <string>

#include “VulkanBuffer.hpp”

#include “VulkanBufferManager.hpp”

#include “VulkanImage.hpp”

#include “VulkanImageView.hpp”

file Vertex.cpp

#include “Vertex.hpp”

file Vertex.hpp

file File.cpp

#include “File.hpp”

#include “spdlog/spdlog.h”

#include <fstream>

#include <iostream>

file File.hpp

#include <string>

#include <vector>

file ShaderHelper.cpp

#include <iomanip>

#include <sstream>

#include “ShaderHelper.hpp”

#include “ShaderIncludes.hpp”

#include “Utilities.hpp”

#include “VulkanRendererConfig.hpp”

#include “spdlog/spdlog.h”

file ShaderHelper.hpp

#include <vulkan/vulkan.h>

#include <string>

#include <vector>

#include “VulkanDevice.hpp”

file ShaderIncludes.hpp

#include “VulkanRendererConfig.hpp”

#include <filesystem>

#include <string>

#include <vector>

#include “spdlog/spdlog.h”

file VulkanBuffer.cpp

#include “VulkanBuffer.hpp”

#include <stdexcept>

#include “MemoryHelper.hpp”

#include “Utilities.hpp”

file VulkanBuffer.hpp

#include <vulkan/vulkan.h>

#include “VulkanDevice.hpp”

file VulkanBufferManager.cpp

#include “VulkanBufferManager.hpp”

#include “Utilities.hpp”

file VulkanBufferManager.hpp

#include <vulkan/vulkan.h>

#include <vector>

#include “CommandBufferManager.hpp”

#include “VulkanBuffer.hpp”

#include <cstring>

file VulkanDebug.cpp

#include “VulkanDebug.hpp”

#include <iostream>

#include <sstream>

#include <string>

#include “Utilities.hpp”

file VulkanDebug.hpp

#include <vulkan/vulkan.h>

file VulkanDevice.cpp

#include “VulkanDevice.hpp”

#include <string.h>

#include <Utilities.hpp>

#include <set>

#include <stdexcept>

#include <string>

#include “spdlog/spdlog.h”

file VulkanDevice.hpp

#include <vulkan/vulkan.h>

#include <vector>

#include “QueueFamilyIndices.hpp”

#include “SwapChainDetails.hpp”

#include “VulkanInstance.hpp”

file VulkanImage.cpp

#include “VulkanImage.hpp”

#include “MemoryHelper.hpp”

#include “Utilities.hpp”

file VulkanImage.hpp

#include <vulkan/vulkan.h>

#include “CommandBufferManager.hpp”

#include “VulkanDevice.hpp”

file VulkanImageView.cpp

#include “VulkanImageView.hpp”

#include <Utilities.hpp>

file VulkanImageView.hpp

#include <vulkan/vulkan.h>

#include “VulkanDevice.hpp”

file VulkanInstance.cpp

#include “VulkanInstance.hpp”

#include “VulkanDebug.hpp”

#include <Utilities.hpp>

#include <string.h>

#include <string>

file VulkanInstance.hpp

#include <vulkan/vulkan.h>

#include <GLFW/glfw3.h>

#include <vector>

Defines

GLFW_INCLUDE_NONE

GLFW_INCLUDE_VULKAN

file VulkanSwapChain.cpp

#include “VulkanSwapChain.hpp”

#include <limits>

#include “Utilities.hpp”

file VulkanSwapChain.hpp

#include “Texture.hpp”

#include “VulkanDevice.hpp”

#include “Window.hpp”

file Window.cpp

#include “Window.hpp”

#include “spdlog/spdlog.h”

#include <imgui.h>

#include <imgui_impl_glfw.h>

#include <imgui_impl_vulkan.h>

#include <stdexcept>

Functions

static void onErrorCallback(int error, const char *description)

file Window.hpp

#include <stdio.h>

#include <GLFW/glfw3.h>

Defines

GLFW_INCLUDE_NONE

GLFW_INCLUDE_VULKAN

file commitSuite.cpp

#include <gtest/gtest.h>

#include <sstream>

#include <filesystem>

#include <vector>

#include <glad/glad.h>

#include <GLFW/glfw3.h>

#include <iostream>

#include <cstdio>

#include <memory>

#include <string>

#include “ObjLoader.hpp”

#include “Rotation.hpp”

#include “OpenGLRendererConfig.hpp”

#include “GameObject.hpp”

#include “Renderer.hpp”

#include “DebugApp.hpp”

#include “GUI.hpp”

#include “LoadingScreen.hpp”

#include “File.hpp”

#include “Camera.hpp”

#include “GlobalValues.hpp”

#include “Scene.hpp”

#include “Window.hpp”

#include “host_device_shared.hpp”

Functions

TEST(RendererTest, BasicSetup)

TEST(ObjLoaderTest, blob)

file commitSuite.cpp

#include <gtest/gtest.h>

#include <vulkan/vulkan.h>

#include <GLFW/glfw3.h>

#include <glm/glm.hpp>

#include <glm/mat4x4.hpp>

#include <iostream>

#include <memory>

#include <stdexcept>

#include <vector>

#include “GUI.hpp”

#include “VulkanRenderer.hpp”

#include “Window.hpp”

Defines

GLFW_INCLUDE_NONE

GLFW_INCLUDE_VULKAN

GLM_FORCE_RADIANS

GLM_FORCE_DEPTH_ZERO_TO_ONE

Functions

TEST(HelloTestCommit, BasicAssertions)

TEST(Integration, VulkanEngine)

file SetTestFilters.cmake

file SetTestFilters.cmake

file SetTestFilters.cmake

file SetTestFilters.cmake

file compileSuite.cpp

#include “VulkanBuffer.hpp”

#include <gtest/gtest.h>

Functions

TEST(HelloTestCompile, BasicAssertions)

TEST(HelloTestCompile, blob)

file dummy.cpp

#include “fuzztest/fuzztest.h”

#include “gtest/gtest.h”

Functions

TEST(MyTestSuite, OnePlustTwoIsTwoPlusOne)

void IntegerAdditionCommutes(int a, int b)

FUZZ_TEST(MyTestSuite, IntegerAdditionCommutes)

file perfSuite.cpp

#include “VulkanBuffer.hpp”

#include <benchmark/benchmark.h>

Functions

static void BM_StringCreation(benchmark::State &state)

BENCHMARK(BM_StringCreation)

static void BM_StringCopy(benchmark::State &state)

BENCHMARK(BM_StringCopy)

BENCHMARK_MAIN()

dir Src/GraphicsEngineVulkan/renderer/accelerationStructures

dir Src/GraphicsEngineVulkan/app

dir Resources/Shaders/pbr/brdf

dir Resources/Shaders/clouds

dir cmake

dir Src/GraphicsEngineVulkan/cmake

dir Test/commit/OpenGLEngine/cmake

dir Test/commit/VulkanEngine/cmake

dir Test/compile/cmake

dir Test/perf/cmake

dir Test/commit

dir Resources/Shaders/common

dir Src/GraphicsEngineVulkan/common

dir Test/compile

dir Src/GraphicsEngineVulkan/cmake/filters

dir Test/fuzz

dir Src/GraphicsEngineVulkan

dir Src/GraphicsEngineVulkan/gui

dir Resources/Shaders/hostDevice

dir Resources/Shaders/loading_screen

dir Src/GraphicsEngineVulkan/memory

dir Test/commit/OpenGLEngine

dir Resources/Shaders/path_tracing

dir Resources/Shaders/pbr

dir Test/perf

dir Resources/Shaders/post

dir Src/GraphicsEngineVulkan/renderer/pushConstants

dir Resources/Shaders/rasterizer

dir Resources/Shaders/raytracing

dir Src/GraphicsEngineVulkan/renderer

dir Resources

dir Src/GraphicsEngineVulkan/scene

dir Resources/Shaders

dir Resources/Shaders/rasterizer/shadows

dir Resources/Shaders/skybox

dir Src

dir Test

dir Src/GraphicsEngineVulkan/util

dir Src/GraphicsEngineVulkan/vulkan_base

dir Test/commit/VulkanEngine

dir Src/GraphicsEngineVulkan/window