/**********************************************************************************************
*
*   raylib v5.6-dev - 一个简单易用的游戏编程库 (www.raylib.com)
*   FEATURES:
*       - 无外部依赖，所有需要的库都包含在 raylib 中
*       - 多平台支持：Windows、Linux、macOS、FreeBSD、Web、Android、树莓派、DRM 原生等
*       - 使用纯 C 语言编写（C99），采用 PascalCase/camelCase 命名风格
*       - 硬件加速，支持多种 OpenGL 版本（1.1、2.1、3.3、4.3、ES2、ES3 - 编译时选择）
*       - 自定义 OpenGL 抽象层（可作为独立模块使用）：[rlgl]
*       - 支持多种字体格式（TTF、OTF、FNT、BDF、精灵字体）
*       - 支持多种纹理格式，包括压缩格式（DXT、ETC、ASTC）
*       - 全面的 3D 支持，包括 3D 形状、模型、广告牌、地形图等
*       - 灵活的材质系统，支持经典贴图和 PBR 贴图
*       - 支持动画 3D 模型（骨骼动画）（IQM、M3D、GLTF）
*       - 支持着色器，包括模型着色器和后处理着色器
*       - 强大的数学模块，提供向量、矩阵和四元数运算：[raymath]
*       - 音频加载和播放，支持流式（WAV、OGG、MP3、FLAC、QOA、XM、MOD）
*       - VR 立体渲染，支持可配置的 HMD 设备参数
*       - 提供多种编程语言绑定！
*   NOTES:
*       - 在 `InitWindow()->LoadFontDefault()` 中加载一个默认字体 [core, text]
*       - 在 `rlglInit()` 中加载一个默认的 2D 纹理，1x1 白色像素 R8G8B8A8 [rlgl]（OpenGL 3.3 或 ES2）
*       - 在 `rlglInit()->rlLoadShaderDefault()` 中加载一个默认的着色器 [rlgl]（OpenGL 3.3 或 ES2）
*       - 在 `rlglInit()->rlLoadRenderBatch()` 中加载一个默认的渲染批处理 [rlgl]（OpenGL 3.3 或 ES2）
*   
*   DEPENDENCIES:
*       [rcore] 取决于所选平台后端，详情请查看 rcore.c 头文件
*       [rlgl] glad/glad_gles2（David Herberth - github.com/Dav1dde/glad）用于加载 OpenGL 扩展
*       [raudio] miniaudio（David Reid - github.com/mackron/miniaudio）用于音频设备/上下文管理
*
*   可选依赖项（已包含）：
*       [rcore] sinfl（Micha Mettke）用于 DEFLATE 解压缩算法
*       [rcore] sdefl（Micha Mettke）用于 DEFLATE 压缩算法
*       [rcore] rprand（Ramon Santamaria）用于生成伪随机数
*       [rtextures] qoi（Dominic Szablewski - https://phoboslab.org）用于 QOI 图像管理
*       [rtextures] stb_image（Sean Barret）用于图像加载（BMP、TGA、PNG、JPEG、HDR 等）
*       [rtextures] stb_image_write（Sean Barret）用于图像写入（BMP、TGA、PNG、JPG）
*       [rtextures] stb_image_resize2（Sean Barret）用于图像缩放算法
*       [rtextures] stb_perlin（Sean Barret）用于柏林噪声图像生成
*       [rtextures] rl_gputex（Ramon Santamaria）用于 GPU 压缩纹理格式
*       [rtext] stb_truetype（Sean Barret）用于加载 ttf 字体
*       [rtext] stb_rect_pack（Sean Barret）用于矩形打包
*       [rmodels] par_shapes（Philip Rideout）用于生成参数化 3D 形状
*       [rmodels] tinyobj_loader_c（Syoyo Fujita）用于加载模型（OBJ、MTL）
*       [rmodels] cgltf（Johannes Kuhlmann）用于加载模型（glTF）
*       [rmodels] m3d（bzt）用于加载模型（M3D，https://bztsrc.gitlab.io/model3d）
*       [rmodels] vox_loader（Johann Nadalutti）用于加载模型（VOX）
*       [raudio] dr_wav （David Reid）用于加载 WAV 音频文件
*       [raudio] dr_flac（David Reid）用于加载 FLAC 音频文件
*       [raudio] dr_mp3（David Reid）用于加载 MP3 音频文件
*       [raudio] stb_vorbis（Sean Barret）用于加载 OGG 音频
*       [raudio] jar_xm（Joshua Reisenauer）用于加载 XM 音频模块
*       [raudio] jar_mod（Joshua Reisenauer）用于加载 MOD 音频模块
*       [raudio] qoa（Dominic Szablewski - https://phoboslab.org）用于 QOA 音频管理
*
*
*   LICENSE: zlib/libpng
*
*   raylib 采用未经修改的 zlib/libpng 许可证，该许可证是 OSI 认证的类 BSD 许可证，允许静态链接闭源软件：
*   版权所有 (c) 2013-2026 Ramon Santamaria (@raysan5)
*   本软件按“原样”提供，不提供任何明示或暗示的担保。在任何情况下，作者均不对因使用本软件而造成的任何损失承担责任。
*   任何人均可出于任何目的（包括商业应用）使用本软件，并可对其进行修改和自由分发，但须遵守以下限制：
*   1. 不得歪曲本软件的来源；您不得声称您编写了原始软件。如果您在产品中使用此软件，我们感谢您在产品文档中注明出处，但这不是强制性的。
*   2. 修改后的源代码版本必须明确标明，且不得被误导为原始软件。
*   3. 此声明不得从任何源代码分发包中移除或更改。
*
**********************************************************************************************/

#ifndef RAYLIB_H
#define RAYLIB_H

#include <stdarg.h>     // 必需项：va_list - 仅供 TraceLogCallback 使用
#include <stddef.h>     // 必需：size_t
#include <stdint.h>

#define RAYLIB_VERSION_MAJOR 5
#define RAYLIB_VERSION_MINOR 6
#define RAYLIB_VERSION_PATCH 0
#define RAYLIB_VERSION  "5.6-dev"

// 函数说明符，用于库被构建/用作共享库的情况
// 注意：Microsoft 说明符用于告知编译器符号是从 .dll 文件导入/导出的
// 注意：visibility("default") 属性在编译时使用 -fvisibility=hidden 选项会使符号“可见”
#if defined(_WIN32)
    #if defined(__TINYC__)
        #define __declspec(x) __attribute__((x))
    #endif
    #if defined(BUILD_LIBTYPE_SHARED)
        #define RLAPI __declspec(dllexport)     // Building the library as a Win32 shared library (.dll)
    #elif defined(USE_LIBTYPE_SHARED)
        #define RLAPI __declspec(dllimport)     // Using the library as a Win32 shared library (.dll)
    #endif
#else
    #if defined(BUILD_LIBTYPE_SHARED)
        #define RLAPI __attribute__((visibility("default"))) // Building as a Unix shared library (.so/.dylib)
    #endif
#endif

#ifndef RLAPI
    #define RLAPI       // Functions defined as 'extern' by default (implicit specifiers)
#endif

//----------------------------------------------------------------------------------
// 定义和宏
//----------------------------------------------------------------------------------
#ifndef PI
    #define PI 3.14159265358979323846f
#endif
#ifndef DEG2RAD
    #define DEG2RAD (PI/180.0f)
#endif
#ifndef RAD2DEG
    #define RAD2DEG (180.0f/PI)
#endif

// 允许自定义内存分配器（默认使用标准库 malloc/calloc/realloc/free）
// 注意：需要重新编译 raylib 源代码
#ifndef RL_MEM_DIAG
    #define RL_MEM_DIAG 0
#endif

#ifndef RL_MEM_DIAG_FILELINE
    #define RL_MEM_DIAG_FILELINE 1
#endif

#if RL_MEM_DIAG
    #if defined(__cplusplus)
    extern "C" {
    #endif
    RLAPI void *RLMemDiagMallocImpl(size_t allocationSize, const char *sourceFile, int sourceLine, const char *sourceFunction, const char *sourceTag);
    RLAPI void *RLMemDiagCallocImpl(size_t elementCount, size_t elementSize, const char *sourceFile, int sourceLine, const char *sourceFunction, const char *sourceTag);
    RLAPI void *RLMemDiagReallocImpl(void *oldBlock, size_t newSize, const char *sourceFile, int sourceLine, const char *sourceFunction, const char *sourceTag);
    RLAPI void RLMemDiagFreeImpl(void *blockToFree, const char *sourceFile, int sourceLine, const char *sourceFunction);
    #if defined(__cplusplus)
    }
    #endif

    #if RL_MEM_DIAG_FILELINE
        #ifndef RL_MALLOC
            #define RL_MALLOC(allocationSize) RLMemDiagMallocImpl((size_t)(allocationSize), __FILE__, __LINE__, __func__, NULL)
        #endif
        #ifndef RL_CALLOC
            #define RL_CALLOC(elementCount,elementSize) RLMemDiagCallocImpl((size_t)(elementCount), (size_t)(elementSize), __FILE__, __LINE__, __func__, NULL)
        #endif
        #ifndef RL_REALLOC
            #define RL_REALLOC(oldBlock,newSize) RLMemDiagReallocImpl((oldBlock), (size_t)(newSize), __FILE__, __LINE__, __func__, NULL)
        #endif
        #ifndef RL_FREE
            #define RL_FREE(blockToFree) RLMemDiagFreeImpl((blockToFree), __FILE__, __LINE__, __func__)
        #endif

        #define RL_MALLOC_TAG(sourceTag, allocationSize) RLMemDiagMallocImpl((size_t)(allocationSize), __FILE__, __LINE__, __func__, (sourceTag))
        #define RL_CALLOC_TAG(sourceTag, elementCount, elementSize) RLMemDiagCallocImpl((size_t)(elementCount), (size_t)(elementSize), __FILE__, __LINE__, __func__, (sourceTag))
        #define RL_REALLOC_TAG(sourceTag, oldBlock, newSize) RLMemDiagReallocImpl((oldBlock), (size_t)(newSize), __FILE__, __LINE__, __func__, (sourceTag))
    #else
        #ifndef RL_MALLOC
            #define RL_MALLOC(allocationSize) RLMemDiagMallocImpl((size_t)(allocationSize), NULL, 0, NULL, NULL)
        #endif
        #ifndef RL_CALLOC
            #define RL_CALLOC(elementCount,elementSize) RLMemDiagCallocImpl((size_t)(elementCount), (size_t)(elementSize), NULL, 0, NULL, NULL)
        #endif
        #ifndef RL_REALLOC
            #define RL_REALLOC(oldBlock,newSize) RLMemDiagReallocImpl((oldBlock), (size_t)(newSize), NULL, 0, NULL, NULL)
        #endif
        #ifndef RL_FREE
            #define RL_FREE(blockToFree) RLMemDiagFreeImpl((blockToFree), NULL, 0, NULL)
        #endif

        #define RL_MALLOC_TAG(sourceTag, allocationSize) RLMemDiagMallocImpl((size_t)(allocationSize), NULL, 0, NULL, (sourceTag))
        #define RL_CALLOC_TAG(sourceTag, elementCount, elementSize) RLMemDiagCallocImpl((size_t)(elementCount), (size_t)(elementSize), NULL, 0, NULL, (sourceTag))
        #define RL_REALLOC_TAG(sourceTag, oldBlock, newSize) RLMemDiagReallocImpl((oldBlock), (size_t)(newSize), NULL, 0, NULL, (sourceTag))
    #endif
#else
    #ifndef RL_MALLOC
        #define RL_MALLOC(allocationSize) malloc(allocationSize)
    #endif
    #ifndef RL_CALLOC
        #define RL_CALLOC(elementCount,elementSize) calloc(elementCount, elementSize)
    #endif
    #ifndef RL_REALLOC
        #define RL_REALLOC(oldBlock,newSize) realloc(oldBlock, newSize)
    #endif
    #ifndef RL_FREE
        #define RL_FREE(blockToFree) free(blockToFree)
    #endif

    #define RL_MALLOC_TAG(sourceTag, allocationSize) RL_MALLOC(allocationSize)
    #define RL_CALLOC_TAG(sourceTag, elementCount, elementSize) RL_CALLOC((elementCount), (elementSize))
    #define RL_REALLOC_TAG(sourceTag, oldBlock, newSize) RL_REALLOC((oldBlock), (newSize))
#endif

// 注意：MSVC C++ 编译器不支持复合字面量（C99 特性）
// C++ 中的普通结构体（不带构造函数）可以使用 { } 进行初始化
// 这称为聚合初始化（C++11 特性）
#if defined(__cplusplus)
    #define CLITERAL(type)      type
#else
    #define CLITERAL(type)      (type)
#endif

// 某些编译器（主要是 macOS 的 clang）默认使用 C++98，
// 而 C++98 不支持聚合初始化
// 因此，请提供更清晰的错误信息，说明如何解决此问题。
#if !defined(_MSC_VER) && (defined(__cplusplus) && __cplusplus < 201103L)
    #error "C++11 or later is required. Add -std=c++11"
#endif

// 注意：设置一些宏定义，用于定义 raylib 声明的数据类型
// 其他模块（raymath、rlgl）也需要其中一些类型，因此，
// 为了能够独立使用这些模块（不依赖于 raylib）
// 这些宏定义对于内部检查非常有用，可以避免类型（重新）定义。
#define RL_COLOR_TYPE
#define RL_RECTANGLE_TYPE
#define RL_VECTOR2_TYPE
#define RL_VECTOR3_TYPE
#define RL_VECTOR4_TYPE
#define RL_QUATERNION_TYPE
#define RL_MATRIX_TYPE
#define RL_CAMERA_TYPE

// 一些基本颜色
// 注意：自定义 raylib 颜色调色板，可在白色背景上呈现惊艳的视觉效果        
#define LIGHTGRAY  CLITERAL(RLColor){ 200, 200, 200, 255 }   // 浅灰色
#define GRAY       CLITERAL(RLColor){ 130, 130, 130, 255 }   // 灰色
#define DARKGRAY   CLITERAL(RLColor){ 80, 80, 80, 255 }      // 深灰色
#define YELLOW     CLITERAL(RLColor){ 253, 249, 0, 255 }     // 黄色
#define GOLD       CLITERAL(RLColor){ 255, 203, 0, 255 }     // 金色
#define ORANGE     CLITERAL(RLColor){ 255, 161, 0, 255 }     // 橙色
#define PINK       CLITERAL(RLColor){ 255, 109, 194, 255 }   // 粉色
#define RED        CLITERAL(RLColor){ 230, 41, 55, 255 }     // 红色
#define MAROON     CLITERAL(RLColor){ 190, 33, 55, 255 }     // 栗色
#define GREEN      CLITERAL(RLColor){ 0, 228, 48, 255 }      // 绿色
#define LIME       CLITERAL(RLColor){ 0, 158, 47, 255 }      // 浅绿色
#define DARKGREEN  CLITERAL(RLColor){ 0, 117, 44, 255 }      // 深绿色
#define SKYBLUE    CLITERAL(RLColor){ 102, 191, 255, 255 }   // 天蓝色
#define BLUE       CLITERAL(RLColor){ 0, 121, 241, 255 }     // 蓝色
#define DARKBLUE   CLITERAL(RLColor){ 0, 82, 172, 255 }      // 深蓝色
#define PURPLE     CLITERAL(RLColor){ 200, 122, 255, 255 }   // 紫色
#define VIOLET     CLITERAL(RLColor){ 135, 60, 190, 255 }    // 紫罗兰色
#define DARKPURPLE CLITERAL(RLColor){ 112, 31, 126, 255 }    // 深紫色
#define BEIGE      CLITERAL(RLColor){ 211, 176, 131, 255 }   // 米色
#define BROWN      CLITERAL(RLColor){ 127, 106, 79, 255 }    // 棕色
#define DARKBROWN  CLITERAL(RLColor){ 76, 63, 47, 255 }      // 深棕色

#define WHITE      CLITERAL(RLColor){ 255, 255, 255, 255 }   // 白色
#define BLACK      CLITERAL(RLColor){ 0, 0, 0, 255 }         // 黑色
#define BLANK      CLITERAL(RLColor){ 0, 0, 0, 0 }           // 空白（透明）
#define MAGENTA    CLITERAL(RLColor){ 255, 0, 255, 255 }     // 洋红色
#define RAYWHITE   CLITERAL(RLColor){ 245, 245, 245, 255 }   // 我的白色（raylib 标志）

//----------------------------------------------------------------------------------
// 类型和结构定义
//----------------------------------------------------------------------------------
// 布尔类型
#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
    #include <stdbool.h>
#elif !defined(__cplusplus) && !defined(bool)
    typedef enum bool { false = 0, true = !false } bool;
    #define RL_BOOL_TYPE
#endif

// Vector2, 2 components
typedef struct RLVector2 {
    float x;                // 向量 x 分量
    float y;                // 向量 y 分量
} RLVector2;

// Vector3, 3 components
typedef struct RLVector3 {
    float x;                // 向量 x 分量
    float y;                // 向量 y 分量
    float z;                // 向量 z 分量
} RLVector3;

// Vector4, 4 components
typedef struct RLVector4 {
    float x;                // 向量 x 分量
    float y;                // 向量 y 分量
    float z;                // 向量 z 分量
    float w;                // 向量 w 分量
} RLVector4;

// 四元数，4 个分量（Vector4 别名）
typedef RLVector4 RLQuaternion;

// 矩阵，4x4 分量，列优先，OpenGL 风格，右手型
typedef struct RLMatrix {
    float m0, m4, m8, m12;  // 矩阵第一行（4 个分量）
    float m1, m5, m9, m13;  // 矩阵第二行（4 个分量）
    float m2, m6, m10, m14; // 矩阵第三行（4 个分量）
    float m3, m7, m11, m15; // 矩阵第四行（4 个分量）
} RLMatrix;

// 颜色，4 个分量，R8G8B8A8（32 位）
typedef struct RLColor {
    unsigned char r;        // 红色值
    unsigned char g;        // 绿色值
    unsigned char b;        // 蓝色值
    unsigned char a;        // 透明值
} RLColor;

// Rectangle, 4 components
typedef struct RLRectangle {
    float x;                // 矩形左上角坐标 x
    float y;                // 矩形左上角坐标 y
    float width;            // 矩形宽度
    float height;           // 矩形高度
} RLRectangle;

// 图像，像素数据存储在CPU内存（RAM）中
typedef struct RLImage {
    void *data;             // 图像原始数据
    int width;              // 图像基准宽度
    int height;             // 图像基准高度
    int mipmaps;            // Mipmap 层级，默认为 1
    int format;             // 数据格式（PixelFormat 类型）
} RLImage;

// 纹理、tex 数据存储在 GPU 内存（VRAM）中
typedef struct RLTexture {
    unsigned int id;        // OpenGL 纹理 ID
    int width;              // 纹理基础宽度
    int height;             // 纹理基础高度
    int mipmaps;            // Mipmap 层级，默认为 1
    int format;             // 数据格式（PixelFormat 类型）
} RLTexture;

// Texture2D，与 Texture 相同
typedef RLTexture RLTexture2D;

// TextureCubemap，与 Texture 相同
typedef RLTexture RLTextureCubemap;

// RenderTexture，用于纹理渲染的 fbo
typedef struct RLRenderTexture {
    unsigned int id;        // OpenGL 帧缓冲区对象 ID
    RLTexture texture;      // 颜色缓冲区附件纹理
    RLTexture depth;        // 深度缓冲区附件纹理
} RLRenderTexture;

// RenderTexture2D，与 RenderTexture 相同
typedef RLRenderTexture RLRenderTexture2D;

// NPatchInfo，n-patch 布局信息
typedef struct RLNPatchInfo {
    RLRectangle source;     // 纹理源矩形
    int left;               // 左边界偏移
    int top;                // 上边界偏移
    int right;              // 右边界偏移
    int bottom;             // 下边界偏移
    int layout;             // n 面片布局：3x3、1x3 或 3x1
} RLNPatchInfo;

// GlyphInfo，字体字符字形信息
typedef struct RLGlyphInfo {
    int value;              // 字符值（Unicode）
    int offsetX;            // 绘制时字符的 X 轴偏移量
    int offsetY;            // 绘制时字符的 Y 轴偏移量
    int advanceX;           // 字符前进位置 X
    RLImage image;          // 字符图像数据
} RLGlyphInfo;

// 字体、字体纹理和字形信息数组数据
typedef struct RLFont {
    int baseSize;           // 基本大小（默认字符高度）
    int glyphCount;         // 字形字符数
    int glyphPadding;       // 字形字符周围的填充
    RLTexture2D texture;    // 包含字形的纹理图集
    RLRectangle *recs;      // 纹理中用于表示字形的矩形
    RLGlyphInfo *glyphs;    // 字形信息数据
} RLFont;

// 相机，定义其在三维空间中的位置/方向
typedef struct RLCamera3D {
    RLVector3 position;     // 摄像机位置
    RLVector3 target;       // 摄像机注视目标
    RLVector3 up;           // 摄像机向上矢量（绕其轴旋转）
    float fovy;             // 透视投影中摄像机的 Y 轴视场角（度），在正交投影中用作近平面高度（世界单位）
    int projection;         // 摄像机投影：CAMERA_PERSPECTIVE 或 CAMERA_ORTHOGRAPHIC
} RLCamera3D;

typedef RLCamera3D RLCamera;    // 相机类型备用方案，默认为 Camera3D

// Camera2D，定义二维空间中的位置/方向
typedef struct RLCamera2D {
    RLVector2 offset;      // 相机偏移量（屏幕空间中相对于窗口原点的偏移量）
    RLVector2 target;      // 相机目标点（映射到屏幕空间偏移量的世界空间目标点）
    float rotation;        // 相机旋转角度（以度为单位，围绕目标点旋转）
    float zoom;            // 相机缩放（围绕目标点缩放），不能设置为 0，设置为 1.0f 则不缩放。
} RLCamera2D;

// 网格、顶点数据和 VAO/VBO
typedef struct RLMesh {
    int vertexCount;        // 存储在数组中的顶点数量
    int triangleCount;      // 存储的三角形数量（无论是否使用索引）

    // 顶点属性数据
    float *vertices;        // 顶点位置（XYZ - 每个顶点 3 个分量）（shader-location = 0）
    float *texcoords;       // 顶点纹理坐标（UV - 每个顶点 2 个分量）（shader-location = 1）
    float *texcoords2;      // 顶点纹理第二坐标（UV - 每个顶点 2 个分量）（shader-location = 5）
    float *normals;         // 顶点法线（XYZ - 每个顶点 3 个分量）（shader-location = 2）
    float *tangents;        // 顶点切线（XYZW - 每个顶点 4 个分量）（shader-location = 4）
    unsigned char *colors;  // 顶点颜色（RGBA - 每个顶点 4 个分量）（shader-location = 3）
    unsigned short *indices;// 顶点索引（如果顶点数据带有索引）

    // 动画顶点数据
    float *animVertices;    // 动画顶点位置（骨骼变换后）
    float *animNormals;     // 动画法线（骨骼变换后）
    unsigned char *boneIds; // 顶点骨骼 ID，最多 255 个骨骼 ID，每个顶点最多影响 4 个骨骼（蒙皮）（shader-location = 6）
    float *boneWeights;     // 顶点骨骼权重，每个顶点最多影响 4 个骨骼（蒙皮）（shader-location = 7）
    RLMatrix *boneMatrices; // 骨骼动画变换矩阵
    int boneCount;          // 骨骼数量

    // OpenGL 标识符
    unsigned int vaoId;     // OpenGL 顶点数组对象 ID
    unsigned int *vboId;    // OpenGL 顶点缓冲区对象 ID（默认顶点数据）
} RLMesh;

// 着色器
typedef struct RLShader {
    unsigned int id;        // 着色器程序 ID
    int *locs;              // 着色器位置数组 (RL_MAX_SHADER_LOCATIONS)
} RLShader;

// MaterialMap
typedef struct RLMaterialMap {
    RLTexture2D texture;    // 材质贴图纹理
    RLColor color;          // 材质贴图颜色
    float value;            // 材质贴图值
} RLMaterialMap;

//材质，包括着色器和贴图
typedef struct RLMaterial {
    RLShader shader;        // 材质着色器
    RLMaterialMap *maps;    // 材质贴图数组 (MAX_MATERIAL_MAPS)
    float params[4];        // 材质通用参数（如果需要）
} RLMaterial;

// 变换，顶点变换数据
typedef struct RLTransform {
    RLVector3 translation;    // 平移
    RLQuaternion rotation;    // 旋转
    RLVector3 scale;          // 缩放
} RLTransform;

// 骨骼，骨骼动画骨骼
typedef struct RLBoneInfo {
    char name[32];          // 骨骼名称
    int parent;             // 骨骼父级
} RLBoneInfo;

// 模型、网格、材质和动画数据
typedef struct RLModel {
    RLMatrix transform;     // 局部变换矩阵

    int meshCount;          // 网格数量
    int materialCount;      // 材质数量
    RLMesh *meshes;         // 网格数组
    RLMaterial *materials;  // 材质数组
    int *meshMaterial;      // 网格材质编号

    // 动画数据
    int boneCount;          // 骨骼数量
    RLBoneInfo *bones;      // 骨骼信息（骨架）
    RLTransform *bindPose;  // 骨骼基础变换（姿势）
} RLModel;

// 模型动画
typedef struct RLModelAnimation {
    char name[32];          // 动画名称
    int boneCount;          // 骨骼数量
    int frameCount;         // 动画帧数
    RLBoneInfo *bones;      // 骨骼信息（骨架）
    RLTransform **framePoses;// 按帧排列的姿势数组
} RLModelAnimation;

// Ray，用于光线投射的 ray
typedef struct RLRay {
    RLVector3 position;       // 射线位置（原点）
    RLVector3 direction;      // 射线方向（归一化）
} RLRay;

// 光线碰撞，光线命中信息
typedef struct RLRayCollision {
    bool hit;               // 射线是否击中物体？
    float distance;         // 到最近击中点的距离
    RLVector3 point;        // 最近击中点的位置
    RLVector3 normal;       // 击中点的表面法线
} RLRayCollision;

// 边界框
typedef struct RLBoundingBox {
    RLVector3 min;            // 最小顶点盒角
    RLVector3 max;            // 最大顶点盒角
} RLBoundingBox;

// 波形，音频波形数据
typedef struct RLWave {
    unsigned int frameCount;    // 总帧数（考虑声道）
    unsigned int sampleRate;    // 采样频率（每秒采样数）
    unsigned int sampleSize;    // 位深度（每个样本的位数）：8、16、32（不支持 24 位）
    unsigned int channels;      // 声道数（1-单声道，2-立体声，……）
    void *data;                 // 缓冲区数据指针
} RLWave;

// 不透明结构体声明
// 注意：实际的结构体在 raudio 模块内部定义
typedef struct rAudioBuffer rAudioBuffer;
typedef struct rAudioProcessor rAudioProcessor;

// AudioStream，自定义音频流
typedef struct RLAudioStream {
    rAudioBuffer *buffer;       // 指向音频系统使用的内部数据的指针
    rAudioProcessor *processor; // 指向内部数据处理器的指针，用于音频效果

    unsigned int sampleRate;    // 频率（每秒采样数）
    unsigned int sampleSize;    // 位深度（每个采样位数）：8、16、32（不支持 24 位）
    unsigned int channels;      // 声道数（1-单声道，2-立体声，……）
} RLAudioStream;

// 声音
typedef struct RLSound {
    RLAudioStream stream;       // 声音// 音频流
    unsigned int frameCount;    // 总帧数（考虑声道）
} RLSound;

// 音乐、音频流，任何超过约 10 秒的内容都应该进行流式传输。
typedef struct RLMusic {
    RLAudioStream stream;       // 音频流
    unsigned int frameCount;    // 总帧数（考虑声道）
    bool looping;               // 音乐循环启用

    int ctxType;                // 音乐上下文类型（音频文件类型）
    void *ctxData;              // 音频上下文数据，取决于类型
} RLMusic;

// VrDeviceInfo，头戴式显示器设备参数
typedef struct RLVrDeviceInfo {
    int hResolution;                // 水平分辨率（像素）
    int vResolution;                // 垂直分辨率（像素）
    float hScreenSize;              // 水平尺寸（米）
    float vScreenSize;              // 垂直尺寸（米）
    float eyeToScreenDistance;      // 眼睛到显示器的距离（米）
    float lensSeparationDistance;   // 镜头间距（米）
    float interpupillaryDistance;   // 瞳距（米）
    float lensDistortionValues[4];  // 镜头畸变常数参数
    float chromaAbCorrection[4];    // 色差校正参数
} RLVrDeviceInfo;

// VrStereoConfig，模拟器的 VR 立体渲染配置
typedef struct RLVrStereoConfig {
    RLMatrix projection[2];         // VR 投影矩阵（每只眼睛）
    RLMatrix viewOffset[2];         // VR 视图偏移矩阵（每只眼睛）
    float leftLensCenter[2];        // VR 左镜头中心
    float rightLensCenter[2];       // VR 右镜头中心
    float leftScreenCenter[2];      // VR 左屏幕中心
    float rightScreenCenter[2];     // VR 右屏幕中心
    float scale[2];                 // VR 畸变比例
    float scaleIn[2];               // VR 畸变比例
} RLVrStereoConfig;

// 文件路径列表
typedef struct RLFilePathList {
    unsigned int count;             // 文件路径条目数
    char **paths;                   // 文件路径条目
} RLFilePathList;

// 自动化事件
typedef struct RLAutomationEvent {
    unsigned int frame;             // 事件框架
    unsigned int type;              // 事件类型（AutomationEventType）
    int params[4];                  // 事件参数（如有需要）
} RLAutomationEvent;

// 自动化事件列表
typedef struct RLAutomationEventList {
    unsigned int capacity;          // 事件最大条目数 (MAX_AUTOMATION_EVENTS)
    unsigned int count;             // 事件条目数
    RLAutomationEvent *events;      // 事件条目
} RLAutomationEventList;

//----------------------------------------------------------------------------------
// 枚举器定义
//----------------------------------------------------------------------------------
// 系统/窗口配置标志
// 注意：每个位注册一个状态（与位掩码一起使用）
// 默认情况下，所有标志均设置为 0
typedef enum {
    RL_E_FLAG_VSYNC_HINT         = 0x00000040,          // 尝试启用 GPU 垂直同步
    RL_E_FLAG_FULLSCREEN_MODE    = 0x00000002,          // 设置为全屏运行程序
    RL_E_FLAG_WINDOW_RESIZABLE   = 0x00000004,          // 设置为允许调整窗口大小
    RL_E_FLAG_WINDOW_UNDECORATED = 0x00000008,          // 设置为禁用窗口装饰（边框和按钮）
    RL_E_FLAG_WINDOW_HIDDEN      = 0x00000080,          // 设置为隐藏窗口
    RL_E_FLAG_WINDOW_MINIMIZED   = 0x00000200,          // 设置为最小化窗口（图标化）
    RL_E_FLAG_WINDOW_MAXIMIZED   = 0x00000400,          // 设置为最大化窗口（扩展到整个显示器）
    RL_E_FLAG_WINDOW_UNFOCUSED   = 0x00000800,          // 设置为窗口非焦点状态
    RL_E_FLAG_WINDOW_TOPMOST     = 0x00001000,          // 设置为窗口始终置顶
    RL_E_FLAG_WINDOW_ALWAYS_RUN  = 0x00000100,          // 设置为允许窗口在最小化状态下运行
    RL_E_FLAG_WINDOW_TRANSPARENT = 0x00000010,          // 设置为允许透明帧缓冲区
    RL_E_FLAG_WINDOW_HIGHDPI     = 0x00002000,          // 设置为支持高 DPI
    RL_E_FLAG_WINDOW_MOUSE_PASSTHROUGH = 0x00004000,    // 设置为支持鼠标透视，仅当 FLAG_WINDOW_UNDECORATED 时才支持
    RL_E_FLAG_BORDERLESS_WINDOWED_MODE = 0x00008000,    // 设置为以无边框窗口模式运行程
    RL_E_FLAG_MSAA_4X_HINT       = 0x00000020,          // 设置尝试启用 MSAA 4X
    RL_E_FLAG_INTERLACED_HINT    = 0x00010000,          // 设置尝试启用隔行扫描视频格式（适用于 V3D）
    RL_E_FLAG_WINDOW_EVENT_THREAD        = 0x00020000,  // [GLFW/Win32] 为此窗口创建一个专用的消息/事件线程（与渲染线程分离）
    RL_E_FLAG_WINDOW_REFRESH_CALLBACK   = 0x00040000,   // [GLFW/Win32] 在 Win32 模态循环（移动/调整大小/菜单）期间启用操作系统驱动的刷新；与 RLSetWindowRefreshCallback() 一起使用
    RL_E_FLAG_WINDOW_BROADCAST_WAKE    = 0x00080000,    // [GLFW/Win32] 在关闭窗口时向所有窗口的渲染线程广播唤醒信号（可选）
    RL_E_FLAG_WINDOW_SNAP_LAYOUT       = 0x00100000     // [GLFW/Win32] 即使窗口不可调整大小，也保留 Win11 的窗口贴靠布局功能（阻止交互式调整边框大小）
} RLConfigFlags;

// 跟踪日志级别
// 注意：按优先级排序
typedef enum {
    RL_E_LOG_ALL = 0,        // 显示所有日志
    RL_E_LOG_TRACE,          // 跟踪日志，仅供内部使用
    RL_E_LOG_DEBUG,          // 调试日志，用于内部调试，在发布版本中应禁用
    RL_E_LOG_INFO,           // 信息日志，用于程序执行信息
    RL_E_LOG_WARNING,        // 警告日志，用于可恢复的故障
    RL_E_LOG_ERROR,          // 错误日志，用于不可恢复的故障
    RL_E_LOG_FATAL,          // 致命日志，用于中止程序：exit(EXIT_FAILURE)
    RL_E_LOG_NONE            // 禁用日志记录
} RLTraceLogLevel;

// 键盘按键（美式键盘布局）
// 注意：使用 GetKeyPressed() 函数可以重新定义其他布局所需的按键。
typedef enum {
    RL_E_KEY_NULL            = 0,        // 键：NULL，表示未按下任何键
    // 字母数字键
    RL_E_KEY_APOSTROPHE      = 39,       // Key: '
    RL_E_KEY_COMMA           = 44,       // Key: ,
    RL_E_KEY_MINUS           = 45,       // Key: -
    RL_E_KEY_PERIOD          = 46,       // Key: .
    RL_E_KEY_SLASH           = 47,       // Key: /
    RL_E_KEY_ZERO            = 48,       // Key: 0
    RL_E_KEY_ONE             = 49,       // Key: 1
    RL_E_KEY_TWO             = 50,       // Key: 2
    RL_E_KEY_THREE           = 51,       // Key: 3
    RL_E_KEY_FOUR            = 52,       // Key: 4
    RL_E_KEY_FIVE            = 53,       // Key: 5
    RL_E_KEY_SIX             = 54,       // Key: 6
    RL_E_KEY_SEVEN           = 55,       // Key: 7
    RL_E_KEY_EIGHT           = 56,       // Key: 8
    RL_E_KEY_NINE            = 57,       // Key: 9
    RL_E_KEY_SEMICOLON       = 59,       // Key: ;
    RL_E_KEY_EQUAL           = 61,       // Key: =
    RL_E_KEY_A               = 65,       // Key: A | a
    RL_E_KEY_B               = 66,       // Key: B | b
    RL_E_KEY_C               = 67,       // Key: C | c
    RL_E_KEY_D               = 68,       // Key: D | d
    RL_E_KEY_E               = 69,       // Key: E | e
    RL_E_KEY_F               = 70,       // Key: F | f
    RL_E_KEY_G               = 71,       // Key: G | g
    RL_E_KEY_H               = 72,       // Key: H | h
    RL_E_KEY_I               = 73,       // Key: I | i
    RL_E_KEY_J               = 74,       // Key: J | j
    RL_E_KEY_K               = 75,       // Key: K | k
    RL_E_KEY_L               = 76,       // Key: L | l
    RL_E_KEY_M               = 77,       // Key: M | m
    RL_E_KEY_N               = 78,       // Key: N | n
    RL_E_KEY_O               = 79,       // Key: O | o
    RL_E_KEY_P               = 80,       // Key: P | p
    RL_E_KEY_Q               = 81,       // Key: Q | q
    RL_E_KEY_R               = 82,       // Key: R | r
    RL_E_KEY_S               = 83,       // Key: S | s
    RL_E_KEY_T               = 84,       // Key: T | t
    RL_E_KEY_U               = 85,       // Key: U | u
    RL_E_KEY_V               = 86,       // Key: V | v
    RL_E_KEY_W               = 87,       // Key: W | w
    RL_E_KEY_X               = 88,       // Key: X | x
    RL_E_KEY_Y               = 89,       // Key: Y | y
    RL_E_KEY_Z               = 90,       // Key: Z | z
    RL_E_KEY_LEFT_BRACKET    = 91,       // Key: [
    RL_E_KEY_BACKSLASH       = 92,       // Key: '\'
    RL_E_KEY_RIGHT_BRACKET   = 93,       // Key: ]
    RL_E_KEY_GRAVE           = 96,       // Key: `
    // 功能键
    RL_E_KEY_SPACE           = 32,       // Key: Space
    RL_E_KEY_ESCAPE          = 256,      // Key: Esc
    RL_E_KEY_ENTER           = 257,      // Key: Enter
    RL_E_KEY_TAB             = 258,      // Key: Tab
    RL_E_KEY_BACKSPACE       = 259,      // Key: Backspace
    RL_E_KEY_INSERT          = 260,      // Key: Ins
    RL_E_KEY_DELETE          = 261,      // Key: Del
    RL_E_KEY_RIGHT           = 262,      // Key: Cursor right
    RL_E_KEY_LEFT            = 263,      // Key: Cursor left
    RL_E_KEY_DOWN            = 264,      // Key: Cursor down
    RL_E_KEY_UP              = 265,      // Key: Cursor up
    RL_E_KEY_PAGE_UP         = 266,      // Key: Page up
    RL_E_KEY_PAGE_DOWN       = 267,      // Key: Page down
    RL_E_KEY_HOME            = 268,      // Key: Home
    RL_E_KEY_END             = 269,      // Key: End
    RL_E_KEY_CAPS_LOCK       = 280,      // Key: Caps lock
    RL_E_KEY_SCROLL_LOCK     = 281,      // Key: Scroll down
    RL_E_KEY_NUM_LOCK        = 282,      // Key: Num lock
    RL_E_KEY_PRINT_SCREEN    = 283,      // Key: Print screen
    RL_E_KEY_PAUSE           = 284,      // Key: Pause
    RL_E_KEY_F1              = 290,      // Key: F1
    RL_E_KEY_F2              = 291,      // Key: F2
    RL_E_KEY_F3              = 292,      // Key: F3
    RL_E_KEY_F4              = 293,      // Key: F4
    RL_E_KEY_F5              = 294,      // Key: F5
    RL_E_KEY_F6              = 295,      // Key: F6
    RL_E_KEY_F7              = 296,      // Key: F7
    RL_E_KEY_F8              = 297,      // Key: F8
    RL_E_KEY_F9              = 298,      // Key: F9
    RL_E_KEY_F10             = 299,      // Key: F10
    RL_E_KEY_F11             = 300,      // Key: F11
    RL_E_KEY_F12             = 301,      // Key: F12
    RL_E_KEY_LEFT_SHIFT      = 340,      // Key: Shift left
    RL_E_KEY_LEFT_CONTROL    = 341,      // Key: Control left
    RL_E_KEY_LEFT_ALT        = 342,      // Key: Alt left
    RL_E_KEY_LEFT_SUPER      = 343,      // Key: Super left
    RL_E_KEY_RIGHT_SHIFT     = 344,      // Key: Shift right
    RL_E_KEY_RIGHT_CONTROL   = 345,      // Key: Control right
    RL_E_KEY_RIGHT_ALT       = 346,      // Key: Alt right
    RL_E_KEY_RIGHT_SUPER     = 347,      // Key: Super right
    RL_E_KEY_KB_MENU         = 348,      // Key: KB menu
    // 小键盘按键
    RL_E_KEY_KP_0            = 320,      // Key: Keypad 0
    RL_E_KEY_KP_1            = 321,      // Key: Keypad 1
    RL_E_KEY_KP_2            = 322,      // Key: Keypad 2
    RL_E_KEY_KP_3            = 323,      // Key: Keypad 3
    RL_E_KEY_KP_4            = 324,      // Key: Keypad 4
    RL_E_KEY_KP_5            = 325,      // Key: Keypad 5
    RL_E_KEY_KP_6            = 326,      // Key: Keypad 6
    RL_E_KEY_KP_7            = 327,      // Key: Keypad 7
    RL_E_KEY_KP_8            = 328,      // Key: Keypad 8
    RL_E_KEY_KP_9            = 329,      // Key: Keypad 9
    RL_E_KEY_KP_DECIMAL      = 330,      // Key: Keypad .
    RL_E_KEY_KP_DIVIDE       = 331,      // Key: Keypad /
    RL_E_KEY_KP_MULTIPLY     = 332,      // Key: Keypad *
    RL_E_KEY_KP_SUBTRACT     = 333,      // Key: Keypad -
    RL_E_KEY_KP_ADD          = 334,      // Key: Keypad +
    RL_E_KEY_KP_ENTER        = 335,      // Key: Keypad Enter
    RL_E_KEY_KP_EQUAL        = 336,      // Key: Keypad =
    // 安卓按键
    RL_E_KEY_BACK            = 4,        // Key: 安卓返回键
    RL_E_KEY_MENU            = 5,        // Key: 安卓菜单键
    RL_E_KEY_VOLUME_UP       = 24,       // Key: 安卓音量加键
    RL_E_KEY_VOLUME_DOWN     = 25        // Key: 安卓音量减键
} RLKeyboardKey;

// 添加对已弃用名称的向后兼容性支持
#define MOUSE_LEFT_BUTTON   RL_E_MOUSE_BUTTON_LEFT
#define MOUSE_RIGHT_BUTTON  RL_E_MOUSE_BUTTON_RIGHT
#define MOUSE_MIDDLE_BUTTON RL_E_MOUSE_BUTTON_MIDDLE

// 鼠标按钮
typedef enum {
    RL_E_MOUSE_BUTTON_LEFT    = 0,       // 鼠标左键
    RL_E_MOUSE_BUTTON_RIGHT   = 1,       // 鼠标右键
    RL_E_MOUSE_BUTTON_MIDDLE  = 2,       // 鼠标中键（滚轮按下）
    RL_E_MOUSE_BUTTON_SIDE    = 3,       // 鼠标侧键（高级鼠标设备）
    RL_E_MOUSE_BUTTON_EXTRA   = 4,       // 鼠标侧键（高级鼠标设备）
    RL_E_MOUSE_BUTTON_FORWARD = 5,       // 鼠标前进键（高级鼠标设备）
    RL_E_MOUSE_BUTTON_BACK    = 6,       // 鼠标后退键（高级鼠标设备）
} RLMouseButton;

// 鼠标光标
typedef enum {
    RL_E_MOUSE_CURSOR_DEFAULT       = 0,     // 默认指针形状
    RL_E_MOUSE_CURSOR_ARROW         = 1,     // 箭头形状
    RL_E_MOUSE_CURSOR_IBEAM         = 2,     // 文本输入光标形状
    RL_E_MOUSE_CURSOR_CROSSHAIR     = 3,     // 十字形
    RL_E_MOUSE_CURSOR_POINTING_HAND = 4,     // 指向手形光标
    RL_E_MOUSE_CURSOR_RESIZE_EW     = 5,     // 水平方向调整大小/移动箭头形状
    RL_E_MOUSE_CURSOR_RESIZE_NS     = 6,     // 垂直方向调整大小/移动箭头形状
    RL_E_MOUSE_CURSOR_RESIZE_NWSE   = 7,     // 左上到右下对角线方向调整大小/移动箭头形状
    RL_E_MOUSE_CURSOR_RESIZE_NESW   = 8,     // 右上到左下对角线方向调整大小/移动箭头形状
    RL_E_MOUSE_CURSOR_RESIZE_ALL    = 9,     // 全方位调整大小/移动光标形状
    RL_E_MOUSE_CURSOR_NOT_ALLOWED   = 10     // 禁止操作形状
} RLMouseCursor;

// 游戏手柄按钮
typedef enum {
    RL_E_GAMEPAD_BUTTON_UNKNOWN = 0,         // 未知按键，仅用于错误检查
    RL_E_GAMEPAD_BUTTON_LEFT_FACE_UP,        // 游戏手柄左方向键上键
    RL_E_GAMEPAD_BUTTON_LEFT_FACE_RIGHT,     // 游戏手柄左方向键右键
    RL_E_GAMEPAD_BUTTON_LEFT_FACE_DOWN,      // 游戏手柄左方向键下键
    RL_E_GAMEPAD_BUTTON_LEFT_FACE_LEFT,      // 游戏手柄左方向键左键
    RL_E_GAMEPAD_BUTTON_RIGHT_FACE_UP,       // 游戏手柄右键上键（例如：PS3：三角键，Xbox：Y键）
    RL_E_GAMEPAD_BUTTON_RIGHT_FACE_RIGHT,    // 游戏手柄右键右键（例如：PS3：圆圈键，Xbox：B键）
    RL_E_GAMEPAD_BUTTON_RIGHT_FACE_DOWN,     // 游戏手柄右键下键（例如：PS3：叉键，Xbox：A键）
    RL_E_GAMEPAD_BUTTON_RIGHT_FACE_LEFT,     // 游戏手柄左方向键（例如：PS3：方块键，Xbox：X键）
    RL_E_GAMEPAD_BUTTON_LEFT_TRIGGER_1,      // 游戏手柄顶部/后部扳机键左键（第一个），可能是尾键
    RL_E_GAMEPAD_BUTTON_LEFT_TRIGGER_2,      // 游戏手柄顶部/后部扳机键左键（第二个），可能是尾键
    RL_E_GAMEPAD_BUTTON_RIGHT_TRIGGER_1,     // 游戏手柄顶部/后部扳机键右键（第一个），可能是尾键
    RL_E_GAMEPAD_BUTTON_RIGHT_TRIGGER_2,     // 游戏手柄顶部/后部扳机键右键（第二个），可能是尾键
    RL_E_GAMEPAD_BUTTON_MIDDLE_LEFT,         // 游戏手柄中间按键，左侧一个（例如：PS3：选择键）
    RL_E_GAMEPAD_BUTTON_MIDDLE,              //游戏手柄中间的按键（例如：PS3：PS，Xbox：XBOX）
    RL_E_GAMEPAD_BUTTON_MIDDLE_RIGHT,        // 游戏手柄中间的按键（例如：PS3：开始）
    RL_E_GAMEPAD_BUTTON_LEFT_THUMB,          // 按下游戏手柄摇杆的左侧按键
    RL_E_GAMEPAD_BUTTON_RIGHT_THUMB          // 按下游戏手柄摇杆的右侧按键
} RLGamepadButton;

// 游戏手柄轴
typedef enum {
    RL_E_GAMEPAD_AXIS_LEFT_X        = 0,     // 游戏手柄左摇杆 X 轴
    RL_E_GAMEPAD_AXIS_LEFT_Y        = 1,     // 游戏手柄左摇杆 Y 轴
    RL_E_GAMEPAD_AXIS_RIGHT_X       = 2,     // 游戏手柄右摇杆 X 轴
    RL_E_GAMEPAD_AXIS_RIGHT_Y       = 3,     // 游戏手柄右摇杆 Y 轴
    RL_E_GAMEPAD_AXIS_LEFT_TRIGGER  = 4,     // 游戏手柄后扳机左，压力等级：[1..-1]
    RL_E_GAMEPAD_AXIS_RIGHT_TRIGGER = 5      // 游戏手柄后扳机右，压力等级：[1..-1]
} RLGamepadAxis;

//材质贴图索引
typedef enum {
    RL_E_MATERIAL_MAP_ALBEDO = 0,        // 反照率材质（等同于：MATERIAL_MAP_DIFFUSE）
    RL_E_MATERIAL_MAP_METALNESS,         // 金属度材质（等同于：MATERIAL_MAP_SPECULAR）
    RL_E_MATERIAL_MAP_NORMAL,            // 法线材质
    RL_E_MATERIAL_MAP_ROUGHNESS,         // 粗糙度材质
    RL_E_MATERIAL_MAP_OCCLUSION,         // 环境光遮蔽材质
    RL_E_MATERIAL_MAP_EMISSION,          // 自发光材质
    RL_E_MATERIAL_MAP_HEIGHT,            // 高度图材质
    RL_E_MATERIAL_MAP_CUBEMAP,           // 立方体贴图材质（注意：使用 GL_TEXTURE_CUBE_MAP）
    RL_E_MATERIAL_MAP_IRRADIANCE,        // 辐照度材质（注意：使用 GL_TEXTURE_CUBE_MAP）
    RL_E_MATERIAL_MAP_PREFILTER,         // 预过滤材质（注意：使用 GL_TEXTURE_CUBE_MAP）
    RL_E_MATERIAL_MAP_BRDF               // BRDF 材质
} RLMaterialMapIndex;

#define MATERIAL_MAP_DIFFUSE      RL_E_MATERIAL_MAP_ALBEDO
#define MATERIAL_MAP_SPECULAR     RL_E_MATERIAL_MAP_METALNESS

// 着色器位置索引
typedef enum {
    RL_E_SHADER_LOC_VERTEX_POSITION = 0, // 着色器位置：顶点属性：位置
    RL_E_SHADER_LOC_VERTEX_TEXCOORD01,   // 着色器位置：顶点属性：纹理坐标01
    RL_E_SHADER_LOC_VERTEX_TEXCOORD02,   // 着色器位置：顶点属性：纹理坐标02
    RL_E_SHADER_LOC_VERTEX_NORMAL,       // 着色器位置：顶点属性：法线
    RL_E_SHADER_LOC_VERTEX_TANGENT,      // 着色器位置：顶点属性：切线
    RL_E_SHADER_LOC_VERTEX_COLOR,        // 着色器位置：顶点属性：颜色
    RL_E_SHADER_LOC_MATRIX_MVP,          // 着色器位置：矩阵 uniform：模型-视图-投影
    RL_E_SHADER_LOC_MATRIX_VIEW,         // 着色器位置：矩阵 uniform：视图（相机变换）
    RL_E_SHADER_LOC_MATRIX_PROJECTION,   // 着色器位置：矩阵 uniform：投影
    RL_E_SHADER_LOC_MATRIX_MODEL,        // 着色器位置：矩阵 uniform：模型（变换）
    RL_E_SHADER_LOC_MATRIX_NORMAL,       // 着色器位置：矩阵 uniform：法线
    RL_E_SHADER_LOC_VECTOR_VIEW,         // 着色器位置：向量 uniform：视图
    RL_E_SHADER_LOC_COLOR_DIFFUSE,       // 着色器位置：向量 uniform：漫反射颜色
    RL_E_SHADER_LOC_COLOR_SPECULAR,      // 着色器位置：向量 uniform：镜面反射颜色
    RL_E_SHADER_LOC_COLOR_AMBIENT,       // 着色器位置：向量 uniform：环境光颜色
    RL_E_SHADER_LOC_MAP_ALBEDO,          // 着色器位置：采样器2D纹理：反照率（与 SHADER_LOC_MAP_DIFFUSE 相同）
    RL_E_SHADER_LOC_MAP_METALNESS,       // 着色器位置：sampler2d 纹理：金属度（与 SHADER_LOC_MAP_SPECULAR 相同）
    RL_E_SHADER_LOC_MAP_NORMAL,          // 着色器位置：sampler2d 纹理：法线
    RL_E_SHADER_LOC_MAP_ROUGHNESS,       // 着色器位置：sampler2d 纹理：粗糙度
    RL_E_SHADER_LOC_MAP_OCCLUSION,       // 着色器位置：sampler2d 纹理：遮蔽
    RL_E_SHADER_LOC_MAP_EMISSION,        // 着色器位置：sampler2d 纹理：发射
    RL_E_SHADER_LOC_MAP_HEIGHT,          // 着色器位置：sampler2d 纹理：高度
    RL_E_SHADER_LOC_MAP_CUBEMAP,         // 着色器位置：samplerCube 纹理：立方体贴图
    RL_E_SHADER_LOC_MAP_IRRADIANCE,      // 着色器位置：samplerCube 纹理：辐照度
    RL_E_SHADER_LOC_MAP_PREFILTER,       // 着色器位置：samplerCube 纹理：预过滤
    RL_E_SHADER_LOC_MAP_BRDF,            // 着色器位置：sampler2d 纹理：brdf
    RL_E_SHADER_LOC_VERTEX_BONEIDS,      // 着色器位置：顶点属性：boneIds
    RL_E_SHADER_LOC_VERTEX_BONEWEIGHTS,  // 着色器位置：顶点属性：boneWeights
    RL_E_SHADER_LOC_BONE_MATRICES,       // 着色器位置：矩阵数组 uniform：boneMatrices
    RL_E_SHADER_LOC_VERTEX_INSTANCE_TX   // 着色器位置：顶点属性：instanceTransform
} RLShaderLocationIndex;

#define SHADER_LOC_MAP_DIFFUSE      RL_E_SHADER_LOC_MAP_ALBEDO
#define SHADER_LOC_MAP_SPECULAR     RL_E_SHADER_LOC_MAP_METALNESS

// 着色器 uniform 数据类型
typedef enum {
    RL_E_SHADER_UNIFORM_FLOAT = 0,       // 着色器 uniform 变量类型：float
    RL_E_SHADER_UNIFORM_VEC2,            // 着色器 uniform 变量类型：vec2（2 个 float 值）
    RL_E_SHADER_UNIFORM_VEC3,            // 着色器 uniform 变量类型：vec3（3 个 float 值）
    RL_E_SHADER_UNIFORM_VEC4,            // 着色器 uniform 变量类型：vec4（4 个 float 值）
    RL_E_SHADER_UNIFORM_INT,             // 着色器 uniform 变量类型：int
    RL_E_SHADER_UNIFORM_IVEC2,           // 着色器 uniform 变量类型：ivec2（2 个 int 值）
    RL_E_SHADER_UNIFORM_IVEC3,           // 着色器 uniform 变量类型：ivec3（3 个 int 值）
    RL_E_SHADER_UNIFORM_IVEC4,           // 着色器 uniform 变量类型：ivec4（4 个 int 值）
    RL_E_SHADER_UNIFORM_UINT,            // 着色器 uniform 变量类型：unsigned int
    RL_E_SHADER_UNIFORM_UIVEC2,          // 着色器 uniform 变量类型：uivec2（2 个 unsigned int 值）
    RL_E_SHADER_UNIFORM_UIVEC3,          // 着色器 uniform 变量类型：uivec3（3 个 unsigned int 值）
    RL_E_SHADER_UNIFORM_UIVEC4,          // 着色器 uniform 变量类型：uivec4（4 个 unsigned int 值）
    RL_E_SHADER_UNIFORM_SAMPLER2D        // 着色器 uniform 变量类型：sampler2d
} RLShaderUniformDataType;

// 着色器属性数据类型
typedef enum {
    RL_E_SHADER_ATTRIB_FLOAT = 0,        // 着色器属性类型：float
    RL_E_SHADER_ATTRIB_VEC2,             // 着色器属性类型：vec2（2 个浮点数）
    RL_E_SHADER_ATTRIB_VEC3,             // 着色器属性类型：vec3（3 个浮点数）
    RL_E_SHADER_ATTRIB_VEC4              // 着色器属性类型：vec4（4 个浮点数）
} RLShaderAttributeDataType;

// 像素格式
// 注意：支持情况取决于 OpenGL 版本和平台
typedef enum {
    RL_E_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 每像素 8 位(无 alpha 通道)
    RL_E_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA,    // 8*2 bpp   (2 通道)
    RL_E_PIXELFORMAT_UNCOMPRESSED_R5G6B5,        // 16 bp     (无 alpha 通道)
    RL_E_PIXELFORMAT_UNCOMPRESSED_R8G8B8,        // 24 bp     (无 alpha 通道)
    RL_E_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1,      // 16 bpp    (1 位 alpha 通道)
    RL_E_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4,      // 16 bpp    (4 位 alpha 通道)
    RL_E_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,      // 32 bp     (8 位 alpha 通道)
    RL_E_PIXELFORMAT_UNCOMPRESSED_R32,           // 32 bpp    (1 通道 - float 类型)
    RL_E_PIXELFORMAT_UNCOMPRESSED_R32G32B32,     // 32*3 bpp  (3 通道 - float 类型)
    RL_E_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32,  // 32*4 bpp  (4 通道 - float 类型)
    RL_E_PIXELFORMAT_UNCOMPRESSED_R16,           // 16 bpp    (1 通道 - 半 float 类型)
    RL_E_PIXELFORMAT_UNCOMPRESSED_R16G16B16,     // 16*3 bpp  (3 通道 - 半 float 类型)
    RL_E_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16,  // 16*4 bpp  (4 通道 - 半 float 类型)
    RL_E_PIXELFORMAT_COMPRESSED_DXT1_RGB,        // 4 bpp     (无 alpha 通道)
    RL_E_PIXELFORMAT_COMPRESSED_DXT1_RGBA,       // 4 bpp     (1 位 alpha 通道)
    RL_E_PIXELFORMAT_COMPRESSED_DXT3_RGBA,       // 8 bpp     (4 位 alpha 通道)
    RL_E_PIXELFORMAT_COMPRESSED_DXT5_RGBA,       // 8 bpp     (8 位 alpha 通道)
    RL_E_PIXELFORMAT_COMPRESSED_ETC1_RGB,        // 4 bpp     (无 alpha 通道)
    RL_E_PIXELFORMAT_COMPRESSED_ETC2_RGB,        // 4 bpp     (无 alpha 通道)
    RL_E_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA,   // 8 bpp     (8 位 alpha 通道)
    RL_E_PIXELFORMAT_COMPRESSED_PVRT_RGB,        // 4 bpp     (无 alpha 通道)
    RL_E_PIXELFORMAT_COMPRESSED_PVRT_RGBA,       // 4 bpp     (无 alpha 通道)
    RL_E_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA,   // 8 bpp     (4x4 纹理块)
    RL_E_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA    // 2 bpp     (8x8 纹理块)
} RLPixelFormat;

// 纹理参数：过滤模式
// 注 1：过滤时会考虑纹理中的 mipmap（如果存在）
// 注 2：过滤模式会根据缩小和放大进行相应设置
typedef enum {
    RL_E_TEXTURE_FILTER_POINT = 0,               // 无滤镜，仅像素近似
    RL_E_TEXTURE_FILTER_BILINEAR,                // 线性滤波
    RL_E_TEXTURE_FILTER_TRILINEAR,               // 三线性滤波（带 mipmap 的线性滤波）
    RL_E_TEXTURE_FILTER_ANISOTROPIC_4X,          // 4 倍各向异性滤波
    RL_E_TEXTURE_FILTER_ANISOTROPIC_8X,          // 8 倍各向异性滤波
    RL_E_TEXTURE_FILTER_ANISOTROPIC_16X,         // 16 倍各向异性滤波
} RLTextureFilter;

// 纹理参数：环绕模式
typedef enum {
    RL_E_TEXTURE_WRAP_REPEAT = 0,                // 以平铺模式重复纹理
    RL_E_TEXTURE_WRAP_CLAMP,                     // 以平铺模式将纹理限制在边缘像素
    RL_E_TEXTURE_WRAP_MIRROR_REPEAT,             // 以平铺模式镜像并重复纹理
    RL_E_TEXTURE_WRAP_MIRROR_CLAMP               // 以平铺模式镜像并限制在纹理边缘
} RLTextureWrap;

// 立方体贴图布局
typedef enum {
    RL_E_CUBEMAP_LAYOUT_AUTO_DETECT = 0,        // 自动检测布局类型
    RL_E_CUBEMAP_LAYOUT_LINE_VERTICAL,          // 布局由带面的垂直线定义
    RL_E_CUBEMAP_LAYOUT_LINE_HORIZONTAL,        // 布局由带面的水平线定义
    RL_E_CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR,    // 布局由带立方体贴图面的 3x4 十字定义
    RL_E_CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE     // 布局由带立方体贴图面的 4x3 十字定义
} RLCubemapLayout;

// 字体类型，定义生成方法
typedef enum {
    RL_E_FONT_DEFAULT = 0,               // 默认字体生成，已启用抗锯齿
    RL_E_FONT_BITMAP,                    // 位图字体生成，未启用抗锯齿
    RL_E_FONT_SDF                        // SDF 字体生成，需要外部着色器
} RLFontType;

// 颜色混合模式（预定义）
typedef enum {
    RL_E_BLEND_ALPHA = 0,                // 混合纹理时考虑透明度（默认）
    RL_E_BLEND_ADDITIVE,                 // 混合纹理时添加颜色
    RL_E_BLEND_MULTIPLIED,               // 混合纹理时颜色相乘
    RL_E_BLEND_ADD_COLORS,               // 混合纹理时添加颜色（备选）
    RL_E_BLEND_SUBTRACT_COLORS,          // 混合纹理时颜色相减（备选）
    RL_E_BLEND_ALPHA_PREMULTIPLY,        // 混合预乘纹理时考虑透明度
    RL_E_BLEND_CUSTOM,                   // 使用自定义源/目标因子混合纹理（使用 rlSetBlendFactors()）
    RL_E_BLEND_CUSTOM_SEPARATE           // 使用自定义 RGB/透明度分离的源/目标因子混合纹理（使用 rlSetBlendFactorsSeparate()）
} RLBlendMode;

// 手势
// 注意：以位标志的形式提供，以便仅启用所需的手势。
typedef enum {
    RL_E_GESTURE_NONE        = 0,        // 无手势
    RL_E_GESTURE_TAP         = 1,        // 单击手势
    RL_E_GESTURE_DOUBLETAP   = 2,        // 双击手势
    RL_E_GESTURE_HOLD        = 4,        // 按住手势
    RL_E_GESTURE_DRAG        = 8,        // 拖动手势
    RL_E_GESTURE_SWIPE_RIGHT = 16,       // 向右滑动手势
    RL_E_GESTURE_SWIPE_LEFT  = 32,       // 向左滑动手势
    RL_E_GESTURE_SWIPE_UP    = 64,       // 向上滑动手势
    RL_E_GESTURE_SWIPE_DOWN  = 128,      // 向下滑动手势
    RL_E_GESTURE_PINCH_IN    = 256,      // 双指捏合手势
    RL_E_GESTURE_PINCH_OUT   = 512       // 双指张开手势
} RLGesture;

// 相机系统模式
typedef enum {
    RL_E_CAMERA_CUSTOM = 0,              // 自定义相机，由用户控制（UpdateCamera() 函数不执行任何操作）
    RL_E_CAMERA_FREE,                    // 相机自由模式
    RL_E_CAMERA_ORBITAL,                 // 相机环绕目标，支持缩放
    RL_E_CAMERA_FIRST_PERSON,            // 第一人称视角
    RL_E_CAMERA_THIRD_PERSON             // 第三人称视角
} RLCameraMode;

// 摄像机投影
typedef enum {
    RL_E_CAMERA_PERSPECTIVE = 0,         // 透视投影
    RL_E_CAMERA_ORTHOGRAPHIC             // 正射投影
} RLCameraProjection;

// N-patch布局
typedef enum {
    RL_E_NPATCH_NINE_PATCH = 0,          // Npatch 布局：3x3 方格
    RL_E_NPATCH_THREE_PATCH_VERTICAL,    // Npatch 布局：1x3 方格
    RL_E_NPATCH_THREE_PATCH_HORIZONTAL   // Npatch 布局：3x1 方格
} RLNPatchLayout;

// 用于挂钩某些内部函数的回调函数
// 警告：这些回调函数仅供高级用户使用
typedef void (*RLTraceLogCallback)(int logLevel, const char *text, va_list args);           // 日志记录：重定向跟踪日志消息
typedef unsigned char *(*RLLoadFileDataCallback)(const char *fileName, int *dataSize);      // 文件 I/O：加载二进制数据
typedef bool (*RLSaveFileDataCallback)(const char *fileName, void *data, int dataSize);     // 文件 I/O：保存二进制数据
typedef char *(*RLLoadFileTextCallback)(const char *fileName);                              // 文件 I/O：加载文本数据
typedef bool (*RLSaveFileTextCallback)(const char *fileName, const char *text);             // 文件 I/O：保存文本数据


// 窗口刷新回调
// 注意：当启用 FLAG_WINDOW_REFRESH_CALLBACK 时（Win32/GLFW），可以在操作系统处于模态循环（例如交互式移动/调整大小或菜单跟踪）时调用此回调，
// 以便应用程序无需使用单独的事件线程即可重绘。
// 回调在调用线程上有效的 OpenGL 上下文中执行。
typedef void (*RLWindowRefreshCallback)(void);

//------------------------------------------------------------------------------------
// 全局变量定义
//------------------------------------------------------------------------------------
// 这里好寂寞……
//------------------------------------------------------------------------------------
// 窗口和图形设备函数（模块：core）
//------------------------------------------------------------------------------------
// 上下文管理（Route2）：不透明上下文句柄。
// 默认情况下，首次使用时会为每个线程创建一个默认上下文。
typedef struct RLContext RLContext;


// 上下文/窗口之间的 GPU 资源共享（桌面 OpenGL 后端）。
// 注意：资源共享使用平台 OpenGL 上下文共享（GLFW 共享参数）实现。
// 启用后，在一个上下文中创建的 OpenGL 对象（纹理、缓冲区、着色器等）将
// 对同一共享组中的其他上下文可见。
//// 重要提示：
// - 共享取决于后端；目前仅支持桌面 (GLFW) OpenGL。
// - 必须在调用该上下文的 RLInitWindow/RLInitWindowEx 之前配置共享。
// - RL_CONTEXT_SHARE_WITH_PRIMARY 和 RL_CONTEXT_SHARE_WITH_CONTEXT 要求对等窗口/上下文
// 在创建新窗口时已有一个活动窗口；失败是显式的，并且
// 不会回退到 RL_CONTEXT_SHARE_NONE。
// - GPU 对象的生命周期是共享组范围的，并且采用引用计数：在任何上下文中卸载都会递减共享组的引用计数；当引用计数达到 0 时，删除操作将被延迟，直到在具有当前 OpenGL 上下文的线程上耗尽资源（通过 RLDeletePendingSharedGpuResources() 显式调用，以及在 RLCloseWindow() 期间）。
// - 当选择 RL_CONTEXT_SHARE_NONE 时，内部共享组也用于延迟删除的生命周期管理。
// 但这本身并不意味着被跟踪的对象位于共享命名空间中。
// - 对于 RL_CONTEXT_SHARE_NONE，被跟踪对象的作用域最初是上下文局部的，只有当上下文实际加入共享资源命名空间时，才会提升为共享组作用域。
// - 如果上下文在不同的线程上渲染，则需要您负责同步（glFlush/glFinish/fences）。

typedef enum RLContextResourceShareMode {
    RL_CONTEXT_SHARE_NONE = 0,             // 不共享 GPU 对象（默认）。
    RL_CONTEXT_SHARE_WITH_PRIMARY = 1,     // 与进程的主窗口/上下文共享（首次创建并已初始化）。
    RL_CONTEXT_SHARE_WITH_CONTEXT = 2      // 与已初始化窗口的显式 RLContext 共享。
} RLContextResourceShareMode;

typedef enum RLContextResourceShareValidationError {
    RL_CONTEXT_SHARE_VALIDATION_OK = 0,
    RL_CONTEXT_SHARE_VALIDATION_CTX_NULL = 1,
    RL_CONTEXT_SHARE_VALIDATION_INVALID_MODE = 2,
    RL_CONTEXT_SHARE_VALIDATION_TARGET_NULL = 3,
    RL_CONTEXT_SHARE_VALIDATION_TARGET_SELF = 4,
    RL_CONTEXT_SHARE_VALIDATION_TARGET_WINDOW_UNAVAILABLE = 5,
    RL_CONTEXT_SHARE_VALIDATION_PRIMARY_WINDOW_UNAVAILABLE = 6
} RLContextResourceShareValidationError;

#if defined(__cplusplus)
extern "C" {            // 防止函数名称混淆
#endif

// 与上下文相关的函数
RLAPI RLContext *RLCreateContext(void);
RLAPI void RLDestroyContext(RLContext *ctx);
RLAPI void RLSetCurrentContext(RLContext *ctx);
RLAPI RLContext *RLGetCurrentContext(void);

// 配置为当前上下文创建的下一个窗口如何共享 GPU 资源。
// 显式共享模式要求在 RLInitWindow/RLInitWindowEx 运行时目标/主窗口已存在。
RLAPI bool RLContextSetResourceShareMode(RLContext* ctx, RLContextResourceShareMode mode, RLContext* shareWith);
RLAPI RLContextResourceShareMode RLContextGetResourceShareMode(RLContext* ctx);
RLAPI RLContext* RLContextGetResourceShareContext(RLContext* ctx);
RLAPI bool RLContextValidateResourceShareConfig(RLContext* ctx);    // 验证共享配置并记录最新验证状态
RLAPI bool RLContextIsResourceShareConfigValid(RLContext* ctx);     // 查询最新共享配置验证状态
RLAPI int RLContextGetResourceShareValidationError(RLContext* ctx); // 查询最新共享验证错误代码 (RLContextResourceShareValidationError)

// 共享组范围内的 GPU 生命周期辅助函数（引用计数、延迟删除）。
// 注意：调用这些函数时，目标共享组的上下文必须处于当前状态。
// 对于纹理/渲染纹理 CPU 对象，请使用下面的 RLRetain/Release*Object API。
RLAPI bool RLSharedRetainShader(RLShader shader);
RLAPI bool RLSharedReleaseShader(RLShader shader);

// 用于底层共享对象的对象 ID 辅助函数。
// 这些辅助函数一次只能操作一个对象 ID。
// 默认的帧缓冲区辅助函数还会处理当前绑定到该帧缓冲区的跟踪对象。
// 如果您只想保留或释放帧缓冲区对象本身，请使用基础辅助函数。
RLAPI bool RLSharedRetainBuffer(unsigned int bufferId);
RLAPI bool RLSharedReleaseBuffer(unsigned int bufferId);
RLAPI bool RLSharedRetainVertexArray(unsigned int vertexArrayId);
RLAPI bool RLSharedReleaseVertexArray(unsigned int vertexArrayId);
// 默认帧缓冲区保留/释放进程跟踪绑定到此帧缓冲区的对象。
RLAPI bool RLSharedRetainFramebuffer(unsigned int framebufferId);
RLAPI bool RLSharedReleaseFramebuffer(unsigned int framebufferId);
// 基本帧缓冲区保留/释放仅处理帧缓冲区对象本身。
RLAPI bool RLSharedRetainFramebufferBase(unsigned int framebufferId);
RLAPI bool RLSharedReleaseFramebufferBase(unsigned int framebufferId);
RLAPI bool RLSharedRetainRenderbuffer(unsigned int renderbufferId);
RLAPI bool RLSharedReleaseRenderbuffer(unsigned int renderbufferId);
RLAPI bool RLDeletePendingSharedGpuResources(void);

// 共享着色器并发使用范围策略。
// 当一个着色器程序被多个上下文/线程使用时，请使用这些 API。
typedef enum RLSharedShaderUsePolicy {
    RL_SHARED_SHADER_USE_PHASED = 1,   // 合理序列化使用（票务顺序）
    RL_SHARED_SHADER_USE_LOCKED = 2    // 互斥序列化使用
} RLSharedShaderUsePolicy;

// 进入/离开给定着色器程序的序列化共享着色器作用域。
// 在调用 RLBeginShaderMode() 之前调用 RLBeginSharedShaderUse()，然后按此顺序调用
// RLEndShaderMode() 和 RLSharedShaderUseEnd()。
RLAPI bool RLBeginSharedShaderUse(RLShader shader, int policy);
RLAPI void RLSharedShaderUseEnd(RLShader shader, int policy);
// 配置一次共享着色器栅栏等待策略（通常在 RLInitWindow() 之后、首次使用共享着色器之前）。
// waitSliceUs：轮询切片的时间间隔（以微秒为单位），waitTimeoutUs：总超时时间（以微秒为单位）。
RLAPI bool RLConfigureSharedShaderFenceWait(unsigned int waitSliceUs, unsigned int waitTimeoutUs);

typedef enum RLSharedObjectType {
    RL_SHARED_OBJECT_TEXTURE = 1,
    RL_SHARED_OBJECT_BUFFER = 2,
    RL_SHARED_OBJECT_VERTEX_ARRAY = 3,
    RL_SHARED_OBJECT_FRAMEBUFFER = 4,
    RL_SHARED_OBJECT_RENDERBUFFER = 5,
    RL_SHARED_OBJECT_PROGRAM = 6
} RLSharedObjectType;

typedef enum RLSharedGpuTrackingMode {
    RL_SHARED_GPU_TRACKING_COMPATIBLE = 0, // 未注册的 retain/release 操作遵循兼容性回退机制。
    RL_SHARED_GPU_TRACKING_STRICT = 1      // 未注册的 retain/release 操作将被拒绝并上报。
} RLSharedGpuTrackingMode;

typedef struct RLSharedGpuGroupDiagStats {
    int hasShareGroup;                                  // 当当前上下文绑定了共享组时为 1，否则为 0
    int usesSharedTrackedScope;                         // 当跟踪对象的作用域提升为共享组的作用域时为 1
    unsigned int contextRefCount;                       // 当前附加到共享组的上下文数量
    unsigned long long liveObjectCount;                 // 当前跟踪的活跃共享 GPU 对象数量
    unsigned long long pendingDeleteCount;              // 等待释放的延迟删除操作数量
    unsigned long long ownerEntryCount;                 // 已记录的共享对象所有者条目数量
    unsigned long long orphanedOwnerCount;              // 等待被采用或最终释放的孤立所有者条目数量
    unsigned long long framebufferAttachmentMapCount;   // 帧缓冲区附件映射条目数量
    unsigned long long framebufferDepthMapCount;        // 旧版帧缓冲区深度映射条目数量
    unsigned long long programLocEntryCount;            // 程序辅助位置条目数量
    unsigned long long programUseScopeCount;            // 共享着色器使用范围条目数量
    unsigned long long pendingProgramFenceCount;        // 等待释放的已排队程序屏障数量
    unsigned long long textureTraceCount;               // 纹理跟踪元数据条目数量
    unsigned long long liveTextureCount;
    unsigned long long liveBufferCount;
    unsigned long long liveVertexArrayCount;
    unsigned long long liveFramebufferCount;
    unsigned long long liveRenderbufferCount;
    unsigned long long liveProgramCount;
    unsigned long long pendingTextureCount;
    unsigned long long pendingBufferCount;
    unsigned long long pendingVertexArrayCount;
    unsigned long long pendingFramebufferCount;
    unsigned long long pendingRenderbufferCount;
    unsigned long long pendingProgramCount;
    unsigned long long releaseUntrackedCount;           // 观察到的未跟踪对象的释放调用数量
    unsigned long long framebufferMapHitCount;          // 帧缓冲区树保留/释放映射命中次数
    unsigned long long framebufferMapMissCount;         // 帧缓冲区树保留/释放映射未命中次数
    unsigned long long framebufferReleaseSkippedCount;  // 由于附件缺失而跳过的已映射附件释放次数
} RLSharedGpuGroupDiagStats;

typedef struct RLSharedGpuTrackingRejectDiagStats {
    unsigned long long unregisteredRetainRejectCount;  // 对未注册对象执行严格模式保留操作的拒绝次数
    unsigned long long unregisteredReleaseRejectCount; // 对未注册对象执行严格模式释放操作的拒绝次数
} RLSharedGpuTrackingRejectDiagStats;

// 查询并转移同一共享组内对象的写入所有权。
// 转移要求当前上下文为当前所有者（或所有者未设置），且目标上下文位于同一共享组中。
// 对于同时被高级对象元数据跟踪的对象类型（例如纹理/渲染纹理），
// RLTryTransferSharedObjectOwner 会同时更新共享所有者元数据和被跟踪所有者元数据。
// 如果共享组是从上下文本地跟踪升级而来，则预先存在的被跟踪对象将被迁移到共享组。
// 在后续的转移/采用操作之前，请观察共享组命名空间。
RLAPI RLContext* RLGetSharedObjectOwnerContext(RLSharedObjectType type, unsigned int objectId);
RLAPI bool RLIsSharedObjectOwnedByCurrentContext(RLSharedObjectType type, unsigned int objectId);
RLAPI bool RLTryTransferSharedObjectOwner(RLSharedObjectType type, unsigned int objectId, RLContext* targetCtx);
// 为共享对象采用孤立所有者元数据。
// 仅当对象所有者在上下文销毁期间被显式标记为孤立时，此操作才会成功。
RLAPI bool RLTryAdoptOrphanedSharedObject(RLSharedObjectType type, unsigned int objectId, RLContext* targetCtx);
// 共享对象所有权 API 的通用别名（与 RLGet/Is/TryTransferSharedObjectOwner 具有相同的语义）。
RLAPI RLContext* RLGetObjectOwnerContext(RLSharedObjectType type, unsigned int objectId);
RLAPI bool RLIsObjectOwnedByCurrentContext(RLSharedObjectType type, unsigned int objectId);
RLAPI bool RLTryTransferObjectOwner(RLSharedObjectType type, unsigned int objectId, RLContext* targetCtx);
RLAPI bool RLTryAdoptOrphanedObject(RLSharedObjectType type, unsigned int objectId, RLContext* targetCtx);
// 运行时共享跟踪策略切换。
// 默认模式为 RL_SHARED_GPU_TRACKING_STRICT。
RLAPI void RLSetSharedGpuTrackingMode(int mode);
RLAPI int RLGetSharedGpuTrackingMode(void);
RLAPI void RLEnableSharedGpuCumulativeDiagStats(void);                                  // 运行时启用共享 GPU 累积诊断计数（仅当构建时 RL_SHARED_GPU_DIAG_STATS=1 时有效）
RLAPI void RLDisableSharedGpuCumulativeDiagStats(void);                                 // 运行时禁用共享 GPU 累积诊断计数
RLAPI bool RLIsSharedGpuCumulativeDiagStatsEnabled(void);                               // 检查共享 GPU 累积诊断运行时开关
RLAPI void RLResetCurrentSharedGpuGroupDiagStats(void);                                 // 重置当前上下文共享组的共享 GPU 累积诊断
RLAPI bool RLResetSharedGpuGroupDiagStatsForContext(RLContext *ctx);                    // 重置指定上下文共享组的共享 GPU 累积诊断
RLAPI RLSharedGpuGroupDiagStats RLGetCurrentSharedGpuGroupDiagStats(void);              // 获取当前上下文的共享组诊断快照
RLAPI RLSharedGpuGroupDiagStats RLGetSharedGpuGroupDiagStatsForContext(RLContext *ctx); // 获取指定上下文的共享组诊断快照
RLAPI RLSharedGpuTrackingRejectDiagStats RLGetSharedGpuTrackingRejectDiagStats(void);   // 获取进程范围的严格模式拒绝计数器
RLAPI void RLResetSharedGpuTrackingRejectDiagStats(void);                               // 重置进程范围的严格模式拒绝计数器
RLAPI void RLDebugDumpSharedGpuState(const char *label);                                // 将共享组诊断快照转储到日志

// 窗口相关函数
RLAPI void RLInitWindow(int width, int height, const char *title);                                      // 初始化窗口和 OpenGL 上下文
RLAPI void RLInitWindowEx(int width, int height, const char *title, const char *win32ClassName);        // 使用可选的 Win32 类名初始化窗口（Windows 系统下为桌面 + GLFW）
RLAPI void RLCloseWindow(void);                                                                         // 关闭窗口并卸载 OpenGL 上下文
RLAPI bool RLWindowShouldClose(void);                                                                   // 检查应用程序是否应该关闭（按下 KEY_ESCAPE 键或点击窗口关闭图标）
RLAPI bool RLIsWindowReady(void);                                                                       // 检查窗口是否已成功初始化
RLAPI bool RLIsWindowFullscreen(void);                                                                  // 检查窗口当前是否为全屏模式
RLAPI bool RLIsWindowHidden(void);                                                                      // 检查窗口当前是否为隐藏模式
RLAPI bool RLIsWindowMinimized(void);                                                                   // 检查窗口当前是否为最小化模式
RLAPI bool RLIsWindowMaximized(void);                                                                   // 检查窗口当前是否为最大化模式
RLAPI bool RLIsWindowFocused(void);                                                                     // 检查窗口当前是否处于焦点状态
RLAPI bool RLIsWindowResized(void);                                                                     // 检查窗口是否在上一帧调整过大小
RLAPI bool RLIsWindowState(unsigned int flag);                                                          // 检查是否启用了某个特定的窗口标志
RLAPI unsigned int RLGetWindowState(void);                                                              // 获取当前窗口配置状态标志
RLAPI void RLSetWindowState(unsigned int flags);                                                        // 使用标志设置窗口配置状态
RLAPI void RLClearWindowState(unsigned int flags);                                                      // 清除窗口配置状态标志
RLAPI void RLToggleFullscreen(void);                                                                    // 切换窗口状态：全屏/窗口模式，调整显示器大小以匹配窗口分辨率
RLAPI void RLToggleBorderlessWindowed(void);                                                            // 切换窗口状态：无边框窗口模式，调整窗口大小以匹配显示器分辨率
RLAPI void RLMaximizeWindow(void);                                                                      // 设置窗口状态：最大化（如果窗口可调整大小）
RLAPI void RLMinimizeWindow(void);                                                                      // 设置窗口状态：最小化（如果窗口可调整大小）可调整大小
RLAPI void RLRestoreWindow(void);                                                                       // 恢复窗口的最小化/最大化状态
RLAPI void RLSetWindowIcon(RLImage image);                                                              // 设置窗口图标（单张图片，RGBA 32位）
RLAPI bool RLTrySetWindowIcons(RLImage *images, int count);                                             // 尝试设置窗口图标（多张图片，RGBA 32位），返回成功/失败
RLAPI void RLSetWindowIcons(RLImage *images, int count);                                                // 设置窗口图标（多张图片，RGBA 32位）
RLAPI void RLSetWindowTitle(const char *title);                                                         // 设置窗口标题
RLAPI void RLSetWindowPosition(int x, int y);                                                           // 设置窗口在屏幕上的位置
RLAPI void RLSetWindowMonitor(int monitor);                                                             // 设置当前窗口的显示器
RLAPI void RLSetWindowMinSize(int width, int height);                                                   // 设置窗口最小尺寸（对于 FLAG_WINDOW_RESIZABLE）
RLAPI void RLSetWindowMaxSize(int width, int height);                                                   // 设置窗口最大尺寸（对于 FLAG_WINDOW_RESIZABLE）
RLAPI void RLSetWindowSize(int width, int height);                                                      // 设置窗口尺寸
RLAPI void RLSetWindowOpacity(float opacity);                                                           // 设置窗口不透明度 [0.0f..1.0f]
RLAPI void RLSetWindowFocused(void);                                                                    // 设置窗口焦点
RLAPI void *RLGetWindowHandle(void);                                                                    // 获取窗口本地句柄

#if defined(_WIN32)
// Win32 辅助函数（属性包 + 消息钩子）
// 注意：仅在 Windows 上使用 GLFW 桌面后端时可用。
// 属性值通过底层 HWND 的 SetProp/GetProp/RemoveProp 方法存储。
/// 返回非零值以标记消息已处理。如果已处理，窗口过程将返回 *result。
typedef int (*RLWin32MessageHook)(void* hwnd, unsigned int uMsg, uintptr_t wParam, intptr_t lParam, intptr_t* result, void* user);

RLAPI int RLWin32SetWindowProp(const char* name, void* value);
RLAPI void* RLWin32GetWindowProp(const char* name);
RLAPI void* RLWin32RemoveWindowProp(const char* name);

// 返回一个不透明的令牌，该令牌将传递给 RLWin32RemoveMessageHook。
RLAPI void* RLWin32AddMessageHook(RLWin32MessageHook hook, void* user);
RLAPI int RLWin32RemoveMessageHook(void* token);

// 全局窗口管理（进程级）
// 如果 outHwnds 为 NULL 或 maxCount <= 0，则返回当前跟踪的 raylib 窗口的数量。
RLAPI int RLWin32GetAllWindowHandles(void** outHwnds, int maxCount);
RLAPI void* RLWin32GetPrimaryWindowHandle(void);
RLAPI int RLWin32IsKnownWindowHandle(void* hwnd);

// 跨线程辅助函数（通过 HWND 对特定的 raylib 窗口进行操作）
RLAPI int RLWin32SetWindowPropByHandle(void* hwnd, const char* name, void* value);
RLAPI void* RLWin32GetWindowPropByHandle(void* hwnd, const char* name);
RLAPI void* RLWin32RemoveWindowPropByHandle(void* hwnd, const char* name);

RLAPI void* RLWin32AddMessageHookByHandle(void* hwnd, RLWin32MessageHook hook, void* user);
RLAPI int RLWin32RemoveMessageHookByHandle(void* hwnd, void* token);
// 通用跨线程调度原语（高级）
// 注意：窗口线程调用在拥有 HWND 的 Win32 线程上运行（对 Win32 UI 操作安全）。
#ifndef RL_WIN32_WINDOW_THREAD_INVOKE_DEFINED
#define RL_WIN32_WINDOW_THREAD_INVOKE_DEFINED
typedef intptr_t (*RLWin32WindowThreadInvoke)(void* hwnd, void* user);
#endif
RLAPI intptr_t RLWin32InvokeOnWindowThreadByHandle(void* hwnd, RLWin32WindowThreadInvoke fn, void* user, int wait);
// 扩展的窗口线程调用 API，具有显式的有效负载所有权。
// 如果 userDtor 非空，则 dispatch 在 API 入口处取得用户所有权：
// - dispatch 拒绝/提交失败：在返回之前调用 userDtor，
// - 已分发的回调执行：所有权转移到回调实现。
RLAPI intptr_t RLWin32InvokeOnWindowThreadByHandleEx(void* hwnd, RLWin32WindowThreadInvoke fn, void* user, int wait, void (*userDtor)(void*));

// 注意：渲染线程调用是一种原始的线程亲和性原语。
// 它在目标窗口的渲染线程上运行，但不保证帧边界时间。
// 在非事件线程模式下，此方法仅在从拥有目标 OpenGL 上下文的同一线程调用时才有效。
#ifndef RL_WINDOW_RENDER_THREAD_INVOKE_DEFINED
#define RL_WINDOW_RENDER_THREAD_INVOKE_DEFINED
typedef intptr_t (*RLWindowRenderThreadInvoke)(void* hwnd, void* user);
#endif
RLAPI intptr_t RLInvokeOnWindowRenderThreadByHandle(void* hwnd, RLWindowRenderThreadInvoke fn, void* user, int wait);
// 扩展了渲染线程调用 API，并明确指定了有效负载的所有权。
// 如果 userDtor 非空，则 dispatch 在 API 入口处取得用户的所有权：
// - dispatch 拒绝/提交失败：在返回之前调用 userDtor，
// - 队列中的调用在执行前因关闭/停止而被拒绝：调用 userDtor，
// - 调用的回调已执行：所有权转移到回调实现。
RLAPI intptr_t RLInvokeOnWindowRenderThreadByHandleEx(void* hwnd, RLWindowRenderThreadInvoke fn, void* user, int wait, void (*userDtor)(void*));

// 帧回调队列优先级。
// - 正常：有界回调队列，具有有限的反压；在持续压力下，入队操作可能因超时而失败。
// - 严重：用于生命周期/清理操作的有界回调队列，具有更长的有限反压。
typedef enum RLFrameCallbackKind {
    RL_FRAME_CALLBACK_KIND_NORMAL = 0,
    RL_FRAME_CALLBACK_KIND_CRITICAL = 1
} RLFrameCallbackKind;

// 注意：帧回调函数在绘制过程中是帧安全的。
// 回调函数在目标窗口渲染线程中执行，执行时间为 RLEndDrawing() 函数内部的固定时间点，在最终批处理刷新/交换之前。
// 成功入队时返回 1，无效参数、关闭/停止状态、不支持的模式、分配失败或队列等待超时时返回 0。
RLAPI int RLPostWindowFrameCallbackByHandle(void* hwnd, RLWindowRenderThreadInvoke fn, void* user);
// 扩展了带有回调类型的帧回调 API。
RLAPI int RLPostWindowFrameCallbackByHandleEx(void* hwnd, RLWindowRenderThreadInvoke fn, void* user, RLFrameCallbackKind kind);
// 扩展的帧回调 API，具有显式的有效负载所有权。
// 如果 userDtor 非 NULL，则队列在 API 入口处取得用户的所有权：
// - 入队失败/队列已满：在返回之前调用 userDtor，
// - 队列中的回调在执行之前被驱逐/清空：调用 userDtor，
// - 回调执行：所有权转移到回调实现。
RLAPI int RLPostWindowFrameCallbackByHandleEx2(void* hwnd, RLWindowRenderThreadInvoke fn, void* user, RLFrameCallbackKind kind, void (*userDtor)(void*));

// 刷新目标窗口渲染线程上待处理的共享 GPU 延迟删除操作。
// wait：非零值表示等待完成；0 表示立即执行并返回。
RLAPI int RLDeletePendingSharedGpuResourcesByHandle(void* hwnd, int wait);

#endif

RLAPI void RLSetWindowWin32ClassName(const char *win32ClassName);   // 设置下次创建窗口的一次性 Win32 类名（Windows 系统下桌面+GLFW）

RLAPI int RLGetScreenWidth(void);                                   // 获取当前屏幕宽度
RLAPI int RLGetScreenHeight(void);                                  // 获取当前屏幕高度
RLAPI int RLGetRenderWidth(void);                                   // 获取当前渲染宽度（考虑 HiDPI）
RLAPI int RLGetRenderHeight(void);                                  // 获取当前渲染高度（考虑 HiDPI）
RLAPI int RLGetMonitorCount(void);                                  // 获取已连接的显示器数量
RLAPI int RLGetCurrentMonitor(void);                                // 获取窗口所在的当前显示器
RLAPI RLVector2 RLGetMonitorPosition(int monitor);                  // 获取指定显示器的位置
RLAPI int RLGetMonitorWidth(int monitor);                           // 获取指定显示器的宽度（显示器当前使用的视频模式）
RLAPI int RLGetMonitorHeight(int monitor);                          // 获取指定显示器的高度（显示器当前使用的视频模式）
RLAPI int RLGetMonitorPhysicalWidth(int monitor);                   // 获取指定显示器的物理宽度（毫米）
RLAPI int RLGetMonitorPhysicalHeight(int monitor);                  // 获取指定显示器的物理高度（毫米）
RLAPI int RLGetMonitorRefreshRate(int monitor);                     // 获取指定显示器的刷新率
RLAPI RLVector2 RLGetWindowPosition(void);                          // 获取窗口在显示器上的 XY 坐标
RLAPI RLVector2 RLGetWindowScaleDPI(void);                          // 获取窗口缩放的 DPI 因子
RLAPI const char *RLGetMonitorName(int monitor);                    // 获取指定显示器的人类可读的 UTF-8 编码名称
RLAPI void RLSetClipboardText(const char *text);                    // 设置剪贴板文本内容
RLAPI const char *RLGetClipboardText(void);                         // 获取剪贴板文本内容
RLAPI RLImage RLGetClipboardImage(void);                            // 获取剪贴板图像内容
RLAPI void RLEnableEventWaiting(void);                              // 启用等待 EndDrawing() 事件，不自动轮询事件
RLAPI void RLDisableEventWaiting(void);                             // 禁用等待 EndDrawing() 事件EndDrawing()，自动事件轮询

// 光标相关函数
RLAPI void RLShowCursor(void);                                      // 显示光标
RLAPI void RLHideCursor(void);                                      // 隐藏光标
RLAPI bool RLIsCursorHidden(void);                                  // 检查光标是否不可见
RLAPI void RLEnableCursor(void);                                    // 启用光标（解锁光标）
RLAPI void RLDisableCursor(void);                                   // 禁用光标（锁定光标）
RLAPI bool RLIsCursorOnScreen(void);                                // 检查光标是否在屏幕上

// 与绘图相关的功能
RLAPI void RLClearBackground(RLColor color);                        // 设置背景颜色（清除帧缓冲区颜色）
RLAPI void RLBeginDrawing(void);                                    // 设置画布（帧缓冲区）以开始绘制
RLAPI void RLEndDrawing(void);                                      // 结束画布绘制并交换缓冲区（双缓冲）
RLAPI void RLBeginMode2D(RLCamera2D camera);                        // 使用自定义摄像机开始 2D 模式 (2D)
RLAPI void RLEndMode2D(void);                                       // 使用自定义摄像机结束 2D 模式
RLAPI void RLBeginMode3D(RLCamera3D camera);                        // 使用自定义摄像机开始 3D 模式 (3D)
RLAPI void RLEndMode3D(void);                                       // 结束 3D 模式并返回默认的 2D 正交模式
RLAPI void RLBeginTextureMode(RLRenderTexture2D target);            // 开始绘制以渲染纹理
RLAPI void RLEndTextureMode(void);                                  // 结束绘制以渲染纹理
RLAPI void RLBeginShaderMode(RLShader shader);                      // 开始自定义着色器绘制
RLAPI void RLEndShaderMode(void);                                   // 结束自定义着色器绘制（使用默认着色器）
RLAPI void RLBeginBlendMode(int mode);                              // 开始混合模式（alpha、加法、乘法、减法、自定义）
RLAPI void RLEndBlendMode(void);                                    // 结束混合模式（重置为默认值：alpha）混合）
RLAPI void RLBeginScissorMode(int x, int y, int width, int height); // 开始剪切模式（定义后续绘制的屏幕区域）
RLAPI void RLEndScissorMode(void);                                  // 结束剪切模式
RLAPI void RLBeginVrStereoMode(RLVrStereoConfig config);            // 开始立体渲染（需要 VR 模拟器）
RLAPI void RLEndVrStereoMode(void);                                 // 结束立体渲染（需要 VR 模拟器）

// VR模拟器的VR立体配置函数
RLAPI RLVrStereoConfig RLLoadVrStereoConfig(RLVrDeviceInfo device); // 加载 VR 模拟器设备参数的 VR 立体配置
RLAPI void RLUnloadVrStereoConfig(RLVrStereoConfig config);         // 卸载 VR 立体配置

// 着色器管理功能
// 注意：OpenGL 1.1 不支持着色器功能
RLAPI RLShader RLLoadShader(const char *vsFileName, const char *fsFileName);                                    // 从文件加载着色器并绑定默认位置
RLAPI RLShader RLLoadShaderFromMemory(const char *vsCode, const char *fsCode);                                  // 从代码字符串加载着色器并绑定默认位置
RLAPI bool RLIsShaderValid(RLShader shader);                                                                    // 检查着色器是否有效（已加载到 GPU）
RLAPI int RLGetShaderLocation(RLShader shader, const char *uniformName);                                        // 获取着色器 uniform 变量的位置
RLAPI int RLGetShaderLocationAttrib(RLShader shader, const char *attribName);                                   // 获取着色器属性的位置
RLAPI void RLSetShaderValue(RLShader shader, int locIndex, const void *value, int uniformType);                 // 设置着色器 uniform 变量的值
RLAPI void RLSetShaderValueV(RLShader shader, int locIndex, const void *value, int uniformType, int count);     // 设置着色器 uniform 变量的值向量
RLAPI void RLSetShaderValueMatrix(RLShader shader, int locIndex, RLMatrix mat);                                 // 设置着色器 uniform 变量的值（4x4 矩阵）
RLAPI void RLSetShaderValueTexture(RLShader shader, int locIndex, RLTexture2D texture);                         // 设置着色器 uniform 变量的值并绑定纹理（sampler2d）
RLAPI void RLUnloadShader(RLShader shader);                                                                     // 从 GPU 内存 (VRAM) 中卸载着色器

// 屏幕空间相关函数
#define GetMouseRay RLGetScreenToWorldRay                                                           // 兼容旧版 raylib 的 hack
RLAPI RLRay RLGetScreenToWorldRay(RLVector2 position, RLCamera camera);                             // 从屏幕位置（例如鼠标位置）获取光线追踪
RLAPI RLRay RLGetScreenToWorldRayEx(RLVector2 position, RLCamera camera, int width, int height);    // 从视口中的屏幕位置（例如鼠标位置）获取光线追踪
RLAPI RLVector2 RLGetWorldToScreen(RLVector3 position, RLCamera camera);                            // 获取 3D 世界空间位置对应的屏幕空间位置
RLAPI RLVector2 RLGetWorldToScreenEx(RLVector3 position, RLCamera camera, int width, int height);   // 获取 3D 世界空间位置对应的尺寸位置
RLAPI RLVector2 RLGetWorldToScreen2D(RLVector2 position, RLCamera2D camera);                        // 获取 2D 摄像机世界空间位置对应的屏幕空间位置
RLAPI RLVector2 RLGetScreenToWorld2D(RLVector2 position, RLCamera2D camera);                        // 获取 2D 摄像机屏幕空间位置对应的世界空间位置
RLAPI RLMatrix RLGetCameraMatrix(RLCamera camera);                                                  // 获取摄像机变换矩阵（视图矩阵）
RLAPI RLMatrix RLGetCameraMatrix2D(RLCamera2D camera);                                              // 获取摄像机 2D 变换矩阵

// 时序相关函数
RLAPI void RLSetTargetFPS(int fps);                       // 设置目标帧率（最大值）
RLAPI float RLGetFrameTime(void);                         // 获取上一帧绘制时间（秒）（时间差）
RLAPI double RLGetTime(void);                             // 获取自 InitWindow() 以来经过的时间（秒）
RLAPI int RLGetFPS(void);                                 // 获取当前帧率

// 自定义帧控制函数
// 注意：这些函数面向希望完全控制帧处理的高级用户
// 默认情况下，EndDrawing() 函数执行以下操作：绘制所有内容 + SwapScreenBuffer() + 管理帧时序 + PollInputEvents()
// 要避免此行为并手动控制帧处理，请在 config.h 中启用：SUPPORT_CUSTOM_FRAME_CONTROL
RLAPI void RLSwapScreenBuffer(void);                      // 交换前后缓冲区（屏幕绘制）
RLAPI void RLPollInputEvents(void);                       // 注册所有输入事件
RLAPI void RLWaitTime(double seconds);                    // 等待一段时间（暂停程序执行）

// 随机值生成函数
RLAPI void RLSetRandomSeed(unsigned int seed);                          // 设置随机数生成器的种子
RLAPI int RLGetRandomValue(int min, int max);                           // 获取介于最小值和最大值之间的随机值（包含最小值和最大值）
RLAPI int *RLLoadRandomSequence(unsigned int count, int min, int max);  // 加载随机值序列，不重复
RLAPI void RLUnloadRandomSequence(int *sequence);                       // 卸载随机值序列

// 其他功能
RLAPI void RLTakeScreenshot(const char *fileName);                      // 截取当前屏幕的屏幕截图（文件名扩展名决定格式）
RLAPI void RLSetConfigFlags(unsigned int flags);                        // 设置初始化配置标志（查看 FLAGS）
RLAPI void RLSetWindowRefreshCallback(RLWindowRefreshCallback callback);// 设置用户窗口刷新回调（由 FLAG_WINDOW_REFRESH_CALLBACK 使用）
RLAPI void RLOpenURL(const char *url);                                  // 使用系统默认浏览器打开 URL（如果可用）

// 日志系统
RLAPI void RLSetTraceLogLevel(int logLevel);                            // 设置当前阈值（最低）日志级别
RLAPI void RLTraceLog(int logLevel, const char *text, ...);             // 显示跟踪日志消息（LOG_DEBUG、LOG_INFO、LOG_WARNING、LOG_ERROR 等）
RLAPI void RLSetTraceLogCallback(RLTraceLogCallback callback);          // 设置自定义跟踪日志

// 使用内部分配器进行内存管理
RLAPI void *RLMemAlloc(unsigned int size);                       // 内部内存分配器
RLAPI void *RLMemRealloc(void *ptr, unsigned int size);          // 内部内存重新分配器
RLAPI void RLMemFree(void *ptr);                                 // 内部内存释放

typedef struct RLMemoryDiagStats {
    unsigned long long allocCount;
    unsigned long long callocCount;
    unsigned long long reallocCount;
    unsigned long long freeCount;
    unsigned long long allocBytes;
    unsigned long long freeBytes;
    unsigned long long allocFailCount;
    unsigned long long reallocFailCount;
    unsigned long long currentOutstandingBytes;
    unsigned long long peakOutstandingBytes;
    unsigned long long bucketGrowCount;
    unsigned long long bucketGrowLimitHitCount;
} RLMemoryDiagStats;

RLAPI void RLEnableMemoryDiagStats(void);
RLAPI void RLDisableMemoryDiagStats(void);
RLAPI bool RLIsMemoryDiagStatsEnabled(void);
RLAPI void RLResetMemoryDiagStats(void);
RLAPI RLMemoryDiagStats RLGetMemoryDiagStats(void);
RLAPI void RLDumpMemoryLeaks(void);

// 文件系统管理功能
RLAPI unsigned char *RLLoadFileData(const char *fileName, int *dataSize);                       // 以字节数组形式加载文件数据（读取）
RLAPI void RLUnloadFileData(unsigned char *data);                                               // 卸载 LoadFileData() 分配的文件数据
RLAPI bool RLSaveFileData(const char *fileName, void *data, int dataSize);                      // 将字节数组中的数据保存到文件（写入），成功返回 true
RLAPI bool RLExportDataAsCode(const unsigned char *data, int dataSize, const char *fileName);   // 将数据导出到代码（.h），成功返回 true
RLAPI char *RLLoadFileText(const char *fileName);                                               // 从文件中加载文本数据（读取），返回以 '\0' 结尾的字符串
RLAPI void RLUnloadFileText(char *text);                                                        // 卸载 LoadFileText() 分配的文件文本数据
RLAPI bool RLSaveFileText(const char *fileName, const char *text);                              // 将文本数据保存到文件（写入），字符串必须以 '\0' 结尾，成功返回 true

// 文件访问自定义回调
// 警告：回调设置仅供高级用户使用
RLAPI void RLSetLoadFileDataCallback(RLLoadFileDataCallback callback);  // 设置自定义文件二进制数据加载器
RLAPI void RLSetSaveFileDataCallback(RLSaveFileDataCallback callback);  // 设置自定义文件二进制数据保存器
RLAPI void RLSetLoadFileTextCallback(RLLoadFileTextCallback callback);  // 设置自定义文件文本数据加载器
RLAPI void RLSetSaveFileTextCallback(RLSaveFileTextCallback callback);  // 设置自定义文件文本数据保存器

RLAPI int RLFileRename(const char *fileName, const char *fileRename);                           // 重命名文件或将其移动到目标路径（如果存在）
RLAPI int RLFileRemove(const char *fileName);                                                   // 删除文件（如果存在）
RLAPI int RLFileCopy(const char *srcPath, const char *dstPath);                                 // 将文件从一个路径复制到另一个路径，如果目标路径不存在，则创建目标路径
RLAPI int RLFileMove(const char *srcPath, const char *dstPath);                                 // 将文件从一个目录移动到另一个目录，如果目标路径不存在，则创建目标路径
RLAPI int RLFileTextReplace(const char *fileName, const char *search, const char *replacement); // 替换现有文件中的文本
RLAPI int RLFileTextFindIndex(const char *fileName, const char *search);                        // 在现有文件中查找文本
RLAPI bool RLFileExists(const char *fileName);                                                  // 检查文件是否存在
RLAPI bool RLDirectoryExists(const char *dirPath);                                              // 检查目录路径是否存在
RLAPI bool RLIsFileExtension(const char *fileName, const char *ext);                            // 检查文件扩展名（建议包含点：.png、.wav）
RLAPI int RLGetFileLength(const char *fileName);                                                // 获取文件长度（字节）（注意：GetFileSize() 与 windows.h 冲突）
RLAPI long RLGetFileModTime(const char *fileName);                                              // 获取文件修改时间（上次写入时间）
RLAPI const char *RLGetFileExtension(const char *fileName);                                     // 获取文件名字符串的扩展名指针（包含点：'.png'）
RLAPI const char *RLGetFileName(const char *filePath);                                          // 获取路径字符串的文件名指针
RLAPI const char *RLGetFileNameWithoutExt(const char *filePath);                                // 获取不带扩展名的文件名字符串（使用静态字符串）
RLAPI const char *RLGetDirectoryPath(const char *filePath);                                     // 获取给定文件名的完整路径（使用静态字符串）
RLAPI const char *RLGetPrevDirectoryPath(const char *dirPath);                                  // 获取给定路径的前一个目录路径（使用静态字符串）字符串)
RLAPI const char *RLGetWorkingDirectory(void);                                                  // 获取当前工作目录（使用静态字符串）
RLAPI const char *RLGetApplicationDirectory(void);                                              // 获取正在运行的应用程序的目录（使用静态字符串）
RLAPI int RLMakeDirectory(const char *dirPath);                                                 // 创建目录（包括请求的完整路径），成功返回 0
RLAPI bool RLChangeDirectory(const char *dirPath);                                              // 更改工作目录，成功返回 true
RLAPI bool RLIsPathFile(const char *path);                                                      // 检查给定路径是文件还是目录
RLAPI bool RLIsFileNameValid(const char *fileName);                                             // 检查文件名是否适用于平台/操作系统
RLAPI RLFilePathList RLLoadDirectoryFiles(const char *dirPath);                                 // 加载目录文件路径
RLAPI RLFilePathList RLLoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs);    // 加载目录文件路径，并进行扩展名过滤和递归目录扫描。在过滤字符串中使用“DIR”可将目录包含在结果中。
RLAPI void RLUnloadDirectoryFiles(RLFilePathList files);                                                    // 卸载文件路径
RLAPI bool RLIsFileDropped(void);                                                                           // 检查是否有文件拖放到窗口中
RLAPI RLFilePathList RLLoadDroppedFiles(void);                                                              // 加载已拖放的文件路径
RLAPI void RLUnloadDroppedFiles(RLFilePathList files);                                                      // 卸载已拖放的文件路径
RLAPI unsigned int RLGetDirectoryFileCount(const char *dirPath);                                            // 获取目录中的文件数量
RLAPI unsigned int RLGetDirectoryFileCountEx(const char *basePath, const char *filter, bool scanSubdirs);// 获取目录中的文件数量，并进行文件扩展名过滤和递归目录扫描。在过滤字符串中使用“DIR”可将目录包含在结果中。

// 压缩/编码功能
RLAPI unsigned char *RLCompressData(const unsigned char *data, int dataSize, int *compDataSize);        // 压缩数据（DEFLATE 算法），内存必须为 MemFree()
RLAPI unsigned char *RLDecompressData(const unsigned char *compData, int compDataSize, int *dataSize);  // 解压缩数据（DEFLATE 算法），内存必须为 MemFree()
RLAPI char *RLEncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize);               // 将数据编码为 Base64 字符串（包含 NULL 终止符），内存必须为 MemFree()
RLAPI unsigned char *RLDecodeDataBase64(const char *text, int *outputSize);                             // 解码 Base64 字符串（预期以 NULL 终止），内存必须为 MemFree()
RLAPI unsigned int RLComputeCRC32(unsigned char *data, int dataSize);       // 计算 CRC32 哈希码
RLAPI unsigned int *RLComputeMD5(unsigned char *data, int dataSize);        // 计算 MD5 哈希码，返回静态整数 int[4]（16 字节）
RLAPI unsigned int *RLComputeSHA1(unsigned char *data, int dataSize);       // 计算 SHA1 哈希码，返回静态整数 int[5]（20 字节）
RLAPI unsigned int *RLComputeSHA256(unsigned char *data, int dataSize);     // 计算 SHA256 哈希码，返回静态整数 int[8]（32 字节）

// 自动化事件功能
RLAPI RLAutomationEventList RLLoadAutomationEventList(const char *fileName);                // 从文件加载自动化事件列表，NULL 表示列表为空，容量 = MAX_AUTOMATION_EVENTS
RLAPI void RLUnloadAutomationEventList(RLAutomationEventList list);                         // 从文件卸载自动化事件列表
RLAPI bool RLExportAutomationEventList(RLAutomationEventList list, const char *fileName);   // 将自动化事件列表导出为文本文件
RLAPI void RLSetAutomationEventList(RLAutomationEventList *list);                           // 设置要录制的自动化事件列表
RLAPI void RLSetAutomationEventBaseFrame(int frame);                                        // 设置自动化事件内部基准帧以开始录制
RLAPI void RLStartAutomationEventRecording(void);                                           // 开始录制自动化事件（必须设置 AutomationEventList）
RLAPI void RLStopAutomationEventRecording(void);                                            // 停止录制自动化事件
RLAPI void RLPlayAutomationEvent(RLAutomationEvent event);                                  // 播放已录制的自动化事件

//------------------------------------------------------------------------------------
// 输入处理函数（模块：核心）
//------------------------------------------------------------------------------------

// 输入相关功能：键盘
RLAPI bool RLIsKeyPressed(int key);                             // 检查按键是否被按下一次
RLAPI bool RLIsKeyPressedRepeat(int key);                       // 检查按键是否被再次按下
RLAPI bool RLIsKeyDown(int key);                                // 检查按键是否正在被按下
RLAPI bool RLIsKeyReleased(int key);                            // 检查按键是否被释放一次
RLAPI bool RLIsKeyUp(int key);                                  // 检查按键是否未被按下
RLAPI int RLGetKeyPressed(void);                                // 获取按下的按键（键码），对已排队的按键多次调用，队列为空时返回 0
RLAPI int RLGetCharPressed(void);                               // 获取按下的字符（Unicode），对已排队的字符多次调用，队列为空时返回 0
RLAPI const char *RLGetKeyName(int key);                        // 获取当前键盘布局中 QWERTY 按键的名称（例如，AZERTY 键盘上的 KEY_A 返回字符串 'q'）
RLAPI void RLSetExitKey(int key);                               // 设置自定义退出程序的按键（默认为 ESC）

// 输入相关功能：游戏手柄
RLAPI bool RLIsGamepadAvailable(int gamepad);                   // 检查游戏手柄是否可用
RLAPI const char *RLGetGamepadName(int gamepad);                // 获取游戏手柄的内部名称 ID
RLAPI bool RLIsGamepadButtonPressed(int gamepad, int button);   // 检查游戏手柄按键是否被按下一次
RLAPI bool RLIsGamepadButtonDown(int gamepad, int button);      // 检查游戏手柄按键是否正在被按下
RLAPI bool RLIsGamepadButtonReleased(int gamepad, int button);  // 检查游戏手柄按键是否被释放一次
RLAPI bool RLIsGamepadButtonUp(int gamepad, int button);        // 检查游戏手柄按键是否未被按下
RLAPI int RLGetGamepadButtonPressed(void);                      // 获取最后按下的游戏手柄按键
RLAPI int RLGetGamepadAxisCount(int gamepad);                   // 获取游戏手柄的轴数
RLAPI float RLGetGamepadAxisMovement(int gamepad, int axis);    // 获取游戏手柄轴的移动值
RLAPI int RLSetGamepadMappings(const char *mappings);           // 设置游戏手柄内部映射（SDL_GameControllerDB）
RLAPI void RLSetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float duration); // 设置游戏手柄两个马达的震动模式（持续时间以秒为单位）

// 输入相关功能：鼠标
RLAPI bool RLIsMouseButtonPressed(int button);                  // 检查鼠标按键是否被按下过一次
RLAPI bool RLIsMouseButtonDown(int button);                     // 检查鼠标按键是否被按下
RLAPI bool RLIsMouseButtonReleased(int button);                 // 检查鼠标按键是否被释放过一次
RLAPI bool RLIsMouseButtonUp(int button);                       // 检查鼠标按键是否未被按下
RLAPI int RLGetMouseX(void);                                    // 获取鼠标 X 坐标
RLAPI int RLGetMouseY(void);                                    // 获取鼠标 Y 坐标
RLAPI RLVector2 RLGetMousePosition(void);                       // 获取鼠标 XY 坐标
RLAPI RLVector2 RLGetMouseDelta(void);                          // 获取帧间鼠标移动量
RLAPI void RLSetMousePosition(int x, int y);                    // 设置鼠标 XY 坐标
RLAPI void RLSetMouseOffset(int offsetX, int offsetY);          // 设置鼠标偏移量
RLAPI void RLSetMouseScale(float scaleX, float scaleY);         // 设置鼠标缩放比例
RLAPI float RLGetMouseWheelMove(void);                          // 获取鼠标滚轮在 X 或 Y 轴上的移动量，取较大值
RLAPI RLVector2 RLGetMouseWheelMoveV(void);                     // 获取鼠标滚轮在 X 和 Y 轴上的移动量
RLAPI void RLSetMouseCursor(int cursor);                        // 设置鼠标光标

// 输入相关功能：触摸
RLAPI int RLGetTouchX(void);                                    // 获取触摸点 0 的触摸 X 坐标（相对于屏幕尺寸）
RLAPI int RLGetTouchY(void);                                    // 获取触摸点 0 的触摸 Y 坐标（相对于屏幕尺寸）
RLAPI RLVector2 RLGetTouchPosition(int index);                  // 获取触摸点索引的触摸 XY 坐标（相对于屏幕尺寸）
RLAPI int RLGetTouchPointId(int index);                         // 获取给定索引的触摸点标识符
RLAPI int RLGetTouchPointCount(void);                           // 获取触摸点数量

//------------------------------------------------------------------------------------
// 手势和触摸处理功能（模块：rgestures）
//------------------------------------------------------------------------------------
RLAPI void RLSetGesturesEnabled(unsigned int flags);            // 使用标志启用一组手势
RLAPI bool RLIsGestureDetected(unsigned int gesture);           // 检查是否已检测到手势
RLAPI int RLGetGestureDetected(void);                           // 获取最近检测到的手势
RLAPI float RLGetGestureHoldDuration(void);                     // 获取手势按住时间（秒）
RLAPI RLVector2 RLGetGestureDragVector(void);                   // 获取手势拖动矢量
RLAPI float RLGetGestureDragAngle(void);                        // 获取手势拖动角度
RLAPI RLVector2 RLGetGesturePinchVector(void);                  // 获取手势捏合增量
RLAPI float RLGetGesturePinchAngle(void);                       // 获取手势捏合角度

//------------------------------------------------------------------------------------
// 相机系统功能（模块：rcamera）
//------------------------------------------------------------------------------------
RLAPI void RLUpdateCamera(RLCamera *camera, int mode);                                              // 更新所选模式下的相机位置
RLAPI void RLUpdateCameraPro(RLCamera *camera, RLVector3 movement, RLVector3 rotation, float zoom); // 更新相机移动/旋转

//------------------------------------------------------------------------------------
// 基本形状绘制函数（模块：形状）
//------------------------------------------------------------------------------------
// 设置用于形状绘制的纹理和矩形
// 注意：当使用基本形状和单一字体时，此功能非常有用。
// 定义一个字体字符白色矩形，即可在一次绘制调用中完成所有绘制。
RLAPI void RLSetShapesTexture(RLTexture2D texture, RLRectangle source); // 设置用于绘制形状的纹理和矩形
RLAPI RLTexture2D RLGetShapesTexture(void);                             // 获取用于绘制形状的纹理
RLAPI RLRectangle RLGetShapesTextureRectangle(void);                    // 获取用于绘制形状的纹理源矩形

// 基本图形绘制函数
RLAPI void RLDrawPixel(int posX, int posY, RLColor color);                                                                                              // 使用几何图形绘制像素 [速度可能较慢，请谨慎使用]
RLAPI void RLDrawPixelV(RLVector2 position, RLColor color);                                                                                             // 使用几何图形绘制像素（矢量版本） [速度可能较慢，请谨慎使用]
RLAPI void RLDrawLine(int startPosX, int startPosY, int endPosX, int endPosY, RLColor color);                                                           // 绘制直线
RLAPI void RLDrawLineV(RLVector2 startPos, RLVector2 endPos, RLColor color);                                                                            // 绘制直线（使用 GL 线条）
RLAPI void RLDrawLineEx(RLVector2 startPos, RLVector2 endPos, float thick, RLColor color);                                                              // 绘制直线（使用三角形/四边形）
RLAPI void RLDrawLineStrip(const RLVector2 *points, int pointCount, RLColor color);                                                                     // 绘制直线序列（使用 GL 线条）
RLAPI void RLDrawLineBezier(RLVector2 startPos, RLVector2 endPos, float thick, RLColor color);                                                          // 绘制线段（三次贝塞尔曲线插值）
RLAPI void RLDrawLineDashed(RLVector2 startPos, RLVector2 endPos, int dashSize, int spaceSize, RLColor color);                                          // 绘制虚线
RLAPI void RLDrawCircle(int centerX, int centerY, float radius, RLColor color);                                                                         // 绘制实心圆
RLAPI void RLDrawCircleSector(RLVector2 center, float radius, float startAngle, float endAngle, int segments, RLColor color);                           // 绘制圆的一部分
RLAPI void RLDrawCircleSectorLines(RLVector2 center, float radius, float startAngle, float endAngle, int segments, RLColor color);                      // 绘制扇形轮廓
RLAPI void RLDrawCircleGradient(int centerX, int centerY, float radius, RLColor inner, RLColor outer);                                                  // 绘制渐变填充圆
RLAPI void RLDrawCircleV(RLVector2 center, float radius, RLColor color);                                                                                // 绘制实心圆（矢量版本）
RLAPI void RLDrawCircleLines(int centerX, int centerY, float radius, RLColor color);                                                                    // 绘制圆轮廓
RLAPI void RLDrawCircleLinesV(RLVector2 center, float radius, RLColor color);                                                                           // 绘制圆轮廓（矢量版本）
RLAPI void RLDrawEllipse(int centerX, int centerY, float radiusH, float radiusV, RLColor color);                                                        // 绘制椭圆
RLAPI void RLDrawEllipseV(RLVector2 center, float radiusH, float radiusV, RLColor color);                                                               // 绘制椭圆（矢量版本）
RLAPI void RLDrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, RLColor color);                                                   // 绘制椭圆轮廓​​
RLAPI void RLDrawEllipseLinesV(RLVector2 center, float radiusH, float radiusV, RLColor color);                                                          // 绘制椭圆轮廓​​（矢量版本）
RLAPI void RLDrawRing(RLVector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, RLColor color);           // 绘制圆环
RLAPI void RLDrawRingLines(RLVector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, RLColor color);      // 绘制圆环轮廓
RLAPI void RLDrawRectangle(int posX, int posY, int width, int height, RLColor color);                                                                   // 绘制实心矩形
RLAPI void RLDrawRectangleV(RLVector2 position, RLVector2 size, RLColor color);                                                                         // 绘制实心矩形（矢量版）
RLAPI void RLDrawRectangleRec(RLRectangle rec, RLColor color);                                                                                          // 绘制一个填充颜色的矩形
RLAPI void RLDrawRectanglePro(RLRectangle rec, RLVector2 origin, float rotation, RLColor color);                                                        // 使用专业参数绘制一个填充颜色的矩形
RLAPI void RLDrawRectangleGradientV(int posX, int posY, int width, int height, RLColor top, RLColor bottom);                                            // 绘制一个垂直渐变填充的矩形
RLAPI void RLDrawRectangleGradientH(int posX, int posY, int width, int height, RLColor left, RLColor right);                                            // 绘制一个水平渐变填充的矩形
RLAPI void RLDrawRectangleGradientEx(RLRectangle rec, RLColor topLeft, RLColor bottomLeft, RLColor bottomRight, RLColor topRight);                      // 使用自定义顶点颜色绘制一个渐变填充的矩形
RLAPI void RLDrawRectangleLines(int posX, int posY, int width, int height, RLColor color);                                                              // 绘制矩形轮廓
RLAPI void RLDrawRectangleLinesEx(RLRectangle rec, float lineThick, RLColor color);                                                                     // 使用扩展参数绘制矩形轮廓
RLAPI void RLDrawRectangleRounded(RLRectangle rec, float roundness, int segments, RLColor color);                                                       // 绘制圆角矩形
RLAPI void RLDrawRectangleRoundedLines(RLRectangle rec, float roundness, int segments, RLColor color);                                                  // 绘制圆角矩形线条
RLAPI void RLDrawRectangleRoundedLinesEx(RLRectangle rec, float roundness, int segments, float lineThick, RLColor color);                               // 绘制圆角矩形轮廓
RLAPI void RLDrawTriangle(RLVector2 v1, RLVector2 v2, RLVector2 v3, RLColor color);                                                                     // 绘制一个填充颜色的三角形（顶点按逆时针方向排列！）
RLAPI void RLDrawTriangleLines(RLVector2 v1, RLVector2 v2, RLVector2 v3, RLColor color);                                                                // 绘制三角形轮廓（顶点按逆时针方向排列！）
RLAPI void RLDrawTriangleFan(const RLVector2 *points, int pointCount, RLColor color);                                                                   // 绘制一个由点定义的三角形扇形（第一个顶点是中心）
RLAPI void RLDrawTriangleStrip(const RLVector2 *points, int pointCount, RLColor color);                                                                 // 绘制一个由点定义的三角形条带
RLAPI void RLDrawPoly(RLVector2 center, int sides, float radius, float rotation, RLColor color);                                                        // 绘制一个正多边形（矢量版）
RLAPI void RLDrawPolyLines(RLVector2 center, int sides, float radius, float rotation, RLColor color);                                                   // 绘制一个 n 边形轮廓
RLAPI void RLDrawPolyLinesEx(RLVector2 center, int sides, float radius, float rotation, float lineThick, RLColor color);                                // 使用扩展参数绘制一个 n 边形轮廓

//样条曲线绘制函数
RLAPI void RLDrawSplineLinear(const RLVector2 *points, int pointCount, float thick, RLColor color);                                                     // 绘制样条曲线：线性，至少 2 个点
RLAPI void RLDrawSplineBasis(const RLVector2 *points, int pointCount, float thick, RLColor color);                                                      // 绘制样条曲线：B 样条，至少 4 个点
RLAPI void RLDrawSplineCatmullRom(const RLVector2 *points, int pointCount, float thick, RLColor color);                                                 // 绘制样条曲线：Catmull-Rom 样条，至少 4 个点
RLAPI void RLDrawSplineBezierQuadratic(const RLVector2 *points, int pointCount, float thick, RLColor color);                                            // 绘制样条曲线：二次贝塞尔曲线，至少 3 个点（1 个控制点）：[p1, c2, p3, c4...]
RLAPI void RLDrawSplineBezierCubic(const RLVector2 *points, int pointCount, float thick, RLColor color);                                                // 绘制样条曲线：三次贝塞尔曲线，至少 4 个点（2 个控制点）：[p1, c2, c3, p4, c5, c6...]
RLAPI void RLDrawSplineSegmentLinear(RLVector2 p1, RLVector2 p2, float thick, RLColor color);                                                           // 绘制样条曲线段：线性，2 个点
RLAPI void RLDrawSplineSegmentBasis(RLVector2 p1, RLVector2 p2, RLVector2 p3, RLVector2 p4, float thick, RLColor color);                                // 绘制样条曲线段：B 样条，4 个点
RLAPI void RLDrawSplineSegmentCatmullRom(RLVector2 p1, RLVector2 p2, RLVector2 p3, RLVector2 p4, float thick, RLColor color);                           // 绘制样条曲线段：Catmull-Rom 样条，4 个点
RLAPI void RLDrawSplineSegmentBezierQuadratic(RLVector2 p1, RLVector2 c2, RLVector2 p3, float thick, RLColor color);                                    // 绘制样条曲线段：二次贝塞尔曲线，2 个点，1 个控制点
RLAPI void RLDrawSplineSegmentBezierCubic(RLVector2 p1, RLVector2 c2, RLVector2 c3, RLVector2 p4, float thick, RLColor color);                          // 绘制样条曲线段：三次贝塞尔曲线，2 个点，2 个控制点

// 样条曲线段点评估函数，对于给定的 t [0.0f .. 1.0f]
RLAPI RLVector2 RLGetSplinePointLinear(RLVector2 startPos, RLVector2 endPos, float t);                           // 获取（评估）样条点：线性
RLAPI RLVector2 RLGetSplinePointBasis(RLVector2 p1, RLVector2 p2, RLVector2 p3, RLVector2 p4, float t);          // 获取（评估）样条点：B样条
RLAPI RLVector2 RLGetSplinePointCatmullRom(RLVector2 p1, RLVector2 p2, RLVector2 p3, RLVector2 p4, float t);     // 获取（评估）样条点：卡特穆尔-罗姆曲线
RLAPI RLVector2 RLGetSplinePointBezierQuad(RLVector2 p1, RLVector2 c2, RLVector2 p3, float t);                   // 获取（评估）样条点：二次贝塞尔曲线
RLAPI RLVector2 RLGetSplinePointBezierCubic(RLVector2 p1, RLVector2 c2, RLVector2 c3, RLVector2 p4, float t);    // 获取（评估）样条点：三次贝塞尔曲线

// 基本形状碰撞检测函数
RLAPI bool RLCheckCollisionRecs(RLRectangle rec1, RLRectangle rec2);                                                                            // 检查两个矩形之间的碰撞
RLAPI bool RLCheckCollisionCircles(RLVector2 center1, float radius1, RLVector2 center2, float radius2);                                         // 检查两个圆之间的碰撞
RLAPI bool RLCheckCollisionCircleRec(RLVector2 center, float radius, RLRectangle rec);                                                          // 检查圆与矩形之间的碰撞
RLAPI bool RLCheckCollisionCircleLine(RLVector2 center, float radius, RLVector2 p1, RLVector2 p2);                                              // 检查圆是否与两点 [p1] 和 [p2] 之间构成的线段碰撞
RLAPI bool RLCheckCollisionPointRec(RLVector2 point, RLRectangle rec);                                                                          // 检查点是否在矩形内
RLAPI bool RLCheckCollisionPointCircle(RLVector2 point, RLVector2 center, float radius);                                                        // 检查点是否在圆内
RLAPI bool RLCheckCollisionPointTriangle(RLVector2 point, RLVector2 p1, RLVector2 p2, RLVector2 p3);                                            // 检查点是否在三角形内
RLAPI bool RLCheckCollisionPointLine(RLVector2 point, RLVector2 p1, RLVector2 p2, int threshold);                                               // 检查点是否属于两点 [p1] 和 [p2] 之间以指定像素值 [threshold] 定义的边距构成的线段
RLAPI bool RLCheckCollisionPointPoly(RLVector2 point, const RLVector2 *points, int pointCount);                                                 // 检查点是否在由顶点数组描述的多边形内
RLAPI bool RLCheckCollisionLines(RLVector2 startPos1, RLVector2 endPos1, RLVector2 startPos2, RLVector2 endPos2, RLVector2 *collisionPoint);    // 检查两条分别由两个点定义的线段之间的碰撞，并按引用返回碰撞点
RLAPI RLRectangle RLGetCollisionRec(RLRectangle rec1, RLRectangle rec2);                                                                        // 获取两个矩形碰撞的碰撞矩形

//------------------------------------------------------------------------------------
// 纹理加载和绘制函数（模块：纹理）
//------------------------------------------------------------------------------------

// 图像加载函数
// 注意：这些函数不需要访问 GPU
RLAPI RLImage RLLoadImage(const char *fileName);                                                                            // 将图像从文件加载到 CPU 内存 (RAM)
RLAPI RLImage RLLoadImageRaw(const char *fileName, int width, int height, int format, int headerSize);                      // 从 RAW 文件数据加载图像
RLAPI RLImage RLLoadImageAnim(const char *fileName, int *frames);                                                           // 从文件加载图像序列（帧追加到 image.data）
RLAPI RLImage RLLoadImageAnimFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int *frames);    // 从内存缓冲区加载图像序列
RLAPI RLImage RLLoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize);                     // 从内存缓冲区加载图像，fileType 指的是文件扩展名，例如 '.png'
RLAPI RLImage RLLoadImageFromTexture(RLTexture2D texture);                                                                  // 从 GPU 纹理数据加载图像
RLAPI RLImage RLLoadImageFromScreen(void);                                                                                  // 从屏幕缓冲区加载图像（截图）
RLAPI bool RLIsImageValid(RLImage image);                                                                                   // 检查图像是否有效（数据和参数）
RLAPI void RLUnloadImage(RLImage image);                                                                                    // 从 CPU 内存 (RAM) 卸载图像
RLAPI bool RLExportImage(RLImage image, const char *fileName);                                                              // 将图像数据导出到文件，成功返回 true
RLAPI unsigned char *RLExportImageToMemory(RLImage image, const char *fileType, int *fileSize);                             // 将图像导出到内存缓冲区
RLAPI bool RLExportImageAsCode(RLImage image, const char *fileName);                                                        // 将图像导出为定义字节数组的代码文件，成功返回 true

// 图像生成函数
RLAPI RLImage RLGenImageColor(int width, int height, RLColor color);                                                // 生成图像：纯色
RLAPI RLImage RLGenImageGradientLinear(int width, int height, int direction, RLColor start, RLColor end);           // 生成图像：线性渐变，方向以度为单位 [0..360]，0 表示垂直渐变
RLAPI RLImage RLGenImageGradientRadial(int width, int height, float density, RLColor inner, RLColor outer);         // 生成图像：径向渐变
RLAPI RLImage RLGenImageGradientSquare(int width, int height, float density, RLColor inner, RLColor outer);         // 生成图像：方形渐变
RLAPI RLImage RLGenImageChecked(int width, int height, int checksX, int checksY, RLColor col1, RLColor col2);       // 生成图像：方格图像
RLAPI RLImage RLGenImageWhiteNoise(int width, int height, float factor);                                            // 生成图像：白噪声
RLAPI RLImage RLGenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale);                  // 生成图像：柏林噪声
RLAPI RLImage RLGenImageCellular(int width, int height, int tileSize);                                              // 生成图像：细胞算法，更大的 tileSize 表示更大的单元格
RLAPI RLImage RLGenImageText(int width, int height, const char *text);                                              // 生成图像：根据文本数据生成灰度图像

// 图像处理函数
RLAPI RLImage RLImageCopy(RLImage image);                                                                               // 创建图像副本（用于图像变换）
RLAPI RLImage RLImageFromImage(RLImage image, RLRectangle rec);                                                         // 从另一幅图像创建图像
RLAPI RLImage RLImageFromChannel(RLImage image, int selectedChannel);                                                   // 从另一幅图像的选定通道创建图像（灰度）
RLAPI RLImage RLImageText(const char *text, int fontSize, RLColor color);                                               // 从文本创建图像（默认字体）
RLAPI RLImage RLImageTextEx(RLFont font, const char *text, float fontSize, float spacing, RLColor tint);                // 从文本创建图像（自定义精灵字体）
RLAPI void RLImageFormat(RLImage *image, int newFormat);                                                                // 将图像数据转换为所需格式
RLAPI void RLImageToPOT(RLImage *image, RLColor fill);                                                                  // 将图像转换为 2 的幂 (POT) 图像
RLAPI void RLImageCrop(RLImage *image, RLRectangle crop);                                                               // 将图像裁剪为指定的矩形
RLAPI void RLImageAlphaCrop(RLImage *image, float threshold);                                                           // 根据 alpha 值裁剪图像
RLAPI void RLImageAlphaClear(RLImage *image, RLColor color, float threshold);                                           // 将 alpha 通道清除为所需颜色
RLAPI void RLImageAlphaMask(RLImage *image, RLImage alphaMask);                                                         // 将 alpha 通道应用到图像
RLAPI void RLImageAlphaPremultiply(RLImage *image);                                                                     // 预乘 alpha 通道
RLAPI void RLImageBlurGaussian(RLImage *image, int blurSize);                                                           // 使用盒式模糊近似应用高斯模糊
RLAPI void RLImageKernelConvolution(RLImage *image, const float *kernel, int kernelSize);                               // 将自定义方形卷积核应用到图像
RLAPI void RLImageResize(RLImage *image, int newWidth, int newHeight);                                                  // 调整图像大小（双三次缩放算​​法）
RLAPI void RLImageResizeNN(RLImage *image, int newWidth, int newHeight);                                                // 调整图像大小（最近邻缩放算法）
RLAPI void RLImageResizeCanvas(RLImage *image, int newWidth, int newHeight, int offsetX, int offsetY, RLColor fill);    // 调整画布大小并填充颜色
RLAPI void RLImageMipmaps(RLImage *image);                                                                              // 计算给定图像的所有 mipmap 级别
RLAPI void RLImageDither(RLImage *image, int rBpp, int gBpp, int bBpp, int aBpp);                                       // 将图像数据抖动到 16 位或更低（Floyd-Steinberg 抖动）
RLAPI void RLImageFlipVertical(RLImage *image);                                                                         // 垂直翻转图像
RLAPI void RLImageFlipHorizontal(RLImage *image);                                                                       // 水平翻转图像
RLAPI void RLImageRotate(RLImage *image, int degrees);                                                                  // 按输入角度（-359 至 359 度）旋转图像
RLAPI void RLImageRotateCW(RLImage *image);                                                                             // 顺时针旋转图像 90 度
RLAPI void RLImageRotateCCW(RLImage *image);                                                                            // 逆时针旋转图像 90 度
RLAPI void RLImageColorTint(RLImage *image, RLColor color);                                                             // 修改图像颜色：色调
RLAPI void RLImageColorInvert(RLImage *image);                                                                          // 修改图像颜色：反转
RLAPI void RLImageColorGrayscale(RLImage *image);                                                                       // 修改图像颜色：灰度
RLAPI void RLImageColorContrast(RLImage *image, float contrast);                                                        // 修改图像颜色：对比度（-100 至 100）
RLAPI void RLImageColorBrightness(RLImage *image, int brightness);                                                      // 修改图像颜色：亮度（-255 至 255）
RLAPI void RLImageColorReplace(RLImage *image, RLColor color, RLColor replace);                                         // 修改图像颜色：替换颜色
RLAPI RLColor *RLLoadImageColors(RLImage image);                                                                        // 从图像加载颜色数据，并将其作为 Color 数组（RGBA - 32 位）加载
RLAPI RLColor *RLLoadImagePalette(RLImage image, int maxPaletteSize, int *colorCount);                                  // 从图像加载调色板，并将其作为 Color 数组（RGBA - 32 位）加载
RLAPI void RLUnloadImageColors(RLColor *colors);                                                                        // 卸载使用 LoadImageColors() 加载的颜色数据
RLAPI void RLUnloadImagePalette(RLColor *colors);                                                                       // 卸载使用 LoadImagePalette() 加载的调色板
RLAPI RLRectangle RLGetImageAlphaBorder(RLImage image, float threshold);                                                // 获取图像 alpha 边框矩形
RLAPI RLColor RLGetImageColor(RLImage image, int x, int y);                                                             // 获取图像像素 (x, y) 位置

// 图像绘制函数
// 注意：图像软件渲染函数（CPU）
RLAPI void RLImageClearBackground(RLImage *dst, RLColor color);                                                                             // 使用指定颜色清除图像背景
RLAPI void RLImageDrawPixel(RLImage *dst, int posX, int posY, RLColor color);                                                               // 在图像中绘制像素
RLAPI void RLImageDrawPixelV(RLImage *dst, RLVector2 position, RLColor color);                                                              // 在图像中绘制像素（矢量版本）
RLAPI void RLImageDrawLine(RLImage *dst, int startPosX, int startPosY, int endPosX, int endPosY, RLColor color);                            // 在图像中绘制线条
RLAPI void RLImageDrawLineV(RLImage *dst, RLVector2 start, RLVector2 end, RLColor color);                                                   // 在图像中绘制线条（矢量版本）
RLAPI void RLImageDrawLineEx(RLImage *dst, RLVector2 start, RLVector2 end, int thick, RLColor color);                                       // 在图像中绘制定义粗细的线条
RLAPI void RLImageDrawCircle(RLImage *dst, int centerX, int centerY, int radius, RLColor color);                                            // 在图像中绘制实心圆
RLAPI void RLImageDrawCircleV(RLImage *dst, RLVector2 center, int radius, RLColor color);                                                   // 在图像中绘制实心圆（矢量版本）
RLAPI void RLImageDrawCircleLines(RLImage *dst, int centerX, int centerY, int radius, RLColor color);                                       // 在图像中绘制圆的轮廓
RLAPI void RLImageDrawCircleLinesV(RLImage *dst, RLVector2 center, int radius, RLColor color);                                              // 在图像中绘制圆的轮廓（矢量版本）
RLAPI void RLImageDrawRectangle(RLImage *dst, int posX, int posY, int width, int height, RLColor color);                                    // 在图像中绘制矩形
RLAPI void RLImageDrawRectangleV(RLImage *dst, RLVector2 position, RLVector2 size, RLColor color);                                          // 在图像中绘制矩形（矢量版本）
RLAPI void RLImageDrawRectangleRec(RLImage *dst, RLRectangle rec, RLColor color);                                                           // 在图像中绘制矩形
RLAPI void RLImageDrawRectangleLines(RLImage *dst, RLRectangle rec, int thick, RLColor color);                                              // 在图像中绘制矩形线段
RLAPI void RLImageDrawTriangle(RLImage *dst, RLVector2 v1, RLVector2 v2, RLVector2 v3, RLColor color);                                      // 在图像中绘制三角形
RLAPI void RLImageDrawTriangleEx(RLImage *dst, RLVector2 v1, RLVector2 v2, RLVector2 v3, RLColor c1, RLColor c2, RLColor c3);               // 在图像中绘制插值颜色的三角形
RLAPI void RLImageDrawTriangleLines(RLImage *dst, RLVector2 v1, RLVector2 v2, RLVector2 v3, RLColor color);                                 // 在图像中绘制三角形轮廓
RLAPI void RLImageDrawTriangleFan(RLImage *dst, const RLVector2 *points, int pointCount, RLColor color);                                    // 在图像中绘制由点定义的三角形扇形（第一个顶点是中心）
RLAPI void RLImageDrawTriangleStrip(RLImage *dst, const RLVector2 *points, int pointCount, RLColor color);                                  // 在图像中绘制由点定义的三角形条带
RLAPI void RLImageDraw(RLImage *dst, RLImage src, RLRectangle srcRec, RLRectangle dstRec, RLColor tint);                                    // 在目标图像中绘制源图像（对源图像应用色调）
RLAPI void RLImageDrawText(RLImage *dst, const char *text, int posX, int posY, int fontSize, RLColor color);                                // 在目标图像中绘制文本（使用默认字体）
RLAPI void RLImageDrawTextEx(RLImage *dst, RLFont font, const char *text, RLVector2 position, float fontSize, float spacing, RLColor tint); // 绘制图像（目标）中的文本（自定义精灵字体）

// 纹理加载函数
// 注意：这些函数需要 GPU 访问权限
RLAPI RLTexture2D RLLoadTexture(const char *fileName);                                                          // 将纹理从文件加载到 GPU 内存 (VRAM)
RLAPI RLTexture2D RLLoadTextureFromImage(RLImage image);                                                        // 从图像数据加载纹理
RLAPI RLTextureCubemap RLLoadTextureCubemap(RLImage image, int layout);                                         // 从图像加载立方体贴图，支持多种图像立方体贴图布局
RLAPI RLRenderTexture2D RLLoadRenderTexture(int width, int height);                                             // 加载用于渲染的纹理（帧缓冲区）
RLAPI bool RLIsTextureValid(RLTexture2D texture);                                                               // 检查纹理是否有效（已加载到 GPU）
RLAPI bool RLRetainTextureObject(RLTexture2D texture);                                                          // 增加纹理对象的 CPU 端引用计数
RLAPI bool RLReleaseTextureObject(RLTexture2D texture);                                                         // 减少 CPU 端引用计数，并在计数达到零时销毁纹理对象
RLAPI RLContext* RLGetTextureObjectOwnerContext(RLTexture2D texture);                                           // 查询纹理对象所有者上下文（如果未跟踪则为 NULL）
RLAPI bool RLIsTextureObjectOwnedByCurrentContext(RLTexture2D texture);                                         // 检查纹理对象所有者是否为当前上下文
RLAPI bool RLTryTransferTextureObjectOwner(RLTexture2D texture, RLContext* targetCtx);                          // 将纹理对象所有者转移到目标上下文
RLAPI void RLUnloadTexture(RLTexture2D texture);                                                                // 从 GPU 内存 (VRAM) 卸载纹理
RLAPI bool RLIsRenderTextureValid(RLRenderTexture2D target);                                                    // 检查渲染纹理是否有效（已加载到 GPU）
RLAPI bool RLRetainRenderTextureObject(RLRenderTexture2D target);                                               // 增加渲染纹理对象的 CPU 端引用计数
RLAPI bool RLReleaseRenderTextureObject(RLRenderTexture2D target);                                              // 减少 CPU 端引用计数，并在计数达到零时销毁纹理对象
RLAPI RLContext* RLGetRenderTextureObjectOwnerContext(RLRenderTexture2D target);                                // 查询渲染纹理所有者上下文（如果未跟踪则为 NULL）
RLAPI bool RLIsRenderTextureObjectOwnedByCurrentContext(RLRenderTexture2D target);                              // 检查渲染纹理所有者是否为当前上下文
RLAPI bool RLTryTransferRenderTextureObjectOwner(RLRenderTexture2D target, RLContext* targetCtx);               // 将渲染纹理所有者转移到目标上下文
RLAPI void RLUnloadRenderTexture(RLRenderTexture2D target);                                                     // 从 GPU 内存 (VRAM) 卸载渲染纹理
RLAPI void RLUpdateTexture(RLTexture2D texture, const void *pixels);                                            // 更新 GPU使用新数据更新纹理（像素应能填充纹理）
RLAPI void RLUpdateTextureRec(RLTexture2D texture, RLRectangle rec, const void *pixels);                        // 使用新数据更新 GPU 纹理矩形（像素和矩形应适合纹理）

// 纹理配置函数
RLAPI void RLGenTextureMipmaps(RLTexture2D *texture);                                                        // 为纹理生成 GPU mipmap
RLAPI void RLSetTextureFilter(RLTexture2D texture, int filter);                                              // 设置纹理缩放过滤模式
RLAPI void RLSetTextureWrap(RLTexture2D texture, int wrap);                                                  // 设置纹理环绕模式

// 纹理绘制函数
RLAPI void RLDrawTexture(RLTexture2D texture, int posX, int posY, RLColor tint);                                                                // 绘制 Texture2D
RLAPI void RLDrawTextureV(RLTexture2D texture, RLVector2 position, RLColor tint);                                                               // 绘制一个位置定义为 Vector2 的 Texture2D
RLAPI void RLDrawTextureEx(RLTexture2D texture, RLVector2 position, float rotation, float scale, RLColor tint);                                 // 绘制一个带有扩展参数的 Texture2D
RLAPI void RLDrawTextureRec(RLTexture2D texture, RLRectangle source, RLVector2 position, RLColor tint);                                         // 绘制由矩形定义的纹理的一部分
RLAPI void RLDrawTexturePro(RLTexture2D texture, RLRectangle source, RLRectangle dest, RLVector2 origin, float rotation, RLColor tint);         // 绘制由矩形定义的纹理的一部分，并使用“pro”参数
RLAPI void RLDrawTextureNPatch(RLTexture2D texture, RLNPatchInfo nPatchInfo, RLRectangle dest, RLVector2 origin, float rotation, RLColor tint); // 绘制一个可以平滑拉伸或收缩的纹理（或其一部分）

// 颜色/像素相关函数
RLAPI bool RLColorIsEqual(RLColor col1, RLColor col2);                          // 检查两种颜色是否相等
RLAPI RLColor RLFade(RLColor color, float alpha);                               // 获取应用了透明度（Alpha 通道）的颜色，透明度范围为 0.0f 到 1.0f
RLAPI int RLColorToInt(RLColor color);                                          // 获取颜色的十六进制值 (0xRRGGBBAA)
RLAPI RLVector4 RLColorNormalize(RLColor color);                                // 获取归一化为浮点数 [0..1] 的颜色
RLAPI RLColor RLColorFromNormalized(RLVector4 normalized);                      // 从归一化值 [0..1] 获取颜色
RLAPI RLVector3 RLColorToHSV(RLColor color);                                    // 获取颜色的 HSV 值，色调 [0..360]，饱和度/明度 [0..1]
RLAPI RLColor RLColorFromHSV(float hue, float saturation, float value);         // 从 HSV 值获取颜色，色调 [0..360]，饱和度/明度 [0..1]
RLAPI RLColor RLColorTint(RLColor color, RLColor tint);                         // 获取颜色与另一种颜色相乘后的结果
RLAPI RLColor RLColorBrightness(RLColor color, float factor);                   // 获取应用了亮度校正的颜色，亮度因子范围为 -1.0f 到 1.0f
RLAPI RLColor RLColorContrast(RLColor color, float contrast);                   // 获取应用了对比度校正的颜色，对比度值范围为 -1.0f 到 1.0f
RLAPI RLColor RLColorAlpha(RLColor color, float alpha);                         // 获取应用了透明度（Alpha 通道）的颜色，透明度范围为 0.0f 到 1.0f
RLAPI RLColor RLColorAlphaBlend(RLColor dst, RLColor src, RLColor tint);        // 获取源颜色将 alpha 通道混合到目标颜色并添加色调
RLAPI RLColor RLColorLerp(RLColor color1, RLColor color2, float factor);        // 获取两种颜色之间的线性插值，插值因子为 [0.0f..1.0f]
RLAPI RLColor RLGetColor(unsigned int hexValue);                                // 从十六进制值获取颜色结构
RLAPI RLColor RLGetPixelColor(void *srcPtr, int format);                        // 从特定格式的源像素指针获取颜色
RLAPI void RLSetPixelColor(void *dstPtr, RLColor color, int format);            // 将格式化后的颜色设置到目标像素指针
RLAPI int RLGetPixelDataSize(int width, int height, int format);                // 获取特定格式的像素数据大小（以字节为单位）

//------------------------------------------------------------------------------------
// 字体加载和文本绘制功能（模块：文本）
//------------------------------------------------------------------------------------

// 字体加载/卸载功能
RLAPI RLFont RLGetFontDefault(void);                                                                                                                                // 获取默认字体
RLAPI RLFont RLLoadFont(const char *fileName);                                                                                                                      // 从文件加载字体到 GPU 内存 (VRAM)
RLAPI RLFont RLLoadFontEx(const char *fileName, int fontSize, const int *codepoints, int codepointCount);                                                           // 使用扩展参数从文件加载字体，使用 NULL 表示码点，0 表示码点计数以加载默认字符集，字体大小以像素高度为单位
RLAPI RLFont RLLoadFontFromImage(RLImage image, RLColor key, int firstChar);                                                                                        // 从图像加载字体（XNA 风格）
RLAPI RLFont RLLoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, const int *codepoints, int codepointCount);      // 从内存缓冲区加载字体，fileType 指的是文件扩展名，例如 '.ttf'
RLAPI bool RLIsFontValid(RLFont font);                                                                                                                              // 检查字体是否有效（字体数据已加载，警告：未检查 GPU 纹理）
RLAPI RLGlyphInfo *RLLoadFontData(const unsigned char *fileData, int dataSize, int fontSize, const int *codepoints, int codepointCount, int type, int *glyphCount); // 加载字体数据以供后续使用
RLAPI RLImage RLGenImageFontAtlas(const RLGlyphInfo *glyphs, RLRectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod);                   // 使用字符信息生成图像字体图集
RLAPI void RLUnloadFontData(RLGlyphInfo *glyphs, int glyphCount);                                                                                                   // 卸载字体字符信息数据（RAM）
RLAPI bool RLRetainFont(RLFont font);                                                                                                                               // 增加已加载字体对象的 CPU 端引用计数
RLAPI bool RLReleaseFont(RLFont font);                                                                                                                              // 减少 CPU 端引用计数，并在其达到零时销毁
RLAPI RLContext* RLGetFontOwnerContext(RLFont font);                                                                                                                // 查询字体所有者上下文（如果未跟踪则为 NULL）
RLAPI bool RLIsFontOwnedByCurrentContext(RLFont font);                                                                                                              // 检查字体所有者是否为当前上下文
RLAPI bool RLTryTransferFontOwner(RLFont font, RLContext* targetCtx);                                                                                               // 将字体所有者转移到目标上下文
RLAPI void RLUnloadFont(RLFont font);                                                                                                                               // 从 GPU 内存 (VRAM) 卸载字体
RLAPI bool RLExportFontAsCode(RLFont font, const char *fileName);                                                                                                   // 将字体导出为代码文件，如果为真则返回 true 成功

// 文本绘制函数
RLAPI void RLDrawFPS(int posX, int posY);                                                                                                                   // 绘制当前帧率
RLAPI void RLDrawText(const char *text, int posX, int posY, int fontSize, RLColor color);                                                                   // 绘制文本（使用默认字体）
RLAPI void RLDrawTextEx(RLFont font, const char *text, RLVector2 position, float fontSize, float spacing, RLColor tint);                                    // 使用字体和其他参数绘制文本
RLAPI void RLDrawTextPro(RLFont font, const char *text, RLVector2 position, RLVector2 origin, float rotation, float fontSize, float spacing, RLColor tint); // 使用字体和专业参数（旋转）绘制文本
RLAPI void RLDrawTextCodepoint(RLFont font, int codepoint, RLVector2 position, float fontSize, RLColor tint);                                               // 绘制单个字符（代码点）
RLAPI void RLDrawTextCodepoints(RLFont font, const int *codepoints, int codepointCount, RLVector2 position, float fontSize, float spacing, RLColor tint);   // 绘制多个字符（代码点）

// 文本字体信息函数
RLAPI void RLSetTextLineSpacing(int spacing);                                                       // 设置带换行符绘图时的垂直行距
RLAPI int RLMeasureText(const char *text, int fontSize);                                            // 测量默认字体的字符串宽度
RLAPI RLVector2 RLMeasureTextEx(RLFont font, const char *text, float fontSize, float spacing);      // 测量字体的字符串大小
RLAPI int RLGetGlyphIndex(RLFont font, int codepoint);                                              // 获取代码点（Unicode 字符）在字体中的字形索引位置，如果未找到则回退到“？”
RLAPI RLGlyphInfo RLGetGlyphInfo(RLFont font, int codepoint);                                       // 获取代码点（Unicode 字符）的字形字体信息数据，如果未找到则回退到“？”
RLAPI RLRectangle RLGetGlyphAtlasRec(RLFont font, int codepoint);                                   // 获取代码点（Unicode 字符）在字体图集中的字形矩形，如果未找到则回退到“？”

// 文本码位管理函数（Unicode字符）
RLAPI char *RLLoadUTF8(const int *codepoints, int length);                                    // 从码位数组加载 UTF-8 编码的文本
RLAPI void RLUnloadUTF8(char *text);                                                          // 从码位数组卸载 UTF-8 编码的文本
RLAPI int *RLLoadCodepoints(const char *text, int *count);                                    // 从 UTF-8 文本字符串加载所有码位，码位数量由参数返回
RLAPI void RLUnloadCodepoints(int *codepoints);                                               // 从内存卸载码位数据
RLAPI int RLGetCodepointCount(const char *text);                                              // 获取 UTF-8 编码字符串中的码位总数
RLAPI int RLGetCodepoint(const char *text, int *codepointSize);                               // 获取 UTF-8 编码字符串中的下一个码位，失败时返回 0x3f('?')
RLAPI int RLGetCodepointNext(const char *text, int *codepointSize);                           // 获取 UTF-8 编码字符串中的下一个码位，失败时返回 0x3f('?')
RLAPI int RLGetCodepointPrevious(const char *text, int *codepointSize);                       // 获取 UTF-8 编码字符串中的上一个码位，失败时返回 0x3f('?')
RLAPI const char *RLCodepointToUTF8(int codepoint, int *utf8Size);                            // 将一个码位编码为 UTF-8 字节数组（数组长度由参数返回）

// 文本字符串管理函数（不支持 UTF-8 字符串，仅支持字节字符）
// 警告 1：这些函数大多使用内部静态缓冲区[]，建议将返回数据存储在用户端以便重用
// 警告 2：某些字符串会在内部为返回的字符串分配内存，用户必须使用 MemFree() 函数释放这些内存。
RLAPI char **RLLoadTextLines(const char *text, int *count);                                                         // 将文本作为单独的行加载（'\n'），分配失败时返回 NULL
RLAPI void RLUnloadTextLines(char **text, int lineCount);                                                           // 卸载文本行
RLAPI int RLTextCopy(char *dst, const char *src);                                                                   // 将一个字符串复制到另一个字符串，返回复制的字节数
RLAPI bool RLTextIsEqual(const char *text1, const char *text2);                                                     // 检查两个文本字符串是否相等
RLAPI unsigned int RLTextLength(const char *text);                                                                  // 获取文本长度，检查是否以 '\0' 结尾
RLAPI const char *RLTextFormat(const char *text, ...);                                                              // 使用变量进行文本格式化（类似 sprintf() 函数）
RLAPI int RLTextFormatTo(char *outText, int outTextSize, const char *text, ...);                                    // 将文本格式化到用户缓冲区，返回所需的字节数（不包括终止符）
RLAPI const char *RLTextSubtext(const char *text, int position, int length);                                        // 获取文本字符串的一部分
RLAPI const char *RLTextRemoveSpaces(const char *text);                                                             // 删除文本空格，连接单词
RLAPI char *RLGetTextBetween(const char *text, const char *begin, const char *end);                                 // 获取两个字符串之间的文本
RLAPI char *RLTextReplace(const char *text, const char *search, const char *replacement);                           // 替换文本字符串（警告：必须释放内存！）
RLAPI char *RLTextReplaceBetween(const char *text, const char *begin, const char *end, const char *replacement);    // 替换两个指定字符串之间的文本（警告：必须释放内存！）
RLAPI char *RLTextInsert(const char *text, const char *insert, int position);                                       // 在指定位置插入文本（警告：必须释放内存！）
RLAPI char *RLTextJoin(char **textList, int count, const char *delimiter);                                          // 使用分隔符连接文本字符串
RLAPI char **RLTextSplit(const char *text, char delimiter, int *count);                                             // 使用 MAX_TEXTSPLIT_COUNT 个静态字符串将文本拆分为多个字符串
RLAPI void RLTextAppend(char *text, const char *append, int *position);                                             // 在指定位置追加文本并移动光标
RLAPI int RLTextFindIndex(const char *text, const char *search);                                                    // 查找字符串中的第一个文本匹配项，如果未找到则返回 -1已找到
RLAPI char *RLTextToUpper(const char *text);                                                                        // 获取指定字符串的大写版本
RLAPI char *RLTextToLower(const char *text);                                                                        // 获取指定字符串的小写版本
RLAPI char *RLTextToPascal(const char *text);                                                                       // 获取指定字符串的 Pascal 命名法版本
RLAPI char *RLTextToSnake(const char *text);                                                                        // 获取指定字符串的 Snake 命名法版本
RLAPI char *RLTextToCamel(const char *text);                                                                        // 获取指定字符串的 Camel 命名法版本
RLAPI int RLTextToInteger(const char *text);                                                                        // 从文本中获取整数值
RLAPI float RLTextToFloat(const char *text);                                                                        // 从文本中获取浮点值

//------------------------------------------------------------------------------------
// 基本三维图形绘制功能（模块：模型）
//------------------------------------------------------------------------------------

// 基本几何三维图形绘制功能
RLAPI void RLDrawLine3D(RLVector3 startPos, RLVector3 endPos, RLColor color);                                                           // 在三维世界空间中绘制一条线
RLAPI void RLDrawPoint3D(RLVector3 position, RLColor color);                                                                            // 在三维空间中绘制一个点，实际上是一条短线
RLAPI void RLDrawCircle3D(RLVector3 center, float radius, RLVector3 rotationAxis, float rotationAngle, RLColor color);                  // 在三维世界空间中绘制一个圆
RLAPI void RLDrawTriangle3D(RLVector3 v1, RLVector3 v2, RLVector3 v3, RLColor color);                                                   // 绘制一个填充颜色的三角形（顶点按逆时针方向排列！）
RLAPI void RLDrawTriangleStrip3D(const RLVector3 *points, int pointCount, RLColor color);                                               // 绘制一个由点定义的三角形带
RLAPI void RLDrawCube(RLVector3 position, float width, float height, float length, RLColor color);                                      // 绘制一个立方体
RLAPI void RLDrawCubeV(RLVector3 position, RLVector3 size, RLColor color);                                                              // 绘制一个立方体（矢量版本）
RLAPI void RLDrawCubeWires(RLVector3 position, float width, float height, float length, RLColor color);                                 // 绘制立方体线框
RLAPI void RLDrawCubeWiresV(RLVector3 position, RLVector3 size, RLColor color);                                                         // 绘制一个立方体线框（矢量版本）
RLAPI void RLDrawSphere(RLVector3 centerPos, float radius, RLColor color);                                                              // 绘制一个球体
RLAPI void RLDrawSphereEx(RLVector3 centerPos, float radius, int rings, int slices, RLColor color);                                     // 绘制一个带有扩展参数的球体
RLAPI void RLDrawSphereWires(RLVector3 centerPos, float radius, int rings, int slices, RLColor color);                                  // 绘制一个球体线框
RLAPI void RLDrawCylinder(RLVector3 position, float radiusTop, float radiusBottom, float height, int slices, RLColor color);            // 绘制一个圆柱体/圆锥体
RLAPI void RLDrawCylinderEx(RLVector3 startPos, RLVector3 endPos, float startRadius, float endRadius, int sides, RLColor color);        // 绘制一个圆柱体线框，其底面位于 startPos，顶面位于 endPos
RLAPI void RLDrawCylinderWires(RLVector3 position, float radiusTop, float radiusBottom, float height, int slices, RLColor color);       // 绘制一个圆柱体/圆锥体线框
RLAPI void RLDrawCylinderWiresEx(RLVector3 startPos, RLVector3 endPos, float startRadius, float endRadius, int sides, RLColor color);   // 绘制一个圆柱体线框，底面位于 startPos，顶面位于 endPos
RLAPI void RLDrawCapsule(RLVector3 startPos, RLVector3 endPos, float radius, int slices, int rings, RLColor color);                     // 绘制一个胶囊体，其球冠中心分别位于 startPos 和 endPos
RLAPI void RLDrawCapsuleWires(RLVector3 startPos, RLVector3 endPos, float radius, int slices, int rings, RLColor color);                // 绘制一个胶囊体线框，其球冠中心分别位于 startPos 和 endPos
RLAPI void RLDrawPlane(RLVector3 centerPos, RLVector2 size, RLColor color);                                                             // 绘制一个 XZ 平面
RLAPI void RLDrawRay(RLRay ray, RLColor color);                                                                                         // 绘制一条射线
RLAPI void RLDrawGrid(int slices, float spacing);                                                                                       // 绘制一个网格（中心位于 (0, 0, 0)）

//------------------------------------------------------------------------------------
// 三维模型加载和绘制功能（模块：模型）
//------------------------------------------------------------------------------------

// 模型管理功能
RLAPI RLModel RLLoadModel(const char *fileName);                                                // 从文件加载模型（网格和材质）
RLAPI RLModel RLLoadModelFromMesh(RLMesh mesh);                                                 // 从生成的网格加载模型（默认材质）
RLAPI bool RLIsModelValid(RLModel model);                                                       // 检查模型是否有效（已加载到 GPU、VAO/VBO）
RLAPI bool RLRetainModelObject(RLModel model);                                                  // 增加模型对象的 CPU 端引用计数
RLAPI bool RLReleaseModelObject(RLModel model);                                                 // 减少 CPU 端引用计数，并在计数达到零时销毁模型
RLAPI RLContext* RLGetModelObjectOwnerContext(RLModel model);                                   // 查询模型所有者上下文（如果未跟踪则为 NULL）
RLAPI bool RLIsModelObjectOwnedByCurrentContext(RLModel model);                                 // 检查模型所有者是否为当前上下文
RLAPI bool RLTryTransferModelObjectOwner(RLModel model, RLContext* targetCtx);                  // 将模型所有者转移到目标上下文
RLAPI void RLUnloadModel(RLModel model);                                                        // 从内存（RAM 和/或 VRAM）卸载模型（包括网格）
RLAPI RLBoundingBox RLGetModelBoundingBox(RLModel model);                                       // 计算模型边界框范围（考虑所有网格）

// 模型绘图功能
RLAPI void RLDrawModel(RLModel model, RLVector3 position, float scale, RLColor tint);                                                                                                       // 绘制模型（如果设置了纹理，则包含纹理）
RLAPI void RLDrawModelEx(RLModel model, RLVector3 position, RLVector3 rotationAxis, float rotationAngle, RLVector3 scale, RLColor tint);                                                    // 绘制带有扩展参数的模型
RLAPI void RLDrawModelWires(RLModel model, RLVector3 position, float scale, RLColor tint);                                                                                                  // 绘制模型线框（如果设置了纹理，则包含纹理）
RLAPI void RLDrawModelWiresEx(RLModel model, RLVector3 position, RLVector3 rotationAxis, float rotationAngle, RLVector3 scale, RLColor tint);                                               // 绘制带有扩展参数的模型线框（如果设置了纹理，则包含纹理）
RLAPI void RLDrawModelPoints(RLModel model, RLVector3 position, float scale, RLColor tint);                                                                                                 // 将模型绘制为点阵
RLAPI void RLDrawModelPointsEx(RLModel model, RLVector3 position, RLVector3 rotationAxis, float rotationAngle, RLVector3 scale, RLColor tint);                                              // 将模型绘制为带有扩展参数的点阵
RLAPI void RLDrawBoundingBox(RLBoundingBox box, RLColor color);                                                                                                                             // 绘制边界框（线阵）
RLAPI void RLDrawBillboard(RLCamera camera, RLTexture2D texture, RLVector3 position, float scale, RLColor tint);                                                                            // 绘制公告牌纹理
RLAPI void RLDrawBillboardRec(RLCamera camera, RLTexture2D texture, RLRectangle source, RLVector3 position, RLVector2 size, RLColor tint);                                                  // 绘制由源定义的公告牌纹理
RLAPI void RLDrawBillboardPro(RLCamera camera, RLTexture2D texture, RLRectangle source, RLVector3 position, RLVector3 up, RLVector2 size, RLVector2 origin, float rotation, RLColor tint);  // 绘制由源和旋转定义的公告牌纹理

// 网格管理功能
RLAPI void RLUploadMesh(RLMesh *mesh, bool dynamic);                                                         // 将网格顶点数据上传到 GPU 并提供 VAO/VBO ID
RLAPI void RLUpdateMeshBuffer(RLMesh mesh, int index, const void *data, int dataSize, int offset);           // 更新 GPU 中特定缓冲区索引的网格顶点数据
RLAPI bool RLRetainMeshObject(RLMesh mesh);                                                                  // 增加网格对象的 CPU 端引用计数
RLAPI bool RLReleaseMeshObject(RLMesh mesh);                                                                 // 减少 CPU 端引用计数，并在计数达到零时销毁网格对象
RLAPI RLContext* RLGetMeshObjectOwnerContext(RLMesh mesh);                                                   // 查询网格所有者上下文（如果未跟踪则返回 NULL）
RLAPI bool RLIsMeshObjectOwnedByCurrentContext(RLMesh mesh);                                                 // 检查网格所有者是否为当前上下文
RLAPI bool RLTryTransferMeshObjectOwner(RLMesh mesh, RLContext* targetCtx);                                  // 将网格所有者转移到目标上下文
RLAPI void RLUnloadMesh(RLMesh mesh);                                                                        // 从 CPU 和 GPU 卸载网格数据
RLAPI void RLDrawMesh(RLMesh mesh, RLMaterial material, RLMatrix transform);                                 // 使用材质和变换绘制 3D 网格
RLAPI void RLDrawMeshInstanced(RLMesh mesh, RLMaterial material, const RLMatrix *transforms, int instances); // 使用材质和不同的变换绘制多个网格实例
RLAPI RLBoundingBox RLGetMeshBoundingBox(RLMesh mesh);                                                       // 计算网格边界框
RLAPI void RLGenMeshTangents(RLMesh *mesh);                                                                  // 计算网格切线
RLAPI bool RLExportMesh(RLMesh mesh, const char *fileName);                                                  // 将网格数据导出到文件，成功返回 true
RLAPI bool RLExportMeshAsCode(RLMesh mesh, const char *fileName);                                            // 将网格导出为定义多个顶点属性数组的代码文件 (.h)

// 网格生成函数
RLAPI RLMesh RLGenMeshPoly(int sides, float radius);                                            // 生成多边形网格
RLAPI RLMesh RLGenMeshPlane(float width, float length, int resX, int resZ);                     // 生成平面网格（带细分）
RLAPI RLMesh RLGenMeshCube(float width, float height, float length);                            // 生成长方体网格
RLAPI RLMesh RLGenMeshSphere(float radius, int rings, int slices);                              // 生成球体网格（标准球体）
RLAPI RLMesh RLGenMeshHemiSphere(float radius, int rings, int slices);                          // 生成半球体网格（无底面）
RLAPI RLMesh RLGenMeshCylinder(float radius, float height, int slices);                         // 生成圆柱体网格
RLAPI RLMesh RLGenMeshCone(float radius, float height, int slices);                             // 生成圆锥/棱锥网格
RLAPI RLMesh RLGenMeshTorus(float radius, float size, int radSeg, int sides);                   // 生成环面网格
RLAPI RLMesh RLGenMeshKnot(float radius, float size, int radSeg, int sides);                    // 生成三叶结网格
RLAPI RLMesh RLGenMeshHeightmap(RLImage heightmap, RLVector3 size);                             // 从图像数据生成高度图网格
RLAPI RLMesh RLGenMeshCubicmap(RLImage cubicmap, RLVector3 cubeSize);                           // 从图像数据生成基于立方体的地图网格

// 物料装载/卸载功能
RLAPI RLMaterial *RLLoadMaterials(const char *fileName, int *materialCount);                    // 从模型文件加载材质
RLAPI RLMaterial RLLoadMaterialDefault(void);                                                   // 加载默认材质（支持：漫反射、高光、法线贴图
RLAPI bool RLIsMaterialValid(RLMaterial material);                                              // 检查材质是否有效（着色器已分配、贴图纹理已加载到 GPU）
RLAPI bool RLRetainMaterialObject(RLMaterial material);                                         // 增加材质对象的 CPU 端引用计数
RLAPI bool RLReleaseMaterialObject(RLMaterial material);                                        // 减少 CPU 端引用计数，并在计数达到零时销毁材质对象
RLAPI RLContext* RLGetMaterialObjectOwnerContext(RLMaterial material);                          // 查询材质所有者上下文（如果未跟踪则返回 NULL）
RLAPI bool RLIsMaterialObjectOwnedByCurrentContext(RLMaterial material);                        // 检查材质所有者是否为当前上下文
RLAPI bool RLTryTransferMaterialObjectOwner(RLMaterial material, RLContext* targetCtx);         // 将材质所有者转移到目标上下文
RLAPI void RLUnloadMaterial(RLMaterial material);                                               // 从 GPU 内存 (VRAM) 中卸载材质
RLAPI void RLSetMaterialTexture(RLMaterial *material, int mapType, RLTexture2D texture);        // 设置材质贴图类型的纹理（MATERIAL_MAP_DIFFUSE、MATERIAL_MAP_SPECULAR 等）
RLAPI void RLSetModelMeshMaterial(RLModel *model, int meshId, int materialId);                  // 设置网格的材质

// 模型动画加载/卸载函数
RLAPI RLModelAnimation *RLLoadModelAnimations(const char *fileName, int *animCount);            // 从文件加载模型动画
RLAPI void RLUpdateModelAnimation(RLModel model, RLModelAnimation anim, int frame);             // 更新模型动画姿态（CPU）
RLAPI void RLUpdateModelAnimationBones(RLModel model, RLModelAnimation anim, int frame);        // 更新模型动画网格骨骼矩阵（GPU 蒙皮）
RLAPI void RLUnloadModelAnimation(RLModelAnimation anim);                                       // 卸载动画数据
RLAPI void RLUnloadModelAnimations(RLModelAnimation *animations, int animCount);                // 卸载动画数组数据
RLAPI bool RLIsModelAnimationValid(RLModel model, RLModelAnimation anim);                       // 检查模型动画骨架匹配情况

// 碰撞检测函数
RLAPI bool RLCheckCollisionSpheres(RLVector3 center1, float radius1, RLVector3 center2, float radius2);        // 检查两个球体之间的碰撞
RLAPI bool RLCheckCollisionBoxes(RLBoundingBox box1, RLBoundingBox box2);                                      // 检查两个边界框之间的碰撞
RLAPI bool RLCheckCollisionBoxSphere(RLBoundingBox box, RLVector3 center, float radius);                       // 检查边界框和球体之间的碰撞
RLAPI RLRayCollision RLGetRayCollisionSphere(RLRay ray, RLVector3 center, float radius);                       // 获取射线与球体之间的碰撞信息
RLAPI RLRayCollision RLGetRayCollisionBox(RLRay ray, RLBoundingBox box);                                       // 获取射线与边界框之间的碰撞信息
RLAPI RLRayCollision RLGetRayCollisionMesh(RLRay ray, RLMesh mesh, RLMatrix transform);                        // 获取射线与网格之间的碰撞信息
RLAPI RLRayCollision RLGetRayCollisionTriangle(RLRay ray, RLVector3 p1, RLVector3 p2, RLVector3 p3);           // 获取射线与三角形之间的碰撞信息
RLAPI RLRayCollision RLGetRayCollisionQuad(RLRay ray, RLVector3 p1, RLVector3 p2, RLVector3 p3, RLVector3 p4); // 获取射线与四边形之间的碰撞信息

//------------------------------------------------------------------------------------
// 音频加载和播放功能（模块：音频）
//------------------------------------------------------------------------------------
typedef void (*RLAudioCallback)(void *bufferData, unsigned int frames);

// 音频设备管理功能
RLAPI void RLInitAudioDevice(void);                                     // 初始化音频设备和上下文
RLAPI void RLCloseAudioDevice(void);                                    // 关闭音频设备和上下文
RLAPI bool RLIsAudioDeviceReady(void);                                  // 检查音频设备是否已成功初始化
RLAPI void RLSetMasterVolume(float volume);                             // 设置主音量（监听器）
RLAPI float RLGetMasterVolume(void);                                    // 获取主音量（监听器）

// 波形/声音加载/卸载函数
RLAPI RLWave RLLoadWave(const char *fileName);                                                          // 从文件加载波形数据
RLAPI RLWave RLLoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize);   // 从内存缓冲区加载波形，fileType 指的是文件扩展名，例如 '.wav'
RLAPI bool RLIsWaveValid(RLWave wave);                                                                  // 检查波形数据是否有效（数据和参数是否已加载）
RLAPI RLSound RLLoadSound(const char *fileName);                                                        // 从文件加载声音
RLAPI RLSound RLLoadSoundFromWave(RLWave wave);                                                         // 从波形数据加载声音
RLAPI RLSound RLLoadSoundAlias(RLSound source);                                                         // 创建一个与源声音共享相同采样数据的新声音，但不拥有该声音数据
RLAPI bool RLIsSoundValid(RLSound sound);                                                               // 检查声音是否有效（数据是否已加载且缓冲区已初始化）
RLAPI void RLUpdateSound(RLSound sound, const void *data, int sampleCount);                             // 使用新数据更新声音缓冲区（默认数据格式：32 位浮点数，立体声）
RLAPI void RLUnloadWave(RLWave wave);                                                                   // 卸载波形数据
RLAPI void RLUnloadSound(RLSound sound);                                                                // 卸载声音
RLAPI void RLUnloadSoundAlias(RLSound alias);                                                           // 卸载声音别名（不释放采样数据）
RLAPI bool RLExportWave(RLWave wave, const char *fileName);                                             // 将波形数据导出到文件，成功返回 true
RLAPI bool RLExportWaveAsCode(RLWave wave, const char *fileName);                                       // 将波形采样数据导出到代码（.h），成功返回 true

// 波形/声音管理功能
RLAPI void RLPlaySound(RLSound sound);                                                  // 播放声音
RLAPI void RLStopSound(RLSound sound);                                                  // 停止播放声音
RLAPI void RLPauseSound(RLSound sound);                                                 // 暂停声音
RLAPI void RLResumeSound(RLSound sound);                                                // 恢复暂停的声音
RLAPI bool RLIsSoundPlaying(RLSound sound);                                             // 检查声音是否正在播放
RLAPI void RLSetSoundVolume(RLSound sound, float volume);                               // 设置声音音量（1.0 为最大音量）
RLAPI void RLSetSoundPitch(RLSound sound, float pitch);                                 // 设置声音音调（1.0 为基准音调）
RLAPI void RLSetSoundPan(RLSound sound, float pan);                                     // 设置声音声像（-1.0 左，0.0 中，1.0 右）
RLAPI RLWave RLWaveCopy(RLWave wave);                                                   // 将波形复制到新波形
RLAPI void RLWaveCrop(RLWave *wave, int initFrame, int finalFrame);                     // 将波形裁剪到指定的帧范围
RLAPI void RLWaveFormat(RLWave *wave, int sampleRate, int sampleSize, int channels);    // 将波形数据转换为所需格式
RLAPI float *RLLoadWaveSamples(RLWave wave);                                            // 将波形中的采样数据加载为 32 位浮点数数据数组
RLAPI void RLUnloadWaveSamples(float *samples);                                         // 卸载使用 LoadWaveSamples() 加载的采样数据

// 音乐管理功能
RLAPI RLMusic RLLoadMusicStream(const char *fileName);                                                      // 从文件加载音乐流
RLAPI RLMusic RLLoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize);   // 从数据加载音乐流
RLAPI bool RLIsMusicValid(RLMusic music);                                                                   // 检查音乐流是否有效（上下文和缓冲区已初始化）
RLAPI void RLUnloadMusicStream(RLMusic music);                                                              // 卸载音乐流
RLAPI void RLPlayMusicStream(RLMusic music);                                                                // 开始播放音乐
RLAPI bool RLIsMusicStreamPlaying(RLMusic music);                                                           // 检查音乐是否正在播放
RLAPI void RLUpdateMusicStream(RLMusic music);                                                              // 更新音乐流的缓冲区
RLAPI void RLStopMusicStream(RLMusic music);                                                                // 停止播放音乐
RLAPI void RLPauseMusicStream(RLMusic music);                                                               // 暂停播放音乐
RLAPI void RLResumeMusicStream(RLMusic music);                                                              // 恢复播放已暂停的音乐
RLAPI void RLSeekMusicStream(RLMusic music, float position);                                                // 将音乐定位到指定位置（以秒为单位）
RLAPI void RLSetMusicVolume(RLMusic music, float volume);                                                   // 设置音乐音量（1.0 为最大音量）
RLAPI void RLSetMusicPitch(RLMusic music, float pitch);                                                     // 设置音乐音调（1.0 为基准音）
RLAPI void RLSetMusicPan(RLMusic music, float pan);                                                         // 设置音乐声像（-1.0 左，0.0 中，1.0 右）
RLAPI float RLGetMusicTimeLength(RLMusic music);                                                            // 获取音乐播放时长（以秒为单位）
RLAPI float RLGetMusicTimePlayed(RLMusic music);                                                            // 获取当前音乐播放时长（以秒为单位）

// 音频流管理功能
RLAPI RLAudioStream RLLoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // 加载音频流（用于传输原始音频 PCM 数据）
RLAPI bool RLIsAudioStreamValid(RLAudioStream stream);                                                          // 检查音频流是否有效（缓冲区已初始化）
RLAPI void RLUnloadAudioStream(RLAudioStream stream);                                                           // 卸载音频流并释放内存
RLAPI void RLUpdateAudioStream(RLAudioStream stream, const void *data, int frameCount);                         // 使用数据更新音频流缓冲区
RLAPI bool RLIsAudioStreamProcessed(RLAudioStream stream);                                                      // 检查是否有音频流缓冲区需要重新填充
RLAPI void RLPlayAudioStream(RLAudioStream stream);                                                             // 播放音频流
RLAPI void RLPauseAudioStream(RLAudioStream stream);                                                            // 暂停音频流
RLAPI void RLResumeAudioStream(RLAudioStream stream);                                                           // 恢复音频流
RLAPI bool RLIsAudioStreamPlaying(RLAudioStream stream);                                                        // 检查音频流是否正在播放
RLAPI void RLStopAudioStream(RLAudioStream stream);                                                             // 停止音频流
RLAPI void RLSetAudioStreamVolume(RLAudioStream stream, float volume);                                          // 设置音频流的音量（1.0 为最大音量）
RLAPI void RLSetAudioStreamPitch(RLAudioStream stream, float pitch);                                            // 设置音频流的音调（1.0 为基准音调）
RLAPI void RLSetAudioStreamPan(RLAudioStream stream, float pan);                                                // 设置音频流的声像（0.5 为居中声像）
RLAPI void RLSetAudioStreamBufferSizeDefault(int size);                                                         // 新音频流的默认大小
RLAPI void RLSetAudioStreamCallback(RLAudioStream stream, RLAudioCallback callback);                            // 音频线程回调，用于请求新数据

RLAPI void RLAttachAudioStreamProcessor(RLAudioStream stream, RLAudioCallback processor);                       // 将音频流处理器附加到音频流，接收帧 x 2 个采样点的“浮点数”（立体声）数据
RLAPI void RLDetachAudioStreamProcessor(RLAudioStream stream, RLAudioCallback processor);                       // 将音频流处理器从音频流中分离

RLAPI void RLAttachAudioMixedProcessor(RLAudioCallback processor);                                              // 将音频流处理器附加到整个音频管道，接收帧 x 2 个采样点的“浮点数”（立体声）数据
RLAPI void RLDetachAudioMixedProcessor(RLAudioCallback processor);                                              // 将音频流处理器从音频管道中分离整个音频管道

//------------------------------------------------------------------------------------
// 事件线程诊断（桌面 GLFW Win32 扩展）
//------------------------------------------------------------------------------------
// 注意：仅当使用 FLAG_WINDOW_EVENT_THREAD 且库构建时设置了 RL_EVENT_DIAG_STATS=1 时才有意义（参见 src/config.h 或编译定义）。

typedef struct RLEventThreadDiagStats {
    // 渲染线程任务包络（内部）
    unsigned long long renderCallAlloc;
    unsigned long long renderCallFree;

    // 有效载荷分配（跨线程发布的通用输入/窗口回调）
    unsigned long long payloadAlloc;
    unsigned long long payloadFree;
    unsigned long long payloadAllocBytes;
    unsigned long long payloadFreeBytes;
    unsigned long long payloadOutstandingMax;

    // 每个有效载荷的细分（仅计数；字节数包含在有效载荷*字节总数中）
    unsigned long long mouseMoveAlloc, mouseMoveFree;
    unsigned long long mouseWheelAlloc, mouseWheelFree;
    unsigned long long mouseButtonAlloc, mouseButtonFree;
    unsigned long long keyAlloc, keyFree;
    unsigned long long chAlloc, chFree;
    unsigned long long winPosAlloc, winPosFree;
    unsigned long long fbSizeAlloc, fbSizeFree;
    unsigned long long scaleAlloc, scaleFree;
    unsigned long long dropAlloc, dropFree;
    unsigned long long winCloseAlloc, winCloseFree;
    unsigned long long otherAlloc, otherFree;

    // 任务/泵性能
    // 注意：
    // - `taskQueueDepthCurrent` / `taskQueueDepthMax` 是 raylib 端的逻辑队列深度指标。
    // 它们源自 `tasksPosted - tasksExecuted`，可能与原生队列深度不同。
    // - `nativeTaskQueue*` 是 GLFW Win32 原生线程任务环形队列指标
    // （`queued`、`peak`、`dropped`、按类丢弃和唤醒统计信息）。
    unsigned long long tasksPosted;
    unsigned long long tasksExecuted;
    unsigned long long tasksPostFailed;
    unsigned long long taskQueueDepthCurrent;
    unsigned long long taskQueueDepthMax;
    // (*) 当启用事件诊断时，从后端原生任务队列诊断源镜像。
    unsigned int       nativeTaskQueueCount;
    unsigned int       nativeTaskQueuePeakCount;
    unsigned long long nativeTaskQueueDroppedCount;
    unsigned long long nativeTaskQueueDroppedCriticalCount;
    unsigned long long nativeTaskQueueDroppedStateCount;
    unsigned long long nativeTaskQueueDroppedInputCount;
    unsigned long long nativeTaskQueueDroppedMaintenanceCount;
    unsigned long long nativeTaskWakeSentCount;
    unsigned long long nativeTaskWakeDedupCount;
    unsigned int       nativeTaskQueueLastObservedCount;
    // (*) 当启用事件诊断时，从帧回调诊断源镜像（Win32 + 桌面 GLFW 事件线程路径）。
    unsigned int       frameCallbackQueueCount;
    unsigned int       frameCallbackQueueNormalCount;
    unsigned int       frameCallbackQueueCriticalCount;
    unsigned int       frameCallbackQueuePeakCount;
    unsigned int       frameCallbackQueuePeakNormalCount;
    unsigned int       frameCallbackQueuePeakCriticalCount;
    unsigned long long frameCallbackDroppedCount;
    unsigned long long frameCallbackDroppedNormalCount;
    unsigned long long frameCallbackDroppedCriticalCount;
    unsigned long long frameCallbackExecutedCount;
    unsigned long long frameCallbackExecutedNormalCount;
    unsigned long long frameCallbackExecutedCriticalCount;
    unsigned long long frameCallbackClearedCount;
    unsigned long long frameCallbackClearedNormalCount;
    unsigned long long frameCallbackClearedCriticalCount;
    unsigned long long frameCallbackInlineFallbackCount;
    unsigned long long frameCallbackInlineFallbackNormalCount;
    unsigned long long frameCallbackInlineFallbackCriticalCount;
    unsigned long long pumpCalls;
    unsigned long long pumpTasksExecutedTotal;
    unsigned int       pumpTasksExecutedMax;
    unsigned int       pumpTasksExecutedLast;
    double             pumpTimeTotalMs;
    double             pumpTimeMaxMs;
    double             pumpTimeLastMs;
    double             swapCostMaxMs;
    double             swapCostLastMs;
    double             waitCostMaxMs;
    double             waitCostLastMs;
    double             frameCpuMaxMs;
    double             frameCpuLastMs;
    // (*) 当启用事件诊断时，从 GPU 写入 API 的线程不匹配诊断源镜像。
    unsigned long long threadMismatchDetectedCount;
    unsigned long long threadMismatchHandoffAttemptedCount;
    unsigned long long threadMismatchHandoffSuccessCount;
    unsigned long long threadMismatchHandoffFailedCount;
    unsigned long long threadMismatchDeferredQueuedCount;
    unsigned long long threadMismatchDeferredExecutedCount;
    unsigned long long threadMismatchDeferredFailedCount;
    unsigned long long threadMismatchRejectedCount;
    unsigned long long threadMismatchLastCallerThreadId;
    void *threadMismatchLastWindowHandle;
    char threadMismatchLastApi[64];
    // (*) 启用事件诊断时，从共享 GPU 诊断源镜像。
    unsigned long long sharedUnregisteredRetainRejectCount;
    unsigned long long sharedUnregisteredReleaseRejectCount;
} RLEventThreadDiagStats;

typedef struct RLThreadMismatchDiagStats {
    unsigned long long detectedCount;           // 检测到的非渲染线程 GPU 写入尝试次数
    unsigned long long handoffAttemptedCount;   // 同步切换到渲染线程的尝试次数
    unsigned long long handoffSuccessCount;     // 同步切换成功的次数
    unsigned long long handoffFailedCount;      // 同步切换失败的次数
    unsigned long long deferredQueuedCount;     // 已排队的延迟帧回调切换次数
    unsigned long long deferredExecutedCount;   // 已执行的延迟帧回调切换次数
    unsigned long long deferredFailedCount;     // 延迟帧回调切换队列失败的次数
    unsigned long long rejectedCount;           // 处理不匹配后被拒绝的调用次数
    unsigned long long lastCallerThreadId;      // 最后一个调用线程 ID（如果在此平台上不可用，则为 0）
    void *lastWindowHandle;                     // 检测到不匹配时使用的窗口句柄（可以为 NULL）
    char lastApi[64];                           // 触发不匹配的最后一个 API 名称
} RLThreadMismatchDiagStats;

typedef struct RLFrameCallbackQueueStats {
    unsigned int queuedCount;                          // 已排队帧回调总数（普通帧回调 + 关键帧回调）
    unsigned int queuedNormalCount;                    // 已排队普通帧回调
    unsigned int queuedCriticalCount;                  // 已排队关键帧回调
    unsigned int queuedPeakCount;                      // 自上次重置以来已排队帧回调的峰值
    unsigned int queuedPeakNormalCount;                // 自上次重置以来已排队普通帧回调的峰值
    unsigned int queuedPeakCriticalCount;              // 自上次重置以来已排队关键帧回调的峰值
    unsigned long long droppedCount;                   // 已丢弃帧回调总数
    unsigned long long droppedNormalCount;             // 已丢弃普通帧回调
    unsigned long long droppedCriticalCount;           // 已丢弃关键帧回调
    unsigned long long executedCount;                  // 已执行帧回调总数
    unsigned long long executedNormalCount;            // 已执行普通帧回调
    unsigned long long executedCriticalCount;          // 已执行关键帧回调
    unsigned long long clearedCount;                   // 执行前已清除的已排队帧回调
    unsigned long long clearedNormalCount;             // 已清除普通帧回调
    unsigned long long clearedCriticalCount;           // 已清除关键帧回调
    unsigned long long inlineFallbackCount;            // 队列已满的回调在渲染线程上立即执行
    unsigned long long inlineFallbackNormalCount;      // 通过内联回退执行的普通回调
    unsigned long long inlineFallbackCriticalCount;    // 通过内联回退执行的关键回调
} RLFrameCallbackQueueStats;

typedef struct RLNativeTaskQueueDiagStats {
    unsigned int queuedCount;                          // 当前原生任务队列深度
    unsigned int peakCount;                            // 自上次重置以来的原生任务队列峰值深度
    unsigned long long droppedCount;                   // 已丢弃的原生任务总数
    unsigned long long droppedCriticalCount;           // 已丢弃的关键原生任务
    unsigned long long droppedStateCount;              // 已丢弃的状态类原生任务
    unsigned long long droppedInputCount;              // 已丢弃的输入类原生任务
    unsigned long long droppedMaintenanceCount;        // 已丢弃的维护类原生任务
    unsigned long long wakeSentCount;                  // 唤醒信号发送次数
    unsigned long long wakeDedupCount;                 // 唤醒信号去重次数
} RLNativeTaskQueueDiagStats;

typedef enum RLTrackedObjectDiagFlags {
    RL_TRACKED_OBJECT_DIAG_NONE = 0,
    RL_TRACKED_OBJECT_DIAG_LOG_RELEASE_CALLS = 0x01,          // 记录跟踪对象释放调用和最终引用计数转换
    RL_TRACKED_OBJECT_DIAG_DUMP_STATE_ON_RELEASE_MISS = 0x02, // 释放失败后转储跟踪对象表状态
    RL_TRACKED_OBJECT_DIAG_INCLUDE_TOMBSTONES = 0x04,         // 在 RLDebugDumpTrackedObjectState() 中包含墓碑条目
    RL_TRACKED_OBJECT_DIAG_LOG_PROMOTIONS = 0x08,             // 记录上下文到共享组的跟踪对象提升开始/结束和迁移条目
    RL_TRACKED_OBJECT_DIAG_AUDIT_PROMOTIONS = 0x10            // 审核提升结果，查找过时的上下文条目和重复的活动键
} RLTrackedObjectDiagFlags;

RLAPI RLEventThreadDiagStats RLGetEventThreadDiagStats(void);
RLAPI void RLResetEventThreadDiagStats(void);
RLAPI void RLResetEventThreadDiagStatsForCurrentContext(void);      // 仅重置当前上下文/窗口的核心事件诊断计数器
RLAPI void RLEnableEventDiagStats(void);                            // 运行时启用核心事件诊断计数和镜像 (*) 字段填充（仅当构建时 RL_EVENT_DIAG_STATS=1 时生效）
RLAPI void RLDisableEventDiagStats(void);                           // 运行时禁用核心事件诊断计数，并在 RLGetEventThreadDiagStats() 中抑制镜像 (*) 字段填充
RLAPI bool RLIsEventDiagStatsEnabled(void);                         // 检查运行时诊断开关
RLAPI void RLEnableThreadMismatchDiagStats(void);                   // 运行时启用线程不匹配诊断计数（仅当构建时 RL_THREAD_MISMATCH_DIAG_STATS=1 时生效）
RLAPI void RLDisableThreadMismatchDiagStats(void);                  // 运行时禁用线程不匹配诊断计数
RLAPI bool RLIsThreadMismatchDiagStatsEnabled(void);                // 检查线程不匹配诊断运行时开关
RLAPI RLThreadMismatchDiagStats RLGetThreadMismatchDiagStats(void); // 获取 GPU 写入 API 的线程不匹配诊断
RLAPI void RLResetThreadMismatchDiagStats(void);                    // 重置线程不匹配诊断
RLAPI void RLSetTrackedObjectDiagFlags(unsigned int flags);         // 配置跟踪对象诊断标志（仅当构建时 RL_TRACKED_OBJECT_DIAG=1 时生效）
RLAPI unsigned int RLGetTrackedObjectDiagFlags(void);               // 获取跟踪对象诊断标志
RLAPI void RLDebugDumpTrackedObjectState(const char *label);        //将跟踪对象表状态转储到日志

#if defined(_WIN32)
RLAPI void RLEnableFrameCallbackDiagStats(void);                                                        // 运行时启用帧回调累积诊断计数（仅当构建时 RL_FRAME_CALLBACK_DIAG_STATS=1 时有效）
RLAPI void RLDisableFrameCallbackDiagStats(void);                                                       // 运行时禁用帧回调累积诊断计数
RLAPI bool RLIsFrameCallbackDiagStatsEnabled(void);                                                     // 检查帧回调累积诊断运行时开关
RLAPI void RLResetCurrentWindowFrameCallbackDiagStats(void);                                            // 重置当前窗口/上下文的帧回调累积诊断
RLAPI bool RLGetCurrentWindowFrameCallbackQueueStats(RLFrameCallbackQueueStats *outStats);              // 获取当前窗口/上下文的轻量级帧回调队列统计信息
RLAPI bool RLGetWindowFrameCallbackQueueStatsByHandle(void* hwnd, RLFrameCallbackQueueStats *outStats); // 获取指定 raylib 窗口的轻量级帧回调队列统计信息
RLAPI int RLResetWindowFrameCallbackDiagStatsByHandle(void* hwnd, int wait);                            // 重置指定 raylib 窗口的帧回调累积诊断信息
RLAPI void RLResetAllFrameCallbackDiagStats(void);                                                      // 重置所有跟踪的 raylib 窗口的帧回调累积诊断信息
RLAPI bool RLGetCurrentWindowNativeTaskQueueDiagStats(RLNativeTaskQueueDiagStats *outStats);            // 获取当前窗口/上下文渲染线程的原生任务队列统计信息，而不将诊断任务加入队列
RLAPI bool RLGetNativeTaskQueueDiagStatsByHandle(void* hwnd, RLNativeTaskQueueDiagStats *outStats);     // 获取指定 raylib 窗口渲染线程的原生任务队列统计信息，而不影响队列计数器
RLAPI void RLResetCurrentWindowNativeTaskQueueDiagStats(void);                                          // 重置当前窗口/上下文渲染线程的原生任务队列统计信息
RLAPI int RLResetNativeTaskQueueDiagStatsByHandle(void* hwnd, int wait);                                // 重置原生指定 raylib 窗口渲染线程的任务队列统计信息；当前忽略 wait 参数
RLAPI int RLResetEventThreadDiagStatsByHandle(void* hwnd, int wait);                                    // 验证目标窗口句柄后，仅重置核心事件诊断计数器
#endif

#if defined(__cplusplus)
}
#endif

#endif // RAYLIB_H
