diff --git a/MainFlow.puml b/MainFlow.puml new file mode 100644 index 0000000..b567b22 --- /dev/null +++ b/MainFlow.puml @@ -0,0 +1,151 @@ +@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; +://**run()**//; <> +split +://**initWindow()**//; <> +: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()**//; <> +split +://**createInstance()**//; <> +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 +:glfwCreateWindowSurface(...); +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 +partition "**DeviceControl**" { + :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 +} + +partition "**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 + :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 + :createFramebuffers(...); + note right + This function creates framebuffers for all the images + that are queued to be displayed, very important! + 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 +} +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 +} +: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()**//; <> + :glfwPollEvents(); + :RenderPresent::drawFrame(); +repeat while (!glfwWindowShouldClose(...)) + :vkDeviceWaitIdle(...); +stop +split again +://**cleanup()**//; <> +note right + //This function initiates a series of shutdown// + //destroy functions, safely stopping execution//; +endnote +:return EXIT_SUCCESS; +stop +end split + +@enduml diff --git a/MainFlow.svg b/MainFlow.svg new file mode 100644 index 0000000..b0be798 --- /dev/null +++ b/MainFlow.svg @@ -0,0 +1 @@ +Main ExecutionMain Executionmainrun()initWindow()glfwInit()Create window and initialize default settingswindow = glfwCreateWindow(...)Set the user-defined pointer of the windowglfwSetWindowUserPointer(...)This is a callback to resizing of the windowwe call and set a bool to true, which we getand rebuild the swap chain when true.glfwSetFramebufferSizeCallback(...)initVulkan()createInstance()Debug::checkUnavailableValidationLayers()VkApplicationInfoappInfo{}set appInfo data, Vulkan version,Engine version and name, and titleVkApplicationCreateInfocreateInfo{}createInfo.pApplicationInfo = &appInfoDebug::vulkanDebugSetup(createInfo, vulkaninstance)Setup debug messenger, print data to consoleDebug::setupDebugMessenger(VkInstance&)This function handles Window System Integrationautomatically across platforms based on build environment.Basically, this is an abstraction of the Window across platformsglfwCreateWindowSurface(...)DeviceControlEnumerate through GPU's in thesystem and choose a compatible one.in the future, this should choose the BEST GPU, not just the first one that is compatible..pickPhysicalDevice(...)Logical devices interface with thephysical device and defines queuescreateLogicalDevice(...)Swap Chains are used to handle buffer ownershipinfrastructure. Being platform agnostic has itscomplications, this is a perfect example.This process is HEAVILY documented.createSwapChain(...)This is a cool function, quite a simpledescription of images that will be shown on thescreen! It also determineshowto access the imagecreateImageViews(...)GraphicsThis is pretty simple, it sets up the image bit depthand the color bit depth! Basically, the format of thedisplayed images, simple, but important!createRenderPass(...)This is a complex function that goes through everystep of the render pipeline and sets the settings wedesire for each step!HEAVILYdocumented.createGraphicsPipeline(...)This function creates framebuffers for all the imagesthat are queued to be displayed, very important!createFramebuffers(...)Commands in Vulkan are not executed using function callsYou have to record the ops you want to perform to commandbuffer objects, pools manage the memory used for buffers.createCommandPool(...)BuffersVertex buffers are incredibly useful, in essence,you can read data from memory as vertex input to thevertex shader rather than hardcoded data!createVertexBuffer()Index buffers are cool, basically, you can storesome vertices that would normally be duplicatedat corners to triangulate. this saves cycles atscale, complex objects rejoice!createIndexBuffer()This is the partner to the commandPool creator,storing the commands we wish to perform whilstwaiting in a queue. These are very efficient.Graphics::createCommandBuffer()This isHEAVILYdocumented, create Semaphoresand Fences, for halting and starting execution, basicallya traffic controller for the GPU.RenderPresent::createSyncObject()glfwPollEvents()RenderPresent::drawFrame()mainLoop()!glfwWindowShouldClose(...)vkDeviceWaitIdle(...)This function initiates a series of shutdowndestroy functions, safely stopping execution;cleanup()return EXIT_SUCCESSMain execution from the run function in the entrypointThis dictates basic flow of the vulkan boilerplate system. \ No newline at end of file diff --git a/src/entrypoint.cpp b/src/entrypoint.cpp index 3704c8c..b803580 100644 --- a/src/entrypoint.cpp +++ b/src/entrypoint.cpp @@ -24,7 +24,7 @@ void initWindow() { glfwInit(); glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); // Settings for the window are set, create window reference. - Global::window = glfwCreateWindow(Global::WIDTH, Global::HEIGHT, "Vulkan", nullptr, nullptr); + Global::window = glfwCreateWindow(Global::WIDTH, Global::HEIGHT, "Trimgles :o", nullptr, nullptr); glfwSetWindowUserPointer(Global::window, &EntryApp::getInstance()); glfwSetFramebufferSizeCallback(Global::window, framebufferResizeCallback); } diff --git a/src/main.cpp b/src/main.cpp index 6991f16..f4e33ec 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,4 +1,5 @@ #include "entrypoint.h" + int main() { EntryApp::getInstance().initialize(); try { diff --git a/src/shaders/fragment.spv b/src/shaders/fragment.spv deleted file mode 100644 index da37f7e..0000000 Binary files a/src/shaders/fragment.spv and /dev/null differ diff --git a/src/shaders/vertex.spv b/src/shaders/vertex.spv deleted file mode 100644 index 1e4ce0c..0000000 Binary files a/src/shaders/vertex.spv and /dev/null differ