raylib 5.0.0.3__cp310-cp310-macosx_14_0_arm64.whl → 5.0.0.5__cp310-cp310-macosx_14_0_arm64.whl

raylib/rlgl.h.modified

@@ -0,0 +1,505 @@
+/**********************************************************************************************
+*
+*   rlgl v4.5 - A multi-OpenGL abstraction layer with an immediate-mode style API
+*
+*   DESCRIPTION:
+*       An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0)
+*       that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...)
+*
+*   ADDITIONAL NOTES:
+*       When choosing an OpenGL backend different than OpenGL 1.1, some internal buffer are
+*       initialized on rlglInit() to accumulate vertex data.
+*
+*       When an internal state change is required all the stored vertex data is renderer in batch,
+*       additionally, rlDrawRenderBatchActive() could be called to force flushing of the batch.
+*
+*       Some resources are also loaded for convenience, here the complete list:
+*          - Default batch (RLGL.defaultBatch): RenderBatch system to accumulate vertex data
+*          - Default texture (RLGL.defaultTextureId): 1x1 white pixel R8G8B8A8
+*          - Default shader (RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs)
+*
+*       Internal buffer (and resources) must be manually unloaded calling rlglClose().
+*
+*   CONFIGURATION:
+*       #define GRAPHICS_API_OPENGL_11
+*       #define GRAPHICS_API_OPENGL_21
+*       #define GRAPHICS_API_OPENGL_33
+*       #define GRAPHICS_API_OPENGL_43
+*       #define GRAPHICS_API_OPENGL_ES2
+*       #define GRAPHICS_API_OPENGL_ES3
+*           Use selected OpenGL graphics backend, should be supported by platform
+*           Those preprocessor defines are only used on rlgl module, if OpenGL version is
+*           required by any other module, use rlGetVersion() to check it
+*
+*       #define RLGL_IMPLEMENTATION
+*           Generates the implementation of the library into the included file.
+*           If not defined, the library is in header only mode and can be included in other headers
+*           or source files without problems. But only ONE file should hold the implementation.
+*
+*       #define RLGL_RENDER_TEXTURES_HINT
+*           Enable framebuffer objects (fbo) support (enabled by default)
+*           Some GPUs could not support them despite the OpenGL version
+*
+*       #define RLGL_SHOW_GL_DETAILS_INFO
+*           Show OpenGL extensions and capabilities detailed logs on init
+*
+*       #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT
+*           Enable debug context (only available on OpenGL 4.3)
+*
+*       rlgl capabilities could be customized just defining some internal
+*       values before library inclusion (default values listed):
+*
+*       #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS   8192    // Default internal render batch elements limits
+*       #define RL_DEFAULT_BATCH_BUFFERS              1    // Default number of batch buffers (multi-buffering)
+*       #define RL_DEFAULT_BATCH_DRAWCALLS          256    // Default number of batch draw calls (by state changes: mode, texture)
+*       #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS    4    // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
+*
+*       #define RL_MAX_MATRIX_STACK_SIZE             32    // Maximum size of internal Matrix stack
+*       #define RL_MAX_SHADER_LOCATIONS              32    // Maximum number of shader locations supported
+*       #define RL_CULL_DISTANCE_NEAR              0.01    // Default projection matrix near cull distance
+*       #define RL_CULL_DISTANCE_FAR             1000.0    // Default projection matrix far cull distance
+*
+*       When loading a shader, the following vertex attributes and uniform
+*       location names are tried to be set automatically:
+*
+*       #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Bound by default to shader location: 0
+*       #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Bound by default to shader location: 1
+*       #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL       "vertexNormal"      // Bound by default to shader location: 2
+*       #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Bound by default to shader location: 3
+*       #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT      "vertexTangent"     // Bound by default to shader location: 4
+*       #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Bound by default to shader location: 5
+*       #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP         "mvp"               // model-view-projection matrix
+*       #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW        "matView"           // view matrix
+*       #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION  "matProjection"     // projection matrix
+*       #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL       "matModel"          // model matrix
+*       #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL      "matNormal"         // normal matrix (transpose(inverse(matModelView))
+*       #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR       "colDiffuse"        // color diffuse (base tint color, multiplied by texture color)
+*       #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0  "texture0"          // texture0 (texture slot active 0)
+*       #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1  "texture1"          // texture1 (texture slot active 1)
+*       #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2  "texture2"          // texture2 (texture slot active 2)
+*
+*   DEPENDENCIES:
+*      - OpenGL libraries (depending on platform and OpenGL version selected)
+*      - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core, 4.3 Core)
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2014-2023 Ramon Santamaria (@raysan5)
+*
+*   This software is provided "as-is", without any express or implied warranty. In no event
+*   will the authors be held liable for any damages arising from the use of this software.
+*
+*   Permission is granted to anyone to use this software for any purpose, including commercial
+*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
+*
+*     1. The origin of this software must not be misrepresented; you must not claim that you
+*     wrote the original software. If you use this software in a product, an acknowledgment
+*     in the product documentation would be appreciated but is not required.
+*
+*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
+*     as being the original software.
+*
+*     3. This notice may not be removed or altered from any source distribution.
+*
+**********************************************************************************************/
+// Function specifiers in case library is build/used as a shared library (Windows)
+// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
+// Function specifiers definition
+// Support TRACELOG macros
+// Allow custom memory allocators
+// Security check in case no GRAPHICS_API_OPENGL_* defined
+// Security check in case multiple GRAPHICS_API_OPENGL_* defined
+// OpenGL 2.1 uses most of OpenGL 3.3 Core functionality
+// WARNING: Specific parts are checked with #if defines
+// OpenGL 4.3 uses OpenGL 3.3 Core functionality
+// OpenGL ES 3.0 uses OpenGL ES 2.0 functionality (and more)
+// Support framebuffer objects by default
+// NOTE: Some driver implementation do not support it, despite they should
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+// Default internal render batch elements limits
+        // This is the maximum amount of elements (quads) per batch
+        // NOTE: Be careful with text, every letter maps to a quad
+// Internal Matrix stack
+// Shader limits
+// Projection matrix culling
+// Texture parameters (equivalent to OpenGL defines)
+// Matrix modes (equivalent to OpenGL)
+// Primitive assembly draw modes
+// GL equivalent data types
+// GL buffer usage hint
+// GL Shader type
+// GL blending factors
+// GL blending functions/equations
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+// Dynamic vertex buffers (position + texcoords + colors + indices arrays)
+typedef struct rlVertexBuffer {
+    int elementCount; // Number of elements in the buffer (QUADS)
+    float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+    float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
+    unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
+    unsigned int *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad)
+    unsigned int vaoId; // OpenGL Vertex Array Object id
+    unsigned int vboId[4]; // OpenGL Vertex Buffer Objects id (4 types of vertex data)
+} rlVertexBuffer;
+// Draw call type
+// NOTE: Only texture changes register a new draw, other state-change-related elements are not
+// used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any
+// of those state-change happens (this is done in core module)
+typedef struct rlDrawCall {
+    int mode; // Drawing mode: LINES, TRIANGLES, QUADS
+    int vertexCount; // Number of vertex of the draw
+    int vertexAlignment; // Number of vertex required for index alignment (LINES, TRIANGLES)
+    //unsigned int vaoId;       // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId
+    //unsigned int shaderId;    // Shader id to be used on the draw -> Using RLGL.currentShaderId
+    unsigned int textureId; // Texture id to be used on the draw -> Use to create new draw call if changes
+    //Matrix projection;        // Projection matrix for this draw -> Using RLGL.projection by default
+    //Matrix modelview;         // Modelview matrix for this draw -> Using RLGL.modelview by default
+} rlDrawCall;
+// rlRenderBatch type
+typedef struct rlRenderBatch {
+    int bufferCount; // Number of vertex buffers (multi-buffering support)
+    int currentBuffer; // Current buffer tracking in case of multi-buffering
+    rlVertexBuffer *vertexBuffer; // Dynamic buffer(s) for vertex data
+    rlDrawCall *draws; // Draw calls array, depends on textureId
+    int drawCounter; // Draw calls counter
+    float currentDepth; // Current depth value for next draw
+} rlRenderBatch;
+// OpenGL version
+typedef enum {
+    RL_OPENGL_11 = 1, // OpenGL 1.1
+    RL_OPENGL_21, // OpenGL 2.1 (GLSL 120)
+    RL_OPENGL_33, // OpenGL 3.3 (GLSL 330)
+    RL_OPENGL_43, // OpenGL 4.3 (using GLSL 330)
+    RL_OPENGL_ES_20, // OpenGL ES 2.0 (GLSL 100)
+    RL_OPENGL_ES_30 // OpenGL ES 3.0 (GLSL 300 es)
+} rlGlVersion;
+// Trace log level
+// NOTE: Organized by priority level
+typedef enum {
+    RL_LOG_ALL = 0, // Display all logs
+    RL_LOG_TRACE, // Trace logging, intended for internal use only
+    RL_LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds
+    RL_LOG_INFO, // Info logging, used for program execution info
+    RL_LOG_WARNING, // Warning logging, used on recoverable failures
+    RL_LOG_ERROR, // Error logging, used on unrecoverable failures
+    RL_LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE)
+    RL_LOG_NONE // Disable logging
+} rlTraceLogLevel;
+// Texture pixel formats
+// NOTE: Support depends on OpenGL version
+typedef enum {
+    RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
+    RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels)
+    RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp
+    RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp
+    RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha)
+    RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha)
+    RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp
+    RL_PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float)
+    RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float)
+    RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float)
+    RL_PIXELFORMAT_UNCOMPRESSED_R16, // 16 bpp (1 channel - half float)
+    RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16, // 16*3 bpp (3 channels - half float)
+    RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, // 16*4 bpp (4 channels - half float)
+    RL_PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha)
+    RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha)
+    RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp
+} rlPixelFormat;
+// Texture parameters: filter mode
+// NOTE 1: Filtering considers mipmaps if available in the texture
+// NOTE 2: Filter is accordingly set for minification and magnification
+typedef enum {
+    RL_TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation
+    RL_TEXTURE_FILTER_BILINEAR, // Linear filtering
+    RL_TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps)
+    RL_TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x
+    RL_TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x
+    RL_TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x
+} rlTextureFilter;
+// Color blending modes (pre-defined)
+typedef enum {
+    RL_BLEND_ALPHA = 0, // Blend textures considering alpha (default)
+    RL_BLEND_ADDITIVE, // Blend textures adding colors
+    RL_BLEND_MULTIPLIED, // Blend textures multiplying colors
+    RL_BLEND_ADD_COLORS, // Blend textures adding colors (alternative)
+    RL_BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative)
+    RL_BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha
+    RL_BLEND_CUSTOM, // Blend textures using custom src/dst factors (use rlSetBlendFactors())
+    RL_BLEND_CUSTOM_SEPARATE // Blend textures using custom src/dst factors (use rlSetBlendFactorsSeparate())
+} rlBlendMode;
+// Shader location point type
+typedef enum {
+    RL_SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position
+    RL_SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01
+    RL_SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02
+    RL_SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal
+    RL_SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent
+    RL_SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color
+    RL_SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection
+    RL_SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform)
+    RL_SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection
+    RL_SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform)
+    RL_SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal
+    RL_SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view
+    RL_SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color
+    RL_SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color
+    RL_SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color
+    RL_SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE)
+    RL_SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR)
+    RL_SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal
+    RL_SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness
+    RL_SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion
+    RL_SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission
+    RL_SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height
+    RL_SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap
+    RL_SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance
+    RL_SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter
+    RL_SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf
+} rlShaderLocationIndex;
+// Shader uniform data type
+typedef enum {
+    RL_SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float
+    RL_SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float)
+    RL_SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float)
+    RL_SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float)
+    RL_SHADER_UNIFORM_INT, // Shader uniform type: int
+    RL_SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int)
+    RL_SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int)
+    RL_SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int)
+    RL_SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d
+} rlShaderUniformDataType;
+// Shader attribute data types
+typedef enum {
+    RL_SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float
+    RL_SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float)
+    RL_SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float)
+    RL_SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float)
+} rlShaderAttributeDataType;
+// Framebuffer attachment type
+// NOTE: By default up to 8 color channels defined, but it can be more
+typedef enum {
+    RL_ATTACHMENT_COLOR_CHANNEL0 = 0, // Framebuffer attachment type: color 0
+    RL_ATTACHMENT_COLOR_CHANNEL1 = 1, // Framebuffer attachment type: color 1
+    RL_ATTACHMENT_COLOR_CHANNEL2 = 2, // Framebuffer attachment type: color 2
+    RL_ATTACHMENT_COLOR_CHANNEL3 = 3, // Framebuffer attachment type: color 3
+    RL_ATTACHMENT_COLOR_CHANNEL4 = 4, // Framebuffer attachment type: color 4
+    RL_ATTACHMENT_COLOR_CHANNEL5 = 5, // Framebuffer attachment type: color 5
+    RL_ATTACHMENT_COLOR_CHANNEL6 = 6, // Framebuffer attachment type: color 6
+    RL_ATTACHMENT_COLOR_CHANNEL7 = 7, // Framebuffer attachment type: color 7
+    RL_ATTACHMENT_DEPTH = 100, // Framebuffer attachment type: depth
+    RL_ATTACHMENT_STENCIL = 200, // Framebuffer attachment type: stencil
+} rlFramebufferAttachType;
+// Framebuffer texture attachment type
+typedef enum {
+    RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0, // Framebuffer texture attachment type: cubemap, +X side
+    RL_ATTACHMENT_CUBEMAP_NEGATIVE_X = 1, // Framebuffer texture attachment type: cubemap, -X side
+    RL_ATTACHMENT_CUBEMAP_POSITIVE_Y = 2, // Framebuffer texture attachment type: cubemap, +Y side
+    RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y = 3, // Framebuffer texture attachment type: cubemap, -Y side
+    RL_ATTACHMENT_CUBEMAP_POSITIVE_Z = 4, // Framebuffer texture attachment type: cubemap, +Z side
+    RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z = 5, // Framebuffer texture attachment type: cubemap, -Z side
+    RL_ATTACHMENT_TEXTURE2D = 100, // Framebuffer texture attachment type: texture2d
+    RL_ATTACHMENT_RENDERBUFFER = 200, // Framebuffer texture attachment type: renderbuffer
+} rlFramebufferAttachTextureType;
+// Face culling mode
+typedef enum {
+    RL_CULL_FACE_FRONT = 0,
+    RL_CULL_FACE_BACK
+} rlCullMode;
+//------------------------------------------------------------------------------------
+// Functions Declaration - Matrix operations
+//------------------------------------------------------------------------------------
+      void rlMatrixMode(int mode); // Choose the current matrix to be transformed
+      void rlPushMatrix(void); // Push the current matrix to stack
+      void rlPopMatrix(void); // Pop latest inserted matrix from stack
+      void rlLoadIdentity(void); // Reset current matrix to identity matrix
+      void rlTranslatef(float x, float y, float z); // Multiply the current matrix by a translation matrix
+      void rlRotatef(float angle, float x, float y, float z); // Multiply the current matrix by a rotation matrix
+      void rlScalef(float x, float y, float z); // Multiply the current matrix by a scaling matrix
+      void rlMultMatrixf(const float *matf); // Multiply the current matrix by another matrix
+      void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar);
+      void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar);
+      void rlViewport(int x, int y, int width, int height); // Set the viewport area
+//------------------------------------------------------------------------------------
+// Functions Declaration - Vertex level operations
+//------------------------------------------------------------------------------------
+      void rlBegin(int mode); // Initialize drawing mode (how to organize vertex)
+      void rlEnd(void); // Finish vertex providing
+      void rlVertex2i(int x, int y); // Define one vertex (position) - 2 int
+      void rlVertex2f(float x, float y); // Define one vertex (position) - 2 float
+      void rlVertex3f(float x, float y, float z); // Define one vertex (position) - 3 float
+      void rlTexCoord2f(float x, float y); // Define one vertex (texture coordinate) - 2 float
+      void rlNormal3f(float x, float y, float z); // Define one vertex (normal) - 3 float
+      void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Define one vertex (color) - 4 byte
+      void rlColor3f(float x, float y, float z); // Define one vertex (color) - 3 float
+      void rlColor4f(float x, float y, float z, float w); // Define one vertex (color) - 4 float
+//------------------------------------------------------------------------------------
+// Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2)
+// NOTE: This functions are used to completely abstract raylib code from OpenGL layer,
+// some of them are direct wrappers over OpenGL calls, some others are custom
+//------------------------------------------------------------------------------------
+// Vertex buffers state
+      bool rlEnableVertexArray(unsigned int vaoId); // Enable vertex array (VAO, if supported)
+      void rlDisableVertexArray(void); // Disable vertex array (VAO, if supported)
+      void rlEnableVertexBuffer(unsigned int id); // Enable vertex buffer (VBO)
+      void rlDisableVertexBuffer(void); // Disable vertex buffer (VBO)
+      void rlEnableVertexBufferElement(unsigned int id);// Enable vertex buffer element (VBO element)
+      void rlDisableVertexBufferElement(void); // Disable vertex buffer element (VBO element)
+      void rlEnableVertexAttribute(unsigned int index); // Enable vertex attribute index
+      void rlDisableVertexAttribute(unsigned int index);// Disable vertex attribute index
+// Textures state
+      void rlActiveTextureSlot(int slot); // Select and active a texture slot
+      void rlEnableTexture(unsigned int id); // Enable texture
+      void rlDisableTexture(void); // Disable texture
+      void rlEnableTextureCubemap(unsigned int id); // Enable texture cubemap
+      void rlDisableTextureCubemap(void); // Disable texture cubemap
+      void rlTextureParameters(unsigned int id, int param, int value); // Set texture parameters (filter, wrap)
+      void rlCubemapParameters(unsigned int id, int param, int value); // Set cubemap parameters (filter, wrap)
+// Shader state
+      void rlEnableShader(unsigned int id); // Enable shader program
+      void rlDisableShader(void); // Disable shader program
+// Framebuffer state
+      void rlEnableFramebuffer(unsigned int id); // Enable render texture (fbo)
+      void rlDisableFramebuffer(void); // Disable render texture (fbo), return to default framebuffer
+      void rlActiveDrawBuffers(int count); // Activate multiple draw color buffers
+      void rlBlitFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int dstX, int dstY, int dstWidth, int dstHeight, int bufferMask); // Blit active framebuffer to main framebuffer
+// General render state
+      void rlEnableColorBlend(void); // Enable color blending
+      void rlDisableColorBlend(void); // Disable color blending
+      void rlEnableDepthTest(void); // Enable depth test
+      void rlDisableDepthTest(void); // Disable depth test
+      void rlEnableDepthMask(void); // Enable depth write
+      void rlDisableDepthMask(void); // Disable depth write
+      void rlEnableBackfaceCulling(void); // Enable backface culling
+      void rlDisableBackfaceCulling(void); // Disable backface culling
+      void rlSetCullFace(int mode); // Set face culling mode
+      void rlEnableScissorTest(void); // Enable scissor test
+      void rlDisableScissorTest(void); // Disable scissor test
+      void rlScissor(int x, int y, int width, int height); // Scissor test
+      void rlEnableWireMode(void); // Enable wire mode
+      void rlEnablePointMode(void); //  Enable point mode
+      void rlDisableWireMode(void); // Disable wire mode ( and point ) maybe rename
+      void rlSetLineWidth(float width); // Set the line drawing width
+      float rlGetLineWidth(void); // Get the line drawing width
+      void rlEnableSmoothLines(void); // Enable line aliasing
+      void rlDisableSmoothLines(void); // Disable line aliasing
+      void rlEnableStereoRender(void); // Enable stereo rendering
+      void rlDisableStereoRender(void); // Disable stereo rendering
+      bool rlIsStereoRenderEnabled(void); // Check if stereo render is enabled
+      void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Clear color buffer with color
+      void rlClearScreenBuffers(void); // Clear used screen buffers (color and depth)
+      void rlCheckErrors(void); // Check and log OpenGL error codes
+      void rlSetBlendMode(int mode); // Set blending mode
+      void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation); // Set blending mode factor and equation (using OpenGL factors)
+      void rlSetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha); // Set blending mode factors and equations separately (using OpenGL factors)
+//------------------------------------------------------------------------------------
+// Functions Declaration - rlgl functionality
+//------------------------------------------------------------------------------------
+// rlgl initialization functions
+      void rlglInit(int width, int height); // Initialize rlgl (buffers, shaders, textures, states)
+      void rlglClose(void); // De-initialize rlgl (buffers, shaders, textures)
+      void rlLoadExtensions(void *loader); // Load OpenGL extensions (loader function required)
+      int rlGetVersion(void); // Get current OpenGL version
+      void rlSetFramebufferWidth(int width); // Set current framebuffer width
+      int rlGetFramebufferWidth(void); // Get default framebuffer width
+      void rlSetFramebufferHeight(int height); // Set current framebuffer height
+      int rlGetFramebufferHeight(void); // Get default framebuffer height
+      unsigned int rlGetTextureIdDefault(void); // Get default texture id
+      unsigned int rlGetShaderIdDefault(void); // Get default shader id
+      int *rlGetShaderLocsDefault(void); // Get default shader locations
+// Render batch management
+// NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode
+// but this render batch API is exposed in case of custom batches are required
+      rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements); // Load a render batch system
+      void rlUnloadRenderBatch(rlRenderBatch batch); // Unload render batch system
+      void rlDrawRenderBatch(rlRenderBatch *batch); // Draw render batch data (Update->Draw->Reset)
+      void rlSetRenderBatchActive(rlRenderBatch *batch); // Set the active render batch for rlgl (NULL for default internal)
+      void rlDrawRenderBatchActive(void); // Update and draw internal render batch
+      bool rlCheckRenderBatchLimit(int vCount); // Check internal buffer overflow for a given number of vertex
+      void rlSetTexture(unsigned int id); // Set current texture for render batch and check buffers limits
+//------------------------------------------------------------------------------------------------------------------------
+// Vertex buffers management
+      unsigned int rlLoadVertexArray(void); // Load vertex array (vao) if supported
+      unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic); // Load a vertex buffer attribute
+      unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic); // Load a new attributes element buffer
+      void rlUpdateVertexBuffer(unsigned int bufferId, const void *data, int dataSize, int offset); // Update GPU buffer with new data
+      void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset); // Update vertex buffer elements with new data
+      void rlUnloadVertexArray(unsigned int vaoId);
+      void rlUnloadVertexBuffer(unsigned int vboId);
+      void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, const void *pointer);
+      void rlSetVertexAttributeDivisor(unsigned int index, int divisor);
+      void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count); // Set vertex attribute default value
+      void rlDrawVertexArray(int offset, int count);
+      void rlDrawVertexArrayElements(int offset, int count, const void *buffer);
+      void rlDrawVertexArrayInstanced(int offset, int count, int instances);
+      void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances);
+// Textures management
+      unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount); // Load texture in GPU
+      unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer); // Load depth texture/renderbuffer (to be attached to fbo)
+      unsigned int rlLoadTextureCubemap(const void *data, int size, int format); // Load texture cubemap
+      void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data); // Update GPU texture with new data
+      void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType); // Get OpenGL internal formats
+      const char *rlGetPixelFormatName(unsigned int format); // Get name string for pixel format
+      void rlUnloadTexture(unsigned int id); // Unload texture from GPU memory
+      void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps); // Generate mipmap data for selected texture
+      void *rlReadTexturePixels(unsigned int id, int width, int height, int format); // Read texture pixel data
+      unsigned char *rlReadScreenPixels(int width, int height); // Read screen pixel data (color buffer)
+// Framebuffer management (fbo)
+      unsigned int rlLoadFramebuffer(int width, int height); // Load an empty framebuffer
+      void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer
+      bool rlFramebufferComplete(unsigned int id); // Verify framebuffer is complete
+      void rlUnloadFramebuffer(unsigned int id); // Delete framebuffer from GPU
+// Shaders management
+      unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode); // Load shader from code strings
+      unsigned int rlCompileShader(const char *shaderCode, int type); // Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER)
+      unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId); // Load custom shader program
+      void rlUnloadShaderProgram(unsigned int id); // Unload shader program
+      int rlGetLocationUniform(unsigned int shaderId, const char *uniformName); // Get shader location uniform
+      int rlGetLocationAttrib(unsigned int shaderId, const char *attribName); // Get shader location attribute
+      void rlSetUniform(int locIndex, const void *value, int uniformType, int count); // Set shader value uniform
+      void rlSetUniformMatrix(int locIndex, Matrix mat); // Set shader value matrix
+      void rlSetUniformSampler(int locIndex, unsigned int textureId); // Set shader value sampler
+      void rlSetShader(unsigned int id, int *locs); // Set shader currently active (id and locations)
+// Compute shader management
+      unsigned int rlLoadComputeShaderProgram(unsigned int shaderId); // Load compute shader program
+      void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ); // Dispatch compute shader (equivalent to *draw* for graphics pipeline)
+// Shader buffer storage object management (ssbo)
+      unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint); // Load shader storage buffer object (SSBO)
+      void rlUnloadShaderBuffer(unsigned int ssboId); // Unload shader storage buffer object (SSBO)
+      void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset); // Update SSBO buffer data
+      void rlBindShaderBuffer(unsigned int id, unsigned int index); // Bind SSBO buffer
+      void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset); // Read SSBO buffer data (GPU->CPU)
+      void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count); // Copy SSBO data between buffers
+      unsigned int rlGetShaderBufferSize(unsigned int id); // Get SSBO buffer size
+// Buffer management
+      void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly); // Bind image texture
+// Matrix state management
+      Matrix rlGetMatrixModelview(void); // Get internal modelview matrix
+      Matrix rlGetMatrixProjection(void); // Get internal projection matrix
+      Matrix rlGetMatrixTransform(void); // Get internal accumulated transform matrix
+      Matrix rlGetMatrixProjectionStereo(int eye); // Get internal projection matrix for stereo render (selected eye)
+      Matrix rlGetMatrixViewOffsetStereo(int eye); // Get internal view offset matrix for stereo render (selected eye)
+      void rlSetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix)
+      void rlSetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix)
+      void rlSetMatrixProjectionStereo(Matrix right, Matrix left); // Set eyes projection matrices for stereo rendering
+      void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left); // Set eyes view offsets matrices for stereo rendering
+// Quick and dirty cube/quad buffers load->draw->unload
+      void rlLoadDrawCube(void); // Load and draw a cube
+      void rlLoadDrawQuad(void); // Load and draw a quad
+/***********************************************************************************
+*
+*   RLGL IMPLEMENTATION
+*
+************************************************************************************/

raylib/version.py

@@ -1 +1 @@
-__version__ = "5.0.0.3"
+__version__ = "5.0.0.5"

{raylib-5.0.0.3.dist-info → raylib-5.0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: raylib
-Version: 5.0.0.3
+Version: 5.0.0.5
 Summary: Python CFFI bindings for Raylib
 Home-page: https://github.com/electronstudio/raylib-python-cffi
 Author: Electron Studio
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cffi >=1.17.0rc1
+Requires-Dist: cffi>=1.17.1
 
 # Python Bindings for Raylib 5.0
 
@@ -58,7 +58,7 @@ Then install
     python3 -m pip install setuptools
     python3 -m pip install raylib
 
-On most platforms it should install a binary wheel (Windows 10 x64, MacOS 10.15 x64, Linux Ubuntu1804 x64).
+On most platforms it should install a binary wheel (Windows 10 x64, MacOS 12 x64/arm64, Linux Ubuntu2004 x64/arm64).
 
 If yours isn't available then pip will attempt to build from source, in which case you will need to have Raylib development libs installed, e.g. 
 using homebrew, apt, etc.
@@ -179,7 +179,7 @@ If you need more performance, do in this order:
 in your update loop
 and then only convert them to C data structures when you have to call the C functions for drawing.
 
-3. The raylib.* functions are potentially 1.5x faster than the pyray.* equivalents, so if you need a tiny bit more performance
+3. The raylib.* functions are potentially *slightly* faster than the pyray.* equivalents, so if you need a tiny bit more performance
 you can switch your inner loop functions to these.
 
 4. There is a version of Python that is faster than Pypy: GraalPy.  However it's not fully compatible with all Python

raylib-5.0.0.5.dist-info/RECORD

@@ -0,0 +1,23 @@
+pyray/__init__.py,sha256=6sEm8KxRaK2B2PQo7ZlbXkHoxBDLW43wYSs_Cl7rUMg,7119
+pyray/__init__.pyi,sha256=TlSjWwfJdjyVBAMm3eS6ueCh-Wz0Vq6gVSFabEzFxyc,173184
+pyray/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raylib/__init__.py,sha256=zTSGLz_KdS8jJZKAXOGeaaWHZZPsrmFKAwxRt4iDFvU,1193
+raylib/__init__.pyi,sha256=5X8aWKjsPEVzMlXaAmej-y8FQfevmwGDhci8SQVGrsM,152655
+raylib/_raylib_cffi.cpython-310-darwin.so,sha256=FBmgnkGdEnMHCi4lzP21lJ_hnaGLxqz1lQU3mL1H8Rg,2846960
+raylib/build.py,sha256=2ALzT9DBkpN8qReIarxFcAlVJ3fcrmxpZBX2CEm7QRQ,8679
+raylib/colors.py,sha256=_u-mYrpdx7_v_4wnJrnSu_m36ixKJWbort780_V6rTw,1523
+raylib/defines.py,sha256=L1Wr1LGz1da7wCvYCXHTpZFfVNbra8S4bcFim28LjJM,15807
+raylib/enums.py,sha256=RtQpN23zViI2mQSHPPc0Ay4IvNdiDk_xggdMPLCR0ng,17586
+raylib/glfw3.h.modified,sha256=NIUx9jE3V1Ir4NQehh02sTwiT_7i4PxlZshO24gHfGg,208458
+raylib/physac.h.modified,sha256=GZEIVO0ot8kuHkb7IIuNPieilfC3Poxn6BLlQyvRGEY,9895
+raylib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raylib/raygui.h.modified,sha256=5NKMOQHYZsoD51ewmIezTkNuTKdERqde486NXjbys6M,44607
+raylib/raylib.h.modified,sha256=unvQ4E54KOdr8ScXltaLbgF4eh7wZbVHGFqCupeL3hE,102852
+raylib/raymath.h.modified,sha256=GaiB8wHjC-Hzfx7DWrK9geLH555QFBJyAMszTWP9q0g,23185
+raylib/rlgl.h.modified,sha256=F0bhxnn3Y7K9XOSjOag0N4xpcavCZ9riSFjUT3A9uWk,35329
+raylib/version.py,sha256=TJFIkW6_BlGa9PGistgwofqMEQ6si0P5KY5qQyU8jyc,23
+raylib-5.0.0.5.dist-info/LICENSE,sha256=C-zxZWe-t3-iUrdmRjHdF3yPmhiJ5ImVtFN5xxMOUwM,14198
+raylib-5.0.0.5.dist-info/METADATA,sha256=rQk2FgvjX8-kQk0m_c29eCIYzevno2nvBlbBWyYY3no,8070
+raylib-5.0.0.5.dist-info/WHEEL,sha256=nhj80l19nxJ1hG06BXbDsZO4W6BJh5pq_DGaGn40OdY,109
+raylib-5.0.0.5.dist-info/top_level.txt,sha256=PnMBDWaUP4jsbn_NewagcC9FjHYpzSAIQuhxNzt9hkg,13
+raylib-5.0.0.5.dist-info/RECORD,,

{raylib-5.0.0.3.dist-info → raylib-5.0.0.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (74.1.2)
 Root-Is-Purelib: false
 Tag: cp310-cp310-macosx_14_0_arm64
 

raylib-5.0.0.3.dist-info/RECORD

@@ -1,15 +0,0 @@
-pyray/__init__.py,sha256=6sEm8KxRaK2B2PQo7ZlbXkHoxBDLW43wYSs_Cl7rUMg,7119
-pyray/__init__.pyi,sha256=NzZYOclAa6OEJkekHN704GI9AKnAXh-YrSv_QR-1TQg,149512
-raylib/__init__.py,sha256=DWXPmoq7tC5wzZsrt6rReGy1RflyZwk-SdF-9lBZHok,919
-raylib/__init__.pyi,sha256=3YBqdluKw1mXCDJI_vkp188Y7N2uxd3FKMHGJ6xlx0I,137557
-raylib/_raylib_cffi.abi3.so,sha256=Q8_yiNAw8PD1BL8CDUumxbo-MoJ25XUY9b5P8vgGhbs,2845656
-raylib/build.py,sha256=GkLvtK5cxhIUmqNW113QNGt-fFmqGxq6qCwrAn_HlzM,8460
-raylib/colors.py,sha256=_u-mYrpdx7_v_4wnJrnSu_m36ixKJWbort780_V6rTw,1523
-raylib/defines.py,sha256=lMv6zU8WSkaH5Dj5Ydx0AlggeA-r76xePcA1M7EudnA,15951
-raylib/enums.py,sha256=RtQpN23zViI2mQSHPPc0Ay4IvNdiDk_xggdMPLCR0ng,17586
-raylib/version.py,sha256=kuKcU79UeiMEhJ65u2Xk2MIB8Bc2rN6wJHdZ3MYmvP4,23
-raylib-5.0.0.3.dist-info/LICENSE,sha256=C-zxZWe-t3-iUrdmRjHdF3yPmhiJ5ImVtFN5xxMOUwM,14198
-raylib-5.0.0.3.dist-info/METADATA,sha256=ekuSWjQ6Lv64-mRVN_CgrO7r0XZOYNdphmnKd3I_uHQ,8059
-raylib-5.0.0.3.dist-info/WHEEL,sha256=2EVZhLi4jIk3Z3bCc03RR_L3RG1Nt_XPRZ0Vawo2Rps,110
-raylib-5.0.0.3.dist-info/top_level.txt,sha256=PnMBDWaUP4jsbn_NewagcC9FjHYpzSAIQuhxNzt9hkg,13
-raylib-5.0.0.3.dist-info/RECORD,,