This commit introduces significant progress on the Vulkan rendering backend for raylib, enabling the rendering of basic 2D shapes.
Key changes include:
1. **Vertex Data Handling (`rlgl.h`, `rlvk.c`, `rlvk.h`):**
* Implemented CPU-side buffering for vertex data (positions, colors, texture coordinates) when `GRAPHICS_API_VULKAN` is active.
* `rlgl` functions (`rlVertex3f`, `rlColor4ub`, `rlTexCoord2f`, etc.) now route data to `rlvk` for accumulation.
2. **Vulkan Vertex Buffer Management (`rlvk.c`, `rlvk.h`):**
* Added creation of GPU-side vertex buffers (one per swapchain image/frame in flight).
* Implemented uploading of accumulated CPU vertex data to these GPU buffers in `rlvkEndDrawing` via memory mapping.
* Vertex buffers are bound, and `vkCmdDraw` is issued in `rlvkEndDrawing`.
3. **Shader Compilation and Pipeline (`CMakeLists.txt`, `rlvk.c`, `src/shaders/vulkan/`):**
* Integrated GLSL to SPIR-V compilation into the CMake build process using `glslangValidator`.
* `shapes_vert.glsl` and `shapes_frag.glsl` are compiled into C header files containing SPIR-V bytecode.
* `rlvk.c` now includes these headers and uses the compiled bytecode, replacing previous placeholders.
* Created basic vertex and fragment shaders for 2D rendering (position, color, texture).
* Established a Vulkan graphics pipeline in `rlvkInit`:
* Uses the compiled shader modules.
* Defines vertex input state for `rlvkVertex` (pos, color, texcoord).
* Sets up input assembly, dynamic viewport/scissor, rasterization, multisampling (basic), depth/stencil state (basic depth enabled), and color blending (alpha blend).
* Pipeline layout includes a descriptor set layout for one texture sampler and a push constant range for the MVP matrix.
* The graphics pipeline is bound in `rlvkBeginDrawing`.
4. **Texture Handling - Default Texture (`rlvk.c`, `rlvk.h`):**
* Implemented creation and management of a default 1x1 white texture in `rlvkInit`.
* This includes `VkImage`, `VkDeviceMemory`, `VkImageView`, and `VkSampler`.
* A `VkDescriptorPool` and a default `VkDescriptorSet` are created. The descriptor set is updated to point to the default white texture.
* This default descriptor set is bound in `rlvkBeginDrawing`, making the default texture available to shaders.
* `RLGL.State.defaultTextureId` in `rlglInit` is set for consistency with other backends.
5. **Matrix Transformations (`rlgl.h`, `rlvk.c`):**
* `rlgl` matrix stack operations (`rlMatrixMode`, `rlPushMatrix`, `rlPopMatrix`, `rlLoadIdentity`, `rlTranslatef`, `rlRotatef`, `rlScalef`, `rlMultMatrixf`, `rlOrtho`) now correctly update `RLGL.State` matrices when `GRAPHICS_API_VULKAN` is defined.
* `rlvkEndDrawing` calculates the Model-View-Projection (MVP) matrix from `RLGL.State` and uploads it to the vertex shader using `vkCmdPushConstants`.
6. **Build System (`src/CMakeLists.txt`):**
* CMake now attempts to find `glslangValidator`.
* Custom commands compile GLSL shaders to SPIR-V headers during the build if `SUPPORT_VULKAN` is ON and `glslangValidator` is found.
* Generated shader headers are included by `rlvk.c`.
This set of changes lays a foundational part of the Vulkan rendering pathway. Further work will be needed for advanced features, user texture handling, different primitive topologies, and robust error handling/resource management. I will be testing these changes separately.
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.
The review confirmed the plan's viability and strengths. I also identified some minor areas for clarification and key challenges. I didn't find an existing Vulkan rendering backend in the core raylib source, which makes this plan relevant.
This outlines the necessary modifications across the build system (CMake), graphics abstraction layer (rlgl), core library (rcore), platform-specific code, and shader handling to integrate Vulkan support into raylib. The strategy emphasizes conditional compilation based on a `GRAPHICS_API_VULKAN` flag and aims to mirror the existing OpenGL backend abstraction.
This commit introduces a new file, vulkan-upgrade-plan, which outlines a comprehensive strategy for integrating Vulkan as a compile-time graphics backend option for raylib.
The plan details the necessary changes across the codebase, including:
- Creation of a Vulkan abstraction layer (rlvk).
- Modifications to the core library (rcore.c) for conditional graphics backend selection.
- Updates to the platform layer (e.g., rcore_desktop_glfw.c) for Vulkan surface creation.
- Integration into the CMake build system.
- Shader management for SPIR-V.
This document serves as a roadmap for the potential Vulkan implementation and does not modify any existing code other than adding this plan file.
