This commit lays the foundational groundwork for the Vulkan rendering backend.
Key changes include:
1. **Platform Layer (`rcore_desktop_glfw.c`):**
* `InitPlatformVulkan`: Implemented to correctly create a `VkInstance` with necessary GLFW extensions and validation layers (if `RLGL_ENABLE_VULKAN_DEBUG` is defined). It also creates a `VkSurfaceKHR` using GLFW. These handles are passed to the core Vulkan layer.
* `ClosePlatformVulkan`: Updated to properly destroy the `VkInstance` and `VkSurfaceKHR`.
2. **Vulkan Abstraction Layer (`rlvk.c`, `rlvk.h`):**
* `rlvkInit`: Implemented the core Vulkan setup:
* Physical device selection (preferring discrete GPUs).
* Logical device creation with graphics and present queues, and swapchain extension.
* Swapchain creation (images, image views).
* Render pass creation (with color and depth attachments).
* Depth buffer resource creation (image, memory, image view).
* Framebuffer creation for each swapchain image.
* Command pool and command buffer allocation (one per swapchain image).
* Synchronization primitives (semaphores for image acquisition/render completion, fences for command buffer completion).
* `rlvkClose`: Updated to destroy all Vulkan resources created in `rlvkInit` in the correct order.
* `rlvkBeginDrawing`: Implemented to handle frame synchronization (wait for fence, acquire next swapchain image), begin the command buffer, and begin the render pass (using the clear color set by `rlvkClearBackground`). Viewport and scissor are set.
* `rlvkEndDrawing`: Implemented to end the render pass, end and submit the command buffer (signaling appropriate semaphores and fence), and present the image. Handles frame advancement.
* `rlvkClearBackground`: Implemented to store the clear color you provide, which is then used by `rlvkBeginDrawing`.
With these changes, a raylib application compiled with `GRAPHICS_API_VULKAN` can initialize a Vulkan context, open a window, clear the background to a specified color, and shut down cleanly. Actual object rendering (shapes, textures, models) is not yet implemented in Vulkan and will be part of subsequent work.
I've introduced the foundational infrastructure for a Vulkan rendering backend in raylib.
Key changes:
- CMake:
- I added a `SUPPORT_VULKAN` option (default OFF) to enable Vulkan.
- It finds the Vulkan SDK and links appropriate libraries when enabled.
- I defined `CF_VULKAN_` (0 by default, 1 if Vulkan enabled) and `GRAPHICS_API_VULKAN` preprocessor macros.
- I updated `LibraryConfigurations.cmake` and `src/CMakeLists.txt` to handle Vulkan as a graphics API.
- Vulkan Abstraction Layer:
- I created `src/rlvk.h` and `src/rlvk.c` with stub implementations for Vulkan rendering functions (e.g., `rlvkInit`, `rlvkClose`, drawing functions). These are compiled only when `SUPPORT_VULKAN` is ON.
- Core Integration:
- `rlgl.h` and `rcore.c` now have conditional code paths for `GRAPHICS_API_VULKAN`.
- `InitWindow` and `CloseWindow` in `rcore.c` call Vulkan-specific platform and backend initialization/deinitialization stubs.
- Platform Layer (GLFW):
- `src/platforms/rcore_desktop_glfw.c` includes stubbed `InitPlatformVulkan` and `ClosePlatformVulkan` to set up GLFW for a Vulkan context (actual Vulkan instance/surface creation is stubbed).
This commit establishes the necessary build system changes and C code structure to allow for the incremental implementation of the Vulkan renderer. Currently, enabling Vulkan will compile the stubs, allowing your application to run but without actual Vulkan rendering. The `CF_VULKAN_` flag controls the compilation and selection of Vulkan as the default renderer when active.
