Implemented basic normal-dot product shading, preparing for more complex methods such as Blinn-Phong and PBR

.gitignore

@@ -6,7 +6,9 @@
 *.slo
 *.lo
 *.o
-*.obj
+
+# Compiled Shader files
+*.spv
 
 # Precompiled Headers
 *.gch
@@ -31,4 +33,6 @@
 *.exe
 *.out
 *.app
+build/
 
+compile_commands.json

Flowgraph.puml

@@ -0,0 +1,222 @@
+@startuml
+title Main Execution
+caption 
+  //**Main execution from the run function in the entrypoint**//
+  //**This dictates basic flow of the vulkan boilerplate system. **//
+endcaption
+
+://**main()**//; <<procedure>>
+://**run()**//; <<procedure>>
+split
+://**initWindow()**//; <<procedure>>
+:glfwInit();
+:window = glfwCreateWindow(...);
+note left
+  //Create window and initialize default settings//
+endnote
+:glfwSetWindowUserPointer(...);
+note left 
+  //Set the user-defined pointer of the window//
+endnote
+:glfwSetFramebufferSizeCallback(...);
+note left 
+  //This is a callback to resizing of the window//
+  //we call and set a bool to true, which we get//
+  //and rebuild the swap chain when true.//
+endnote
+stop
+split again
+://**initVulkan()**//; <<procedure>>
+split
+://**createInstance()**//; <<procedure>>
+split
+:**Debug**::checkUnavailableValidationLayers();
+:**VkApplicationInfo** appInfo{};
+://set appInfo data, Vulkan version,// 
+//Engine version and name, and title//;
+:**VkApplicationCreateInfo** createInfo{};
+:createInfo.pApplicationInfo = &appInfo;
+:Debug::vulkanDebugSetup(createInfo, vulkaninstance);
+end split
+split again
+:**Debug**::setupDebugMessenger(VkInstance&);
+note right: Setup debug messenger, print data to console
+
+partition "**DeviceControl**" {
+:createSurface(...);
+note right
+  This function handles Window System Integration 
+  automatically across platforms based on build environment.
+  ====
+  //Basically, this is an abstraction of the Window across platforms//
+end note
+  :pickPhysicalDevice(...);
+  note right
+    Enumerate through GPU's in the 
+    system and choose a compatible one.
+    ====
+    //in the future, this should choose the BEST// 
+    //GPU, not just the first one that is compatible..//
+  end note
+  :createLogicalDevice(...);
+  note right
+    Logical devices interface with the 
+    physical device and defines queues
+  end note
+  :createSwapChain(...);
+  note right
+    Swap Chains are used to handle buffer ownership 
+    infrastructure. Being platform agnostic has its 
+    complications, this is a perfect example.
+    This process is HEAVILY documented.
+  end note
+  :createImageViews(...);
+  note right
+    This is a cool function, quite a simple
+    description of images that will be shown on the
+    screen! It also determines //how// to access the image
+  end note
+}
+
+:**Graphics**::createRenderPass(...);
+note right
+  This is pretty simple, it sets up the image bit depth 
+  and the color bit depth! Basically, the format of the
+  displayed images, simple, but important!
+end note
+:**Buffers**::createDescriptorSetLayout();
+note right 
+  This function creates a table of pointers to the stored
+  data that we want, in this case it would be pointing to 
+  pre-programmed model view and projection values, and 
+  a time variable.
+end note
+partition "**Graphics**" {
+  :createGraphicsPipeline(...);
+  note right
+    This is a complex function that goes through every 
+    step of the render pipeline and sets the settings we
+    desire for each step! **HEAVILY** documented.
+  end note
+  :createCommandPool(...);
+  note right
+    Commands in Vulkan are not executed using function calls 
+    You have to record the ops you want to perform to command 
+    buffer objects, pools manage the memory used for buffers.
+  end note
+}
+
+:**Texture**::createDepthResources();
+note right 
+  This function sets up the image views and sets for the 
+  depth testing buffer to handle objects above or below
+  other objects!
+end note
+:**Graphics**::createFramebuffers(...);
+note right
+  This function creates framebuffers for all the images 
+  that are queued to be displayed, very important!
+end note
+
+partition "**Texture**" {
+  :createTextureImage();
+  note right 
+    This function imports the pixels from an image, puts them
+    into a buffer, and copies them from memory into a texture!
+    A bit complicated because we are moving and freeing lots of
+    memory, but quite useful.
+  end note
+  :createTextureImageView();
+  note right
+    This function creates a image view for the texture, just 
+    builds a struct holding information about the texture, like
+    layers, mip levels, and etc.
+  end note
+  :createTextureSampler();
+  note right
+    This function is **incredibly** important. This builds a 
+    texture sampler, information about what to do with the 
+    texture once its created. This defines settings like 
+    //UVW mode//, //Filtering//, //Anisotropy//, and 
+    //Mipmap modes//
+  end note
+}
+partition "**Model**" {
+  :loadModel();
+  note right 
+    Exactly what it sounds like, as of now, call our function 
+    to load .OBJ files with STB. Obviously want to support FBX 
+    in the future but the format is quite complex.
+    This function simply loads vertices and indices into the 
+    arrays to be parsed!
+  end note
+}
+partition "**Buffers**" {
+  :createVertexBuffer();
+  note right 
+    Vertex buffers are incredibly useful, in essence,
+    you can read data from memory as vertex input to the
+    vertex shader rather than hardcoded data!
+  end note
+  :createIndexBuffer();
+  note right
+    Index buffers are cool, basically, you can store
+    some vertices that would normally be duplicated 
+    at corners to triangulate. this saves cycles at 
+    scale, complex objects rejoice!
+  end note
+  :createUniformBuffer();
+  note right
+    Map the buffer data to memory (The struct) as a pointer
+    we can use this as a reference of where to write data to 
+    when the fence lets us write data.
+    (see **recordCommandBuffer()**).
+  end note
+  :createDescriptorPool();
+  note right
+    Here we create a pool to manage the memory and allocate
+    space for the descriptor sets! Very useful and the same 
+    structure as command buffers & pools.
+  end note
+  :createDescriptorSetLayout();
+  note right
+    //Descriptor set **layouts** specify the types of resources accessible//
+    //by the graphical pipeline. A descriptor set is the actual buffer//
+    //or resource that gets bound to descriptors and passed in.//
+    These differ from Vertex & Index buffers, as they are not unique
+    to the graphics pipeline. Specification of compute vs. graphics is 
+    therefore necessary. (see **createDescriptorSets()**)
+  end note
+}
+:**Graphics**::createCommandBuffer();
+note right 
+  This is the partner to the commandPool creator, 
+  storing the commands we wish to perform whilst 
+  waiting in a queue. These are very efficient.
+end note
+:**RenderPresent**::createSyncObject();
+note right
+  This is **HEAVILY** documented, create Semaphores
+  and Fences, for halting and starting execution, basically 
+  a traffic controller for the GPU.
+end note
+end split
+stop
+split again
+repeat ://**mainLoop()**//; <<procedure>>
+  :glfwPollEvents();
+  :RenderPresent::drawFrame();
+repeat while (!glfwWindowShouldClose(...))
+  :vkDeviceWaitIdle(...);
+stop
+split again
+://**cleanup()**//; <<procedure>>
+note right
+  //This function initiates a series of shutdown//
+  //destroy functions, safely stopping execution//;
+endnote
+:return EXIT_SUCCESS;
+stop
+end split
+
+@enduml

Makefile

@@ -1,32 +1,58 @@
-CC=gcc
+CPPFLAGS=-std=c++23 -g
-CXX=g++
+CFLAGS = -g
-CPPFLAGS=-g
+LDFLAGS=-lglfw -Ilib -ldl -lpthread -lX11 -lXxf86vm -lXrandr -lXi -ltinyobjloader -Ilib/imgui -DIMGUI_IMPL_VULKAN_NO_PROTOTYPES
-
+MAKEFLAGS += -j16
-SRC=$(shell find . -name *.cpp)
+SRC = $(shell find . -name "*.cpp")
-OBJ=$(SRC:%.cpp=%.o)
+CSRC = $(shell find . -name "*.c")
-BIN= build/placeholderengine
+SHDRSRC = $(shell find . -name "*.frag" -o -name "*.vert")
-
+SPV = $(SHDRSRC:%.vert=%.spv) $(SHDRSRC:%.frag=%.spv)
+OBJ = $(SRC:%.cpp=%.o)
+COBJ=$(CSRC:%.c=%.o)
+BIN=build/agnosiaengine
 
 .PHONY: all
 all: $(BIN)
 
+.PHONY: run
+run: $(BIN)
+	./$(BIN)
+
+.PHONY: gdb
+gdb: $(BIN)
+	gdb -q $(BIN)
+.PHONY: debug
+debug: $(BIN)
+	./$(BIN)
+
 .PHONY: dep
 dep: 
-	sudo pacman -S $(CC)
+	sudo pacman -S gcc glfw glm shaderc libxi libxxf86vm gdb shaderc stb
 .PHONY: info
 info: 
 	@echo "make:		Build executable"
 	@echo "make dep: 	Make all required dependencies"
 	@echo "make debug: 	Make with Debug hooked in"
+	@echo "make gdb:	Make with GDB hooked in"
 	@echo "make clean:	Clean all files"
+	@echo "make run: 	Run the executable after building"
 
-$(BIN): $(OBJ)
+$(BIN): $(OBJ) $(COBJ) $(SPV)
 	mkdir -p build
-	$(CXX) $(CPPFLAGS) -o $(BIN) $(OBJ)
+	g++ $(CPPFLAGS) -o $(BIN) $(OBJ) $(COBJ) $(LDFLAGS)
 
 %.o: %.cpp
-	g++ -c $< -o $@
+	g++ -c $(CPPFLAGS) $< -o $@ $(LDFLAGS)
+%.o : %.c
+	gcc -c $(CFLAGS) $< -o $@ $(LDFLAGS)
+%.spv: %.frag
+	glslc $< -o $@
+%.spv: %.vert
+	glslc $< -o $@
+%.spv: %.glsl
+	glslc $< -o $@
 
 .PHONY: clean
 clean:
 	rm -rf build
+	find . -name "*.o" -type f -delete
+	find . -name "*.spv" -type f -delete

README.md

@@ -1,8 +1,12 @@
-# PlaceholderNameEngine
+# Agnosia Engine
 
 ## Goals
 
+[Current Simple Docs](https://docs.vulkan.org/tutorial/latest/03_Drawing_a_triangle/00_Setup/00_Base_code.html)
 - Implement Vulkan SDK
 - Play with OpenXR
-- Raytracing, Raymarching
+- Implement features for maximum fidelity/performance ratio
+- Implement custom Raytracing and Raymarching protocols
+- Mess with cutting edge design, VDB's, 3D Guassian Splatting, 
+- 1000000+ FPS on Potato GPUs 
 

assets/models/UVSphere.mtl

@@ -0,0 +1,2 @@
+# Blender 4.2.3 LTS MTL File: 'None'
+# www.blender.org

assets/models/untitled.mtl

@@ -0,0 +1,2 @@
+# Blender 4.2.3 LTS MTL File: 'None'
+# www.blender.org

assets/models/untitled.obj

@@ -0,0 +1,39 @@
+# Blender 4.2.3 LTS
+# www.blender.org
+mtllib untitled.mtl
+o Cube
+v -6.996062 0.060240 6.002291
+v -6.996062 0.123414 6.002291
+v -6.996062 0.060240 -6.002291
+v -6.996062 0.123414 -6.002291
+v 6.996062 0.060240 6.002291
+v 6.996062 0.123414 6.002291
+v 6.996062 0.060240 -6.002291
+v 6.996062 0.123414 -6.002291
+vn -1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 -1.0000
+vn 1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 1.0000
+vn -0.0000 -1.0000 -0.0000
+vn -0.0000 1.0000 -0.0000
+vt 0.561014 0.000000
+vt 0.625000 0.000000
+vt 0.625000 0.250000
+vt 0.561014 0.250000
+vt 0.625000 0.500000
+vt 0.561014 0.500000
+vt 0.625000 0.750000
+vt 0.561014 0.750000
+vt 0.625000 1.000000
+vt 0.561014 1.000000
+vt 0.125000 0.500000
+vt 0.125000 0.750000
+vt 0.875000 0.500000
+vt 0.875000 0.750000
+s 0
+f 1/1/1 2/2/1 4/3/1 3/4/1
+f 3/4/2 4/3/2 8/5/2 7/6/2
+f 7/6/3 8/5/3 6/7/3 5/8/3
+f 5/8/4 6/7/4 2/9/4 1/10/4
+f 3/11/5 7/6/5 5/8/5 1/12/5
+f 8/5/6 4/13/6 2/14/6 6/7/6

imgui.ini

@@ -0,0 +1,8 @@
+[Window][Debug##Default]
+Pos=60,60
+Size=400,400
+
+[Window][Agnosia Debug]
+Pos=57,392
+Size=623,438
+

lib/imgui/imconfig.h

@@ -0,0 +1,138 @@
+//-----------------------------------------------------------------------------
+// DEAR IMGUI COMPILE-TIME OPTIONS
+// Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
+// You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
+//-----------------------------------------------------------------------------
+// A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/rebased branch with your modifications to it)
+// B) or '#define IMGUI_USER_CONFIG "my_imgui_config.h"' in your project and then add directives in your own file without touching this template.
+//-----------------------------------------------------------------------------
+// You need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include the imgui*.cpp
+// files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on data structures.
+// Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts.
+// Call IMGUI_CHECKVERSION() from your .cpp file to verify that the data structures your files are using are matching the ones imgui.cpp is using.
+//-----------------------------------------------------------------------------
+
+#pragma once
+
+//---- Define assertion handler. Defaults to calling assert().
+// If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
+//#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
+//#define IM_ASSERT(_EXPR)  ((void)(_EXPR))     // Disable asserts
+
+//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
+// Using Dear ImGui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
+// - Windows DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
+//   for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more details.
+//#define IMGUI_API __declspec(dllexport)                   // MSVC Windows: DLL export
+//#define IMGUI_API __declspec(dllimport)                   // MSVC Windows: DLL import
+//#define IMGUI_API __attribute__((visibility("default")))  // GCC/Clang: override visibility when set is hidden
+
+//---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to clean your code of obsolete function/names.
+//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+
+//---- Disable all of Dear ImGui or don't implement standard windows/tools.
+// It is very strongly recommended to NOT disable the demo windows and debug tool during development. They are extremely useful in day to day work. Please read comments in imgui_demo.cpp.
+//#define IMGUI_DISABLE                                     // Disable everything: all headers and source files will be empty.
+//#define IMGUI_DISABLE_DEMO_WINDOWS                        // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty.
+//#define IMGUI_DISABLE_DEBUG_TOOLS                         // Disable metrics/debugger and other debug tools: ShowMetricsWindow(), ShowDebugLogWindow() and ShowIDStackToolWindow() will be empty.
+
+//---- Don't implement some functions to reduce linkage requirements.
+//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc. (user32.lib/.a, kernel32.lib/.a)
+//#define IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS          // [Win32] [Default with Visual Studio] Implement default IME handler (require imm32.lib/.a, auto-link for Visual Studio, -limm32 on command-line for MinGW)
+//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // [Win32] [Default with non-Visual Studio compilers] Don't implement default IME handler (won't require imm32.lib/.a)
+//#define IMGUI_DISABLE_WIN32_FUNCTIONS                     // [Win32] Won't use and link with any Win32 function (clipboard, IME).
+//#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS      // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
+//#define IMGUI_DISABLE_DEFAULT_SHELL_FUNCTIONS             // Don't implement default platform_io.Platform_OpenInShellFn() handler (Win32: ShellExecute(), require shell32.lib/.a, Mac/Linux: use system("")).
+//#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS            // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf)
+//#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS              // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself.
+//#define IMGUI_DISABLE_FILE_FUNCTIONS                      // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle at all (replace them with dummies)
+//#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS              // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
+//#define IMGUI_DISABLE_DEFAULT_ALLOCATORS                  // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
+//#define IMGUI_DISABLE_SSE                                 // Disable use of SSE intrinsics even if available
+
+//---- Enable Test Engine / Automation features.
+//#define IMGUI_ENABLE_TEST_ENGINE                          // Enable imgui_test_engine hooks. Generally set automatically by include "imgui_te_config.h", see Test Engine for details.
+
+//---- Include imgui_user.h at the end of imgui.h as a convenience
+// May be convenient for some users to only explicitly include vanilla imgui.h and have extra stuff included.
+//#define IMGUI_INCLUDE_IMGUI_USER_H
+//#define IMGUI_USER_H_FILENAME         "my_folder/my_imgui_user.h"
+
+//---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
+//#define IMGUI_USE_BGRA_PACKED_COLOR
+
+//---- Use 32-bit for ImWchar (default is 16-bit) to support Unicode planes 1-16. (e.g. point beyond 0xFFFF like emoticons, dingbats, symbols, shapes, ancient languages, etc...)
+//#define IMGUI_USE_WCHAR32
+
+//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
+// By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
+//#define IMGUI_STB_TRUETYPE_FILENAME   "my_folder/stb_truetype.h"
+//#define IMGUI_STB_RECT_PACK_FILENAME  "my_folder/stb_rect_pack.h"
+//#define IMGUI_STB_SPRINTF_FILENAME    "my_folder/stb_sprintf.h"    // only used if IMGUI_USE_STB_SPRINTF is defined.
+//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
+//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
+//#define IMGUI_DISABLE_STB_SPRINTF_IMPLEMENTATION                   // only disabled if IMGUI_USE_STB_SPRINTF is defined.
+
+//---- Use stb_sprintf.h for a faster implementation of vsnprintf instead of the one from libc (unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined)
+// Compatibility checks of arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by stb_sprintf.h.
+//#define IMGUI_USE_STB_SPRINTF
+
+//---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
+// Requires FreeType headers to be available in the include path. Requires program to be compiled with 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided).
+// On Windows you may use vcpkg with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
+//#define IMGUI_ENABLE_FREETYPE
+
+//---- Use FreeType + plutosvg or lunasvg to render OpenType SVG fonts (SVGinOT)
+// Only works in combination with IMGUI_ENABLE_FREETYPE.
+// - lunasvg is currently easier to acquire/install, as e.g. it is part of vcpkg.
+// - plutosvg will support more fonts and may load them faster. It currently requires to be built manually but it is fairly easy. See misc/freetype/README for instructions.
+// - Both require headers to be available in the include path + program to be linked with the library code (not provided).
+// - (note: lunasvg implementation is based on Freetype's rsvg-port.c which is licensed under CeCILL-C Free Software License Agreement)
+//#define IMGUI_ENABLE_FREETYPE_PLUTOSVG
+//#define IMGUI_ENABLE_FREETYPE_LUNASVG
+
+//---- Use stb_truetype to build and rasterize the font atlas (default)
+// The only purpose of this define is if you want force compilation of the stb_truetype backend ALONG with the FreeType backend.
+//#define IMGUI_ENABLE_STB_TRUETYPE
+
+//---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
+// This will be inlined as part of ImVec2 and ImVec4 class declarations.
+/*
+#define IM_VEC2_CLASS_EXTRA                                                     \
+        constexpr ImVec2(const MyVec2& f) : x(f.x), y(f.y) {}                   \
+        operator MyVec2() const { return MyVec2(x,y); }
+
+#define IM_VEC4_CLASS_EXTRA                                                     \
+        constexpr ImVec4(const MyVec4& f) : x(f.x), y(f.y), z(f.z), w(f.w) {}   \
+        operator MyVec4() const { return MyVec4(x,y,z,w); }
+*/
+//---- ...Or use Dear ImGui's own very basic math operators.
+//#define IMGUI_DEFINE_MATH_OPERATORS
+
+//---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices.
+// Your renderer backend will need to support it (most example renderer backends support both 16/32-bit indices).
+// Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer.
+// Read about ImGuiBackendFlags_RendererHasVtxOffset for details.
+//#define ImDrawIdx unsigned int
+
+//---- Override ImDrawCallback signature (will need to modify renderer backends accordingly)
+//struct ImDrawList;
+//struct ImDrawCmd;
+//typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data);
+//#define ImDrawCallback MyImDrawCallback
+
+//---- Debug Tools: Macro to break in Debugger (we provide a default implementation of this in the codebase)
+// (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.)
+//#define IM_DEBUG_BREAK  IM_ASSERT(0)
+//#define IM_DEBUG_BREAK  __debugbreak()
+
+//---- Debug Tools: Enable slower asserts
+//#define IMGUI_DEBUG_PARANOID
+
+//---- Tip: You can add extra functions within the ImGui:: namespace from anywhere (e.g. your own sources/header files)
+/*
+namespace ImGui
+{
+    void MyFunction(const char* name, MyMatrix44* mtx);
+}
+*/

lib/imgui/imgui_impl_glfw.cpp

@@ -0,0 +1,925 @@
+// dear imgui: Platform Backend for GLFW
+// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
+// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
+// (Requires: GLFW 3.1+. Prefer GLFW 3.3+ or GLFW 3.4+ for full feature support.)
+
+// Implemented features:
+//  [X] Platform: Clipboard support.
+//  [X] Platform: Mouse support. Can discriminate Mouse/TouchScreen/Pen (Windows only).
+//  [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy GLFW_KEY_* values are obsolete since 1.87 and not supported since 1.91.5]
+//  [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
+//  [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+// About Emscripten support:
+// - Emscripten provides its own GLFW (3.2.1) implementation (syntax: "-sUSE_GLFW=3"), but Joystick is broken and several features are not supported (multiple windows, clipboard, timer, etc.)
+// - A third-party Emscripten GLFW (3.4.0) implementation (syntax: "--use-port=contrib.glfw3") fixes the Joystick issue and implements all relevant features for the browser.
+// See https://github.com/pongasoft/emscripten-glfw/blob/master/docs/Comparison.md for details.
+
+// CHANGELOG
+// (minor and older changes stripped away, please see git history for details)
+//  2024-08-22: moved some OS/backend related function pointers from ImGuiIO to ImGuiPlatformIO:
+//               - io.GetClipboardTextFn    -> platform_io.Platform_GetClipboardTextFn
+//               - io.SetClipboardTextFn    -> platform_io.Platform_SetClipboardTextFn
+//               - io.PlatformOpenInShellFn -> platform_io.Platform_OpenInShellFn
+//  2024-07-31: Added ImGui_ImplGlfw_Sleep() helper function for usage by our examples app, since GLFW doesn't provide one.
+//  2024-07-08: *BREAKING* Renamed ImGui_ImplGlfw_InstallEmscriptenCanvasResizeCallback to ImGui_ImplGlfw_InstallEmscriptenCallbacks(), added GLFWWindow* parameter.
+//  2024-07-08: Emscripten: Added support for GLFW3 contrib port (GLFW 3.4.0 features + bug fixes): to enable, replace -sUSE_GLFW=3 with --use-port=contrib.glfw3 (requires emscripten 3.1.59+) (https://github.com/pongasoft/emscripten-glfw)
+//  2024-07-02: Emscripten: Added io.PlatformOpenInShellFn() handler for Emscripten versions.
+//  2023-12-19: Emscripten: Added ImGui_ImplGlfw_InstallEmscriptenCanvasResizeCallback() to register canvas selector and auto-resize GLFW window.
+//  2023-10-05: Inputs: Added support for extra ImGuiKey values: F13 to F24 function keys.
+//  2023-07-18: Inputs: Revert ignoring mouse data on GLFW_CURSOR_DISABLED as it can be used differently. User may set ImGuiConfigFLags_NoMouse if desired. (#5625, #6609)
+//  2023-06-12: Accept glfwGetTime() not returning a monotonically increasing value. This seems to happens on some Windows setup when peripherals disconnect, and is likely to also happen on browser + Emscripten. (#6491)
+//  2023-04-04: Inputs: Added support for io.AddMouseSourceEvent() to discriminate ImGuiMouseSource_Mouse/ImGuiMouseSource_TouchScreen/ImGuiMouseSource_Pen on Windows ONLY, using a custom WndProc hook. (#2702)
+//  2023-03-16: Inputs: Fixed key modifiers handling on secondary viewports (docking branch). Broken on 2023/01/04. (#6248, #6034)
+//  2023-03-14: Emscripten: Avoid using glfwGetError() and glfwGetGamepadState() which are not correctly implemented in Emscripten emulation. (#6240)
+//  2023-02-03: Emscripten: Registering custom low-level mouse wheel handler to get more accurate scrolling impulses on Emscripten. (#4019, #6096)
+//  2023-01-04: Inputs: Fixed mods state on Linux when using Alt-GR text input (e.g. German keyboard layout), could lead to broken text input. Revert a 2022/01/17 change were we resumed using mods provided by GLFW, turns out they were faulty.
+//  2022-11-22: Perform a dummy glfwGetError() read to cancel missing names with glfwGetKeyName(). (#5908)
+//  2022-10-18: Perform a dummy glfwGetError() read to cancel missing mouse cursors errors. Using GLFW_VERSION_COMBINED directly. (#5785)
+//  2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
+//  2022-09-26: Inputs: Renamed ImGuiKey_ModXXX introduced in 1.87 to ImGuiMod_XXX (old names still supported).
+//  2022-09-01: Inputs: Honor GLFW_CURSOR_DISABLED by not setting mouse position *EDIT* Reverted 2023-07-18.
+//  2022-04-30: Inputs: Fixed ImGui_ImplGlfw_TranslateUntranslatedKey() for lower case letters on OSX.
+//  2022-03-23: Inputs: Fixed a regression in 1.87 which resulted in keyboard modifiers events being reported incorrectly on Linux/X11.
+//  2022-02-07: Added ImGui_ImplGlfw_InstallCallbacks()/ImGui_ImplGlfw_RestoreCallbacks() helpers to facilitate user installing callbacks after initializing backend.
+//  2022-01-26: Inputs: replaced short-lived io.AddKeyModsEvent() (added two weeks ago) with io.AddKeyEvent() using ImGuiKey_ModXXX flags. Sorry for the confusion.
+//  2021-01-20: Inputs: calling new io.AddKeyAnalogEvent() for gamepad support, instead of writing directly to io.NavInputs[].
+//  2022-01-17: Inputs: calling new io.AddMousePosEvent(), io.AddMouseButtonEvent(), io.AddMouseWheelEvent() API (1.87+).
+//  2022-01-17: Inputs: always update key mods next and before key event (not in NewFrame) to fix input queue with very low framerates.
+//  2022-01-12: *BREAKING CHANGE*: Now using glfwSetCursorPosCallback(). If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetCursorPosCallback() and forward it to the backend via ImGui_ImplGlfw_CursorPosCallback().
+//  2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
+//  2022-01-05: Inputs: Converting GLFW untranslated keycodes back to translated keycodes (in the ImGui_ImplGlfw_KeyCallback() function) in order to match the behavior of every other backend, and facilitate the use of GLFW with lettered-shortcuts API.
+//  2021-08-17: *BREAKING CHANGE*: Now using glfwSetWindowFocusCallback() to calling io.AddFocusEvent(). If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() and forward it to the backend via ImGui_ImplGlfw_WindowFocusCallback().
+//  2021-07-29: *BREAKING CHANGE*: Now using glfwSetCursorEnterCallback(). MousePos is correctly reported when the host platform window is hovered but not focused. If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() callback and forward it to the backend via ImGui_ImplGlfw_CursorEnterCallback().
+//  2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
+//  2020-01-17: Inputs: Disable error callback while assigning mouse cursors because some X11 setup don't have them and it generates errors.
+//  2019-12-05: Inputs: Added support for new mouse cursors added in GLFW 3.4+ (resizing cursors, not allowed cursor).
+//  2019-10-18: Misc: Previously installed user callbacks are now restored on shutdown.
+//  2019-07-21: Inputs: Added mapping for ImGuiKey_KeyPadEnter.
+//  2019-05-11: Inputs: Don't filter value from character callback before calling AddInputCharacter().
+//  2019-03-12: Misc: Preserve DisplayFramebufferScale when main window is minimized.
+//  2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
+//  2018-11-07: Inputs: When installing our GLFW callbacks, we save user's previously installed ones - if any - and chain call them.
+//  2018-08-01: Inputs: Workaround for Emscripten which doesn't seem to handle focus related calls.
+//  2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
+//  2018-06-08: Misc: Extracted imgui_impl_glfw.cpp/.h away from the old combined GLFW+OpenGL/Vulkan examples.
+//  2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
+//  2018-02-20: Inputs: Added support for mouse cursors (ImGui::GetMouseCursor() value, passed to glfwSetCursor()).
+//  2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
+//  2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
+//  2018-01-25: Inputs: Added gamepad support if ImGuiConfigFlags_NavEnableGamepad is set.
+//  2018-01-25: Inputs: Honoring the io.WantSetMousePos by repositioning the mouse (when using navigation and ImGuiConfigFlags_NavMoveMouse is set).
+//  2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
+//  2018-01-18: Inputs: Added mapping for ImGuiKey_Insert.
+//  2017-08-25: Inputs: MousePos set to -FLT_MAX,-FLT_MAX when mouse is unavailable/missing (instead of -1,-1).
+//  2016-10-15: Misc: Added a void* user_data parameter to Clipboard function handlers.
+
+#include "imgui.h"
+#ifndef IMGUI_DISABLE
+#include "imgui_impl_glfw.h"
+
+// Clang warnings with -Weverything
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wold-style-cast"     // warning: use of old-style cast
+#pragma clang diagnostic ignored "-Wsign-conversion"    // warning: implicit conversion changes signedness
+#endif
+
+// GLFW
+#include <GLFW/glfw3.h>
+
+#ifdef _WIN32
+#undef APIENTRY
+#ifndef GLFW_EXPOSE_NATIVE_WIN32
+#define GLFW_EXPOSE_NATIVE_WIN32
+#endif
+#include <GLFW/glfw3native.h>   // for glfwGetWin32Window()
+#endif
+#ifdef __APPLE__
+#ifndef GLFW_EXPOSE_NATIVE_COCOA
+#define GLFW_EXPOSE_NATIVE_COCOA
+#endif
+#include <GLFW/glfw3native.h>   // for glfwGetCocoaWindow()
+#endif
+#ifndef _WIN32
+#include <unistd.h>             // for usleep()
+#endif
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+#include <emscripten/html5.h>
+#ifdef EMSCRIPTEN_USE_PORT_CONTRIB_GLFW3
+#include <GLFW/emscripten_glfw3.h>
+#else
+#define EMSCRIPTEN_USE_EMBEDDED_GLFW3
+#endif
+#endif
+
+// We gather version tests as define in order to easily see which features are version-dependent.
+#define GLFW_VERSION_COMBINED           (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 + GLFW_VERSION_REVISION)
+#ifdef GLFW_RESIZE_NESW_CURSOR          // Let's be nice to people who pulled GLFW between 2019-04-16 (3.4 define) and 2019-11-29 (cursors defines) // FIXME: Remove when GLFW 3.4 is released?
+#define GLFW_HAS_NEW_CURSORS            (GLFW_VERSION_COMBINED >= 3400) // 3.4+ GLFW_RESIZE_ALL_CURSOR, GLFW_RESIZE_NESW_CURSOR, GLFW_RESIZE_NWSE_CURSOR, GLFW_NOT_ALLOWED_CURSOR
+#else
+#define GLFW_HAS_NEW_CURSORS            (0)
+#endif
+#define GLFW_HAS_GAMEPAD_API            (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetGamepadState() new api
+#define GLFW_HAS_GETKEYNAME             (GLFW_VERSION_COMBINED >= 3200) // 3.2+ glfwGetKeyName()
+#define GLFW_HAS_GETERROR               (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetError()
+
+// GLFW data
+enum GlfwClientApi
+{
+    GlfwClientApi_Unknown,
+    GlfwClientApi_OpenGL,
+    GlfwClientApi_Vulkan,
+};
+
+struct ImGui_ImplGlfw_Data
+{
+    GLFWwindow*             Window;
+    GlfwClientApi           ClientApi;
+    double                  Time;
+    GLFWwindow*             MouseWindow;
+    GLFWcursor*             MouseCursors[ImGuiMouseCursor_COUNT];
+    ImVec2                  LastValidMousePos;
+    bool                    InstalledCallbacks;
+    bool                    CallbacksChainForAllWindows;
+#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
+    const char*             CanvasSelector;
+#endif
+
+    // Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
+    GLFWwindowfocusfun      PrevUserCallbackWindowFocus;
+    GLFWcursorposfun        PrevUserCallbackCursorPos;
+    GLFWcursorenterfun      PrevUserCallbackCursorEnter;
+    GLFWmousebuttonfun      PrevUserCallbackMousebutton;
+    GLFWscrollfun           PrevUserCallbackScroll;
+    GLFWkeyfun              PrevUserCallbackKey;
+    GLFWcharfun             PrevUserCallbackChar;
+    GLFWmonitorfun          PrevUserCallbackMonitor;
+#ifdef _WIN32
+    WNDPROC                 PrevWndProc;
+#endif
+
+    ImGui_ImplGlfw_Data()   { memset((void*)this, 0, sizeof(*this)); }
+};
+
+// Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
+// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
+// FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
+// - Because glfwPollEvents() process all windows and some events may be called outside of it, you will need to register your own callbacks
+//   (passing install_callbacks=false in ImGui_ImplGlfw_InitXXX functions), set the current dear imgui context and then call our callbacks.
+// - Otherwise we may need to store a GLFWWindow* -> ImGuiContext* map and handle this in the backend, adding a little bit of extra complexity to it.
+// FIXME: some shared resources (mouse cursor shape, gamepad) are mishandled when using multi-context.
+static ImGui_ImplGlfw_Data* ImGui_ImplGlfw_GetBackendData()
+{
+    return ImGui::GetCurrentContext() ? (ImGui_ImplGlfw_Data*)ImGui::GetIO().BackendPlatformUserData : nullptr;
+}
+
+// Functions
+
+// Not static to allow third-party code to use that if they want to (but undocumented)
+ImGuiKey ImGui_ImplGlfw_KeyToImGuiKey(int keycode, int scancode);
+ImGuiKey ImGui_ImplGlfw_KeyToImGuiKey(int keycode, int scancode)
+{
+    IM_UNUSED(scancode);
+    switch (keycode)
+    {
+        case GLFW_KEY_TAB: return ImGuiKey_Tab;
+        case GLFW_KEY_LEFT: return ImGuiKey_LeftArrow;
+        case GLFW_KEY_RIGHT: return ImGuiKey_RightArrow;
+        case GLFW_KEY_UP: return ImGuiKey_UpArrow;
+        case GLFW_KEY_DOWN: return ImGuiKey_DownArrow;
+        case GLFW_KEY_PAGE_UP: return ImGuiKey_PageUp;
+        case GLFW_KEY_PAGE_DOWN: return ImGuiKey_PageDown;
+        case GLFW_KEY_HOME: return ImGuiKey_Home;
+        case GLFW_KEY_END: return ImGuiKey_End;
+        case GLFW_KEY_INSERT: return ImGuiKey_Insert;
+        case GLFW_KEY_DELETE: return ImGuiKey_Delete;
+        case GLFW_KEY_BACKSPACE: return ImGuiKey_Backspace;
+        case GLFW_KEY_SPACE: return ImGuiKey_Space;
+        case GLFW_KEY_ENTER: return ImGuiKey_Enter;
+        case GLFW_KEY_ESCAPE: return ImGuiKey_Escape;
+        case GLFW_KEY_APOSTROPHE: return ImGuiKey_Apostrophe;
+        case GLFW_KEY_COMMA: return ImGuiKey_Comma;
+        case GLFW_KEY_MINUS: return ImGuiKey_Minus;
+        case GLFW_KEY_PERIOD: return ImGuiKey_Period;
+        case GLFW_KEY_SLASH: return ImGuiKey_Slash;
+        case GLFW_KEY_SEMICOLON: return ImGuiKey_Semicolon;
+        case GLFW_KEY_EQUAL: return ImGuiKey_Equal;
+        case GLFW_KEY_LEFT_BRACKET: return ImGuiKey_LeftBracket;
+        case GLFW_KEY_BACKSLASH: return ImGuiKey_Backslash;
+        case GLFW_KEY_RIGHT_BRACKET: return ImGuiKey_RightBracket;
+        case GLFW_KEY_GRAVE_ACCENT: return ImGuiKey_GraveAccent;
+        case GLFW_KEY_CAPS_LOCK: return ImGuiKey_CapsLock;
+        case GLFW_KEY_SCROLL_LOCK: return ImGuiKey_ScrollLock;
+        case GLFW_KEY_NUM_LOCK: return ImGuiKey_NumLock;
+        case GLFW_KEY_PRINT_SCREEN: return ImGuiKey_PrintScreen;
+        case GLFW_KEY_PAUSE: return ImGuiKey_Pause;
+        case GLFW_KEY_KP_0: return ImGuiKey_Keypad0;
+        case GLFW_KEY_KP_1: return ImGuiKey_Keypad1;
+        case GLFW_KEY_KP_2: return ImGuiKey_Keypad2;
+        case GLFW_KEY_KP_3: return ImGuiKey_Keypad3;
+        case GLFW_KEY_KP_4: return ImGuiKey_Keypad4;
+        case GLFW_KEY_KP_5: return ImGuiKey_Keypad5;
+        case GLFW_KEY_KP_6: return ImGuiKey_Keypad6;
+        case GLFW_KEY_KP_7: return ImGuiKey_Keypad7;
+        case GLFW_KEY_KP_8: return ImGuiKey_Keypad8;
+        case GLFW_KEY_KP_9: return ImGuiKey_Keypad9;
+        case GLFW_KEY_KP_DECIMAL: return ImGuiKey_KeypadDecimal;
+        case GLFW_KEY_KP_DIVIDE: return ImGuiKey_KeypadDivide;
+        case GLFW_KEY_KP_MULTIPLY: return ImGuiKey_KeypadMultiply;
+        case GLFW_KEY_KP_SUBTRACT: return ImGuiKey_KeypadSubtract;
+        case GLFW_KEY_KP_ADD: return ImGuiKey_KeypadAdd;
+        case GLFW_KEY_KP_ENTER: return ImGuiKey_KeypadEnter;
+        case GLFW_KEY_KP_EQUAL: return ImGuiKey_KeypadEqual;
+        case GLFW_KEY_LEFT_SHIFT: return ImGuiKey_LeftShift;
+        case GLFW_KEY_LEFT_CONTROL: return ImGuiKey_LeftCtrl;
+        case GLFW_KEY_LEFT_ALT: return ImGuiKey_LeftAlt;
+        case GLFW_KEY_LEFT_SUPER: return ImGuiKey_LeftSuper;
+        case GLFW_KEY_RIGHT_SHIFT: return ImGuiKey_RightShift;
+        case GLFW_KEY_RIGHT_CONTROL: return ImGuiKey_RightCtrl;
+        case GLFW_KEY_RIGHT_ALT: return ImGuiKey_RightAlt;
+        case GLFW_KEY_RIGHT_SUPER: return ImGuiKey_RightSuper;
+        case GLFW_KEY_MENU: return ImGuiKey_Menu;
+        case GLFW_KEY_0: return ImGuiKey_0;
+        case GLFW_KEY_1: return ImGuiKey_1;
+        case GLFW_KEY_2: return ImGuiKey_2;
+        case GLFW_KEY_3: return ImGuiKey_3;
+        case GLFW_KEY_4: return ImGuiKey_4;
+        case GLFW_KEY_5: return ImGuiKey_5;
+        case GLFW_KEY_6: return ImGuiKey_6;
+        case GLFW_KEY_7: return ImGuiKey_7;
+        case GLFW_KEY_8: return ImGuiKey_8;
+        case GLFW_KEY_9: return ImGuiKey_9;
+        case GLFW_KEY_A: return ImGuiKey_A;
+        case GLFW_KEY_B: return ImGuiKey_B;
+        case GLFW_KEY_C: return ImGuiKey_C;
+        case GLFW_KEY_D: return ImGuiKey_D;
+        case GLFW_KEY_E: return ImGuiKey_E;
+        case GLFW_KEY_F: return ImGuiKey_F;
+        case GLFW_KEY_G: return ImGuiKey_G;
+        case GLFW_KEY_H: return ImGuiKey_H;
+        case GLFW_KEY_I: return ImGuiKey_I;
+        case GLFW_KEY_J: return ImGuiKey_J;
+        case GLFW_KEY_K: return ImGuiKey_K;
+        case GLFW_KEY_L: return ImGuiKey_L;
+        case GLFW_KEY_M: return ImGuiKey_M;
+        case GLFW_KEY_N: return ImGuiKey_N;
+        case GLFW_KEY_O: return ImGuiKey_O;
+        case GLFW_KEY_P: return ImGuiKey_P;
+        case GLFW_KEY_Q: return ImGuiKey_Q;
+        case GLFW_KEY_R: return ImGuiKey_R;
+        case GLFW_KEY_S: return ImGuiKey_S;
+        case GLFW_KEY_T: return ImGuiKey_T;
+        case GLFW_KEY_U: return ImGuiKey_U;
+        case GLFW_KEY_V: return ImGuiKey_V;
+        case GLFW_KEY_W: return ImGuiKey_W;
+        case GLFW_KEY_X: return ImGuiKey_X;
+        case GLFW_KEY_Y: return ImGuiKey_Y;
+        case GLFW_KEY_Z: return ImGuiKey_Z;
+        case GLFW_KEY_F1: return ImGuiKey_F1;
+        case GLFW_KEY_F2: return ImGuiKey_F2;
+        case GLFW_KEY_F3: return ImGuiKey_F3;
+        case GLFW_KEY_F4: return ImGuiKey_F4;
+        case GLFW_KEY_F5: return ImGuiKey_F5;
+        case GLFW_KEY_F6: return ImGuiKey_F6;
+        case GLFW_KEY_F7: return ImGuiKey_F7;
+        case GLFW_KEY_F8: return ImGuiKey_F8;
+        case GLFW_KEY_F9: return ImGuiKey_F9;
+        case GLFW_KEY_F10: return ImGuiKey_F10;
+        case GLFW_KEY_F11: return ImGuiKey_F11;
+        case GLFW_KEY_F12: return ImGuiKey_F12;
+        case GLFW_KEY_F13: return ImGuiKey_F13;
+        case GLFW_KEY_F14: return ImGuiKey_F14;
+        case GLFW_KEY_F15: return ImGuiKey_F15;
+        case GLFW_KEY_F16: return ImGuiKey_F16;
+        case GLFW_KEY_F17: return ImGuiKey_F17;
+        case GLFW_KEY_F18: return ImGuiKey_F18;
+        case GLFW_KEY_F19: return ImGuiKey_F19;
+        case GLFW_KEY_F20: return ImGuiKey_F20;
+        case GLFW_KEY_F21: return ImGuiKey_F21;
+        case GLFW_KEY_F22: return ImGuiKey_F22;
+        case GLFW_KEY_F23: return ImGuiKey_F23;
+        case GLFW_KEY_F24: return ImGuiKey_F24;
+        default: return ImGuiKey_None;
+    }
+}
+
+// X11 does not include current pressed/released modifier key in 'mods' flags submitted by GLFW
+// See https://github.com/ocornut/imgui/issues/6034 and https://github.com/glfw/glfw/issues/1630
+static void ImGui_ImplGlfw_UpdateKeyModifiers(GLFWwindow* window)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    io.AddKeyEvent(ImGuiMod_Ctrl,  (glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS) || (glfwGetKey(window, GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS));
+    io.AddKeyEvent(ImGuiMod_Shift, (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT)   == GLFW_PRESS) || (glfwGetKey(window, GLFW_KEY_RIGHT_SHIFT)   == GLFW_PRESS));
+    io.AddKeyEvent(ImGuiMod_Alt,   (glfwGetKey(window, GLFW_KEY_LEFT_ALT)     == GLFW_PRESS) || (glfwGetKey(window, GLFW_KEY_RIGHT_ALT)     == GLFW_PRESS));
+    io.AddKeyEvent(ImGuiMod_Super, (glfwGetKey(window, GLFW_KEY_LEFT_SUPER)   == GLFW_PRESS) || (glfwGetKey(window, GLFW_KEY_RIGHT_SUPER)   == GLFW_PRESS));
+}
+
+static bool ImGui_ImplGlfw_ShouldChainCallback(GLFWwindow* window)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    return bd->CallbacksChainForAllWindows ? true : (window == bd->Window);
+}
+
+void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackMousebutton != nullptr && ImGui_ImplGlfw_ShouldChainCallback(window))
+        bd->PrevUserCallbackMousebutton(window, button, action, mods);
+
+    ImGui_ImplGlfw_UpdateKeyModifiers(window);
+
+    ImGuiIO& io = ImGui::GetIO();
+    if (button >= 0 && button < ImGuiMouseButton_COUNT)
+        io.AddMouseButtonEvent(button, action == GLFW_PRESS);
+}
+
+void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackScroll != nullptr && ImGui_ImplGlfw_ShouldChainCallback(window))
+        bd->PrevUserCallbackScroll(window, xoffset, yoffset);
+
+#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
+    // Ignore GLFW events: will be processed in ImGui_ImplEmscripten_WheelCallback().
+    return;
+#endif
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.AddMouseWheelEvent((float)xoffset, (float)yoffset);
+}
+
+// FIXME: should this be baked into ImGui_ImplGlfw_KeyToImGuiKey()? then what about the values passed to io.SetKeyEventNativeData()?
+static int ImGui_ImplGlfw_TranslateUntranslatedKey(int key, int scancode)
+{
+#if GLFW_HAS_GETKEYNAME && !defined(EMSCRIPTEN_USE_EMBEDDED_GLFW3)
+    // GLFW 3.1+ attempts to "untranslate" keys, which goes the opposite of what every other framework does, making using lettered shortcuts difficult.
+    // (It had reasons to do so: namely GLFW is/was more likely to be used for WASD-type game controls rather than lettered shortcuts, but IHMO the 3.1 change could have been done differently)
+    // See https://github.com/glfw/glfw/issues/1502 for details.
+    // Adding a workaround to undo this (so our keys are translated->untranslated->translated, likely a lossy process).
+    // This won't cover edge cases but this is at least going to cover common cases.
+    if (key >= GLFW_KEY_KP_0 && key <= GLFW_KEY_KP_EQUAL)
+        return key;
+    GLFWerrorfun prev_error_callback = glfwSetErrorCallback(nullptr);
+    const char* key_name = glfwGetKeyName(key, scancode);
+    glfwSetErrorCallback(prev_error_callback);
+#if GLFW_HAS_GETERROR && !defined(EMSCRIPTEN_USE_EMBEDDED_GLFW3) // Eat errors (see #5908)
+    (void)glfwGetError(nullptr);
+#endif
+    if (key_name && key_name[0] != 0 && key_name[1] == 0)
+    {
+        const char char_names[] = "`-=[]\\,;\'./";
+        const int char_keys[] = { GLFW_KEY_GRAVE_ACCENT, GLFW_KEY_MINUS, GLFW_KEY_EQUAL, GLFW_KEY_LEFT_BRACKET, GLFW_KEY_RIGHT_BRACKET, GLFW_KEY_BACKSLASH, GLFW_KEY_COMMA, GLFW_KEY_SEMICOLON, GLFW_KEY_APOSTROPHE, GLFW_KEY_PERIOD, GLFW_KEY_SLASH, 0 };
+        IM_ASSERT(IM_ARRAYSIZE(char_names) == IM_ARRAYSIZE(char_keys));
+        if (key_name[0] >= '0' && key_name[0] <= '9')               { key = GLFW_KEY_0 + (key_name[0] - '0'); }
+        else if (key_name[0] >= 'A' && key_name[0] <= 'Z')          { key = GLFW_KEY_A + (key_name[0] - 'A'); }
+        else if (key_name[0] >= 'a' && key_name[0] <= 'z')          { key = GLFW_KEY_A + (key_name[0] - 'a'); }
+        else if (const char* p = strchr(char_names, key_name[0]))   { key = char_keys[p - char_names]; }
+    }
+    // if (action == GLFW_PRESS) printf("key %d scancode %d name '%s'\n", key, scancode, key_name);
+#else
+    IM_UNUSED(scancode);
+#endif
+    return key;
+}
+
+void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int keycode, int scancode, int action, int mods)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackKey != nullptr && ImGui_ImplGlfw_ShouldChainCallback(window))
+        bd->PrevUserCallbackKey(window, keycode, scancode, action, mods);
+
+    if (action != GLFW_PRESS && action != GLFW_RELEASE)
+        return;
+
+    ImGui_ImplGlfw_UpdateKeyModifiers(window);
+
+    keycode = ImGui_ImplGlfw_TranslateUntranslatedKey(keycode, scancode);
+
+    ImGuiIO& io = ImGui::GetIO();
+    ImGuiKey imgui_key = ImGui_ImplGlfw_KeyToImGuiKey(keycode, scancode);
+    io.AddKeyEvent(imgui_key, (action == GLFW_PRESS));
+    io.SetKeyEventNativeData(imgui_key, keycode, scancode); // To support legacy indexing (<1.87 user code)
+}
+
+void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window, int focused)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackWindowFocus != nullptr && ImGui_ImplGlfw_ShouldChainCallback(window))
+        bd->PrevUserCallbackWindowFocus(window, focused);
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.AddFocusEvent(focused != 0);
+}
+
+void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window, double x, double y)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackCursorPos != nullptr && ImGui_ImplGlfw_ShouldChainCallback(window))
+        bd->PrevUserCallbackCursorPos(window, x, y);
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.AddMousePosEvent((float)x, (float)y);
+    bd->LastValidMousePos = ImVec2((float)x, (float)y);
+}
+
+// Workaround: X11 seems to send spurious Leave/Enter events which would make us lose our position,
+// so we back it up and restore on Leave/Enter (see https://github.com/ocornut/imgui/issues/4984)
+void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window, int entered)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackCursorEnter != nullptr && ImGui_ImplGlfw_ShouldChainCallback(window))
+        bd->PrevUserCallbackCursorEnter(window, entered);
+
+    ImGuiIO& io = ImGui::GetIO();
+    if (entered)
+    {
+        bd->MouseWindow = window;
+        io.AddMousePosEvent(bd->LastValidMousePos.x, bd->LastValidMousePos.y);
+    }
+    else if (!entered && bd->MouseWindow == window)
+    {
+        bd->LastValidMousePos = io.MousePos;
+        bd->MouseWindow = nullptr;
+        io.AddMousePosEvent(-FLT_MAX, -FLT_MAX);
+    }
+}
+
+void ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if (bd->PrevUserCallbackChar != nullptr && ImGui_ImplGlfw_ShouldChainCallback(window))
+        bd->PrevUserCallbackChar(window, c);
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.AddInputCharacter(c);
+}
+
+void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor*, int)
+{
+	// Unused in 'master' branch but 'docking' branch will use this, so we declare it ahead of it so if you have to install callbacks you can install this one too.
+}
+
+#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
+static EM_BOOL ImGui_ImplEmscripten_WheelCallback(int, const EmscriptenWheelEvent* ev, void*)
+{
+    // Mimic Emscripten_HandleWheel() in SDL.
+    // Corresponding equivalent in GLFW JS emulation layer has incorrect quantizing preventing small values. See #6096
+    float multiplier = 0.0f;
+    if (ev->deltaMode == DOM_DELTA_PIXEL)       { multiplier = 1.0f / 100.0f; } // 100 pixels make up a step.
+    else if (ev->deltaMode == DOM_DELTA_LINE)   { multiplier = 1.0f / 3.0f; }   // 3 lines make up a step.
+    else if (ev->deltaMode == DOM_DELTA_PAGE)   { multiplier = 80.0f; }         // A page makes up 80 steps.
+    float wheel_x = ev->deltaX * -multiplier;
+    float wheel_y = ev->deltaY * -multiplier;
+    ImGuiIO& io = ImGui::GetIO();
+    io.AddMouseWheelEvent(wheel_x, wheel_y);
+    //IMGUI_DEBUG_LOG("[Emsc] mode %d dx: %.2f, dy: %.2f, dz: %.2f --> feed %.2f %.2f\n", (int)ev->deltaMode, ev->deltaX, ev->deltaY, ev->deltaZ, wheel_x, wheel_y);
+    return EM_TRUE;
+}
+#endif
+
+#ifdef _WIN32
+// GLFW doesn't allow to distinguish Mouse vs TouchScreen vs Pen.
+// Add support for Win32 (based on imgui_impl_win32), because we rely on _TouchScreen info to trickle inputs differently.
+static ImGuiMouseSource GetMouseSourceFromMessageExtraInfo()
+{
+    LPARAM extra_info = ::GetMessageExtraInfo();
+    if ((extra_info & 0xFFFFFF80) == 0xFF515700)
+        return ImGuiMouseSource_Pen;
+    if ((extra_info & 0xFFFFFF80) == 0xFF515780)
+        return ImGuiMouseSource_TouchScreen;
+    return ImGuiMouseSource_Mouse;
+}
+static LRESULT CALLBACK ImGui_ImplGlfw_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    switch (msg)
+    {
+    case WM_MOUSEMOVE: case WM_NCMOUSEMOVE:
+    case WM_LBUTTONDOWN: case WM_LBUTTONDBLCLK: case WM_LBUTTONUP:
+    case WM_RBUTTONDOWN: case WM_RBUTTONDBLCLK: case WM_RBUTTONUP:
+    case WM_MBUTTONDOWN: case WM_MBUTTONDBLCLK: case WM_MBUTTONUP:
+    case WM_XBUTTONDOWN: case WM_XBUTTONDBLCLK: case WM_XBUTTONUP:
+        ImGui::GetIO().AddMouseSourceEvent(GetMouseSourceFromMessageExtraInfo());
+        break;
+    }
+    return ::CallWindowProcW(bd->PrevWndProc, hWnd, msg, wParam, lParam);
+}
+#endif
+
+void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    IM_ASSERT(bd->InstalledCallbacks == false && "Callbacks already installed!");
+    IM_ASSERT(bd->Window == window);
+
+    bd->PrevUserCallbackWindowFocus = glfwSetWindowFocusCallback(window, ImGui_ImplGlfw_WindowFocusCallback);
+    bd->PrevUserCallbackCursorEnter = glfwSetCursorEnterCallback(window, ImGui_ImplGlfw_CursorEnterCallback);
+    bd->PrevUserCallbackCursorPos = glfwSetCursorPosCallback(window, ImGui_ImplGlfw_CursorPosCallback);
+    bd->PrevUserCallbackMousebutton = glfwSetMouseButtonCallback(window, ImGui_ImplGlfw_MouseButtonCallback);
+    bd->PrevUserCallbackScroll = glfwSetScrollCallback(window, ImGui_ImplGlfw_ScrollCallback);
+    bd->PrevUserCallbackKey = glfwSetKeyCallback(window, ImGui_ImplGlfw_KeyCallback);
+    bd->PrevUserCallbackChar = glfwSetCharCallback(window, ImGui_ImplGlfw_CharCallback);
+    bd->PrevUserCallbackMonitor = glfwSetMonitorCallback(ImGui_ImplGlfw_MonitorCallback);
+    bd->InstalledCallbacks = true;
+}
+
+void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    IM_ASSERT(bd->InstalledCallbacks == true && "Callbacks not installed!");
+    IM_ASSERT(bd->Window == window);
+
+    glfwSetWindowFocusCallback(window, bd->PrevUserCallbackWindowFocus);
+    glfwSetCursorEnterCallback(window, bd->PrevUserCallbackCursorEnter);
+    glfwSetCursorPosCallback(window, bd->PrevUserCallbackCursorPos);
+    glfwSetMouseButtonCallback(window, bd->PrevUserCallbackMousebutton);
+    glfwSetScrollCallback(window, bd->PrevUserCallbackScroll);
+    glfwSetKeyCallback(window, bd->PrevUserCallbackKey);
+    glfwSetCharCallback(window, bd->PrevUserCallbackChar);
+    glfwSetMonitorCallback(bd->PrevUserCallbackMonitor);
+    bd->InstalledCallbacks = false;
+    bd->PrevUserCallbackWindowFocus = nullptr;
+    bd->PrevUserCallbackCursorEnter = nullptr;
+    bd->PrevUserCallbackCursorPos = nullptr;
+    bd->PrevUserCallbackMousebutton = nullptr;
+    bd->PrevUserCallbackScroll = nullptr;
+    bd->PrevUserCallbackKey = nullptr;
+    bd->PrevUserCallbackChar = nullptr;
+    bd->PrevUserCallbackMonitor = nullptr;
+}
+
+// Set to 'true' to enable chaining installed callbacks for all windows (including secondary viewports created by backends or by user.
+// This is 'false' by default meaning we only chain callbacks for the main viewport.
+// We cannot set this to 'true' by default because user callbacks code may be not testing the 'window' parameter of their callback.
+// If you set this to 'true' your user callback code will need to make sure you are testing the 'window' parameter.
+void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows)
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    bd->CallbacksChainForAllWindows = chain_for_all_windows;
+}
+
+#ifdef __EMSCRIPTEN__
+#if EMSCRIPTEN_USE_PORT_CONTRIB_GLFW3 >= 34020240817
+void ImGui_ImplGlfw_EmscriptenOpenURL(const char* url) { if (url) emscripten::glfw3::OpenURL(url); }
+#else
+EM_JS(void, ImGui_ImplGlfw_EmscriptenOpenURL, (const char* url), { url = url ? UTF8ToString(url) : null; if (url) window.open(url, '_blank'); });
+#endif
+#endif
+
+static bool ImGui_ImplGlfw_Init(GLFWwindow* window, bool install_callbacks, GlfwClientApi client_api)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    IMGUI_CHECKVERSION();
+    IM_ASSERT(io.BackendPlatformUserData == nullptr && "Already initialized a platform backend!");
+    //printf("GLFW_VERSION: %d.%d.%d (%d)", GLFW_VERSION_MAJOR, GLFW_VERSION_MINOR, GLFW_VERSION_REVISION, GLFW_VERSION_COMBINED);
+
+    // Setup backend capabilities flags
+    ImGui_ImplGlfw_Data* bd = IM_NEW(ImGui_ImplGlfw_Data)();
+    io.BackendPlatformUserData = (void*)bd;
+    io.BackendPlatformName = "imgui_impl_glfw";
+    io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;         // We can honor GetMouseCursor() values (optional)
+    io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos;          // We can honor io.WantSetMousePos requests (optional, rarely used)
+
+    bd->Window = window;
+    bd->Time = 0.0;
+
+    ImGuiPlatformIO& platform_io = ImGui::GetPlatformIO();
+    platform_io.Platform_SetClipboardTextFn = [](ImGuiContext*, const char* text) { glfwSetClipboardString(NULL, text); };
+    platform_io.Platform_GetClipboardTextFn = [](ImGuiContext*) { return glfwGetClipboardString(NULL); };
+#ifdef __EMSCRIPTEN__
+    platform_io.Platform_OpenInShellFn = [](ImGuiContext*, const char* url) { ImGui_ImplGlfw_EmscriptenOpenURL(url); return true; };
+#endif
+
+    // Create mouse cursors
+    // (By design, on X11 cursors are user configurable and some cursors may be missing. When a cursor doesn't exist,
+    // GLFW will emit an error which will often be printed by the app, so we temporarily disable error reporting.
+    // Missing cursors will return nullptr and our _UpdateMouseCursor() function will use the Arrow cursor instead.)
+    GLFWerrorfun prev_error_callback = glfwSetErrorCallback(nullptr);
+    bd->MouseCursors[ImGuiMouseCursor_Arrow] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_TextInput] = glfwCreateStandardCursor(GLFW_IBEAM_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNS] = glfwCreateStandardCursor(GLFW_VRESIZE_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeEW] = glfwCreateStandardCursor(GLFW_HRESIZE_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_Hand] = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
+#if GLFW_HAS_NEW_CURSORS
+    bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_RESIZE_ALL_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_RESIZE_NESW_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_RESIZE_NWSE_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_NOT_ALLOWED_CURSOR);
+#else
+    bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+    bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
+#endif
+    glfwSetErrorCallback(prev_error_callback);
+#if GLFW_HAS_GETERROR && !defined(__EMSCRIPTEN__) // Eat errors (see #5908)
+    (void)glfwGetError(nullptr);
+#endif
+
+    // Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
+    if (install_callbacks)
+        ImGui_ImplGlfw_InstallCallbacks(window);
+
+    // Set platform dependent data in viewport
+    ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+    main_viewport->PlatformHandle = (void*)bd->Window;
+#ifdef _WIN32
+    main_viewport->PlatformHandleRaw = glfwGetWin32Window(bd->Window);
+#elif defined(__APPLE__)
+    main_viewport->PlatformHandleRaw = (void*)glfwGetCocoaWindow(bd->Window);
+#else
+    IM_UNUSED(main_viewport);
+#endif
+
+    // Windows: register a WndProc hook so we can intercept some messages.
+#ifdef _WIN32
+    bd->PrevWndProc = (WNDPROC)::GetWindowLongPtrW((HWND)main_viewport->PlatformHandleRaw, GWLP_WNDPROC);
+    IM_ASSERT(bd->PrevWndProc != nullptr);
+    ::SetWindowLongPtrW((HWND)main_viewport->PlatformHandleRaw, GWLP_WNDPROC, (LONG_PTR)ImGui_ImplGlfw_WndProc);
+#endif
+
+    // Emscripten: the same application can run on various platforms, so we detect the Apple platform at runtime
+    // to override io.ConfigMacOSXBehaviors from its default (which is always false in Emscripten).
+#ifdef __EMSCRIPTEN__
+#if EMSCRIPTEN_USE_PORT_CONTRIB_GLFW3 >= 34020240817
+    if (emscripten::glfw3::IsRuntimePlatformApple())
+    {
+        ImGui::GetIO().ConfigMacOSXBehaviors = true;
+
+        // Due to how the browser (poorly) handles the Meta Key, this line essentially disables repeats when used.
+        // This means that Meta + V only registers a single key-press, even if the keys are held.
+        // This is a compromise for dealing with this issue in ImGui since ImGui implements key repeat itself.
+        // See https://github.com/pongasoft/emscripten-glfw/blob/v3.4.0.20240817/docs/Usage.md#the-problem-of-the-super-key
+        emscripten::glfw3::SetSuperPlusKeyTimeouts(10, 10);
+    }
+#endif
+#endif
+
+    bd->ClientApi = client_api;
+    return true;
+}
+
+bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks)
+{
+    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_OpenGL);
+}
+
+bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks)
+{
+    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_Vulkan);
+}
+
+bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window, bool install_callbacks)
+{
+    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_Unknown);
+}
+
+void ImGui_ImplGlfw_Shutdown()
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    IM_ASSERT(bd != nullptr && "No platform backend to shutdown, or already shutdown?");
+    ImGuiIO& io = ImGui::GetIO();
+
+    if (bd->InstalledCallbacks)
+        ImGui_ImplGlfw_RestoreCallbacks(bd->Window);
+#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
+    if (bd->CanvasSelector)
+        emscripten_set_wheel_callback(bd->CanvasSelector, nullptr, false, nullptr);
+#endif
+
+    for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++)
+        glfwDestroyCursor(bd->MouseCursors[cursor_n]);
+
+    // Windows: restore our WndProc hook
+#ifdef _WIN32
+    ImGuiViewport* main_viewport = ImGui::GetMainViewport();
+    ::SetWindowLongPtrW((HWND)main_viewport->PlatformHandleRaw, GWLP_WNDPROC, (LONG_PTR)bd->PrevWndProc);
+    bd->PrevWndProc = nullptr;
+#endif
+
+    io.BackendPlatformName = nullptr;
+    io.BackendPlatformUserData = nullptr;
+    io.BackendFlags &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_HasGamepad);
+    IM_DELETE(bd);
+}
+
+static void ImGui_ImplGlfw_UpdateMouseData()
+{
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    ImGuiIO& io = ImGui::GetIO();
+
+    // (those braces are here to reduce diff with multi-viewports support in 'docking' branch)
+    {
+        GLFWwindow* window = bd->Window;
+#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
+        const bool is_window_focused = true;
+#else
+        const bool is_window_focused = glfwGetWindowAttrib(window, GLFW_FOCUSED) != 0;
+#endif
+        if (is_window_focused)
+        {
+            // (Optional) Set OS mouse position from Dear ImGui if requested (rarely used, only when io.ConfigNavMoveSetMousePos is enabled by user)
+            if (io.WantSetMousePos)
+                glfwSetCursorPos(window, (double)io.MousePos.x, (double)io.MousePos.y);
+
+            // (Optional) Fallback to provide mouse position when focused (ImGui_ImplGlfw_CursorPosCallback already provides this when hovered or captured)
+            if (bd->MouseWindow == nullptr)
+            {
+                double mouse_x, mouse_y;
+                glfwGetCursorPos(window, &mouse_x, &mouse_y);
+                bd->LastValidMousePos = ImVec2((float)mouse_x, (float)mouse_y);
+                io.AddMousePosEvent((float)mouse_x, (float)mouse_y);
+            }
+        }
+    }
+}
+
+static void ImGui_ImplGlfw_UpdateMouseCursor()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    if ((io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) || glfwGetInputMode(bd->Window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
+        return;
+
+    ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
+    // (those braces are here to reduce diff with multi-viewports support in 'docking' branch)
+    {
+        GLFWwindow* window = bd->Window;
+        if (imgui_cursor == ImGuiMouseCursor_None || io.MouseDrawCursor)
+        {
+            // Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
+            glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
+        }
+        else
+        {
+            // Show OS mouse cursor
+            // FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
+            glfwSetCursor(window, bd->MouseCursors[imgui_cursor] ? bd->MouseCursors[imgui_cursor] : bd->MouseCursors[ImGuiMouseCursor_Arrow]);
+            glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+        }
+    }
+}
+
+// Update gamepad inputs
+static inline float Saturate(float v) { return v < 0.0f ? 0.0f : v  > 1.0f ? 1.0f : v; }
+static void ImGui_ImplGlfw_UpdateGamepads()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0) // FIXME: Technically feeding gamepad shouldn't depend on this now that they are regular inputs.
+        return;
+
+    io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
+#if GLFW_HAS_GAMEPAD_API && !defined(EMSCRIPTEN_USE_EMBEDDED_GLFW3)
+    GLFWgamepadstate gamepad;
+    if (!glfwGetGamepadState(GLFW_JOYSTICK_1, &gamepad))
+        return;
+    #define MAP_BUTTON(KEY_NO, BUTTON_NO, _UNUSED)          do { io.AddKeyEvent(KEY_NO, gamepad.buttons[BUTTON_NO] != 0); } while (0)
+    #define MAP_ANALOG(KEY_NO, AXIS_NO, _UNUSED, V0, V1)    do { float v = gamepad.axes[AXIS_NO]; v = (v - V0) / (V1 - V0); io.AddKeyAnalogEvent(KEY_NO, v > 0.10f, Saturate(v)); } while (0)
+#else
+    int axes_count = 0, buttons_count = 0;
+    const float* axes = glfwGetJoystickAxes(GLFW_JOYSTICK_1, &axes_count);
+    const unsigned char* buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_1, &buttons_count);
+    if (axes_count == 0 || buttons_count == 0)
+        return;
+    #define MAP_BUTTON(KEY_NO, _UNUSED, BUTTON_NO)          do { io.AddKeyEvent(KEY_NO, (buttons_count > BUTTON_NO && buttons[BUTTON_NO] == GLFW_PRESS)); } while (0)
+    #define MAP_ANALOG(KEY_NO, _UNUSED, AXIS_NO, V0, V1)    do { float v = (axes_count > AXIS_NO) ? axes[AXIS_NO] : V0; v = (v - V0) / (V1 - V0); io.AddKeyAnalogEvent(KEY_NO, v > 0.10f, Saturate(v)); } while (0)
+#endif
+    io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
+    MAP_BUTTON(ImGuiKey_GamepadStart,       GLFW_GAMEPAD_BUTTON_START,          7);
+    MAP_BUTTON(ImGuiKey_GamepadBack,        GLFW_GAMEPAD_BUTTON_BACK,           6);
+    MAP_BUTTON(ImGuiKey_GamepadFaceLeft,    GLFW_GAMEPAD_BUTTON_X,              2);     // Xbox X, PS Square
+    MAP_BUTTON(ImGuiKey_GamepadFaceRight,   GLFW_GAMEPAD_BUTTON_B,              1);     // Xbox B, PS Circle
+    MAP_BUTTON(ImGuiKey_GamepadFaceUp,      GLFW_GAMEPAD_BUTTON_Y,              3);     // Xbox Y, PS Triangle
+    MAP_BUTTON(ImGuiKey_GamepadFaceDown,    GLFW_GAMEPAD_BUTTON_A,              0);     // Xbox A, PS Cross
+    MAP_BUTTON(ImGuiKey_GamepadDpadLeft,    GLFW_GAMEPAD_BUTTON_DPAD_LEFT,      13);
+    MAP_BUTTON(ImGuiKey_GamepadDpadRight,   GLFW_GAMEPAD_BUTTON_DPAD_RIGHT,     11);
+    MAP_BUTTON(ImGuiKey_GamepadDpadUp,      GLFW_GAMEPAD_BUTTON_DPAD_UP,        10);
+    MAP_BUTTON(ImGuiKey_GamepadDpadDown,    GLFW_GAMEPAD_BUTTON_DPAD_DOWN,      12);
+    MAP_BUTTON(ImGuiKey_GamepadL1,          GLFW_GAMEPAD_BUTTON_LEFT_BUMPER,    4);
+    MAP_BUTTON(ImGuiKey_GamepadR1,          GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER,   5);
+    MAP_ANALOG(ImGuiKey_GamepadL2,          GLFW_GAMEPAD_AXIS_LEFT_TRIGGER,     4,      -0.75f,  +1.0f);
+    MAP_ANALOG(ImGuiKey_GamepadR2,          GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER,    5,      -0.75f,  +1.0f);
+    MAP_BUTTON(ImGuiKey_GamepadL3,          GLFW_GAMEPAD_BUTTON_LEFT_THUMB,     8);
+    MAP_BUTTON(ImGuiKey_GamepadR3,          GLFW_GAMEPAD_BUTTON_RIGHT_THUMB,    9);
+    MAP_ANALOG(ImGuiKey_GamepadLStickLeft,  GLFW_GAMEPAD_AXIS_LEFT_X,           0,      -0.25f,  -1.0f);
+    MAP_ANALOG(ImGuiKey_GamepadLStickRight, GLFW_GAMEPAD_AXIS_LEFT_X,           0,      +0.25f,  +1.0f);
+    MAP_ANALOG(ImGuiKey_GamepadLStickUp,    GLFW_GAMEPAD_AXIS_LEFT_Y,           1,      -0.25f,  -1.0f);
+    MAP_ANALOG(ImGuiKey_GamepadLStickDown,  GLFW_GAMEPAD_AXIS_LEFT_Y,           1,      +0.25f,  +1.0f);
+    MAP_ANALOG(ImGuiKey_GamepadRStickLeft,  GLFW_GAMEPAD_AXIS_RIGHT_X,          2,      -0.25f,  -1.0f);
+    MAP_ANALOG(ImGuiKey_GamepadRStickRight, GLFW_GAMEPAD_AXIS_RIGHT_X,          2,      +0.25f,  +1.0f);
+    MAP_ANALOG(ImGuiKey_GamepadRStickUp,    GLFW_GAMEPAD_AXIS_RIGHT_Y,          3,      -0.25f,  -1.0f);
+    MAP_ANALOG(ImGuiKey_GamepadRStickDown,  GLFW_GAMEPAD_AXIS_RIGHT_Y,          3,      +0.25f,  +1.0f);
+    #undef MAP_BUTTON
+    #undef MAP_ANALOG
+}
+
+void ImGui_ImplGlfw_NewFrame()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    IM_ASSERT(bd != nullptr && "Context or backend not initialized! Did you call ImGui_ImplGlfw_InitForXXX()?");
+
+    // Setup display size (every frame to accommodate for window resizing)
+    int w, h;
+    int display_w, display_h;
+    glfwGetWindowSize(bd->Window, &w, &h);
+    glfwGetFramebufferSize(bd->Window, &display_w, &display_h);
+    io.DisplaySize = ImVec2((float)w, (float)h);
+    if (w > 0 && h > 0)
+        io.DisplayFramebufferScale = ImVec2((float)display_w / (float)w, (float)display_h / (float)h);
+
+    // Setup time step
+    // (Accept glfwGetTime() not returning a monotonically increasing value. Seems to happens on disconnecting peripherals and probably on VMs and Emscripten, see #6491, #6189, #6114, #3644)
+    double current_time = glfwGetTime();
+    if (current_time <= bd->Time)
+        current_time = bd->Time + 0.00001f;
+    io.DeltaTime = bd->Time > 0.0 ? (float)(current_time - bd->Time) : (float)(1.0f / 60.0f);
+    bd->Time = current_time;
+
+    ImGui_ImplGlfw_UpdateMouseData();
+    ImGui_ImplGlfw_UpdateMouseCursor();
+
+    // Update game controllers (if enabled and available)
+    ImGui_ImplGlfw_UpdateGamepads();
+}
+
+// GLFW doesn't provide a portable sleep function
+void ImGui_ImplGlfw_Sleep(int milliseconds)
+{
+#ifdef _WIN32
+    ::Sleep(milliseconds);
+#else
+    usleep(milliseconds * 1000);
+#endif
+}
+
+#ifdef EMSCRIPTEN_USE_EMBEDDED_GLFW3
+static EM_BOOL ImGui_ImplGlfw_OnCanvasSizeChange(int event_type, const EmscriptenUiEvent* event, void* user_data)
+{
+    ImGui_ImplGlfw_Data* bd = (ImGui_ImplGlfw_Data*)user_data;
+    double canvas_width, canvas_height;
+    emscripten_get_element_css_size(bd->CanvasSelector, &canvas_width, &canvas_height);
+    glfwSetWindowSize(bd->Window, (int)canvas_width, (int)canvas_height);
+    return true;
+}
+
+static EM_BOOL ImGui_ImplEmscripten_FullscreenChangeCallback(int event_type, const EmscriptenFullscreenChangeEvent* event, void* user_data)
+{
+    ImGui_ImplGlfw_Data* bd = (ImGui_ImplGlfw_Data*)user_data;
+    double canvas_width, canvas_height;
+    emscripten_get_element_css_size(bd->CanvasSelector, &canvas_width, &canvas_height);
+    glfwSetWindowSize(bd->Window, (int)canvas_width, (int)canvas_height);
+    return true;
+}
+
+// 'canvas_selector' is a CSS selector. The event listener is applied to the first element that matches the query.
+// STRING MUST PERSIST FOR THE APPLICATION DURATION. PLEASE USE A STRING LITERAL OR ENSURE POINTER WILL STAY VALID.
+void ImGui_ImplGlfw_InstallEmscriptenCallbacks(GLFWwindow*, const char* canvas_selector)
+{
+    IM_ASSERT(canvas_selector != nullptr);
+    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
+    IM_ASSERT(bd != nullptr && "Context or backend not initialized! Did you call ImGui_ImplGlfw_InitForXXX()?");
+
+    bd->CanvasSelector = canvas_selector;
+    emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, bd, false, ImGui_ImplGlfw_OnCanvasSizeChange);
+    emscripten_set_fullscreenchange_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, bd, false, ImGui_ImplEmscripten_FullscreenChangeCallback);
+
+    // Change the size of the GLFW window according to the size of the canvas
+    ImGui_ImplGlfw_OnCanvasSizeChange(EMSCRIPTEN_EVENT_RESIZE, {}, bd);
+
+    // Register Emscripten Wheel callback to workaround issue in Emscripten GLFW Emulation (#6096)
+    // We intentionally do not check 'if (install_callbacks)' here, as some users may set it to false and call GLFW callback themselves.
+    // FIXME: May break chaining in case user registered their own Emscripten callback?
+    emscripten_set_wheel_callback(bd->CanvasSelector, nullptr, false, ImGui_ImplEmscripten_WheelCallback);
+}
+#elif defined(EMSCRIPTEN_USE_PORT_CONTRIB_GLFW3)
+// When using --use-port=contrib.glfw3 for the GLFW implementation, you can override the behavior of this call
+// by invoking emscripten_glfw_make_canvas_resizable afterward.
+// See https://github.com/pongasoft/emscripten-glfw/blob/master/docs/Usage.md#how-to-make-the-canvas-resizable-by-the-user for an explanation
+void ImGui_ImplGlfw_InstallEmscriptenCallbacks(GLFWwindow* window, const char* canvas_selector)
+{
+  GLFWwindow* w = (GLFWwindow*)(EM_ASM_INT({ return Module.glfwGetWindow(UTF8ToString($0)); }, canvas_selector));
+  IM_ASSERT(window == w); // Sanity check
+  IM_UNUSED(w);
+  emscripten_glfw_make_canvas_resizable(window, "window", nullptr);
+}
+#endif // #ifdef EMSCRIPTEN_USE_PORT_CONTRIB_GLFW3
+
+//-----------------------------------------------------------------------------
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+#endif // #ifndef IMGUI_DISABLE

lib/imgui/imgui_impl_glfw.h

@@ -0,0 +1,63 @@
+// dear imgui: Platform Backend for GLFW
+// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
+// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
+
+// Implemented features:
+//  [X] Platform: Clipboard support.
+//  [X] Platform: Mouse support. Can discriminate Mouse/TouchScreen/Pen (Windows only).
+//  [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy GLFW_KEY_* values are obsolete since 1.87 and not supported since 1.91.5]
+//  [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
+//  [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+#pragma once
+#include "imgui.h"      // IMGUI_IMPL_API
+#ifndef IMGUI_DISABLE
+
+struct GLFWwindow;
+struct GLFWmonitor;
+
+// Follow "Getting Started" link and check examples/ folder to learn about using backends!
+IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks);
+IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks);
+IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOther(GLFWwindow* window, bool install_callbacks);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_Shutdown();
+IMGUI_IMPL_API void     ImGui_ImplGlfw_NewFrame();
+
+// Emscripten related initialization phase methods (call after ImGui_ImplGlfw_InitForOpenGL)
+#ifdef __EMSCRIPTEN__
+IMGUI_IMPL_API void     ImGui_ImplGlfw_InstallEmscriptenCallbacks(GLFWwindow* window, const char* canvas_selector);
+//static inline void    ImGui_ImplGlfw_InstallEmscriptenCanvasResizeCallback(const char* canvas_selector) { ImGui_ImplGlfw_InstallEmscriptenCallbacks(nullptr, canvas_selector); } } // Renamed in 1.91.0
+#endif
+
+// GLFW callbacks install
+// - When calling Init with 'install_callbacks=true': ImGui_ImplGlfw_InstallCallbacks() is called. GLFW callbacks will be installed for you. They will chain-call user's previously installed callbacks, if any.
+// - When calling Init with 'install_callbacks=false': GLFW callbacks won't be installed. You will need to call individual function yourself from your own GLFW callbacks.
+IMGUI_IMPL_API void     ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
+
+// GFLW callbacks options:
+// - Set 'chain_for_all_windows=true' to enable chaining callbacks for all windows (including secondary viewports created by backends or by user)
+IMGUI_IMPL_API void     ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
+
+// GLFW callbacks (individual callbacks to call yourself if you didn't install callbacks)
+IMGUI_IMPL_API void     ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window, int focused);        // Since 1.84
+IMGUI_IMPL_API void     ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window, int entered);        // Since 1.84
+IMGUI_IMPL_API void     ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window, double x, double y);   // Since 1.87
+IMGUI_IMPL_API void     ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor, int event);
+
+// GLFW helpers
+IMGUI_IMPL_API void     ImGui_ImplGlfw_Sleep(int milliseconds);
+
+#endif // #ifndef IMGUI_DISABLE

lib/imgui/imgui_impl_vulkan.h

@@ -0,0 +1,203 @@
+// dear imgui: Renderer Backend for Vulkan
+// This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
+
+// Implemented features:
+//  [!] Renderer: User texture binding. Use 'VkDescriptorSet' as ImTextureID. Read the FAQ about ImTextureID! See https://github.com/ocornut/imgui/pull/914 for discussions.
+//  [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+//  [X] Renderer: Expose selected render state for draw callbacks to use. Access in '(ImGui_ImplXXXX_RenderState*)GetPlatformIO().Renderer_RenderState'.
+
+// The aim of imgui_impl_vulkan.h/.cpp is to be usable in your engine without any modification.
+// IF YOU FEEL YOU NEED TO MAKE ANY CHANGE TO THIS CODE, please share them and your feedback at https://github.com/ocornut/imgui/
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+// Important note to the reader who wish to integrate imgui_impl_vulkan.cpp/.h in their own engine/app.
+// - Common ImGui_ImplVulkan_XXX functions and structures are used to interface with imgui_impl_vulkan.cpp/.h.
+//   You will use those if you want to use this rendering backend in your engine/app.
+// - Helper ImGui_ImplVulkanH_XXX functions and structures are only used by this example (main.cpp) and by
+//   the backend itself (imgui_impl_vulkan.cpp), but should PROBABLY NOT be used by your own engine/app code.
+// Read comments in imgui_impl_vulkan.h.
+
+#pragma once
+#ifndef IMGUI_DISABLE
+#include "imgui.h"      // IMGUI_IMPL_API
+
+// [Configuration] in order to use a custom Vulkan function loader:
+// (1) You'll need to disable default Vulkan function prototypes.
+//     We provide a '#define IMGUI_IMPL_VULKAN_NO_PROTOTYPES' convenience configuration flag.
+//     In order to make sure this is visible from the imgui_impl_vulkan.cpp compilation unit:
+//     - Add '#define IMGUI_IMPL_VULKAN_NO_PROTOTYPES' in your imconfig.h file
+//     - Or as a compilation flag in your build system
+//     - Or uncomment here (not recommended because you'd be modifying imgui sources!)
+//     - Do not simply add it in a .cpp file!
+// (2) Call ImGui_ImplVulkan_LoadFunctions() before ImGui_ImplVulkan_Init() with your custom function.
+// If you have no idea what this is, leave it alone!
+//#define IMGUI_IMPL_VULKAN_NO_PROTOTYPES
+
+// Convenience support for Volk
+// (you can also technically use IMGUI_IMPL_VULKAN_NO_PROTOTYPES + wrap Volk via ImGui_ImplVulkan_LoadFunctions().)
+//#define IMGUI_IMPL_VULKAN_USE_VOLK
+
+#if defined(IMGUI_IMPL_VULKAN_NO_PROTOTYPES) && !defined(VK_NO_PROTOTYPES)
+#define VK_NO_PROTOTYPES
+#endif
+#if defined(VK_USE_PLATFORM_WIN32_KHR) && !defined(NOMINMAX)
+#define NOMINMAX
+#endif
+
+// Vulkan includes
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+#include <volk.h>
+#else
+#include <vulkan/vulkan.h>
+#endif
+#if defined(VK_VERSION_1_3) || defined(VK_KHR_dynamic_rendering)
+#define IMGUI_IMPL_VULKAN_HAS_DYNAMIC_RENDERING
+#endif
+
+// Initialization data, for ImGui_ImplVulkan_Init()
+// - VkDescriptorPool should be created with VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
+//   and must contain a pool size large enough to hold an ImGui VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER descriptor.
+// - When using dynamic rendering, set UseDynamicRendering=true and fill PipelineRenderingCreateInfo structure.
+// [Please zero-clear before use!]
+struct ImGui_ImplVulkan_InitInfo
+{
+    VkInstance                      Instance;
+    VkPhysicalDevice                PhysicalDevice;
+    VkDevice                        Device;
+    uint32_t                        QueueFamily;
+    VkQueue                         Queue;
+    VkDescriptorPool                DescriptorPool;               // See requirements in note above
+    VkRenderPass                    RenderPass;                   // Ignored if using dynamic rendering
+    uint32_t                        MinImageCount;                // >= 2
+    uint32_t                        ImageCount;                   // >= MinImageCount
+    VkSampleCountFlagBits           MSAASamples;                  // 0 defaults to VK_SAMPLE_COUNT_1_BIT
+
+    // (Optional)
+    VkPipelineCache                 PipelineCache;
+    uint32_t                        Subpass;
+
+    // (Optional) Dynamic Rendering
+    // Need to explicitly enable VK_KHR_dynamic_rendering extension to use this, even for Vulkan 1.3.
+    bool                            UseDynamicRendering;
+#ifdef IMGUI_IMPL_VULKAN_HAS_DYNAMIC_RENDERING
+    VkPipelineRenderingCreateInfoKHR PipelineRenderingCreateInfo;
+#endif
+
+    // (Optional) Allocation, Debugging
+    const VkAllocationCallbacks*    Allocator;
+    void                            (*CheckVkResultFn)(VkResult err);
+    VkDeviceSize                    MinAllocationSize;      // Minimum allocation size. Set to 1024*1024 to satisfy zealous best practices validation layer and waste a little memory.
+};
+
+// Follow "Getting Started" link and check examples/ folder to learn about using backends!
+IMGUI_IMPL_API bool             ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
+IMGUI_IMPL_API void             ImGui_ImplVulkan_Shutdown();
+IMGUI_IMPL_API void             ImGui_ImplVulkan_NewFrame();
+IMGUI_IMPL_API void             ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data, VkCommandBuffer command_buffer, VkPipeline pipeline = VK_NULL_HANDLE);
+IMGUI_IMPL_API bool             ImGui_ImplVulkan_CreateFontsTexture();
+IMGUI_IMPL_API void             ImGui_ImplVulkan_DestroyFontsTexture();
+IMGUI_IMPL_API void             ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count); // To override MinImageCount after initialization (e.g. if swap chain is recreated)
+
+// Register a texture (VkDescriptorSet == ImTextureID)
+// FIXME: This is experimental in the sense that we are unsure how to best design/tackle this problem
+// Please post to https://github.com/ocornut/imgui/pull/914 if you have suggestions.
+IMGUI_IMPL_API VkDescriptorSet  ImGui_ImplVulkan_AddTexture(VkSampler sampler, VkImageView image_view, VkImageLayout image_layout);
+IMGUI_IMPL_API void             ImGui_ImplVulkan_RemoveTexture(VkDescriptorSet descriptor_set);
+
+// Optional: load Vulkan functions with a custom function loader
+// This is only useful with IMGUI_IMPL_VULKAN_NO_PROTOTYPES / VK_NO_PROTOTYPES
+IMGUI_IMPL_API bool             ImGui_ImplVulkan_LoadFunctions(PFN_vkVoidFunction(*loader_func)(const char* function_name, void* user_data), void* user_data = nullptr);
+
+// [BETA] Selected render state data shared with callbacks.
+// This is temporarily stored in GetPlatformIO().Renderer_RenderState during the ImGui_ImplVulkan_RenderDrawData() call.
+// (Please open an issue if you feel you need access to more data)
+struct ImGui_ImplVulkan_RenderState
+{
+    VkCommandBuffer     CommandBuffer;
+    VkPipeline          Pipeline;
+    VkPipelineLayout    PipelineLayout;
+};
+
+//-------------------------------------------------------------------------
+// Internal / Miscellaneous Vulkan Helpers
+// (Used by example's main.cpp. Used by multi-viewport features. PROBABLY NOT used by your own engine/app.)
+//-------------------------------------------------------------------------
+// You probably do NOT need to use or care about those functions.
+// Those functions only exist because:
+//   1) they facilitate the readability and maintenance of the multiple main.cpp examples files.
+//   2) the multi-viewport / platform window implementation needs them internally.
+// Generally we avoid exposing any kind of superfluous high-level helpers in the bindings,
+// but it is too much code to duplicate everywhere so we exceptionally expose them.
+//
+// Your engine/app will likely _already_ have code to setup all that stuff (swap chain, render pass, frame buffers, etc.).
+// You may read this code to learn about Vulkan, but it is recommended you use you own custom tailored code to do equivalent work.
+// (The ImGui_ImplVulkanH_XXX functions do not interact with any of the state used by the regular ImGui_ImplVulkan_XXX functions)
+//-------------------------------------------------------------------------
+
+struct ImGui_ImplVulkanH_Frame;
+struct ImGui_ImplVulkanH_Window;
+
+// Helpers
+IMGUI_IMPL_API void                 ImGui_ImplVulkanH_CreateOrResizeWindow(VkInstance instance, VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wnd, uint32_t queue_family, const VkAllocationCallbacks* allocator, int w, int h, uint32_t min_image_count);
+IMGUI_IMPL_API void                 ImGui_ImplVulkanH_DestroyWindow(VkInstance instance, VkDevice device, ImGui_ImplVulkanH_Window* wnd, const VkAllocationCallbacks* allocator);
+IMGUI_IMPL_API VkSurfaceFormatKHR   ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device, VkSurfaceKHR surface, const VkFormat* request_formats, int request_formats_count, VkColorSpaceKHR request_color_space);
+IMGUI_IMPL_API VkPresentModeKHR     ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device, VkSurfaceKHR surface, const VkPresentModeKHR* request_modes, int request_modes_count);
+IMGUI_IMPL_API int                  ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);
+
+// Helper structure to hold the data needed by one rendering frame
+// (Used by example's main.cpp. Used by multi-viewport features. Probably NOT used by your own engine/app.)
+// [Please zero-clear before use!]
+struct ImGui_ImplVulkanH_Frame
+{
+    VkCommandPool       CommandPool;
+    VkCommandBuffer     CommandBuffer;
+    VkFence             Fence;
+    VkImage             Backbuffer;
+    VkImageView         BackbufferView;
+    VkFramebuffer       Framebuffer;
+};
+
+struct ImGui_ImplVulkanH_FrameSemaphores
+{
+    VkSemaphore         ImageAcquiredSemaphore;
+    VkSemaphore         RenderCompleteSemaphore;
+};
+
+// Helper structure to hold the data needed by one rendering context into one OS window
+// (Used by example's main.cpp. Used by multi-viewport features. Probably NOT used by your own engine/app.)
+struct ImGui_ImplVulkanH_Window
+{
+    int                 Width;
+    int                 Height;
+    VkSwapchainKHR      Swapchain;
+    VkSurfaceKHR        Surface;
+    VkSurfaceFormatKHR  SurfaceFormat;
+    VkPresentModeKHR    PresentMode;
+    VkRenderPass        RenderPass;
+    VkPipeline          Pipeline;               // The window pipeline may uses a different VkRenderPass than the one passed in ImGui_ImplVulkan_InitInfo
+    bool                UseDynamicRendering;
+    bool                ClearEnable;
+    VkClearValue        ClearValue;
+    uint32_t            FrameIndex;             // Current frame being rendered to (0 <= FrameIndex < FrameInFlightCount)
+    uint32_t            ImageCount;             // Number of simultaneous in-flight frames (returned by vkGetSwapchainImagesKHR, usually derived from min_image_count)
+    uint32_t            SemaphoreCount;         // Number of simultaneous in-flight frames + 1, to be able to use it in vkAcquireNextImageKHR
+    uint32_t            SemaphoreIndex;         // Current set of swapchain wait semaphores we're using (needs to be distinct from per frame data)
+    ImGui_ImplVulkanH_Frame*            Frames;
+    ImGui_ImplVulkanH_FrameSemaphores*  FrameSemaphores;
+
+    ImGui_ImplVulkanH_Window()
+    {
+        memset((void*)this, 0, sizeof(*this));
+        PresentMode = (VkPresentModeKHR)~0;     // Ensure we get an error if user doesn't set this.
+        ClearEnable = true;
+    }
+};
+
+#endif // #ifndef IMGUI_DISABLE

lib/imgui/imstb_rectpack.h

@@ -0,0 +1,627 @@
+// [DEAR IMGUI]
+// This is a slightly modified version of stb_rect_pack.h 1.01.
+// Grep for [DEAR IMGUI] to find the changes.
+// 
+// stb_rect_pack.h - v1.01 - public domain - rectangle packing
+// Sean Barrett 2014
+//
+// Useful for e.g. packing rectangular textures into an atlas.
+// Does not do rotation.
+//
+// Before #including,
+//
+//    #define STB_RECT_PACK_IMPLEMENTATION
+//
+// in the file that you want to have the implementation.
+//
+// Not necessarily the awesomest packing method, but better than
+// the totally naive one in stb_truetype (which is primarily what
+// this is meant to replace).
+//
+// Has only had a few tests run, may have issues.
+//
+// More docs to come.
+//
+// No memory allocations; uses qsort() and assert() from stdlib.
+// Can override those by defining STBRP_SORT and STBRP_ASSERT.
+//
+// This library currently uses the Skyline Bottom-Left algorithm.
+//
+// Please note: better rectangle packers are welcome! Please
+// implement them to the same API, but with a different init
+// function.
+//
+// Credits
+//
+//  Library
+//    Sean Barrett
+//  Minor features
+//    Martins Mozeiko
+//    github:IntellectualKitty
+//
+//  Bugfixes / warning fixes
+//    Jeremy Jaussaud
+//    Fabian Giesen
+//
+// Version history:
+//
+//     1.01  (2021-07-11)  always use large rect mode, expose STBRP__MAXVAL in public section
+//     1.00  (2019-02-25)  avoid small space waste; gracefully fail too-wide rectangles
+//     0.99  (2019-02-07)  warning fixes
+//     0.11  (2017-03-03)  return packing success/fail result
+//     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
+//     0.09  (2016-08-27)  fix compiler warnings
+//     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
+//     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
+//     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
+//     0.05:  added STBRP_ASSERT to allow replacing assert
+//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
+//     0.01:  initial release
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//       INCLUDE SECTION
+//
+
+#ifndef STB_INCLUDE_STB_RECT_PACK_H
+#define STB_INCLUDE_STB_RECT_PACK_H
+
+#define STB_RECT_PACK_VERSION  1
+
+#ifdef STBRP_STATIC
+#define STBRP_DEF static
+#else
+#define STBRP_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct stbrp_context stbrp_context;
+typedef struct stbrp_node    stbrp_node;
+typedef struct stbrp_rect    stbrp_rect;
+
+typedef int            stbrp_coord;
+
+#define STBRP__MAXVAL  0x7fffffff
+// Mostly for internal use, but this is the maximum supported coordinate value.
+
+STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
+// Assign packed locations to rectangles. The rectangles are of type
+// 'stbrp_rect' defined below, stored in the array 'rects', and there
+// are 'num_rects' many of them.
+//
+// Rectangles which are successfully packed have the 'was_packed' flag
+// set to a non-zero value and 'x' and 'y' store the minimum location
+// on each axis (i.e. bottom-left in cartesian coordinates, top-left
+// if you imagine y increasing downwards). Rectangles which do not fit
+// have the 'was_packed' flag set to 0.
+//
+// You should not try to access the 'rects' array from another thread
+// while this function is running, as the function temporarily reorders
+// the array while it executes.
+//
+// To pack into another rectangle, you need to call stbrp_init_target
+// again. To continue packing into the same rectangle, you can call
+// this function again. Calling this multiple times with multiple rect
+// arrays will probably produce worse packing results than calling it
+// a single time with the full rectangle array, but the option is
+// available.
+//
+// The function returns 1 if all of the rectangles were successfully
+// packed and 0 otherwise.
+
+struct stbrp_rect
+{
+   // reserved for your use:
+   int            id;
+
+   // input:
+   stbrp_coord    w, h;
+
+   // output:
+   stbrp_coord    x, y;
+   int            was_packed;  // non-zero if valid packing
+
+}; // 16 bytes, nominally
+
+
+STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
+// Initialize a rectangle packer to:
+//    pack a rectangle that is 'width' by 'height' in dimensions
+//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
+//
+// You must call this function every time you start packing into a new target.
+//
+// There is no "shutdown" function. The 'nodes' memory must stay valid for
+// the following stbrp_pack_rects() call (or calls), but can be freed after
+// the call (or calls) finish.
+//
+// Note: to guarantee best results, either:
+//       1. make sure 'num_nodes' >= 'width'
+//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
+//
+// If you don't do either of the above things, widths will be quantized to multiples
+// of small integers to guarantee the algorithm doesn't run out of temporary storage.
+//
+// If you do #2, then the non-quantized algorithm will be used, but the algorithm
+// may run out of temporary storage and be unable to pack some rectangles.
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
+// Optionally call this function after init but before doing any packing to
+// change the handling of the out-of-temp-memory scenario, described above.
+// If you call init again, this will be reset to the default (false).
+
+
+STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
+// Optionally select which packing heuristic the library should use. Different
+// heuristics will produce better/worse results for different data sets.
+// If you call init again, this will be reset to the default.
+
+enum
+{
+   STBRP_HEURISTIC_Skyline_default=0,
+   STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
+   STBRP_HEURISTIC_Skyline_BF_sortHeight
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// the details of the following structures don't matter to you, but they must
+// be visible so you can handle the memory allocations for them
+
+struct stbrp_node
+{
+   stbrp_coord  x,y;
+   stbrp_node  *next;
+};
+
+struct stbrp_context
+{
+   int width;
+   int height;
+   int align;
+   int init_mode;
+   int heuristic;
+   int num_nodes;
+   stbrp_node *active_head;
+   stbrp_node *free_head;
+   stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     IMPLEMENTATION SECTION
+//
+
+#ifdef STB_RECT_PACK_IMPLEMENTATION
+#ifndef STBRP_SORT
+#include <stdlib.h>
+#define STBRP_SORT qsort
+#endif
+
+#ifndef STBRP_ASSERT
+#include <assert.h>
+#define STBRP_ASSERT assert
+#endif
+
+#ifdef _MSC_VER
+#define STBRP__NOTUSED(v)  (void)(v)
+#define STBRP__CDECL       __cdecl
+#else
+#define STBRP__NOTUSED(v)  (void)sizeof(v)
+#define STBRP__CDECL
+#endif
+
+enum
+{
+   STBRP__INIT_skyline = 1
+};
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
+{
+   switch (context->init_mode) {
+      case STBRP__INIT_skyline:
+         STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
+         context->heuristic = heuristic;
+         break;
+      default:
+         STBRP_ASSERT(0);
+   }
+}
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
+{
+   if (allow_out_of_mem)
+      // if it's ok to run out of memory, then don't bother aligning them;
+      // this gives better packing, but may fail due to OOM (even though
+      // the rectangles easily fit). @TODO a smarter approach would be to only
+      // quantize once we've hit OOM, then we could get rid of this parameter.
+      context->align = 1;
+   else {
+      // if it's not ok to run out of memory, then quantize the widths
+      // so that num_nodes is always enough nodes.
+      //
+      // I.e. num_nodes * align >= width
+      //                  align >= width / num_nodes
+      //                  align = ceil(width/num_nodes)
+
+      context->align = (context->width + context->num_nodes-1) / context->num_nodes;
+   }
+}
+
+STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
+{
+   int i;
+
+   for (i=0; i < num_nodes-1; ++i)
+      nodes[i].next = &nodes[i+1];
+   nodes[i].next = NULL;
+   context->init_mode = STBRP__INIT_skyline;
+   context->heuristic = STBRP_HEURISTIC_Skyline_default;
+   context->free_head = &nodes[0];
+   context->active_head = &context->extra[0];
+   context->width = width;
+   context->height = height;
+   context->num_nodes = num_nodes;
+   stbrp_setup_allow_out_of_mem(context, 0);
+
+   // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
+   context->extra[0].x = 0;
+   context->extra[0].y = 0;
+   context->extra[0].next = &context->extra[1];
+   context->extra[1].x = (stbrp_coord) width;
+   context->extra[1].y = (1<<30);
+   context->extra[1].next = NULL;
+}
+
+// find minimum y position if it starts at x1
+static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
+{
+   stbrp_node *node = first;
+   int x1 = x0 + width;
+   int min_y, visited_width, waste_area;
+
+   STBRP__NOTUSED(c);
+
+   STBRP_ASSERT(first->x <= x0);
+
+   #if 0
+   // skip in case we're past the node
+   while (node->next->x <= x0)
+      ++node;
+   #else
+   STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
+   #endif
+
+   STBRP_ASSERT(node->x <= x0);
+
+   min_y = 0;
+   waste_area = 0;
+   visited_width = 0;
+   while (node->x < x1) {
+      if (node->y > min_y) {
+         // raise min_y higher.
+         // we've accounted for all waste up to min_y,
+         // but we'll now add more waste for everything we've visted
+         waste_area += visited_width * (node->y - min_y);
+         min_y = node->y;
+         // the first time through, visited_width might be reduced
+         if (node->x < x0)
+            visited_width += node->next->x - x0;
+         else
+            visited_width += node->next->x - node->x;
+      } else {
+         // add waste area
+         int under_width = node->next->x - node->x;
+         if (under_width + visited_width > width)
+            under_width = width - visited_width;
+         waste_area += under_width * (min_y - node->y);
+         visited_width += under_width;
+      }
+      node = node->next;
+   }
+
+   *pwaste = waste_area;
+   return min_y;
+}
+
+typedef struct
+{
+   int x,y;
+   stbrp_node **prev_link;
+} stbrp__findresult;
+
+static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
+{
+   int best_waste = (1<<30), best_x, best_y = (1 << 30);
+   stbrp__findresult fr;
+   stbrp_node **prev, *node, *tail, **best = NULL;
+
+   // align to multiple of c->align
+   width = (width + c->align - 1);
+   width -= width % c->align;
+   STBRP_ASSERT(width % c->align == 0);
+
+   // if it can't possibly fit, bail immediately
+   if (width > c->width || height > c->height) {
+      fr.prev_link = NULL;
+      fr.x = fr.y = 0;
+      return fr;
+   }
+
+   node = c->active_head;
+   prev = &c->active_head;
+   while (node->x + width <= c->width) {
+      int y,waste;
+      y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
+      if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
+         // bottom left
+         if (y < best_y) {
+            best_y = y;
+            best = prev;
+         }
+      } else {
+         // best-fit
+         if (y + height <= c->height) {
+            // can only use it if it first vertically
+            if (y < best_y || (y == best_y && waste < best_waste)) {
+               best_y = y;
+               best_waste = waste;
+               best = prev;
+            }
+         }
+      }
+      prev = &node->next;
+      node = node->next;
+   }
+
+   best_x = (best == NULL) ? 0 : (*best)->x;
+
+   // if doing best-fit (BF), we also have to try aligning right edge to each node position
+   //
+   // e.g, if fitting
+   //
+   //     ____________________
+   //    |____________________|
+   //
+   //            into
+   //
+   //   |                         |
+   //   |             ____________|
+   //   |____________|
+   //
+   // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
+   //
+   // This makes BF take about 2x the time
+
+   if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
+      tail = c->active_head;
+      node = c->active_head;
+      prev = &c->active_head;
+      // find first node that's admissible
+      while (tail->x < width)
+         tail = tail->next;
+      while (tail) {
+         int xpos = tail->x - width;
+         int y,waste;
+         STBRP_ASSERT(xpos >= 0);
+         // find the left position that matches this
+         while (node->next->x <= xpos) {
+            prev = &node->next;
+            node = node->next;
+         }
+         STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
+         y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
+         if (y + height <= c->height) {
+            if (y <= best_y) {
+               if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
+                  best_x = xpos;
+                  //STBRP_ASSERT(y <= best_y); [DEAR IMGUI]
+                  best_y = y;
+                  best_waste = waste;
+                  best = prev;
+               }
+            }
+         }
+         tail = tail->next;
+      }
+   }
+
+   fr.prev_link = best;
+   fr.x = best_x;
+   fr.y = best_y;
+   return fr;
+}
+
+static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
+{
+   // find best position according to heuristic
+   stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
+   stbrp_node *node, *cur;
+
+   // bail if:
+   //    1. it failed
+   //    2. the best node doesn't fit (we don't always check this)
+   //    3. we're out of memory
+   if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
+      res.prev_link = NULL;
+      return res;
+   }
+
+   // on success, create new node
+   node = context->free_head;
+   node->x = (stbrp_coord) res.x;
+   node->y = (stbrp_coord) (res.y + height);
+
+   context->free_head = node->next;
+
+   // insert the new node into the right starting point, and
+   // let 'cur' point to the remaining nodes needing to be
+   // stiched back in
+
+   cur = *res.prev_link;
+   if (cur->x < res.x) {
+      // preserve the existing one, so start testing with the next one
+      stbrp_node *next = cur->next;
+      cur->next = node;
+      cur = next;
+   } else {
+      *res.prev_link = node;
+   }
+
+   // from here, traverse cur and free the nodes, until we get to one
+   // that shouldn't be freed
+   while (cur->next && cur->next->x <= res.x + width) {
+      stbrp_node *next = cur->next;
+      // move the current node to the free list
+      cur->next = context->free_head;
+      context->free_head = cur;
+      cur = next;
+   }
+
+   // stitch the list back in
+   node->next = cur;
+
+   if (cur->x < res.x + width)
+      cur->x = (stbrp_coord) (res.x + width);
+
+#ifdef _DEBUG
+   cur = context->active_head;
+   while (cur->x < context->width) {
+      STBRP_ASSERT(cur->x < cur->next->x);
+      cur = cur->next;
+   }
+   STBRP_ASSERT(cur->next == NULL);
+
+   {
+      int count=0;
+      cur = context->active_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      cur = context->free_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      STBRP_ASSERT(count == context->num_nodes+2);
+   }
+#endif
+
+   return res;
+}
+
+static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   if (p->h > q->h)
+      return -1;
+   if (p->h < q->h)
+      return  1;
+   return (p->w > q->w) ? -1 : (p->w < q->w);
+}
+
+static int STBRP__CDECL rect_original_order(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
+}
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
+{
+   int i, all_rects_packed = 1;
+
+   // we use the 'was_packed' field internally to allow sorting/unsorting
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = i;
+   }
+
+   // sort according to heuristic
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
+
+   for (i=0; i < num_rects; ++i) {
+      if (rects[i].w == 0 || rects[i].h == 0) {
+         rects[i].x = rects[i].y = 0;  // empty rect needs no space
+      } else {
+         stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
+         if (fr.prev_link) {
+            rects[i].x = (stbrp_coord) fr.x;
+            rects[i].y = (stbrp_coord) fr.y;
+         } else {
+            rects[i].x = rects[i].y = STBRP__MAXVAL;
+         }
+      }
+   }
+
+   // unsort
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
+
+   // set was_packed flags and all_rects_packed status
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
+      if (!rects[i].was_packed)
+         all_rects_packed = 0;
+   }
+
+   // return the all_rects_packed status
+   return all_rects_packed;
+}
+#endif
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/

src/agnosiaimgui.cpp

@@ -0,0 +1,124 @@
+#include "agnosiaimgui.h"
+#include "devicelibrary.h"
+#include "entrypoint.h"
+#include "graphics/buffers.h"
+#include "graphics/graphicspipeline.h"
+#include "graphics/texture.h"
+#include "imgui.h"
+#include "imgui_impl_glfw.h"
+#include "imgui_impl_vulkan.h"
+#include <glm/gtc/type_ptr.hpp>
+#include <stdexcept>
+
+VkDescriptorPool imGuiDescriptorPool;
+
+void initImGuiWindow() {
+  if (ImGui::TreeNode("Model Transforms")) {
+    for (Model *model : Model::getInstances()) {
+
+      ImGui::DragFloat3(model->getID().c_str(),
+                        const_cast<float *>(glm::value_ptr(model->getPos())));
+    }
+    ImGui::TreePop();
+  }
+
+  ImGui::DragFloat3("Camera Position", Graphics::getCamPos());
+  ImGui::DragFloat3("Light Position", Graphics::getLightPos());
+  ImGui::DragFloat3("Center Position", Graphics::getCenterPos());
+  ImGui::DragFloat("Depth of Field", &Graphics::getDepthField(), 0.1f, 1.0f,
+                   180.0f, NULL, ImGuiSliderFlags_AlwaysClamp);
+  ImGui::DragFloat2("Near and Far fields", Graphics::getDistanceField());
+}
+
+void drawTabs() {
+  if (ImGui::BeginTabBar("MainTabBar", ImGuiTabBarFlags_Reorderable)) {
+    if (ImGui::BeginTabItem("Transforms Control")) {
+      initImGuiWindow();
+      ImGui::EndTabItem();
+    }
+
+    ImGui::EndTabBar();
+  }
+}
+
+void Gui::drawImGui() {
+
+  ImGui_ImplVulkan_NewFrame();
+  ImGui_ImplGlfw_NewFrame();
+  ImGui::NewFrame();
+
+  ImGui::Begin("Agnosia Debug");
+
+  ImGui::Text("Application average %.3f ms/frame (%.1f FPS)",
+              1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
+
+  drawTabs();
+
+  ImGui::End();
+
+  ImGui::Render();
+}
+
+void Gui::initImgui(VkInstance instance) {
+  auto load_vk_func = [&](const char *fn) {
+    if (auto proc = vkGetDeviceProcAddr(DeviceControl::getDevice(), fn))
+      return proc;
+    return vkGetInstanceProcAddr(instance, fn);
+  };
+  ImGui_ImplVulkan_LoadFunctions(
+      [](const char *fn, void *data) {
+        return (*(decltype(load_vk_func) *)data)(fn);
+      },
+      &load_vk_func);
+
+  IMGUI_CHECKVERSION();
+  ImGui::CreateContext();
+  // TODO
+  ImGuiIO &io = ImGui::GetIO();
+  (void)io;
+  io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+
+  ImGui::StyleColorsDark();
+
+  ImGui_ImplGlfw_InitForVulkan(EntryApp::getWindow(), true);
+
+  VkDescriptorPoolSize ImGuiPoolSizes[]{
+      {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1},
+  };
+  VkDescriptorPoolCreateInfo ImGuiPoolInfo{
+      .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
+      .flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
+      .maxSets = 1,
+      .poolSizeCount = 1,
+      .pPoolSizes = ImGuiPoolSizes,
+  };
+  if (vkCreateDescriptorPool(DeviceControl::getDevice(), &ImGuiPoolInfo,
+                             nullptr, &imGuiDescriptorPool) != VK_SUCCESS) {
+    throw std::runtime_error("Failed to create ImGui descriptor pool!");
+  }
+
+  VkPipelineRenderingCreateInfo pipelineRenderingCreateInfo{
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
+      .colorAttachmentCount = 1,
+      .pColorAttachmentFormats = &DeviceControl::getImageFormat(),
+      .depthAttachmentFormat = Texture::findDepthFormat(),
+  };
+
+  ImGui_ImplVulkan_InitInfo initInfo{
+      .Instance = instance,
+      .PhysicalDevice = DeviceControl::getPhysicalDevice(),
+      .Device = DeviceControl::getDevice(),
+      .QueueFamily =
+          DeviceControl::findQueueFamilies(DeviceControl::getPhysicalDevice())
+              .graphicsFamily.value(),
+      .Queue = DeviceControl::getGraphicsQueue(),
+      .DescriptorPool = imGuiDescriptorPool,
+      .MinImageCount = Buffers::getMaxFramesInFlight(),
+      .ImageCount = Buffers::getMaxFramesInFlight(),
+      .MSAASamples = DeviceControl::getPerPixelSampleCount(),
+      .UseDynamicRendering = true,
+      .PipelineRenderingCreateInfo = pipelineRenderingCreateInfo,
+  };
+
+  ImGui_ImplVulkan_Init(&initInfo);
+}

src/agnosiaimgui.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "volk.h"
+
+class Gui {
+public:
+  static void drawImGui();
+  static void initImgui(VkInstance instance);
+};

src/devicelibrary.cpp

@@ -0,0 +1,496 @@
+#include "devicelibrary.h"
+#include <algorithm>
+#include <limits>
+#include <set>
+#include <stdexcept>
+#include <string>
+
+VkPhysicalDeviceProperties deviceProperties;
+VkDevice device;
+VkSurfaceKHR surface;
+VkQueue graphicsQueue;
+VkQueue presentQueue;
+VkPhysicalDevice physicalDevice;
+VkSampleCountFlagBits perPixelSampleCount;
+
+VkSwapchainKHR swapChain;
+std::vector<VkImage> swapChainImages;
+std::vector<VkImageView> swapChainImageViews;
+VkFormat swapChainImageFormat;
+VkExtent2D swapChainExtent;
+
+struct SwapChainSupportDetails {
+  VkSurfaceCapabilitiesKHR capabilities;
+  std::vector<VkSurfaceFormatKHR> formats;
+  std::vector<VkPresentModeKHR> presentModes;
+};
+const std::vector<const char *> deviceExtensions = {
+    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
+    VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME,
+};
+
+DeviceControl::QueueFamilyIndices
+DeviceControl::findQueueFamilies(VkPhysicalDevice device) {
+  // First we feed in a integer we want to use to hold the number of queued
+  // items, that fills it, then we create that amount of default constructed
+  // *VkQueueFamilyProperties* structs. These store the flags, the amount of
+  // queued items in the family, and timestamp data. Queue families are simply
+  // group collections of tasks we want to get done. Next, we check the flags of
+  // the queueFamily item, use a bitwise and to see if they match, i.e. support
+  // graphical operations, then return that to notify that we have at least one
+  // family that supports VK_QUEUE_GRAPHICS_BIT. Which means this device
+  // supports graphical operations! We also do the same thing for window
+  // presentation, just check to see if its supported.
+  DeviceControl::QueueFamilyIndices indices;
+  uint32_t queueFamilyCount = 0;
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
+
+  std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount,
+                                           queueFamilies.data());
+
+  int i = 0;
+  for (const auto &queueFamily : queueFamilies) {
+    if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+      indices.graphicsFamily = i;
+    }
+
+    VkBool32 presentSupport = false;
+    vkGetPhysicalDeviceSurfaceSupportKHR(device, i, DeviceControl::getSurface(),
+                                         &presentSupport);
+    if (presentSupport) {
+      indices.presentFamily = i;
+    }
+
+    if (indices.isComplete()) {
+      break;
+    }
+    i++;
+  }
+  return indices;
+}
+SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device) {
+
+  /* Swap chains are weird ngl, it's another one of those Vulkan platform
+  agnosticity. The swapchain is basically a wrapper for GDI+, DXGI, X11,
+  Wayland, etc. It lets us use the swap chain rather than create a different
+  framebuffer handler for every targeted platform.  Swap chains handle the
+  ownership of buffers before sending them to the presentation engine.  (still
+  no fucking clue how it works though) */
+  SwapChainSupportDetails details;
+
+  vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface,
+                                            &details.capabilities);
+
+  uint32_t formatCount;
+  vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
+
+  if (formatCount != 0) {
+    details.formats.resize(formatCount);
+    vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount,
+                                         details.formats.data());
+  }
+
+  uint32_t presentModeCount;
+  vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount,
+                                            details.presentModes.data());
+
+  if (presentModeCount != 0) {
+    details.presentModes.resize(presentModeCount);
+    vkGetPhysicalDeviceSurfacePresentModesKHR(
+        device, surface, &presentModeCount, details.presentModes.data());
+  }
+
+  return details;
+}
+
+bool checkDeviceExtensionSupport(VkPhysicalDevice device) {
+  uint32_t extensionCount;
+  vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount,
+                                       nullptr);
+
+  std::vector<VkExtensionProperties> availableExtensions(extensionCount);
+  vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount,
+                                       availableExtensions.data());
+
+  std::set<std::string> requiredExtensions(deviceExtensions.begin(),
+                                           deviceExtensions.end());
+
+  for (const auto &extension : availableExtensions) {
+    requiredExtensions.erase(extension.extensionName);
+  }
+
+  return requiredExtensions.empty();
+}
+
+bool isDeviceSuitable(VkPhysicalDevice device) {
+  // These two are simple, create a structure to hold the apiVersion,
+  // driverVersion, vendorID, deviceID and type, name, and a few other settings.
+  // Then populate it by passing in the device and the structure reference.
+  vkGetPhysicalDeviceProperties(device, &deviceProperties);
+  // Similarly, we can pass in the device and a deviceFeatures struct, this is
+  // quite special, it holds a struct of optional features the GPU can perform.
+  // Some, like a geometry shader, and stereoscopic rendering (multiViewport) we
+  // want, so we dont return true without them.
+  VkPhysicalDeviceFeatures supportedFeatures;
+  vkGetPhysicalDeviceFeatures(device, &supportedFeatures);
+  // We need to find a device that supports graphical operations, or else we
+  // cant do much with it! This function just runs over all the queueFamilies
+  // and sees if there is a queue family with the VK_QUEUE_GRAPHICS_BIT flipped!
+  DeviceControl::QueueFamilyIndices indices =
+      DeviceControl::findQueueFamilies(device);
+  bool extensionSupported = checkDeviceExtensionSupport(device);
+  bool swapChainAdequate = false;
+
+  if (extensionSupported) {
+    SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
+    swapChainAdequate = !swapChainSupport.formats.empty() &&
+                        !swapChainSupport.presentModes.empty();
+  }
+
+  return deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU &&
+         supportedFeatures.samplerAnisotropy && indices.isComplete() &&
+         extensionSupported && swapChainAdequate;
+}
+// -------------------------------------- Swap Chain Settings
+// ----------------------------------------- //
+VkSurfaceFormatKHR chooseSwapSurfaceFormat(
+    const std::vector<VkSurfaceFormatKHR> &availableFormats) {
+  // One of three settings we can set, Surface Format controls the color space
+  // and format.
+
+  for (const auto &availableFormat : availableFormats) {
+    if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB &&
+        availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
+      // sRGB & 32bit BGRA
+      return availableFormat;
+    }
+  }
+  return availableFormats[0];
+}
+VkPresentModeKHR chooseSwapPresentMode(
+    const std::vector<VkPresentModeKHR> &availablePresentModes) {
+  // The second of the three settings, arguably the most important, the
+  // presentation mode! This dictates how images are displayed. MAILBOX is
+  // basically equivalent to triple buffering, it avoids screen tearing with
+  // fairly low latency, However, it is not always supported, so in the case
+  // that it isn't, currently we will default to FIFO, This is most similarly to
+  // standard V-Sync.
+  for (const auto &availablePresentMode : availablePresentModes) {
+    if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) {
+      return availablePresentMode;
+    }
+  }
+
+  return VK_PRESENT_MODE_FIFO_KHR;
+}
+VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR &capabilities,
+                            GLFWwindow *window) {
+  // Swap Extent is just a fancy way of saying the resolution of the swap images
+  // to display. This is almost always going to equal the resolution of the
+  // window in pixels.
+
+  // The max int32 value tells us that the window manager lets us change the
+  // windth and height to what we wish!
+  if (capabilities.currentExtent.width !=
+      std::numeric_limits<uint32_t>::max()) {
+    return capabilities.currentExtent;
+  } else {
+    int width, height;
+    glfwGetFramebufferSize(window, &width, &height);
+
+    VkExtent2D actualExtent = {static_cast<uint32_t>(width),
+                               static_cast<uint32_t>(height)};
+    // Clamp the image size to the minimum extent values specified by vulkan for
+    // our window manager.
+    actualExtent.width =
+        std::clamp(actualExtent.width, capabilities.minImageExtent.width,
+                   capabilities.maxImageExtent.width);
+    actualExtent.height =
+        std::clamp(actualExtent.height, capabilities.minImageExtent.height,
+                   capabilities.maxImageExtent.height);
+
+    return actualExtent;
+  }
+}
+
+VkSampleCountFlagBits getMaxUsableSampleCount() {
+  VkPhysicalDeviceProperties physicalDeviceProps;
+  VkSampleCountFlags maxCounts;
+  vkGetPhysicalDeviceProperties(physicalDevice, &physicalDeviceProps);
+
+  VkSampleCountFlags counts =
+      physicalDeviceProps.limits.framebufferColorSampleCounts &
+      physicalDeviceProps.limits.framebufferDepthSampleCounts;
+  if (counts & VK_SAMPLE_COUNT_64_BIT) {
+    return VK_SAMPLE_COUNT_64_BIT;
+  }
+  if (counts & VK_SAMPLE_COUNT_32_BIT) {
+    return VK_SAMPLE_COUNT_32_BIT;
+  }
+  if (counts & VK_SAMPLE_COUNT_16_BIT) {
+    return VK_SAMPLE_COUNT_16_BIT;
+  }
+  if (counts & VK_SAMPLE_COUNT_8_BIT) {
+    return VK_SAMPLE_COUNT_8_BIT;
+  }
+  if (counts & VK_SAMPLE_COUNT_4_BIT) {
+    return VK_SAMPLE_COUNT_4_BIT;
+  }
+  if (counts & VK_SAMPLE_COUNT_2_BIT) {
+    return VK_SAMPLE_COUNT_2_BIT;
+  }
+
+  return VK_SAMPLE_COUNT_1_BIT;
+}
+// --------------------------------------- External Functions
+// ----------------------------------------- //
+void DeviceControl::pickPhysicalDevice(VkInstance &instance) {
+  uint32_t deviceCount = 0;
+  vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
+
+  if (deviceCount == 0) {
+    throw std::runtime_error("Failed to find GPU's with Vulkan Support!!");
+  }
+  std::vector<VkPhysicalDevice> devices(
+      deviceCount); // Direct Initialization is weird af, yo
+  vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
+
+  for (const auto &device : devices) {
+    if (isDeviceSuitable(device)) {
+      // Once we have buttons or such, maybe ask the user or write a config file
+      // for which GPU to use?
+      physicalDevice = device;
+      perPixelSampleCount = getMaxUsableSampleCount();
+      break;
+    }
+  }
+  if (physicalDevice == VK_NULL_HANDLE) {
+    throw std::runtime_error("Failed to find a suitable GPU!");
+  }
+}
+void DeviceControl::destroySurface(VkInstance &instance) {
+  vkDestroySurfaceKHR(instance, surface, nullptr);
+}
+void DeviceControl::createSurface(VkInstance &instance, GLFWwindow *window) {
+  if (glfwCreateWindowSurface(instance, window, nullptr, &surface) !=
+      VK_SUCCESS) {
+    throw std::runtime_error("Failed to create window surface!!");
+  }
+}
+void DeviceControl::createLogicalDevice() {
+  // Describe how many queues we want for a single family (1) here, right now we
+  // are solely interested in graphics capabilites, but Compute Shaders,
+  // transfer ops, decode and encode operations can also queued with setup! We
+  // also assign each queue a priority. We do this by looping over all the
+  // queueFamilies and sorting them by indices to fill the queue at the end!
+  QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
+
+  std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
+  std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.value(),
+                                            indices.presentFamily.value()};
+
+  float queuePriority = 1.0f;
+  for (uint32_t queueFamily : uniqueQueueFamilies) {
+    VkDeviceQueueCreateInfo queueCreateSingularInfo = {};
+    queueCreateSingularInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+    queueCreateSingularInfo.queueFamilyIndex = queueFamily;
+    queueCreateSingularInfo.queueCount = 1;
+    queueCreateSingularInfo.pQueuePriorities = &queuePriority;
+    queueCreateInfos.push_back(queueCreateSingularInfo);
+  }
+  VkPhysicalDeviceVulkan12Features features12{
+      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
+      .pNext = nullptr,
+      .shaderSampledImageArrayNonUniformIndexing = true,
+      .shaderStorageBufferArrayNonUniformIndexing = true,
+      .shaderStorageImageArrayNonUniformIndexing = true,
+      .descriptorBindingSampledImageUpdateAfterBind = true,
+      .descriptorBindingStorageImageUpdateAfterBind = true,
+      .descriptorBindingStorageBufferUpdateAfterBind = true,
+      .descriptorBindingUpdateUnusedWhilePending = true,
+      .descriptorBindingPartiallyBound = true,
+      .runtimeDescriptorArray = true,
+      .scalarBlockLayout = true,
+      .bufferDeviceAddress = true,
+
+  };
+  VkPhysicalDeviceVulkan13Features features13{
+      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
+      .pNext = &features12,
+      .synchronization2 = true,
+      .dynamicRendering = true,
+
+  };
+  VkPhysicalDeviceFeatures featuresBase{
+      .robustBufferAccess = true,
+      .sampleRateShading = true,
+      .samplerAnisotropy = true,
+
+  };
+
+  VkPhysicalDeviceFeatures2 deviceFeatures{
+      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
+      .pNext = &features13,
+      .features = featuresBase,
+  };
+
+  VkDeviceCreateInfo createDeviceInfo = {};
+  createDeviceInfo.pNext = &deviceFeatures;
+  createDeviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+  createDeviceInfo.pQueueCreateInfos = queueCreateInfos.data();
+  createDeviceInfo.queueCreateInfoCount =
+      static_cast<uint32_t>(queueCreateInfos.size());
+  createDeviceInfo.enabledExtensionCount =
+      static_cast<uint32_t>(deviceExtensions.size());
+  createDeviceInfo.ppEnabledExtensionNames = deviceExtensions.data();
+
+  if (vkCreateDevice(physicalDevice, &createDeviceInfo, nullptr, &device) !=
+      VK_SUCCESS) {
+    throw std::runtime_error("Failed to create logical device");
+  }
+  vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
+  vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
+}
+void DeviceControl::createSwapChain(GLFWwindow *window) {
+  SwapChainSupportDetails swapChainSupport =
+      querySwapChainSupport(physicalDevice);
+
+  VkSurfaceFormatKHR surfaceFormat =
+      chooseSwapSurfaceFormat(swapChainSupport.formats);
+  VkPresentModeKHR presentMode =
+      chooseSwapPresentMode(swapChainSupport.presentModes);
+  VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities, window);
+
+  // Number of images to hold in the swap chain, 1 over the minimum guarantees
+  // we won't have to wait on the driver to complete internal operations before
+  // acquiring another image. Absolutely a TODO to determine the best amount to
+  // queue.
+  uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
+  // Make sure not to queue more than the max! 0 indicates that there is no
+  // maximum.
+  if (swapChainSupport.capabilities.maxImageCount > 0 &&
+      imageCount > swapChainSupport.capabilities.maxImageCount) {
+    imageCount = swapChainSupport.capabilities.maxImageCount;
+  }
+
+  VkSwapchainCreateInfoKHR createSwapChainInfo{};
+  createSwapChainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+  createSwapChainInfo.surface = surface;
+  createSwapChainInfo.minImageCount = imageCount;
+  createSwapChainInfo.imageFormat = surfaceFormat.format;
+  createSwapChainInfo.imageColorSpace = surfaceFormat.colorSpace;
+  createSwapChainInfo.imageExtent = extent;
+  // Image array layers is always 1 unless we are developing for VR (Spoiler: we
+  // are, we will use a build flag.) Image Usage specifies what operations you
+  // use the images for, COLOR_ATTACH means we render directly to them, if you
+  // wanted to render to separate images for things like post processing, you
+  // can use TRANSFER_DST and use a memory operation to transfer the image to a
+  // swap chain, this is also a TODO item eventually.
+  createSwapChainInfo.imageArrayLayers = 1;
+  createSwapChainInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+
+  // This handles swap chain images across multiple queue families, ie, if the
+  // graphics queue family is different from the present queue
+  QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
+  uint32_t queueFamilyIndices[] = {indices.graphicsFamily.value(),
+                                   indices.presentFamily.value()};
+  // Usage across multiple queue families without explicit transfer of ownership
+  // if they are different queue families. Otherwise, no sharing without
+  // explicit handoffs, faster, but not easily supported with multiple families.
+  // Presentation and Graphics families are usually merged on most hardware.
+  if (indices.graphicsFamily != indices.presentFamily) {
+    createSwapChainInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
+    createSwapChainInfo.queueFamilyIndexCount = 2;
+    createSwapChainInfo.pQueueFamilyIndices = queueFamilyIndices;
+  } else {
+    createSwapChainInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+  }
+  // Transformation of image support.
+  createSwapChainInfo.preTransform =
+      swapChainSupport.capabilities.currentTransform;
+  // Do NOT blend with other windows on the system.
+  createSwapChainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+  createSwapChainInfo.presentMode = presentMode;
+  // This is interesting, clip pixels that are obscured for performance, but
+  // that means you wont be able to read them reliably.. I am curious if this
+  // would affect screen-space rendering techniques, may be something to note.
+  createSwapChainInfo.clipped = VK_TRUE;
+  // This is something that needs to be implemented later, operations like
+  // resizing the window invalidate the swap chain and require you to recreate
+  // it and reference the old one specified here, will revisit in a few days.
+  // createSwapChainInfo.oldSwapchain = VK_NULL_HANDLE;
+
+  if (vkCreateSwapchainKHR(device, &createSwapChainInfo, nullptr, &swapChain) !=
+      VK_SUCCESS) {
+    throw std::runtime_error("Failed to create the swap chain!!");
+  }
+
+  vkGetSwapchainImagesKHR(device, swapChain, &imageCount, nullptr);
+  swapChainImages.resize(imageCount);
+  vkGetSwapchainImagesKHR(device, swapChain, &imageCount,
+                          swapChainImages.data());
+
+  swapChainImageFormat = surfaceFormat.format;
+  swapChainExtent = extent;
+}
+void DeviceControl::destroySwapChain() {
+  vkDestroySwapchainKHR(device, swapChain, nullptr);
+}
+VkImageView DeviceControl::createImageView(VkImage image, VkFormat format,
+                                           VkImageAspectFlags flags,
+                                           uint32_t mipLevels) {
+  // This defines the parameters of a newly created image object!
+  VkImageViewCreateInfo viewInfo{};
+  viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+  viewInfo.image = image;
+  viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+  viewInfo.format = format;
+  viewInfo.subresourceRange.aspectMask = flags;
+  viewInfo.subresourceRange.baseMipLevel = 0;
+  viewInfo.subresourceRange.levelCount = 1;
+  viewInfo.subresourceRange.baseArrayLayer = 0;
+  viewInfo.subresourceRange.layerCount = 1;
+  viewInfo.subresourceRange.levelCount = mipLevels;
+
+  VkImageView imageView;
+  if (vkCreateImageView(device, &viewInfo, nullptr, &imageView) != VK_SUCCESS) {
+    throw std::runtime_error("failed to create image view!");
+  }
+
+  return imageView;
+}
+void DeviceControl::createImageViews() {
+  swapChainImageViews.resize(swapChainImages.size());
+
+  for (uint32_t i = 0; i < swapChainImages.size(); i++) {
+    swapChainImageViews[i] = createImageView(
+        swapChainImages[i], swapChainImageFormat, VK_IMAGE_ASPECT_COLOR_BIT, 1);
+  }
+}
+void DeviceControl::destroyImageViews() {
+  for (auto imageView : swapChainImageViews) {
+    vkDestroyImageView(device, imageView, nullptr);
+  }
+}
+
+// --------------------------------------- Getters & Setters
+// ------------------------------------------ //
+VkFormat &DeviceControl::getImageFormat() { return swapChainImageFormat; }
+VkSwapchainKHR &DeviceControl::getSwapChain() { return swapChain; }
+VkExtent2D &DeviceControl::getSwapChainExtent() { return swapChainExtent; }
+std::vector<VkImage> &DeviceControl::getSwapChainImages() {
+  return swapChainImages;
+}
+
+std::vector<VkImageView> &DeviceControl::getSwapChainImageViews() {
+  return swapChainImageViews;
+}
+VkDevice &DeviceControl::getDevice() { return device; }
+VkPhysicalDevice &DeviceControl::getPhysicalDevice() { return physicalDevice; }
+VkSampleCountFlagBits &DeviceControl::getPerPixelSampleCount() {
+  return perPixelSampleCount;
+}
+VkQueue &DeviceControl::getGraphicsQueue() { return graphicsQueue; }
+VkQueue &DeviceControl::getPresentQueue() { return presentQueue; }
+VkSurfaceKHR &DeviceControl::getSurface() { return surface; }

src/devicelibrary.h

@@ -0,0 +1,50 @@
+#pragma once
+#define VK_NO_PROTOTYPES
+#include "volk.h"
+#include <optional>
+#define GLFW_INCLUDE_VULKAN
+#include <GLFW/glfw3.h>
+#include <vector>
+
+class DeviceControl {
+public:
+  struct QueueFamilyIndices {
+    // We need to check that the Queue families support graphics operations and
+    // window presentation, sometimes they can support one or the other,
+    // therefore, we take into account both for completion.
+    std::optional<uint32_t> graphicsFamily;
+    std::optional<uint32_t> presentFamily;
+
+    bool isComplete() {
+      return graphicsFamily.has_value() && presentFamily.has_value();
+    }
+  };
+  static void pickPhysicalDevice(VkInstance &instance);
+  static void createLogicalDevice();
+  static void createSurface(VkInstance &instance, GLFWwindow *window);
+  static void destroySurface(VkInstance &instance);
+  static void createSwapChain(GLFWwindow *window);
+  static void destroySwapChain();
+  static VkImageView createImageView(VkImage image, VkFormat format,
+                                     VkImageAspectFlags flags,
+                                     uint32_t mipLevels);
+  static void createImageViews();
+  static void destroyImageViews();
+  static void createCommandPool();
+  static void destroyCommandPool();
+  static QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device);
+
+  // ---------- Getters & Setters ----------- //
+  static VkFormat &getImageFormat();
+  static VkExtent2D &getSwapChainExtent();
+  static std::vector<VkImage> &getSwapChainImages();
+  static std::vector<VkFramebuffer> &getSwapChainFramebuffers();
+  static VkDevice &getDevice();
+  static VkSurfaceKHR &getSurface();
+  static VkQueue &getGraphicsQueue();
+  static VkQueue &getPresentQueue();
+  static VkPhysicalDevice &getPhysicalDevice();
+  static VkSampleCountFlagBits &getPerPixelSampleCount();
+  static std::vector<VkImageView> &getSwapChainImageViews();
+  static VkSwapchainKHR &getSwapChain();
+};

src/entrypoint.cpp

@@ -0,0 +1,189 @@
+#include "agnosiaimgui.h"
+#include "devicelibrary.h"
+#include "entrypoint.h"
+#include "graphics/buffers.h"
+#include "graphics/graphicspipeline.h"
+
+#include "graphics/model.h"
+#include "graphics/render.h"
+#include "graphics/texture.h"
+
+#define VK_NO_PROTOTYPES
+#include "volk.h"
+#define GLFW_INCLUDE_VULKAN
+#include <GLFW/glfw3.h>
+
+#include "imgui.h"
+#include "imgui_impl_glfw.h"
+#include "imgui_impl_vulkan.h"
+
+#include <stdexcept>
+VkInstance vulkaninstance;
+GLFWwindow *window;
+const uint32_t WIDTH = 800;
+const uint32_t HEIGHT = 600;
+
+// Getters and Setters!
+void EntryApp::setFramebufferResized(bool setter) {
+  framebufferResized = setter;
+}
+bool EntryApp::getFramebufferResized() const { return framebufferResized; }
+static void framebufferResizeCallback(GLFWwindow *window, int width,
+                                      int height) {
+  auto app = reinterpret_cast<EntryApp *>(glfwGetWindowUserPointer(window));
+  app->setFramebufferResized(true);
+}
+
+// Initialize GLFW Window. First, Initialize GLFW lib, disable resizing for
+// now, and create window.
+void initWindow() {
+  glfwInit();
+  glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+  // Settings for the window are set, create window reference.
+  window = glfwCreateWindow(WIDTH, HEIGHT, "Trimgles :o", nullptr, nullptr);
+  glfwSetWindowUserPointer(window, &EntryApp::getInstance());
+  glfwSetFramebufferSizeCallback(window, framebufferResizeCallback);
+}
+
+void createInstance() {
+
+  // Set application info for the vulkan instance!
+  VkApplicationInfo appInfo{};
+
+  appInfo.sType =
+      VK_STRUCTURE_TYPE_APPLICATION_INFO;     // Tell vulkan that appInfo is a
+                                              // Application Info structure
+  appInfo.pApplicationName = "Triangle Test"; // Give the struct a name to use
+  appInfo.applicationVersion = VK_MAKE_VERSION(
+      1, 0,
+      0); // Create a Major Minor Patch version number for the application!
+  appInfo.pEngineName =
+      "Agnosia Engine"; // Give an internal name for the engine running
+  appInfo.engineVersion = VK_MAKE_VERSION(
+      1, 0, 0); // Similar to the App version, give vulkan an *engine* version
+  appInfo.apiVersion =
+      VK_API_VERSION_1_3; // Tell vulkan what the highest API version we will
+                          // allow this program to run on
+
+  // This gets a little weird, Vulkan is platform agnostic, so you need to
+  // figure out what extensions to interface with the current system are needed
+  // So, to figure out what extension codes and how many to use, feed the
+  // pointer into *glfwGetRequiredInstanceExtensions*, which will get the
+  // necessary extensions! From there, we can send that over to our createInfo
+  // Vulkan info struct to make it fully platform agnostic!
+  uint32_t glfwExtensionCount = 0;
+  const char **glfwExtensions;
+  glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
+  std::vector<const char *> extensions(glfwExtensions,
+                                       glfwExtensions + glfwExtensionCount);
+
+  VkInstanceCreateInfo createInfo{}; // Define parameters of new vulkan instance
+  createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+  createInfo.pApplicationInfo = &appInfo;
+  createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
+  createInfo.ppEnabledExtensionNames = extensions.data();
+
+  if (vkCreateInstance(&createInfo, nullptr, &vulkaninstance) != VK_SUCCESS) {
+    throw std::runtime_error("failed to create instance!");
+  }
+}
+void initAgnosia() {
+  Material *sphereMaterial =
+      new Material("sphereMaterial", "assets/textures/checkermap.png");
+  Material *stanfordDragonMaterial =
+      new Material("stanfordDragonMaterial", "assets/textures/checkermap.png");
+  Material *teapotMaterial =
+      new Material("teapotMaterial", "assets/textures/checkermap.png");
+  Model *uvSphere =
+      new Model("uvSphere", *sphereMaterial, "assets/models/UVSphere.obj",
+                glm::vec3(0.0f, 0.0f, 0.0f));
+  Model *stanfordDragon = new Model("stanfordDragon", *stanfordDragonMaterial,
+                                    "assets/models/StanfordDragon800k.obj",
+                                    glm::vec3(0.0f, 2.0f, 0.0f));
+  Model *teapot =
+      new Model("teapot", *teapotMaterial, "assets/models/teapot.obj",
+                glm::vec3(1.0f, -3.0f, -1.0f));
+}
+void initVulkan() {
+  // Initialize volk and continue if successful.
+  volkInitialize();
+  // Initialize vulkan and set up pipeline.
+  createInstance();
+  volkLoadInstance(vulkaninstance);
+  DeviceControl::createSurface(vulkaninstance, window);
+  DeviceControl::pickPhysicalDevice(vulkaninstance);
+  DeviceControl::createLogicalDevice();
+  volkLoadDevice(DeviceControl::getDevice());
+  DeviceControl::createSwapChain(window);
+  Model::createMemoryAllocator(vulkaninstance);
+  DeviceControl::createImageViews();
+  Buffers::createDescriptorSetLayout();
+  Graphics::createGraphicsPipeline();
+  Graphics::createCommandPool();
+  // Image creation MUST be after command pool, because command
+  // buffers.
+  Model::populateModels();
+  Texture::createMaterialTextures(Model::getInstances());
+  Texture::createColorResources();
+  Texture::createDepthResources();
+
+  Buffers::createDescriptorPool();
+  Buffers::createDescriptorSet(Model::getInstances());
+  Graphics::createCommandBuffer();
+  Render::createSyncObject();
+
+  Gui::initImgui(vulkaninstance);
+}
+
+void mainLoop() {
+  while (!glfwWindowShouldClose(window)) {
+    glfwPollEvents();
+
+    Gui::drawImGui();
+    Render::drawFrame();
+  }
+  vkDeviceWaitIdle(DeviceControl::getDevice());
+}
+
+void cleanup() {
+  Render::cleanupSwapChain();
+  Graphics::destroyGraphicsPipeline();
+  Buffers::destroyDescriptorPool();
+  Model::destroyTextures();
+
+  vkDestroyDescriptorSetLayout(DeviceControl::getDevice(),
+                               Buffers::getDescriptorSetLayout(), nullptr);
+
+  Buffers::destroyBuffers();
+  Render::destroyFenceSemaphores();
+  Graphics::destroyCommandPool();
+
+  ImGui_ImplVulkan_Shutdown();
+  ImGui_ImplGlfw_Shutdown();
+  ImGui::DestroyContext();
+
+  vkDestroyDevice(DeviceControl::getDevice(), nullptr);
+  DeviceControl::destroySurface(vulkaninstance);
+  vkDestroyInstance(vulkaninstance, nullptr);
+  glfwDestroyWindow(window);
+  glfwTerminate();
+}
+
+// External Functions
+EntryApp &EntryApp::getInstance() {
+  static EntryApp instance;
+  return instance;
+}
+EntryApp::EntryApp() : initialized(false), framebufferResized(false) {}
+
+void EntryApp::initialize() { initialized = true; }
+bool EntryApp::isInitialized() const { return initialized; }
+GLFWwindow *EntryApp::getWindow() { return window; }
+void EntryApp::run() {
+
+  initWindow();
+  initAgnosia();
+  initVulkan();
+  mainLoop();
+  cleanup();
+}

src/entrypoint.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <GLFW/glfw3.h>
+
+class EntryApp {
+public:
+  static EntryApp &getInstance();
+  void initialize();
+  bool isInitialized() const;
+  void run();
+  void setFramebufferResized(bool frame);
+  bool getFramebufferResized() const;
+  static GLFWwindow *getWindow();
+
+private:
+  EntryApp();
+
+  EntryApp(const EntryApp &) = delete;
+  void operator=(const EntryApp &) = delete;
+
+  bool framebufferResized;
+  bool initialized;
+};

src/graphics/buffers.cpp

@@ -0,0 +1,273 @@
+#include "../devicelibrary.h"
+
+#include "buffers.h"
+#include "model.h"
+
+#include <cstdint>
+#include <cstring>
+
+#include <glm/ext/matrix_clip_space.hpp>
+#include <glm/ext/matrix_transform.hpp>
+
+#include <stdexcept>
+#include <vulkan/vulkan_core.h>
+
+std::vector<VkDescriptorSetLayout> modelSetLayouts;
+
+VkBuffer vertexBuffer;
+VkDeviceMemory vertexBufferMemory;
+VkBuffer indexBuffer;
+VkDeviceMemory indexBufferMemory;
+
+uint32_t indicesSize;
+
+// Select a binding for each descriptor type
+constexpr int STORAGE_BINDING = 0;
+constexpr int SAMPLER_BINDING = 1;
+constexpr int IMAGE_BINDING = 2;
+// Max count of each descriptor type
+// You can query the max values for these with
+// physicalDevice.getProperties().limits.maxDescriptrorSet*******
+constexpr int STORAGE_COUNT = 65536;
+constexpr int SAMPLER_COUNT = 65536;
+constexpr int IMAGE_COUNT = 65536;
+
+// Create descriptor pool
+
+VkDescriptorPool descriptorPool;
+VkDescriptorSetLayout descriptorSetLayout;
+VkDescriptorSet descriptorSet;
+
+VkCommandPool commandPool;
+std::vector<VkCommandBuffer> commandBuffers;
+
+const int MAX_FRAMES_IN_FLIGHT = 2;
+
+void Buffers::createDescriptorSetLayout() {
+  // Create a table of pointers to data, a Descriptor Set!
+
+  VkDescriptorSetLayoutBinding storageLayoutBinding = {
+      .binding = STORAGE_BINDING,
+      .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+      .descriptorCount = STORAGE_COUNT,
+      .stageFlags = VK_SHADER_STAGE_ALL,
+      .pImmutableSamplers = nullptr,
+  };
+
+  VkDescriptorSetLayoutBinding samplerLayoutBinding = {
+      .binding = SAMPLER_BINDING,
+      .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+      .descriptorCount = SAMPLER_COUNT,
+      .stageFlags = VK_SHADER_STAGE_ALL,
+      .pImmutableSamplers = nullptr,
+  };
+
+  VkDescriptorSetLayoutBinding imageLayoutBinding = {
+      .binding = IMAGE_BINDING,
+      .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+      .descriptorCount = IMAGE_COUNT,
+      .stageFlags = VK_SHADER_STAGE_ALL,
+      .pImmutableSamplers = nullptr,
+  };
+
+  std::vector<VkDescriptorSetLayoutBinding> bindings = {
+      storageLayoutBinding, imageLayoutBinding, samplerLayoutBinding};
+
+  std::vector<VkDescriptorBindingFlags> bindingFlags = {
+      VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT |
+          VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
+      VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT |
+          VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
+      VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT |
+          VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
+  };
+  VkDescriptorSetLayoutBindingFlagsCreateInfo setLayoutBindingsFlags = {
+      .sType =
+          VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
+      .bindingCount = 3,
+      .pBindingFlags = bindingFlags.data(),
+  };
+
+  VkDescriptorSetLayoutCreateInfo layoutInfo = {
+      .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+
+      .pNext = &setLayoutBindingsFlags,
+      .flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
+      .bindingCount = static_cast<uint32_t>(bindings.size()),
+      .pBindings = bindings.data(),
+
+  };
+  if (vkCreateDescriptorSetLayout(DeviceControl::getDevice(), &layoutInfo,
+                                  nullptr,
+                                  &descriptorSetLayout) != VK_SUCCESS) {
+    throw std::runtime_error("Failed to create descriptor set layout!");
+  }
+}
+void Buffers::createDescriptorPool() {
+
+  std::vector<VkDescriptorPoolSize> poolSizes = {
+      {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, STORAGE_COUNT},
+      {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, SAMPLER_COUNT},
+      {VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, IMAGE_COUNT},
+  };
+  VkDescriptorPoolCreateInfo poolInfo{};
+  poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+  poolInfo.poolSizeCount = static_cast<uint32_t>(poolSizes.size());
+  poolInfo.pPoolSizes = poolSizes.data();
+  poolInfo.maxSets = 1;
+  poolInfo.flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT;
+
+  if (vkCreateDescriptorPool(DeviceControl::getDevice(), &poolInfo, nullptr,
+                             &descriptorPool) != VK_SUCCESS) {
+    throw std::runtime_error("failed to create descriptor pool!");
+  }
+}
+void Buffers::destroyDescriptorPool() {
+  vkDestroyDescriptorPool(DeviceControl::getDevice(), descriptorPool, nullptr);
+}
+void Buffers::createDescriptorSet(std::vector<Model *> models) {
+  VkDescriptorSetAllocateInfo allocInfo{};
+  allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+  allocInfo.descriptorPool = descriptorPool;
+  allocInfo.descriptorSetCount = 1;
+  allocInfo.pSetLayouts = &descriptorSetLayout;
+
+  if (vkAllocateDescriptorSets(DeviceControl::getDevice(), &allocInfo,
+                               &descriptorSet) != VK_SUCCESS) {
+    throw std::runtime_error("failed to allocate descriptor sets!");
+  }
+  std::vector<VkDescriptorImageInfo> imageInfoSet;
+  imageInfoSet.resize(models.size());
+
+  for (int i = 0; i < models.size(); i++) {
+    imageInfoSet[i].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    imageInfoSet[i].imageView = models[i]->getMaterial().getTextureView();
+    imageInfoSet[i].sampler = models[i]->getMaterial().getTextureSampler();
+  }
+
+  std::vector<VkWriteDescriptorSet> descriptorWrites{};
+  descriptorWrites.resize(models.size());
+
+  for (int i = 0; i < models.size(); i++) {
+    descriptorWrites[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    descriptorWrites[i].dstSet = descriptorSet;
+    descriptorWrites[i].dstBinding = SAMPLER_BINDING;
+    descriptorWrites[i].dstArrayElement = i;
+    descriptorWrites[i].descriptorType =
+        VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    descriptorWrites[i].descriptorCount = 1;
+    descriptorWrites[i].pImageInfo = &imageInfoSet[i];
+  }
+
+  vkUpdateDescriptorSets(DeviceControl::getDevice(),
+                         static_cast<uint32_t>(descriptorWrites.size()),
+                         descriptorWrites.data(), 0, nullptr);
+}
+
+uint32_t Buffers::findMemoryType(uint32_t typeFilter,
+                                 VkMemoryPropertyFlags properties) {
+  // Graphics cards offer different types of memory to allocate from, here we
+  // query to find the right type of memory for our needs. Query the available
+  // types of memory to iterate over.
+  VkPhysicalDeviceMemoryProperties memProperties;
+  vkGetPhysicalDeviceMemoryProperties(DeviceControl::getPhysicalDevice(),
+                                      &memProperties);
+  // iterate over and see if any of the memory types match our needs, in this
+  // case, HOST_VISIBLE and HOST_COHERENT. These will be explained shortly.
+  for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
+    if ((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags &
+                                    properties) == properties) {
+      return i;
+    }
+  }
+  throw std::runtime_error("failed to find suitable memory type!");
+}
+
+void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size) {
+  VkCommandBufferAllocateInfo allocInfo{};
+  allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+  allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+  allocInfo.commandPool = commandPool;
+  allocInfo.commandBufferCount = 1;
+
+  VkCommandBuffer commandBuffer;
+  vkAllocateCommandBuffers(DeviceControl::getDevice(), &allocInfo,
+                           &commandBuffer);
+
+  VkCommandBufferBeginInfo beginInfo{};
+  beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+  beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+
+  vkBeginCommandBuffer(commandBuffer, &beginInfo);
+
+  VkBufferCopy copyRegion{};
+  copyRegion.size = size;
+  vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, &copyRegion);
+
+  vkEndCommandBuffer(commandBuffer);
+
+  VkSubmitInfo submitInfo{};
+  submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+  submitInfo.commandBufferCount = 1;
+  submitInfo.pCommandBuffers = &commandBuffer;
+
+  vkQueueSubmit(DeviceControl::getGraphicsQueue(), 1, &submitInfo,
+                VK_NULL_HANDLE);
+  vkQueueWaitIdle(DeviceControl::getGraphicsQueue());
+
+  vkFreeCommandBuffers(DeviceControl::getDevice(), commandPool, 1,
+                       &commandBuffer);
+}
+
+void Buffers::createBuffer(VkDeviceSize size, VkBufferUsageFlags usage,
+                           VkMemoryPropertyFlags properties, VkBuffer &buffer,
+                           VkDeviceMemory &bufferMemory) {
+  VkBufferCreateInfo bufferInfo{};
+  bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+  bufferInfo.size = size;
+  bufferInfo.usage = usage;
+  bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+  if (vkCreateBuffer(DeviceControl::getDevice(), &bufferInfo, nullptr,
+                     &buffer) != VK_SUCCESS) {
+    throw std::runtime_error("failed to create buffer!");
+  }
+
+  VkMemoryRequirements memRequirements;
+  vkGetBufferMemoryRequirements(DeviceControl::getDevice(), buffer,
+                                &memRequirements);
+
+  VkMemoryAllocateInfo allocInfo{};
+  allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+  allocInfo.allocationSize = memRequirements.size;
+  allocInfo.memoryTypeIndex =
+      findMemoryType(memRequirements.memoryTypeBits, properties);
+
+  if (vkAllocateMemory(DeviceControl::getDevice(), &allocInfo, nullptr,
+                       &bufferMemory) != VK_SUCCESS) {
+    throw std::runtime_error("failed to allocate buffer memory!");
+  }
+
+  vkBindBufferMemory(DeviceControl::getDevice(), buffer, bufferMemory, 0);
+}
+VkDescriptorPool &Buffers::getDescriptorPool() { return descriptorPool; }
+VkDescriptorSet &Buffers::getDescriptorSet() { return descriptorSet; }
+VkDescriptorSetLayout &Buffers::getDescriptorSetLayout() {
+  return descriptorSetLayout;
+}
+
+void Buffers::destroyBuffers() {
+  vkDestroyBuffer(DeviceControl::getDevice(), indexBuffer, nullptr);
+  vkFreeMemory(DeviceControl::getDevice(), indexBufferMemory, nullptr);
+
+  vkDestroyBuffer(DeviceControl::getDevice(), vertexBuffer, nullptr);
+  vkFreeMemory(DeviceControl::getDevice(), vertexBufferMemory, nullptr);
+}
+
+uint32_t Buffers::getMaxFramesInFlight() { return MAX_FRAMES_IN_FLIGHT; }
+std::vector<VkCommandBuffer> &Buffers::getCommandBuffers() {
+  return commandBuffers;
+}
+
+VkCommandPool &Buffers::getCommandPool() { return commandPool; }
+uint32_t Buffers::getIndicesSize() { return indicesSize; }

src/graphics/buffers.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <cstdint>
+
+#define VK_NO_PROTOTYPES
+#include "../types.h"
+#include "model.h"
+#include "volk.h"
+#include <vector>
+#define GLFW_INCLUDE_VULKAN
+#include <GLFW/glfw3.h>
+
+class Buffers {
+public:
+  static Agnosia_T::AllocatedBuffer createBuffer(size_t allocSize,
+                                                 VkBufferUsageFlags usage,
+                                                 VmaMemoryUsage memUsage);
+  static void createMemoryAllocator(VkInstance vkInstance);
+  static void createDescriptorSetLayout();
+  static void createDescriptorSet(std::vector<Model *> models);
+  static void createDescriptorPool();
+  static void destroyDescriptorPool();
+  static void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage,
+                           VkMemoryPropertyFlags props, VkBuffer &buffer,
+                           VkDeviceMemory &bufferMemory);
+  static uint32_t findMemoryType(uint32_t typeFilter,
+                                 VkMemoryPropertyFlags flags);
+  static void destroyBuffers();
+  static VkDescriptorPool &getDescriptorPool();
+  static VkDescriptorSet &getDescriptorSet();
+
+  static VkDescriptorSetLayout &getDescriptorSetLayout();
+  static uint32_t getMaxFramesInFlight();
+  static std::vector<VkCommandBuffer> &getCommandBuffers();
+
+  static VkCommandPool &getCommandPool();
+  static uint32_t getIndicesSize();
+};

src/graphics/graphicspipeline.cpp

@@ -0,0 +1,442 @@
+#include "../devicelibrary.h"
+#include "buffers.h"
+#include "graphicspipeline.h"
+#include "imgui.h"
+#include "imgui_impl_vulkan.h"
+#include "render.h"
+#include "texture.h"
+#include <fstream>
+#define GLM_FORCE_DEPTH_ZERO_TO_ONE
+#include <glm/ext/matrix_clip_space.hpp>
+#include <glm/ext/matrix_transform.hpp>
+
+#include <iostream>
+#include <vulkan/vulkan_core.h>
+
+float lightPos[4] = {5.0f, 5.0f, 5.0f, 0.44f};
+float camPos[4] = {3.0f, 3.0f, 3.0f, 0.44f};
+float centerPos[4] = {0.0f, 0.0f, 0.0f, 0.44f};
+float upDir[4] = {0.0f, 0.0f, 1.0f, 0.44f};
+float depthField = 45.0f;
+float distanceField[2] = {0.1f, 100.0f};
+
+std::vector<VkDynamicState> dynamicStates = {VK_DYNAMIC_STATE_VIEWPORT,
+                                             VK_DYNAMIC_STATE_SCISSOR};
+
+VkPipelineLayout pipelineLayout;
+VkPipeline graphicsPipeline;
+
+static std::vector<char> readFile(const std::string &filename) {
+  std::ifstream file(filename, std::ios::ate | std::ios::binary);
+  if (!file.is_open()) {
+    throw std::runtime_error("failed to open file!");
+  }
+
+  size_t fileSize = (size_t)file.tellg();
+  std::vector<char> buffer(fileSize);
+
+  file.seekg(0);
+  file.read(buffer.data(), fileSize);
+
+  file.close();
+
+  return buffer;
+}
+VkShaderModule createShaderModule(const std::vector<char> &code,
+                                  VkDevice &device) {
+  VkShaderModuleCreateInfo createInfo{};
+  createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+  createInfo.codeSize = code.size();
+  createInfo.pCode = reinterpret_cast<const uint32_t *>(code.data());
+
+  VkShaderModule shaderModule;
+  if (vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) !=
+      VK_SUCCESS) {
+    throw std::runtime_error("failed to create shader module!");
+  }
+  return shaderModule;
+}
+
+void Graphics::destroyGraphicsPipeline() {
+  vkDestroyPipeline(DeviceControl::getDevice(), graphicsPipeline, nullptr);
+  vkDestroyPipelineLayout(DeviceControl::getDevice(), pipelineLayout, nullptr);
+}
+
+void Graphics::createGraphicsPipeline() {
+  // Note to self, for some reason the working directory is not where a read
+  // file is called from, but the project folder!
+  auto vertShaderCode = readFile("src/shaders/vertex.spv");
+  auto fragShaderCode = readFile("src/shaders/fragment.spv");
+  VkShaderModule vertShaderModule =
+      createShaderModule(vertShaderCode, DeviceControl::getDevice());
+  VkShaderModule fragShaderModule =
+      createShaderModule(fragShaderCode, DeviceControl::getDevice());
+  // ------------------ STAGE 1 - INPUT ASSEMBLER ---------------- //
+  // This can get a little complicated, normally, vertices are loaded in
+  // sequential order, with an element buffer however, you can specify the
+  // indices yourself! Using an element buffer means you can reuse vertices,
+  // which can lead to optimizations. If you set PrimRestart to TRUE, you can
+  // utilize the _STRIP modes with special indices
+  VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
+  inputAssembly.sType =
+      VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+  inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+  inputAssembly.primitiveRestartEnable = VK_FALSE;
+
+  // ------------------ STAGE 2 - VERTEX SHADER ------------------ //
+  // this will be revisited, right now we are hardcoding shader data, so we tell
+  // it to not load anything, but that will change.
+  VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
+  vertShaderStageInfo.sType =
+      VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+  vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
+  vertShaderStageInfo.module = vertShaderModule;
+  vertShaderStageInfo.pName = "main";
+  VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
+  vertexInputInfo.sType =
+      VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+
+  // ------------------- STAGE 5 - RASTERIZATION ----------------- //
+  // Take Vertex shader vertices and fragmentize them for the frament shader.
+  // The rasterizer also can perform depth testing, face culling, and scissor
+  // testing. In addition, it can also be configured for wireframe rendering.
+  VkPipelineRasterizationStateCreateInfo rasterizer{};
+  rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+  // Render regardless of the near and far planes, useful for shadow maps,
+  // requires GPU feature *depthClamp*
+  rasterizer.depthClampEnable = VK_FALSE;
+  rasterizer.rasterizerDiscardEnable = VK_FALSE;
+  // MODE_FILL, fill polygons, MODE_LINE, draw wireframe, MODE_POINT, draw
+  // vertices. Anything other than fill requires GPU feature *fillModeNonSolid*
+  rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
+  rasterizer.lineWidth = 1.0f;
+  // How to cull the faces, right here we cull the back faces and tell the
+  // rasterizer front facing vertices are ordered clockwise.
+  rasterizer.cullMode = VK_CULL_MODE_NONE;
+  rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+  // Whether or not to add depth values. e.x. for shadow maps.
+  rasterizer.depthBiasEnable = VK_FALSE;
+
+  // ------------------ STAGE 6 - FRAGMENT SHADER ---------------- //
+  VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
+  fragShaderStageInfo.sType =
+      VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+  fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+  fragShaderStageInfo.module = fragShaderModule;
+  fragShaderStageInfo.pName = "main";
+
+  VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo,
+                                                    fragShaderStageInfo};
+
+  // ------------------ STAGE 7 - COLOR BLENDING ----------------- //
+  VkPipelineColorBlendAttachmentState colorBlendAttachment{};
+  colorBlendAttachment.colorWriteMask =
+      VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+      VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+  colorBlendAttachment.blendEnable = VK_FALSE;
+
+  VkPipelineColorBlendStateCreateInfo colorBlending{};
+  colorBlending.sType =
+      VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+  colorBlending.logicOpEnable = VK_FALSE;
+  colorBlending.logicOp = VK_LOGIC_OP_COPY;
+  colorBlending.attachmentCount = 1;
+  colorBlending.pAttachments = &colorBlendAttachment;
+
+  // ---------------------- STATE CONTROLS ----------------------  //
+  VkPipelineViewportStateCreateInfo viewportState{};
+  viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+  viewportState.viewportCount = 1;
+  viewportState.scissorCount = 1;
+  // Again, this will be revisited, multisampling can be very useful for
+  // anti-aliasing, since it is fast, but we won't implement it for now.
+  // Requires GPU feature UNKNOWN eanbled.
+  VkPipelineMultisampleStateCreateInfo multisampling{};
+  multisampling.sType =
+      VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+  multisampling.sampleShadingEnable = VK_TRUE;
+  multisampling.rasterizationSamples = DeviceControl::getPerPixelSampleCount();
+  // TODO: Document!
+  VkPipelineDepthStencilStateCreateInfo depthStencil{};
+  depthStencil.sType =
+      VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+  depthStencil.depthTestEnable = VK_TRUE;
+  depthStencil.depthWriteEnable = VK_TRUE;
+  depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
+  depthStencil.depthBoundsTestEnable = VK_FALSE;
+  depthStencil.stencilTestEnable = VK_FALSE;
+  // Most of the graphics pipeline is set in stone, some of the pipeline state
+  // can be modified without recreating it at runtime though! There are TONS of
+  // settings, this would be another TODO to see what else we can mess with
+  // dynamically, but right now we just allow dynamic size of the viewport and
+  // dynamic scissor states. Scissors are pretty straightforward, they are
+  // basically pixel masks for the rasterizer. Scissors describe what regions
+  // pixels will be stored, it doesnt cut them after being rendered, it stops
+  // them from ever being rendered in that area in the first place.
+  VkPipelineDynamicStateCreateInfo dynamicState{};
+  dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+  dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());
+  dynamicState.pDynamicStates = dynamicStates.data();
+
+  VkPushConstantRange pushConstant{
+      .stageFlags = VK_SHADER_STAGE_ALL,
+      .offset = 0,
+      .size = sizeof(Agnosia_T::GPUPushConstants),
+  };
+
+  VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
+  pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+  pipelineLayoutInfo.setLayoutCount = 1;
+  pipelineLayoutInfo.pSetLayouts = &Buffers::getDescriptorSetLayout();
+  pipelineLayoutInfo.pPushConstantRanges = &pushConstant;
+  pipelineLayoutInfo.pushConstantRangeCount = 1;
+
+  if (vkCreatePipelineLayout(DeviceControl::getDevice(), &pipelineLayoutInfo,
+                             nullptr, &pipelineLayout) != VK_SUCCESS) {
+    throw std::runtime_error("failed to create pipeline layout!");
+  }
+
+  VkPipelineRenderingCreateInfo pipelineRenderingCreateInfo{
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
+      .colorAttachmentCount = 1,
+      .pColorAttachmentFormats = &DeviceControl::getImageFormat(),
+      .depthAttachmentFormat = Texture::findDepthFormat(),
+  };
+
+  // Here we combine all of the structures we created to make the final
+  // pipeline!
+  VkGraphicsPipelineCreateInfo pipelineInfo{
+      .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
+      .pNext = &pipelineRenderingCreateInfo,
+      .stageCount = 2,
+      .pStages = shaderStages,
+      .pVertexInputState = &vertexInputInfo,
+      .pInputAssemblyState = &inputAssembly,
+      .pViewportState = &viewportState,
+      .pRasterizationState = &rasterizer,
+      .pMultisampleState = &multisampling,
+      .pDepthStencilState = &depthStencil,
+      .pColorBlendState = &colorBlending,
+      .pDynamicState = &dynamicState,
+      .layout = pipelineLayout,
+      .renderPass = nullptr,
+      .subpass = 0,
+  };
+
+  if (vkCreateGraphicsPipelines(DeviceControl::getDevice(), VK_NULL_HANDLE, 1,
+                                &pipelineInfo, nullptr,
+                                &graphicsPipeline) != VK_SUCCESS) {
+    throw std::runtime_error("failed to create graphics pipeline!");
+  }
+  vkDestroyShaderModule(DeviceControl::getDevice(), fragShaderModule, nullptr);
+  vkDestroyShaderModule(DeviceControl::getDevice(), vertShaderModule, nullptr);
+}
+
+void Graphics::createCommandPool() {
+  // Commands in Vulkan are not executed using function calls, you have to
+  // record the ops you wish to perform to command buffers, pools manage the
+  // memory used by the buffer!
+  DeviceControl::QueueFamilyIndices queueFamilyIndices =
+      DeviceControl::findQueueFamilies(DeviceControl::getPhysicalDevice());
+
+  VkCommandPoolCreateInfo poolInfo{};
+  poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+  poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+  poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
+
+  if (vkCreateCommandPool(DeviceControl::getDevice(), &poolInfo, nullptr,
+                          &Buffers::getCommandPool()) != VK_SUCCESS) {
+    throw std::runtime_error("Failed to create command pool!");
+  }
+}
+void Graphics::destroyCommandPool() {
+  vkDestroyCommandPool(DeviceControl::getDevice(), Buffers::getCommandPool(),
+                       nullptr);
+}
+void Graphics::createCommandBuffer() {
+  Buffers::getCommandBuffers().resize(Buffers::getMaxFramesInFlight());
+
+  VkCommandBufferAllocateInfo allocInfo{};
+  allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+  allocInfo.commandPool = Buffers::getCommandPool();
+  allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+  allocInfo.commandBufferCount = (uint32_t)Buffers::getCommandBuffers().size();
+
+  if (vkAllocateCommandBuffers(DeviceControl::getDevice(), &allocInfo,
+                               Buffers::getCommandBuffers().data()) !=
+      VK_SUCCESS) {
+    throw std::runtime_error("Failed to allocate command buffers");
+  }
+}
+void Graphics::recordCommandBuffer(VkCommandBuffer commandBuffer,
+                                   uint32_t imageIndex) {
+  VkCommandBufferBeginInfo beginInfo{};
+  beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+
+  if (vkBeginCommandBuffer(commandBuffer, &beginInfo) != VK_SUCCESS) {
+    throw std::runtime_error("failed to begin recording command buffer!");
+  }
+  const VkImageMemoryBarrier2 imageMemoryBarrier{
+      .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
+      .pNext = nullptr,
+      .srcStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+      .srcAccessMask = 0,
+      .dstStageMask = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+      .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
+      .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
+      .newLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL,
+      .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+      .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+      .image = DeviceControl::getSwapChainImages()[imageIndex],
+      .subresourceRange =
+          {
+              .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+              .baseMipLevel = 0,
+              .levelCount = 1,
+              .baseArrayLayer = 0,
+              .layerCount = 1,
+          },
+  };
+  const VkDependencyInfo dependencyInfo{
+      .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
+      .pNext = nullptr,
+      .imageMemoryBarrierCount = 1,
+      .pImageMemoryBarriers = &imageMemoryBarrier,
+  };
+  vkCmdPipelineBarrier2(commandBuffer, &dependencyInfo);
+
+  // ------------------- DYNAMIC RENDER INFO ---------------------- //
+
+  const VkRenderingAttachmentInfo colorAttachmentInfo{
+      .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
+      .imageView = Texture::getColorImageView(),
+      .imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+      .resolveMode = VK_RESOLVE_MODE_AVERAGE_BIT,
+      .resolveImageView = DeviceControl::getSwapChainImageViews()[imageIndex],
+      .resolveImageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+      .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
+      .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
+      .clearValue = {.color = {0.0f, 0.0f, 0.0f, 1.0f}},
+  };
+  const VkRenderingAttachmentInfo depthAttachmentInfo{
+      .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
+      .imageView = Texture::getDepthImageView(),
+      .imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
+      .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
+      .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+      .clearValue = {.depthStencil = {1.0f, 0}},
+  };
+
+  const VkRenderingInfo renderInfo{
+      .sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
+      .renderArea = {.offset = {0, 0},
+                     .extent = DeviceControl::getSwapChainExtent()},
+      .layerCount = 1,
+      .colorAttachmentCount = 1,
+      .pColorAttachments = &colorAttachmentInfo,
+      .pDepthAttachment = &depthAttachmentInfo,
+  };
+
+  vkCmdBeginRendering(commandBuffer, &renderInfo);
+
+  vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                    graphicsPipeline);
+  VkViewport viewport{};
+  viewport.x = 0.0f;
+  viewport.y = 0.0f;
+  viewport.width = (float)DeviceControl::getSwapChainExtent().width;
+  viewport.height = (float)DeviceControl::getSwapChainExtent().height;
+  viewport.minDepth = 0.0f;
+  viewport.maxDepth = 1.0f;
+  vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
+
+  VkRect2D scissor{};
+  scissor.offset = {0, 0};
+  scissor.extent = DeviceControl::getSwapChainExtent();
+  vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
+  int texID = 0;
+  for (Model *model : Model::getInstances()) {
+
+    vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                            pipelineLayout, 0, 1, &Buffers::getDescriptorSet(),
+                            0, nullptr);
+
+    Agnosia_T::GPUPushConstants pushConsts;
+    pushConsts.vertexBuffer = model->getBuffers().vertexBufferAddress;
+    pushConsts.objPosition = model->getPos();
+    pushConsts.lightPos = glm::vec3(lightPos[0], lightPos[1], lightPos[2]);
+    pushConsts.textureID = texID;
+
+    pushConsts.model =
+        glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f));
+
+    pushConsts.view =
+        glm::lookAt(glm::vec3(camPos[0], camPos[1], camPos[2]),
+                    glm::vec3(centerPos[0], centerPos[1], centerPos[2]),
+                    glm::vec3(upDir[0], upDir[1], upDir[2]));
+
+    pushConsts.proj =
+        glm::perspective(glm::radians(depthField),
+                         DeviceControl::getSwapChainExtent().width /
+                             (float)DeviceControl::getSwapChainExtent().height,
+                         distanceField[0], distanceField[1]);
+    // GLM was created for OpenGL, where the Y coordinate was inverted. This
+    // simply flips the sign.
+    pushConsts.proj[1][1] *= -1;
+
+    vkCmdPushConstants(commandBuffer, pipelineLayout, VK_SHADER_STAGE_ALL, 0,
+                       sizeof(Agnosia_T::GPUPushConstants), &pushConsts);
+
+    vkCmdBindIndexBuffer(commandBuffer, model->getBuffers().indexBuffer.buffer,
+                         0, VK_INDEX_TYPE_UINT32);
+
+    vkCmdDrawIndexed(commandBuffer, static_cast<uint32_t>(model->getIndices()),
+                     1, 0, 0, 0);
+    texID++;
+  }
+  ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), commandBuffer);
+
+  vkCmdEndRendering(commandBuffer);
+
+  const VkImageMemoryBarrier2 prePresentImageBarrier{
+      .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
+      .pNext = nullptr,
+      .srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
+      .srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,
+      .dstStageMask = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT,
+      .dstAccessMask = 0,
+      .oldLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL,
+      .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+      .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+      .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+      .image = DeviceControl::getSwapChainImages()[imageIndex],
+      .subresourceRange =
+          {
+              .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+              .baseMipLevel = 0,
+              .levelCount = 1,
+              .baseArrayLayer = 0,
+              .layerCount = 1,
+          },
+  };
+  const VkDependencyInfo depInfo{
+      .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
+      .pNext = nullptr,
+      .imageMemoryBarrierCount = 1,
+      .pImageMemoryBarriers = &prePresentImageBarrier,
+  };
+
+  vkCmdPipelineBarrier2(Buffers::getCommandBuffers()[Render::getCurrentFrame()],
+                        &depInfo);
+
+  if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) {
+    throw std::runtime_error("failed to record command buffer!");
+  }
+}
+
+float *Graphics::getCamPos() { return camPos; }
+float *Graphics::getLightPos() { return lightPos; }
+float *Graphics::getCenterPos() { return centerPos; }
+float *Graphics::getUpDir() { return upDir; }
+float &Graphics::getDepthField() { return depthField; }
+float *Graphics::getDistanceField() { return distanceField; }

src/graphics/graphicspipeline.h

@@ -0,0 +1,23 @@
+#pragma once
+#define VK_NO_PROTOTYPES
+#include "volk.h"
+
+class Graphics {
+public:
+  static void createGraphicsPipeline();
+  static void destroyGraphicsPipeline();
+  static void createFramebuffers();
+  static void destroyFramebuffers();
+  static void createCommandPool();
+  static void destroyCommandPool();
+  static void createCommandBuffer();
+  static void recordCommandBuffer(VkCommandBuffer cmndBuffer,
+                                  uint32_t imageIndex);
+
+  static float *getCamPos();
+  static float *getLightPos();
+  static float *getCenterPos();
+  static float *getUpDir();
+  static float &getDepthField();
+  static float *getDistanceField();
+};

src/graphics/material.cpp

@@ -0,0 +1,19 @@
+#include "material.h"
+
+Material::Material(const std::string &matID, const std::string &texPath)
+    : ID(matID), texturePath(texPath) {}
+
+std::string Material::getID() const { return ID; }
+std::string Material::getTexturePath() const { return texturePath; }
+
+VkImage &Material::getTextureImage() { return this->textureImage; }
+VkImageView &Material::getTextureView() { return this->textureImageView; }
+VkSampler &Material::getTextureSampler() { return this->textureSampler; }
+
+void Material::setTextureImage(VkImage image) { this->textureImage = image; }
+void Material::setTextureView(VkImageView imageView) {
+  this->textureImageView = imageView;
+}
+void Material::setTextureSampler(VkSampler sampler) {
+  this->textureSampler = sampler;
+}

src/graphics/material.h

@@ -0,0 +1,26 @@
+
+#define VK_NO_PROTOTYPES
+#include "volk.h"
+#include <string>
+
+class Material {
+protected:
+  std::string ID;
+  std::string texturePath;
+
+  VkImage textureImage;
+  VkImageView textureImageView;
+  VkSampler textureSampler;
+
+public:
+  Material(const std::string &matID, const std::string &texPath);
+  std::string getID() const;
+  std::string getTexturePath() const;
+  VkImage &getTextureImage();
+  VkImageView &getTextureView();
+  VkSampler &getTextureSampler();
+
+  void setTextureImage(VkImage image);
+  void setTextureView(VkImageView imageView);
+  void setTextureSampler(VkSampler sampler);
+};

src/graphics/model.cpp

@@ -0,0 +1,243 @@
+#include "buffers.h"
+#include "model.h"
+#include <cstdint>
+#include <cstring>
+#include <unordered_map>
+
+#define TINY_OBJ_IMPLEMENTATION
+#include <stdexcept>
+#include <tiny_obj_loader.h>
+#define GLM_ENABLE_EXPERIMENTAL
+#define GLM_FORCE_DEPTH_ZERO_TO_ONE
+#include "../devicelibrary.h"
+#include <glm/glm.hpp>
+#include <glm/gtx/hash.hpp>
+
+#define VMA_STATIC_VULKAN_FUNCTIONS 0
+#define VMA_DYNAMIC_VULKAN_FUNCTIONS 1
+#define VMA_IMPLEMENTATION
+#include "vk_mem_alloc.h"
+
+std::vector<Model *> Model::instances;
+VmaAllocator _allocator;
+// chatgpt did this and the haters can WEEP fuck hash functions.
+namespace std {
+template <> struct hash<Agnosia_T::Vertex> {
+  size_t operator()(Agnosia_T::Vertex const &vertex) const {
+    size_t hashPos = hash<glm::vec3>()(vertex.pos);
+    size_t hashColor = hash<glm::vec3>()(vertex.color);
+    size_t hashUV = hash<glm::vec2>()(vertex.uv);
+    size_t hashNormal = hash<glm::vec3>()(vertex.normal);
+
+    // Combine all hashes
+    return ((hashPos ^ (hashColor << 1)) >> 1) ^ (hashUV << 1) ^
+           (hashNormal << 2);
+  }
+};
+
+} // namespace std
+void Model::createMemoryAllocator(VkInstance vkInstance) {
+  VmaVulkanFunctions vulkanFuncs{
+      .vkGetInstanceProcAddr = vkGetInstanceProcAddr,
+      .vkGetDeviceProcAddr = vkGetDeviceProcAddr,
+  };
+  VmaAllocatorCreateInfo allocInfo{
+      .flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT,
+      .physicalDevice = DeviceControl::getPhysicalDevice(),
+      .device = DeviceControl::getDevice(),
+      .pVulkanFunctions = &vulkanFuncs,
+      .instance = vkInstance,
+      .vulkanApiVersion = VK_API_VERSION_1_3,
+
+  };
+  vmaCreateAllocator(&allocInfo, &_allocator);
+}
+Agnosia_T::AllocatedBuffer createBuffer(size_t allocSize,
+                                        VkBufferUsageFlags usage,
+                                        VmaMemoryUsage memUsage) {
+  // Allocate the buffer we will use for Device Addresses
+  VkBufferCreateInfo bufferInfo{.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                                .pNext = nullptr,
+                                .size = allocSize,
+                                .usage = usage};
+  VmaAllocationCreateInfo vmaAllocInfo{
+      .flags = VMA_ALLOCATION_CREATE_MAPPED_BIT, .usage = memUsage};
+
+  Agnosia_T::AllocatedBuffer newBuffer;
+  if (vmaCreateBuffer(_allocator, &bufferInfo, &vmaAllocInfo, &newBuffer.buffer,
+                      &newBuffer.allocation, &newBuffer.info) != VK_SUCCESS) {
+    throw std::runtime_error("Failed to allocate a buffer using VMA!");
+  }
+  return newBuffer;
+}
+void immediate_submit(std::function<void(VkCommandBuffer cmd)> &&function) {
+  VkCommandBufferAllocateInfo allocInfo{};
+  allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+  allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+  allocInfo.commandPool = Buffers::getCommandPool();
+  allocInfo.commandBufferCount = 1;
+
+  VkCommandBuffer commandBuffer;
+  vkAllocateCommandBuffers(DeviceControl::getDevice(), &allocInfo,
+                           &commandBuffer);
+
+  VkCommandBufferBeginInfo beginInfo{};
+  beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+  beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+
+  vkBeginCommandBuffer(commandBuffer, &beginInfo);
+
+  function(commandBuffer);
+
+  vkEndCommandBuffer(commandBuffer);
+
+  VkSubmitInfo submitInfo{};
+  submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+  submitInfo.commandBufferCount = 1;
+  submitInfo.pCommandBuffers = &commandBuffer;
+
+  vkQueueSubmit(DeviceControl::getGraphicsQueue(), 1, &submitInfo,
+                VK_NULL_HANDLE);
+  vkQueueWaitIdle(DeviceControl::getGraphicsQueue());
+
+  vkFreeCommandBuffers(DeviceControl::getDevice(), Buffers::getCommandPool(), 1,
+                       &commandBuffer);
+}
+
+Model::Model(const std::string &modelID, const Material &material,
+             const std::string &modelPath, const glm::vec3 &objPos)
+    : ID(modelID), material(material), objPosition(objPos),
+      modelPath(modelPath) {
+  instances.push_back(this);
+}
+
+void Model::populateModels() {
+  for (Model *model : getInstances()) {
+
+    std::vector<Agnosia_T::Vertex> vertices;
+    // Index buffer definition, showing which points to reuse.
+    std::vector<uint32_t> indices;
+    tinyobj::ObjReaderConfig readerConfig;
+    tinyobj::ObjReader reader;
+
+    if (!reader.ParseFromFile(model->modelPath, readerConfig)) {
+      if (!reader.Error().empty()) {
+        throw std::runtime_error(reader.Error());
+      }
+      if (!reader.Warning().empty()) {
+        throw std::runtime_error(reader.Warning());
+      }
+    }
+
+    auto &attrib = reader.GetAttrib();
+    auto &shapes = reader.GetShapes();
+    auto &materials = reader.GetMaterials();
+
+    std::unordered_map<Agnosia_T::Vertex, uint32_t> uniqueVertices{};
+
+    for (const auto &shape : shapes) {
+      for (const auto &index : shape.mesh.indices) {
+        Agnosia_T::Vertex vertex{};
+
+        vertex.pos = {attrib.vertices[3 * index.vertex_index + 0],
+                      attrib.vertices[3 * index.vertex_index + 1],
+                      attrib.vertices[3 * index.vertex_index + 2]};
+
+        vertex.normal = {attrib.normals[3 * index.normal_index + 0],
+                         attrib.normals[3 * index.normal_index + 1],
+                         attrib.normals[3 * index.normal_index + 2]};
+        // TODO: Small fix here, handle if there are no UV's unwrapped for the
+        // model.
+        //       As of now, if it is not unwrapped, it segfaults on texCoord
+        //       assignment. Obviously we should always have UV's, but it
+        //       shouldn't crash, just unwrap in a default method.
+        vertex.uv = {attrib.texcoords[2 * index.texcoord_index + 0],
+                     1.0f - attrib.texcoords[2 * index.texcoord_index + 1]};
+        vertex.color = {1.0f, 1.0f, 1.0f};
+
+        if (uniqueVertices.count(vertex) == 0) {
+          uniqueVertices[vertex] = static_cast<uint32_t>(vertices.size());
+          vertices.push_back(vertex);
+        }
+        indices.push_back(uniqueVertices[vertex]);
+      }
+    }
+
+    const size_t vertexBufferSize = vertices.size() * sizeof(Agnosia_T::Vertex);
+    const size_t indexBufferSize = indices.size() * sizeof(uint32_t);
+
+    Agnosia_T::GPUMeshBuffers newSurface;
+
+    // Create a Vertex Buffer here, infinitely easier than the old Vulkan
+    // method!
+    newSurface.vertexBuffer = createBuffer(
+        vertexBufferSize,
+        VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
+            VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+        VMA_MEMORY_USAGE_GPU_ONLY);
+    // Find the address of the vertex buffer!
+    VkBufferDeviceAddressInfo deviceAddressInfo{
+        .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
+        .buffer = newSurface.vertexBuffer.buffer,
+    };
+    newSurface.vertexBufferAddress = vkGetBufferDeviceAddress(
+        DeviceControl::getDevice(), &deviceAddressInfo);
+
+    // Create the index buffer to iterate over and check for duplicate vertices
+    newSurface.indexBuffer = createBuffer(indexBufferSize,
+                                          VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
+                                              VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+                                          VMA_MEMORY_USAGE_GPU_ONLY);
+
+    Agnosia_T::AllocatedBuffer stagingBuffer = createBuffer(
+        vertexBufferSize + indexBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+        VMA_MEMORY_USAGE_CPU_ONLY);
+
+    void *data = stagingBuffer.allocation->GetMappedData();
+
+    // Copy the vertex buffer
+    memcpy(data, vertices.data(), vertexBufferSize);
+    // Copy the index buffer
+    memcpy((char *)data + vertexBufferSize, indices.data(), indexBufferSize);
+
+    immediate_submit([&](VkCommandBuffer cmd) {
+      VkBufferCopy vertexCopy{0};
+      vertexCopy.dstOffset = 0;
+      vertexCopy.srcOffset = 0;
+      vertexCopy.size = vertexBufferSize;
+
+      vkCmdCopyBuffer(cmd, stagingBuffer.buffer, newSurface.vertexBuffer.buffer,
+                      1, &vertexCopy);
+
+      VkBufferCopy indexCopy{0};
+      indexCopy.dstOffset = 0;
+      indexCopy.srcOffset = vertexBufferSize;
+      indexCopy.size = indexBufferSize;
+
+      vkCmdCopyBuffer(cmd, stagingBuffer.buffer, newSurface.indexBuffer.buffer,
+                      1, &indexCopy);
+    });
+    vmaDestroyBuffer(_allocator, stagingBuffer.buffer,
+                     stagingBuffer.allocation);
+
+    model->buffers = newSurface;
+    model->indiceCount = indices.size();
+  }
+}
+void Model::destroyTextures() {
+  for (Model *model : Model::getInstances()) {
+    vkDestroySampler(DeviceControl::getDevice(),
+                     model->getMaterial().getTextureSampler(), nullptr);
+    vkDestroyImageView(DeviceControl::getDevice(),
+                       model->getMaterial().getTextureView(), nullptr);
+    vkDestroyImage(DeviceControl::getDevice(),
+                   model->getMaterial().getTextureImage(), nullptr);
+  }
+}
+
+std::string Model::getID() { return this->ID; }
+glm::vec3 &Model::getPos() { return this->objPosition; }
+Material &Model::getMaterial() { return this->material; }
+Agnosia_T::GPUMeshBuffers Model::getBuffers() { return this->buffers; }
+uint32_t Model::getIndices() { return this->indiceCount; }
+const std::vector<Model *> &Model::getInstances() { return instances; }

src/graphics/model.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#define VK_NO_PROTOTYPES
+
+#include "../types.h"
+
+#include "material.h"
+#include "volk.h"
+#include <glm/glm.hpp>
+#include <string>
+class Model {
+protected:
+  std::string ID;
+  Agnosia_T::GPUMeshBuffers buffers;
+  Material material;
+  glm::vec3 objPosition;
+  uint32_t indiceCount;
+  std::string modelPath;
+  static std::vector<Model *> instances;
+
+public:
+  Model(const std::string &modelID, const Material &material,
+        const std::string &modelPath, const glm::vec3 &opjPos);
+
+  static void createMemoryAllocator(VkInstance instance);
+  static const std::vector<Model *> &getInstances();
+
+  static void populateModels();
+  static void destroyTextures();
+
+  Agnosia_T::GPUMeshBuffers getBuffers();
+  std::string getID();
+  glm::vec3 &getPos();
+  Material &getMaterial();
+  std::string getModelPath();
+  uint32_t getIndices();
+};

src/graphics/render.cpp

@@ -0,0 +1,186 @@
+
+#include <stdexcept>
+
+#include "imgui.h"
+#include "imgui_impl_vulkan.h"
+
+#include "../devicelibrary.h"
+#include "../entrypoint.h"
+#include "buffers.h"
+#include "graphicspipeline.h"
+#include "render.h"
+#include "texture.h"
+
+uint32_t currentFrame;
+std::vector<VkSemaphore> imageAvailableSemaphores;
+std::vector<VkSemaphore> renderFinishedSemaphores;
+std::vector<VkFence> inFlightFences;
+
+void recreateSwapChain() {
+  int width = 0, height = 0;
+  glfwGetFramebufferSize(EntryApp::getWindow(), &width, &height);
+  while (width == 0 || height == 0) {
+    glfwGetFramebufferSize(EntryApp::getWindow(), &width, &height);
+    glfwWaitEvents();
+  }
+  vkDeviceWaitIdle(DeviceControl::getDevice());
+  // Don't really wanna do this but I also don't want to create an extra class
+  // instance just to call the cleanup function.
+
+  for (auto imageView : DeviceControl::getSwapChainImageViews()) {
+    vkDestroyImageView(DeviceControl::getDevice(), imageView, nullptr);
+  }
+  vkDestroySwapchainKHR(DeviceControl::getDevice(),
+                        DeviceControl::getSwapChain(), nullptr);
+
+  DeviceControl::createSwapChain(EntryApp::getWindow());
+  DeviceControl::createImageViews();
+  Texture::createColorResources();
+  Texture::createDepthResources();
+}
+// At a high level, rendering in Vulkan consists of 5 steps:
+// Wait for the previous frame, acquire a image from the swap chain
+// record a comman d buffer which draws the scene onto that image
+// submit the recorded command buffer and present the image!
+void Render::drawFrame() {
+  vkWaitForFences(DeviceControl::getDevice(), 1, &inFlightFences[currentFrame],
+                  VK_TRUE, UINT64_MAX);
+
+  vkResetFences(DeviceControl::getDevice(), 1, &inFlightFences[currentFrame]);
+
+  uint32_t imageIndex;
+  VkResult result = vkAcquireNextImageKHR(
+      DeviceControl::getDevice(), DeviceControl::getSwapChain(), UINT64_MAX,
+      imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
+  if (result == VK_ERROR_OUT_OF_DATE_KHR) {
+    recreateSwapChain();
+    return;
+  } else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
+    throw std::runtime_error("failed to acquire swap chain image!");
+  }
+
+  vkResetFences(DeviceControl::getDevice(), 1, &inFlightFences[currentFrame]);
+
+  vkResetCommandBuffer(Buffers::getCommandBuffers()[currentFrame],
+                       /*VkCommandBufferResetFlagBits*/ 0);
+  Graphics::recordCommandBuffer(Buffers::getCommandBuffers()[currentFrame],
+                                imageIndex);
+  VkSubmitInfo submitInfo{};
+  submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+
+  VkSemaphore waitSemaphores[] = {imageAvailableSemaphores[currentFrame]};
+  VkPipelineStageFlags waitStages[] = {
+      VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
+  submitInfo.waitSemaphoreCount = 1;
+  submitInfo.pWaitSemaphores = waitSemaphores;
+  submitInfo.pWaitDstStageMask = waitStages;
+  submitInfo.commandBufferCount = 1;
+  submitInfo.pCommandBuffers = &Buffers::getCommandBuffers()[currentFrame];
+
+  VkSemaphore signalSemaphores[] = {renderFinishedSemaphores[currentFrame]};
+  submitInfo.signalSemaphoreCount = 1;
+  submitInfo.pSignalSemaphores = signalSemaphores;
+
+  if (vkQueueSubmit(DeviceControl::getGraphicsQueue(), 1, &submitInfo,
+                    inFlightFences[currentFrame]) != VK_SUCCESS) {
+    throw std::runtime_error("failed to submit draw command buffer!");
+  }
+
+  VkPresentInfoKHR presentInfo{};
+  presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+
+  presentInfo.waitSemaphoreCount = 1;
+  presentInfo.pWaitSemaphores = signalSemaphores;
+
+  VkSwapchainKHR swapChains[] = {DeviceControl::getSwapChain()};
+  presentInfo.swapchainCount = 1;
+  presentInfo.pSwapchains = swapChains;
+  presentInfo.pImageIndices = &imageIndex;
+
+  result = vkQueuePresentKHR(DeviceControl::getPresentQueue(), &presentInfo);
+
+  if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR ||
+      EntryApp::getInstance().getFramebufferResized()) {
+    EntryApp::getInstance().setFramebufferResized(false);
+    recreateSwapChain();
+  } else if (result != VK_SUCCESS) {
+    throw std::runtime_error("failed to present swap chain image!");
+  }
+  currentFrame = (currentFrame + 1) % Buffers::getMaxFramesInFlight();
+}
+
+#pragma info
+// SEMAPHORES
+// Synchronization of execution on the GPU in Vulkan is *explicit* The Order of
+// ops is up to us to define the how we want things to run. Similarly,
+// Semaphores are used to add order between queue ops. There are 2 kinds of
+// Semaphores; binary, and timeline. We are using Binary semaphores, which can
+// be signaled or unsignaled. Semaphores are initizalized unsignaled, the way we
+// use them to order queue operations is by providing the same semaphore in one
+// queue op and a wait in another. For example: VkCommandBuffer QueueOne,
+// QueueTwo = ... VkSemaphore semaphore = ... enqueue QueueOne, Signal semaphore
+// when done, start now. vkQueueSubmit(work: QueueOne, signal: semaphore, wait:
+// none) enqueue QueueTwo, wait on semaphore to start vkQueueSubmit(
+// work: QueueTwo, signal: None, wait: semaphore)
+// FENCES
+// Fences are basically semaphores for the CPU! Otherwise known as the host. If
+// the host needs to know when the GPU has finished a task, we use a fence.
+// VkCommandBuffer cmndBuf = ...
+// VkFence fence = ...
+// Start work immediately, signal fence when done.
+// vkQueueSubmit(work: cmndBuf, fence: fence)
+// vkWaitForFence(fence)
+// doStuffOnceFenceDone()
+#pragma endinfo
+
+void Render::createSyncObject() {
+  imageAvailableSemaphores.resize(Buffers::getMaxFramesInFlight());
+  renderFinishedSemaphores.resize(Buffers::getMaxFramesInFlight());
+  inFlightFences.resize(Buffers::getMaxFramesInFlight());
+
+  VkSemaphoreCreateInfo semaphoreInfo{};
+  semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+
+  VkFenceCreateInfo fenceInfo{};
+  fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+  fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
+
+  for (size_t i = 0; i < Buffers::getMaxFramesInFlight(); i++) {
+    if (vkCreateSemaphore(DeviceControl::getDevice(), &semaphoreInfo, nullptr,
+                          &imageAvailableSemaphores[i]) != VK_SUCCESS ||
+        vkCreateSemaphore(DeviceControl::getDevice(), &semaphoreInfo, nullptr,
+                          &renderFinishedSemaphores[i]) != VK_SUCCESS ||
+        vkCreateFence(DeviceControl::getDevice(), &fenceInfo, nullptr,
+                      &inFlightFences[i]) != VK_SUCCESS) {
+      throw std::runtime_error("Failed to create semaphores!");
+    }
+  }
+}
+void Render::destroyFenceSemaphores() {
+  for (size_t i = 0; i < Buffers::getMaxFramesInFlight(); i++) {
+    vkDestroySemaphore(DeviceControl::getDevice(), renderFinishedSemaphores[i],
+                       nullptr);
+    vkDestroySemaphore(DeviceControl::getDevice(), imageAvailableSemaphores[i],
+                       nullptr);
+    vkDestroyFence(DeviceControl::getDevice(), inFlightFences[i], nullptr);
+  }
+}
+void Render::cleanupSwapChain() {
+  vkDestroyImageView(DeviceControl::getDevice(), Texture::getColorImageView(),
+                     nullptr);
+  vkDestroyImage(DeviceControl::getDevice(), Texture::getColorImage(), nullptr);
+  vkFreeMemory(DeviceControl::getDevice(), Texture::getColorImageMemory(),
+               nullptr);
+  vkDestroyImageView(DeviceControl::getDevice(), Texture::getDepthImageView(),
+                     nullptr);
+  vkDestroyImage(DeviceControl::getDevice(), Texture::getDepthImage(), nullptr);
+  vkFreeMemory(DeviceControl::getDevice(), Texture::getDepthImageMemory(),
+               nullptr);
+
+  for (auto imageView : DeviceControl::getSwapChainImageViews()) {
+    vkDestroyImageView(DeviceControl::getDevice(), imageView, nullptr);
+  }
+  vkDestroySwapchainKHR(DeviceControl::getDevice(),
+                        DeviceControl::getSwapChain(), nullptr);
+}
+uint32_t Render::getCurrentFrame() { return currentFrame; }

src/graphics/render.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <cstdint>
+class Render {
+public:
+  static void drawFrame();
+  static void createSyncObject();
+  static void destroyFenceSemaphores();
+  static void cleanupSwapChain();
+  static float getFloatBar();
+  static uint32_t getCurrentFrame();
+};

src/graphics/texture.cpp

@@ -0,0 +1,444 @@
+#include "../devicelibrary.h"
+#include "buffers.h"
+#include "texture.h"
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#define STB_IMAGE_IMPLEMENTATION
+#include <stb/stb_image.h>
+
+uint32_t mipLevels;
+
+VkDeviceMemory textureImageMemory;
+VkPipelineStageFlags sourceStage;
+VkPipelineStageFlags destinationStage;
+
+VkImage colorImage;
+VkImageView colorImageView;
+VkDeviceMemory colorImageMemory;
+
+VkImage depthImage;
+VkImageView depthImageView;
+VkDeviceMemory depthImageMemory;
+
+void createImage(uint32_t width, uint32_t height, uint32_t mipLevels,
+                 VkSampleCountFlagBits sampleNum, VkFormat format,
+                 VkImageTiling tiling, VkImageUsageFlags usage,
+                 VkMemoryPropertyFlags properties, VkImage &image,
+                 VkDeviceMemory &imageMemory) {
+  // This function specifies all the data in an image object, this is called
+  // directly after the creation of an image object.
+  VkImageCreateInfo imageInfo{};
+  imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+  imageInfo.imageType = VK_IMAGE_TYPE_2D;
+  imageInfo.extent.width = width;
+  imageInfo.extent.height = height;
+  imageInfo.extent.depth = 1;
+  imageInfo.mipLevels = 1;
+  imageInfo.arrayLayers = 1;
+  imageInfo.format = format;
+  imageInfo.tiling = tiling;
+  imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+  imageInfo.usage = usage;
+  imageInfo.samples = sampleNum;
+  imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+  imageInfo.mipLevels = mipLevels;
+
+  if (vkCreateImage(DeviceControl::getDevice(), &imageInfo, nullptr, &image) !=
+      VK_SUCCESS) {
+    throw std::runtime_error("failed to create image!");
+  }
+
+  VkMemoryRequirements memRequirements;
+  vkGetImageMemoryRequirements(DeviceControl::getDevice(), image,
+                               &memRequirements);
+
+  VkMemoryAllocateInfo allocInfo{};
+  allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+  allocInfo.allocationSize = memRequirements.size;
+  allocInfo.memoryTypeIndex =
+      Buffers::findMemoryType(memRequirements.memoryTypeBits, properties);
+
+  if (vkAllocateMemory(DeviceControl::getDevice(), &allocInfo, nullptr,
+                       &imageMemory) != VK_SUCCESS) {
+    throw std::runtime_error("failed to allocate image memory!");
+  }
+
+  vkBindImageMemory(DeviceControl::getDevice(), image, imageMemory, 0);
+}
+
+VkCommandBuffer beginSingleTimeCommands() {
+  // This is a neat function! This sets up a command buffer using our previously
+  // set command pool to return a command buffer to execute commands!
+  VkCommandBufferAllocateInfo allocInfo{};
+  allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+  allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+  allocInfo.commandPool = Buffers::getCommandPool();
+  allocInfo.commandBufferCount = 1;
+
+  VkCommandBuffer commandBuffer;
+  vkAllocateCommandBuffers(DeviceControl::getDevice(), &allocInfo,
+                           &commandBuffer);
+
+  VkCommandBufferBeginInfo beginInfo{};
+  beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+  beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+
+  vkBeginCommandBuffer(commandBuffer, &beginInfo);
+
+  return commandBuffer;
+}
+void endSingleTimeCommands(VkCommandBuffer commandBuffer) {
+  // This function takes a command buffer with the data we wish to execute and
+  // submits it to the graphics queue. Afterwards, it purges the command buffer.
+  vkEndCommandBuffer(commandBuffer);
+
+  VkSubmitInfo submitInfo{};
+  submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+  submitInfo.commandBufferCount = 1;
+  submitInfo.pCommandBuffers = &commandBuffer;
+
+  vkQueueSubmit(DeviceControl::getGraphicsQueue(), 1, &submitInfo,
+                VK_NULL_HANDLE);
+  vkQueueWaitIdle(DeviceControl::getGraphicsQueue());
+
+  vkFreeCommandBuffers(DeviceControl::getDevice(), Buffers::getCommandPool(), 1,
+                       &commandBuffer);
+}
+
+void transitionImageLayout(VkImage image, VkFormat format,
+                           VkImageLayout oldLayout, VkImageLayout newLayout,
+                           uint32_t mipLevels) {
+  // This function handles transitioning image layout data from one layout to
+  // another.
+  VkCommandBuffer commandBuffer = beginSingleTimeCommands();
+
+  VkImageMemoryBarrier barrier{};
+  barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+  barrier.oldLayout = oldLayout;
+  barrier.newLayout = newLayout;
+  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+
+  barrier.image = image;
+  barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+  barrier.subresourceRange.baseMipLevel = 0;
+  barrier.subresourceRange.levelCount = mipLevels;
+  barrier.subresourceRange.baseArrayLayer = 0;
+  barrier.subresourceRange.layerCount = 1;
+
+  if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED &&
+      newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
+    barrier.srcAccessMask = 0;
+    barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+
+    sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+    destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
+  } else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL &&
+             newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
+    barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+    barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+
+    sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
+    destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+  } else {
+    throw std::invalid_argument("unsupported layout transition!");
+  }
+
+  vkCmdPipelineBarrier(commandBuffer, sourceStage, destinationStage, 0, 0,
+                       nullptr, 0, nullptr, 1, &barrier);
+
+  endSingleTimeCommands(commandBuffer);
+}
+void copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width,
+                       uint32_t height) {
+  // This handles copying from the buffer to the image, specifically what
+  // *parts* to copy to the image.
+  VkCommandBuffer commandBuffer = beginSingleTimeCommands();
+
+  VkBufferImageCopy region{};
+  region.bufferOffset = 0;
+  region.bufferRowLength = 0;
+  region.bufferImageHeight = 0;
+
+  region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+  region.imageSubresource.mipLevel = 0;
+  region.imageSubresource.baseArrayLayer = 0;
+  region.imageSubresource.layerCount = 1;
+
+  region.imageOffset = {0, 0, 0};
+  region.imageExtent = {width, height, 1};
+
+  vkCmdCopyBufferToImage(commandBuffer, buffer, image,
+                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
+
+  endSingleTimeCommands(commandBuffer);
+}
+VkFormat findSupportedFormat(const std::vector<VkFormat> &candidates,
+                             VkImageTiling tiling,
+                             VkFormatFeatureFlags features) {
+  for (VkFormat format : candidates) {
+    VkFormatProperties props;
+    vkGetPhysicalDeviceFormatProperties(DeviceControl::getPhysicalDevice(),
+                                        format, &props);
+
+    // Do we support linear tiling?
+    if (tiling == VK_IMAGE_TILING_LINEAR &&
+        (props.linearTilingFeatures & features) == features) {
+      return format;
+      // Or do we support optimal tiling?
+    } else if (tiling == VK_IMAGE_TILING_OPTIMAL &&
+               (props.optimalTilingFeatures & features) == features) {
+      return format;
+    }
+  }
+  throw std::runtime_error("failed to find supported depth buffering format!");
+}
+bool hasStencilComponent(VkFormat format) {
+  return format == VK_FORMAT_D32_SFLOAT_S8_UINT ||
+         format == VK_FORMAT_D24_UNORM_S8_UINT;
+}
+void generateMipmaps(VkImage image, VkFormat imageFormat, int32_t textureWidth,
+                     int32_t textureHeight, uint32_t mipLevels) {
+  // Check if image format supports linear blitting
+  VkFormatProperties formatProperties;
+  vkGetPhysicalDeviceFormatProperties(DeviceControl::getPhysicalDevice(),
+                                      imageFormat, &formatProperties);
+
+  if (!(formatProperties.optimalTilingFeatures &
+        VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)) {
+    throw std::runtime_error(
+        "texture image format does not support linear blitting!");
+  }
+
+  VkCommandBuffer commandBuffer = beginSingleTimeCommands();
+
+  // Specify the parameters of an image memory barrier
+  VkImageMemoryBarrier barrier{};
+  barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+  barrier.image = image;
+  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+  barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+  barrier.subresourceRange.baseArrayLayer = 0;
+  barrier.subresourceRange.layerCount = 1;
+  barrier.subresourceRange.levelCount = 1;
+
+  int32_t mipWidth = textureWidth;
+  int32_t mipHeight = textureHeight;
+
+  for (uint32_t mip = 1; mip < mipLevels; mip++) {
+    barrier.subresourceRange.baseMipLevel = mip - 1;
+    barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+    barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+    barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+
+    vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                         VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0,
+                         nullptr, 1, &barrier);
+
+    VkImageBlit blit{};
+    blit.srcOffsets[0] = {0, 0, 0};
+    blit.srcOffsets[1] = {mipWidth, mipHeight, 1};
+    blit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    blit.srcSubresource.mipLevel = mip - 1;
+    blit.srcSubresource.baseArrayLayer = 0;
+    blit.srcSubresource.layerCount = 1;
+    blit.dstOffsets[0] = {0, 0, 0};
+    blit.dstOffsets[1] = {mipWidth > 1 ? mipWidth / 2 : 1,
+                          mipHeight > 1 ? mipHeight / 2 : 1, 1};
+    blit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    blit.dstSubresource.mipLevel = mip;
+    blit.dstSubresource.baseArrayLayer = 0;
+    blit.dstSubresource.layerCount = 1;
+
+    vkCmdBlitImage(commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                   image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit,
+                   VK_FILTER_LINEAR);
+
+    barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    barrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+    barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+
+    vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                         VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr,
+                         0, nullptr, 1, &barrier);
+
+    if (mipWidth > 1)
+      mipWidth /= 2;
+    if (mipHeight > 1)
+      mipHeight /= 2;
+  }
+  barrier.subresourceRange.baseMipLevel = mipLevels - 1;
+  barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+  barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+  barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+  barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+
+  vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, nullptr, 0,
+                       nullptr, 1, &barrier);
+
+  endSingleTimeCommands(commandBuffer);
+}
+// -------------------------------- Image Libraries
+// ------------------------------- //
+void Texture::createMaterialTextures(std::vector<Model *> models) {
+  // Import pixels from image with data on color channels, width and height, and
+  // colorspace! Its a lot of kind of complicated memory calls to bring it from
+  // a file -> to a buffer -> to a image object.
+  for (Model *model : models) {
+
+    int textureWidth, textureHeight, textureChannels;
+
+    stbi_uc *pixels =
+        stbi_load(model->getMaterial().getTexturePath().c_str(), &textureWidth,
+                  &textureHeight, &textureChannels, STBI_rgb_alpha);
+
+    mipLevels = static_cast<uint32_t>(std::floor(
+                    std::log2(std::max(textureWidth, textureHeight)))) +
+                1;
+
+    VkDeviceSize imageSize = textureWidth * textureHeight * 4;
+
+    if (!pixels) {
+      throw std::runtime_error("Failed to load texture!");
+    }
+    VkBuffer stagingBuffer;
+    VkDeviceMemory stagingBufferMemory;
+    Buffers::createBuffer(imageSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+                          VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                              VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                          stagingBuffer, stagingBufferMemory);
+
+    void *data;
+    vkMapMemory(DeviceControl::getDevice(), stagingBufferMemory, 0, imageSize,
+                0, &data);
+    memcpy(data, pixels, static_cast<size_t>(imageSize));
+    vkUnmapMemory(DeviceControl::getDevice(), stagingBufferMemory);
+
+    stbi_image_free(pixels);
+
+    createImage(textureWidth, textureHeight, mipLevels, VK_SAMPLE_COUNT_1_BIT,
+                VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TILING_OPTIMAL,
+                VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+                    VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                    VK_IMAGE_USAGE_SAMPLED_BIT,
+                VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+                model->getMaterial().getTextureImage(), textureImageMemory);
+
+    transitionImageLayout(model->getMaterial().getTextureImage(),
+                          VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_LAYOUT_UNDEFINED,
+                          VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, mipLevels);
+    copyBufferToImage(stagingBuffer, model->getMaterial().getTextureImage(),
+                      static_cast<uint32_t>(textureWidth),
+                      static_cast<uint32_t>(textureHeight));
+
+    vkDestroyBuffer(DeviceControl::getDevice(), stagingBuffer, nullptr);
+    vkFreeMemory(DeviceControl::getDevice(), stagingBufferMemory, nullptr);
+
+    generateMipmaps(model->getMaterial().getTextureImage(),
+                    VK_FORMAT_R8G8B8A8_SRGB, textureWidth, textureHeight,
+                    mipLevels);
+    // Create a texture image view, which is a struct of information about the
+    // image.
+    model->getMaterial().setTextureView(DeviceControl::createImageView(
+        model->getMaterial().getTextureImage(), VK_FORMAT_R8G8B8A8_SRGB,
+        VK_IMAGE_ASPECT_COLOR_BIT, mipLevels));
+
+    // Create a sampler to access and parse the texture object.
+
+    VkSamplerCreateInfo samplerInfo{};
+    samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+    // These two options define the filtering method when sampling the texture.
+    // It also handles zooming in versus out, min vs mag!
+    samplerInfo.magFilter = VK_FILTER_LINEAR; // TODO: CUBIC
+    samplerInfo.minFilter = VK_FILTER_LINEAR; // TODO: CUBIC
+
+    // These options define UVW edge modes, ClampToEdge extends the last pixels
+    // to the edges when larger than the UVW.
+    samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+    samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+    samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+
+    VkPhysicalDeviceProperties properties{};
+    vkGetPhysicalDeviceProperties(DeviceControl::getPhysicalDevice(),
+                                  &properties);
+    // Enable or Disable Anisotropy, and set the amount.
+    samplerInfo.anisotropyEnable = VK_TRUE;
+    samplerInfo.maxAnisotropy = properties.limits.maxSamplerAnisotropy;
+
+    // When sampling with Clamp to Border, the border color is defined here.
+    samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
+    // Normalizing coordinates changes texCoords from [0, texWidth] to [0, 1].
+    // This is what should ALWAYS be used, because it means you can use varying
+    // texture sizes. Another TODO: Normalizing
+    samplerInfo.unnormalizedCoordinates = VK_FALSE;
+    // Compare texels to a value and use the output in filtering!
+    // This is mainly used in percentage-closer filtering on shadow maps, this
+    // will be revisted eventually...
+    samplerInfo.compareEnable = VK_FALSE;
+    samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
+
+    // Mipmaps are basically LoD's for textures, different resolutions to load
+    // based on distance. These settings simply describe how to apply
+    // mipmapping.
+    samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
+    samplerInfo.mipLodBias = 0.0f;
+    samplerInfo.minLod = 0.0f;
+    samplerInfo.maxLod = VK_LOD_CLAMP_NONE;
+
+    if (vkCreateSampler(DeviceControl::getDevice(), &samplerInfo, nullptr,
+                        &model->getMaterial().getTextureSampler()) !=
+        VK_SUCCESS) {
+      throw std::runtime_error("failed to create texture sampler!");
+    }
+  }
+}
+
+VkFormat Texture::findDepthFormat() {
+  return findSupportedFormat(
+      {VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT,
+       VK_FORMAT_D24_UNORM_S8_UINT},
+      VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
+}
+void Texture::createColorResources() {
+  VkFormat colorFormat = DeviceControl::getImageFormat();
+  VkExtent2D swapChainExtent = DeviceControl::getSwapChainExtent();
+
+  createImage(swapChainExtent.width, swapChainExtent.height, 1,
+              DeviceControl::getPerPixelSampleCount(), colorFormat,
+              VK_IMAGE_TILING_OPTIMAL,
+              VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT |
+                  VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+              VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, colorImage,
+              colorImageMemory);
+  colorImageView = DeviceControl::createImageView(colorImage, colorFormat,
+                                                  VK_IMAGE_ASPECT_COLOR_BIT, 1);
+}
+void Texture::createDepthResources() {
+  VkFormat depthFormat = findDepthFormat();
+  VkExtent2D swapChainExtent = DeviceControl::getSwapChainExtent();
+  createImage(
+      swapChainExtent.width, swapChainExtent.height, 1,
+      DeviceControl::getPerPixelSampleCount(), depthFormat,
+      VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+      VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, depthImage, depthImageMemory);
+  depthImageView = DeviceControl::createImageView(depthImage, depthFormat,
+                                                  VK_IMAGE_ASPECT_DEPTH_BIT, 1);
+  // Explicit transition from the layout of the image to the depth attachment is
+  // unnecessary here, since that will be handled in the render pass!
+}
+// ---------------------------- Getters & Setters
+// ---------------------------------//
+uint32_t Texture::getMipLevels() { return mipLevels; }
+
+VkImage &Texture::getColorImage() { return colorImage; }
+VkImageView &Texture::getColorImageView() { return colorImageView; }
+VkDeviceMemory &Texture::getColorImageMemory() { return colorImageMemory; }
+
+VkImage &Texture::getDepthImage() { return depthImage; }
+VkImageView &Texture::getDepthImageView() { return depthImageView; }
+VkDeviceMemory &Texture::getDepthImageMemory() { return depthImageMemory; }

src/graphics/texture.h

@@ -0,0 +1,27 @@
+#pragma once
+#include "model.h"
+
+#define VK_NO_PROTOTYPES
+
+#include "volk.h"
+#include <cstdint>
+class Texture {
+public:
+  static const uint32_t TEXTURE_COUNT = 2;
+  static void createMaterialTextures(std::vector<Model *> models);
+  static void destroyTextureImage();
+  static void destroyTextureSampler();
+  static VkFormat findDepthFormat();
+  static void createDepthResources();
+  static void createColorResources();
+  // ------------ Getters & Setters ------------ //
+  static uint32_t getMipLevels();
+
+  static VkImage &getColorImage();
+  static VkImageView &getColorImageView();
+  static VkDeviceMemory &getColorImageMemory();
+
+  static VkImage &getDepthImage();
+  static VkImageView &getDepthImageView();
+  static VkDeviceMemory &getDepthImageMemory();
+};

src/main.cpp

@@ -1,6 +1,15 @@
+#include "entrypoint.h"
+
 #include <iostream>
 
+#define VOLK_IMPLEMENTATION
 int main() {
-  std::printf("Hello, World!\n");
+  EntryApp::getInstance().initialize();
-  return 0;
+  try {
+    EntryApp::getInstance().run();
+  } catch (const std::exception &e) {
+    std::cerr << e.what() << std::endl;
+    return EXIT_FAILURE;
+  }
+  return EXIT_SUCCESS;
 }

src/shaders/common.glsl

@@ -0,0 +1,23 @@
+#extension GL_EXT_buffer_reference : require
+#extension GL_EXT_scalar_block_layout : require
+#extension GL_EXT_nonuniform_qualifier : require
+
+struct Vertex {
+    vec3 pos;
+    vec3 normal;
+    vec3 color;
+    vec2 texCoord;
+}; 
+
+layout(buffer_reference, scalar) readonly buffer VertexBuffer{ 
+	Vertex vertices[];
+};
+layout( push_constant, scalar ) uniform constants {
+    VertexBuffer vertBuffer;
+    vec3 objPos;
+    vec3 lightPos;
+    int textureID;
+    mat4 model;
+    mat4 view;
+    mat4 proj;
+} PushConstants;

src/shaders/fragment.frag

@@ -0,0 +1,22 @@
+#version 450
+#extension GL_GOOGLE_include_directive : enable
+#include "common.glsl"
+
+layout(binding = 1) uniform sampler2D texSampler[];
+
+
+layout(location = 0) in vec3 v_norm;
+layout(location = 1) in vec3 v_pos;
+layout(location = 2) in vec2 texCoord;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+  vec3 diffuseColor = texture(texSampler[PushConstants.textureID], texCoord).rgb;
+  vec3 ambientColor = vec3(0.05f,0.05f, 0.05f) * diffuseColor;
+  float lightPower = 5;
+  vec3 lightColor = vec3(1.0f, 1.0f, 1.0f);
+  float cosTheta = dot(PushConstants.lightPos, v_norm);
+  float sqrDist = distance(v_pos, PushConstants.lightPos)*distance(v_pos, PushConstants.lightPos);
+  outColor = vec4(ambientColor + clamp(diffuseColor * lightColor * lightPower * cosTheta / sqrDist, vec3(0,0,0), vec3(1,1,1)), 1.0f);
+}

src/shaders/vertex.vert

@@ -0,0 +1,17 @@
+#version 450
+#extension GL_GOOGLE_include_directive : enable
+#include "common.glsl"
+
+layout(location = 0) out vec3 v_norm;
+layout(location = 1) out vec3 v_pos;
+layout(location = 2) out vec2 texCoord;
+
+void main() {
+    Vertex vertex = PushConstants.vertBuffer.vertices[gl_VertexIndex];
+    
+    gl_Position = PushConstants.proj * PushConstants.view * PushConstants.model * 
+                    vec4(vertex.pos + PushConstants.objPos, 1.0f);
+    v_norm = vertex.normal;
+    v_pos = vertex.pos;
+    texCoord = vertex.texCoord;
+}

src/types.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#define GLM_FORCE_DEPTH_ZERO_TO_ONE
+#include "vk_mem_alloc.h"
+#include <glm/glm.hpp>
+
+class Agnosia_T {
+public:
+  struct Vertex {
+    // This defines what a vertex is!
+    // We control the position, color and texture coordinate here!
+    glm::vec3 pos;
+    glm::vec3 normal;
+    glm::vec3 color;
+    glm::vec2 uv;
+
+    bool operator==(const Vertex &other) const {
+      return pos == other.pos && normal == other.normal &&
+             color == other.color && uv == other.uv;
+    }
+  };
+  struct AllocatedBuffer {
+    VkBuffer buffer;
+    VmaAllocation allocation;
+    VmaAllocationInfo info;
+  };
+  struct GPUMeshBuffers {
+    AllocatedBuffer indexBuffer;
+    AllocatedBuffer vertexBuffer;
+    VkDeviceAddress vertexBufferAddress;
+  };
+  struct GPUPushConstants {
+    VkDeviceAddress vertexBuffer;
+    glm::vec3 objPosition;
+    glm::vec3 lightPos;
+    int textureID;
+    glm::mat4 model;
+    glm::mat4 view;
+    glm::mat4 proj;
+  };
+};