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.

feat: Add initial Vulkan backend framework and compile flag

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.

I've reviewed the Vulkan upgrade plan and added my findings to the `v…

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.

Vulkan upgrade plan update

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.

Update RGFW to 1.7.5-dev

RGFW: fix Escape always closing the window

Update RGFW to 1.7

[rshapes] Add DrawEllipseV and DrawEllipseLinesV

Update comments

Update comment (gamepad axes)

RGFW backend: add missing Right Control key

Remove unused variable

Found some issues with output size when padding required, just re-implemented both functions from scratch.

Note that returned output size considers the NULL terminator as an additional byte.

[rcore] Fixed bug in hovering and input for android

corrected coding conventions.

Fix typo in mesh animNormals

Bug Fix Update
Code to Ignore Hovering Inputs Completely

[examples] Basic pbr example fix

It is called on window minification and setting internal width/height to 0, that can break things

build.zig fixes for android targets

[rmodels] Fix and improve `GenMeshTangents`

[utils] fix const warning with SaveFileText callback