Add vendor/raylib/rlgl.odin

vendor/raylib/rlgl.odin

@@ -0,0 +1,337 @@
+package raylib
+
+import "core:c"
+
+when ODIN_OS == "windows" do foreign import lib "raylib.lib"
+when ODIN_OS == "linux"   do foreign import lib "linux/libraylib.a"
+when ODIN_OS == "darwin"  do foreign import lib "macos/libraylib.a"
+
+GRAPHICS_API_OPENGL_11 :: false
+GRAPHICS_API_OPENGL_21 :: true
+GRAPHICS_API_OPENGL_33 :: GRAPHICS_API_OPENGL_21
+GRAPHICS_API_OPENGL_ES2 :: false
+
+when !GRAPHICS_API_OPENGL_ES2 {
+	// This is the maximum amount of elements (quads) per batch
+	// NOTE: Be careful with text, every letter maps to a quad
+	DEFAULT_BATCH_BUFFER_ELEMENTS :: 8192
+} else {
+	// We reduce memory sizes for embedded systems (RPI and HTML5)
+	// NOTE: On HTML5 (emscripten) this is allocated on heap,
+	// by default it's only 16MB!...just take care...
+	DEFAULT_BATCH_BUFFER_ELEMENTS :: 2048
+}
+
+DEFAULT_BATCH_BUFFERS          :: 1                    // Default number of batch buffers (multi-buffering)
+DEFAULT_BATCH_DRAWCALLS        :: 256                  // Default number of batch draw calls (by state changes: mode, texture)
+MAX_BATCH_ACTIVE_TEXTURES      :: 4                    // Maximum number of additional textures that can be activated on batch drawing (SetShaderValueTexture())
+
+// Internal Matrix stack
+MAX_MATRIX_STACK_SIZE           :: 32                  // Maximum size of Matrix stack
+
+// Vertex buffers id limit
+MAX_MESH_VERTEX_BUFFERS          :: 7                  // Maximum vertex buffers (VBO) per mesh
+
+// Shader and material limits
+MAX_SHADER_LOCATIONS            :: 32                  // Maximum number of shader locations supported
+MAX_MATERIAL_MAPS               :: 12                  // Maximum number of shader maps supported
+
+// Projection matrix culling
+RL_CULL_DISTANCE_NEAR         :: 0.01                  // Default near cull distance
+RL_CULL_DISTANCE_FAR          :: 1000.0                // Default far cull distance
+
+// Texture parameters (equivalent to OpenGL defines)
+RL_TEXTURE_WRAP_S               :: 0x2802              // GL_TEXTURE_WRAP_S
+RL_TEXTURE_WRAP_T               :: 0x2803              // GL_TEXTURE_WRAP_T
+RL_TEXTURE_MAG_FILTER           :: 0x2800              // GL_TEXTURE_MAG_FILTER
+RL_TEXTURE_MIN_FILTER           :: 0x2801              // GL_TEXTURE_MIN_FILTER
+
+RL_TEXTURE_FILTER_NEAREST               :: 0x2600      // GL_NEAREST
+RL_TEXTURE_FILTER_LINEAR                :: 0x2601      // GL_LINEAR
+RL_TEXTURE_FILTER_MIP_NEAREST           :: 0x2700      // GL_NEAREST_MIPMAP_NEAREST
+RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR    :: 0x2702      // GL_NEAREST_MIPMAP_LINEAR
+RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST    :: 0x2701      // GL_LINEAR_MIPMAP_NEAREST
+RL_TEXTURE_FILTER_MIP_LINEAR            :: 0x2703      // GL_LINEAR_MIPMAP_LINEAR
+RL_TEXTURE_FILTER_ANISOTROPIC           :: 0x3000      // Anisotropic filter (custom identifier)
+
+RL_TEXTURE_WRAP_REPEAT                  :: 0x2901      // GL_REPEAT
+RL_TEXTURE_WRAP_CLAMP                   :: 0x812F      // GL_CLAMP_TO_EDGE
+RL_TEXTURE_WRAP_MIRROR_REPEAT           :: 0x8370      // GL_MIRRORED_REPEAT
+RL_TEXTURE_WRAP_MIRROR_CLAMP            :: 0x8742      // GL_MIRROR_CLAMP_EXT
+
+// Matrix modes (equivalent to OpenGL)
+RL_MODELVIEW                    :: 0x1700              // GL_MODELVIEW
+RL_PROJECTION                   :: 0x1701              // GL_PROJECTION
+RL_TEXTURE                      :: 0x1702              // GL_TEXTURE
+
+// Primitive assembly draw modes
+RL_LINES                        :: 0x0001              // GL_LINES
+RL_TRIANGLES                    :: 0x0004              // GL_TRIANGLES
+RL_QUADS                        :: 0x0007              // GL_QUADS
+
+// GL equivalent data types
+RL_UNSIGNED_BYTE                :: 0x1401              // GL_UNSIGNED_BYTE
+RL_f32                        :: 0x1406              // GL_f32
+
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+GlVersion :: enum c.int { OPENGL_11 = 1, OPENGL_21, OPENGL_33, OPENGL_ES_20 }
+
+FramebufferAttachType :: enum c. int {
+	COLOR_CHANNEL0 = 0,
+	COLOR_CHANNEL1,
+	COLOR_CHANNEL2,
+	COLOR_CHANNEL3,
+	COLOR_CHANNEL4,
+	COLOR_CHANNEL5,
+	COLOR_CHANNEL6,
+	COLOR_CHANNEL7,
+	DEPTH = 100,
+	STENCIL = 200,
+}
+
+FramebufferAttachTextureType :: enum c.int {
+	CUBEMAP_POSITIVE_X = 0,
+	CUBEMAP_NEGATIVE_X,
+	CUBEMAP_POSITIVE_Y,
+	CUBEMAP_NEGATIVE_Y,
+	CUBEMAP_POSITIVE_Z,
+	CUBEMAP_NEGATIVE_Z,
+	TEXTURE2D = 100,
+	RENDERBUFFER = 200,
+}
+
+VertexBufferIndexType :: c.ushort when GRAPHICS_API_OPENGL_ES2 else c.uint
+
+// Dynamic vertex buffers (position + texcoords + colors + indices arrays)
+VertexBuffer :: struct {
+	elementsCount: c.int,                    // Number of elements in the buffer (QUADS)
+
+	vCounter:      c.int,                    // Vertex position counter to process (and draw) from full buffer
+	tcCounter:     c.int,                    // Vertex texcoord counter to process (and draw) from full buffer
+	cCounter:      c.int,                    // Vertex color counter to process (and draw) from full buffer
+
+	vertices:      [^]f32,                   // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+	texcoords:     [^]f32,                   // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
+	colors:        [^]u8,                    // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
+	indices:       [^]VertexBufferIndexType, // Vertex indices (in case vertex data comes indexed) (6 indices per quad)
+	vaoId:         u32,                      // OpenGL Vertex Array Object id
+	vboId:         [4]u32,                   // OpenGL Vertex Buffer Objects id (4 types of vertex data)
+} 
+
+// 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)
+DrawCall :: struct {
+	mode:            c.int,       // Drawing mode: LINES, TRIANGLES, QUADS
+	vertexCount:     c.int,       // Number of vertex of the draw
+	vertexAlignment: c.int,       // Number of vertex required for index alignment (LINES, TRIANGLES)
+	//vaoId: u32,                 // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId
+	//shaderId: u32,              // Shader id to be used on the draw -> Using RLGL.currentShader.id
+	textureId: u32,               // Texture id to be used on the draw -> Use to create new draw call if changes
+
+	//projection: Matrix,         // Projection matrix for this draw -> Using RLGL.projection by default
+	//modelview:  Matrix,         // Modelview matrix for this draw -> Using RLGL.modelview by default
+} 
+
+// RenderBatch type
+RenderBatch :: struct {
+	buffersCount:  c.int,           // Number of vertex buffers (multi-buffering support)
+	currentBuffer: c.int,           // Current buffer tracking in case of multi-buffering
+	vertexBuffer:  [^]VertexBuffer, // Dynamic buffer(s) for vertex data
+
+	draws:        [^]DrawCall,      // Draw calls array, depends on textureId
+	drawsCounter: c.int,            // Draw calls counter
+	currentDepth: f32,              // Current depth value for next draw
+}
+
+// Shader attribute data types
+ShaderAttributeDataType :: enum c.int {
+	FLOAT = 0,
+	VEC2,
+	VEC3,
+	VEC4,
+}
+
+@(default_calling_convention="c")
+foreign lib {
+	//------------------------------------------------------------------------------------
+	// Functions Declaration - Matrix operations
+	//------------------------------------------------------------------------------------
+	rlMatrixMode   :: proc(mode: c.int) ---                 // Choose the current matrix to be transformed
+	rlPushMatrix   :: proc() ---                            // Push the current matrix to stack
+	rlPopMatrix    :: proc() ---                            // Pop lattest inserted matrix from stack
+	rlLoadIdentity :: proc() ---                            // Reset current matrix to identity matrix
+	rlTranslatef   :: proc(x, y, z: f32) ---                // Multiply the current matrix by a translation matrix
+	rlRotatef      :: proc(angleDeg: f32, x, y, z: f32) --- // Multiply the current matrix by a rotation matrix
+	rlScalef       :: proc(x, y, z: f32) ---                // Multiply the current matrix by a scaling matrix
+	rlMultMatrixf  :: proc(matf: [^]f32) ---                // Multiply the current matrix by another matrix
+	rlFrustum      :: proc(left, right, bottom, top, znear, zfar: f64) ---
+	rlOrtho        :: proc(left, right, bottom, top, znear, zfar: f64) ---
+	rlViewport     :: proc(x, y, width, height: c.int) ---  // Set the viewport area
+
+	//------------------------------------------------------------------------------------
+	// Functions Declaration - Vertex level operations
+	//------------------------------------------------------------------------------------
+	rlBegin        :: proc(mode: c.int)     --- // Initialize drawing mode (how to organize vertex)
+	rlEnd          :: proc()                --- // Finish vertex providing
+	rlVertex2i     :: proc(x, y: c.int)     --- // Define one vertex (position) - 2 int
+	rlVertex2f     :: proc(x, y: f32)       --- // Define one vertex (position) - 2 f32
+	rlVertex3f     :: proc(x, y, z: f32)    --- // Define one vertex (position) - 3 f32
+	rlTexCoord2f   :: proc(x, y: f32)       --- // Define one vertex (texture coordinate) - 2 f32
+	rlNormal3f     :: proc(x, y, z: f32)    --- // Define one vertex (normal) - 3 f32
+	rlColor4ub     :: proc(r, g, b, a: u8)  --- // Define one vertex (color) - 4 byte
+	rlColor3f      :: proc(x, y, z: f32)    --- // Define one vertex (color) - 3 f32
+	rlColor4f      :: proc(x, y, z, w: f32) --- // Define one vertex (color) - 4 f32
+
+	//------------------------------------------------------------------------------------
+	// 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
+	rlEnableVertexArray          :: proc(vaoId: u32) -> bool --- // Enable vertex array (VAO, if supported)
+	rlDisableVertexArray         :: proc() ---                   // Disable vertex array (VAO, if supported)
+	rlEnableVertexBuffer         :: proc(id: u32) ---            // Enable vertex buffer (VBO)
+	rlDisableVertexBuffer        :: proc() ---                   // Disable vertex buffer (VBO)
+	rlEnableVertexBufferElement  :: proc(id: u32) ---            // Enable vertex buffer element (VBO element)
+	rlDisableVertexBufferElement :: proc() ---                   // Disable vertex buffer element (VBO element)
+	rlEnableVertexAttribute      :: proc(index: u32) ---         // Enable vertex attribute index
+	rlDisableVertexAttribute     :: proc(index: u32) ---         // Disable vertex attribute index
+	when GRAPHICS_API_OPENGL_11 {
+		rlEnableStatePointer :: proc(vertexAttribType: c.int, buffer: rawptr) ---
+		rlDisableStatePointer :: proc(vertexAttribType: c.int) ---
+	}
+
+	// Textures state
+	rlActiveTextureSlot     :: proc(slot: c.int) ---                         // Select and active a texture slot
+	rlEnableTexture         :: proc(id: u32) ---                             // Enable texture
+	rlDisableTexture        :: proc() ---                                    // Disable texture
+	rlEnableTextureCubemap  :: proc(id: u32) ---                             // Enable texture cubemap
+	rlDisableTextureCubemap :: proc() ---                                    // Disable texture cubemap
+	rlTextureParameters     :: proc(id: u32, param: c.int, value: c.int) --- // Set texture parameters (filter, wrap)
+
+	// Shader state
+	rlEnableShader  :: proc(id: u32) ---                                          // Enable shader program
+	rlDisableShader :: proc() ---                                                 // Disable shader program
+
+	// Framebuffer state
+	rlEnableFramebuffer  :: proc(id: u32) ---                                     // Enable render texture (fbo)
+	rlDisableFramebuffer :: proc() ---                                            // Disable render texture (fbo), return to default framebuffer
+
+	// General render state
+	rlEnableDepthTest        :: proc() ---                                        // Enable depth test
+	rlDisableDepthTest       :: proc() ---                                        // Disable depth test
+	rlEnableDepthMask        :: proc() ---                                        // Enable depth write
+	rlDisableDepthMask       :: proc() ---                                        // Disable depth write
+	rlEnableBackfaceCulling  :: proc() ---                                        // Enable backface culling
+	rlDisableBackfaceCulling :: proc() ---                                        // Disable backface culling
+	rlEnableScissorTest      :: proc() ---                                        // Enable scissor test
+	rlDisableScissorTest     :: proc() ---                                        // Disable scissor test
+	rlScissor                :: proc(x, y, width, height: c.int) ---              // Scissor test
+	rlEnableWireMode         :: proc() ---                                        // Enable wire mode
+	rlDisableWireMode        :: proc() ---                                        // Disable wire mode
+	rlSetLineWidth           :: proc(width: f32) ---                              // Set the line drawing width
+	rlGetLineWidth           :: proc() -> f32 ---                                 // Get the line drawing width
+	rlEnableSmoothLines      :: proc() ---                                        // Enable line aliasing
+	rlDisableSmoothLines     :: proc() ---                                        // Disable line aliasing
+	rlEnableStereoRender     :: proc() ---                                        // Enable stereo rendering
+	rlDisableStereoRender    :: proc() ---                                        // Disable stereo rendering
+	rlIsStereoRenderEnabled  :: proc() -> bool ---                                // Check if stereo render is enabled
+
+	rlClearColor         :: proc(r, g, b, a: u8) ---                              // Clear color buffer with color
+	rlClearScreenBuffers :: proc() ---                                            // Clear used screen buffers (color and depth)
+	rlCheckErrors        :: proc() ---                                            // Check and log OpenGL error codes
+	rlSetBlendMode       :: proc(mode: c.int) ---                                 // Set blending mode
+	rlSetBlendFactors    :: proc(glSrcFactor, glDstFactor, glEquation: c.int) --- // Set blending mode factor and equation (using OpenGL factors)
+
+	//------------------------------------------------------------------------------------
+	// Functions Declaration - rlgl functionality
+	//------------------------------------------------------------------------------------
+	// rlgl initialization functions
+	rlglInit               :: proc(width, height: c.int) ---                               // Initialize rlgl (buffers, shaders, textures, states)
+	rlglClose              :: proc() ---                                                   // De-inititialize rlgl (buffers, shaders, textures)
+	rlLoadExtensions       :: proc(loader: rawptr) ---                                     // Load OpenGL extensions (loader function pointer required)
+	rlGetVersion           :: proc() -> GlVersion ---                                      // Returns current OpenGL version
+	rlGetFramebufferWidth  :: proc() -> c.int ---                                          // Get default framebuffer width
+	rlGetFramebufferHeight :: proc() -> c.int ---                                          // Get default framebuffer height
+
+	rlGetShaderDefault  :: proc() -> Shader ---                                            // Get default shader
+	rlGetTextureDefault :: proc() -> Texture2D ---                                         // Get default texture
+
+	// 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
+	rlLoadRenderBatch       :: proc(numBuffers, bufferElements: c.int) -> RenderBatch ---  // Load a render batch system
+	rlUnloadRenderBatch     :: proc(batch: RenderBatch) ---                                // Unload render batch system
+	rlDrawRenderBatch       :: proc(batch: ^RenderBatch) ---                               // Draw render batch data (Update->Draw->Reset)
+	rlSetRenderBatchActive  :: proc(batch: ^RenderBatch) ---                               // Set the active render batch for rlgl (NULL for default internal)
+	rlDrawRenderBatchActive :: proc() ---                                                  // Update and draw internal render batch
+	rlCheckRenderBatchLimit :: proc(vCount: c.int) -> bool ---                             // Check internal buffer overflow for a given number of vertex
+	rlSetTexture            :: proc(id: u32) ---                                           // Set current texture for render batch and check buffers limits
+
+	//------------------------------------------------------------------------------------------------------------------------
+
+	// Vertex buffers management
+	rlLoadVertexArray                  :: proc() -> u32 ---                                                                 // Load vertex array (vao) if supported
+	rlLoadVertexBuffer                 :: proc(buffer: rawptr, size: c.int, is_dynamic: bool) -> u32 ---                    // Load a vertex buffer attribute
+	rlLoadVertexBufferElement          :: proc(buffer: rawptr, size: c.int, is_dynamic: bool) -> u32 ---                    // Load a new attributes element buffer
+	rlUpdateVertexBuffer               :: proc(bufferId: c.int, data: rawptr, dataSize: c.int, offset: c.int) -> u32 ---    // Update GPU buffer with new data
+	rlUnloadVertexArray                :: proc(vaoId: u32) ---
+	rlUnloadVertexBuffer               :: proc(vboId: u32) ---
+	rlSetVertexAttribute               :: proc(index: u32, compSize: c.int, type: c.int, normalized: bool, stride: c.int, pointer: uintptr) ---
+	rlSetVertexAttributeDivisor        :: proc(index: u32, divisor: c.int) ---
+	rlSetVertexAttributeDefault        :: proc(locIndex: c.int, value: rawptr, attribType: c.int, count: c.int) ---         // Set vertex attribute default value
+	rlDrawVertexArray                  :: proc(offset: c.int, count: c.int) ---
+	rlDrawVertexArrayElements          :: proc(offset: c.int, count: c.int, buffer: rawptr) ---
+	rlDrawVertexArrayInstanced         :: proc(offset: c.int, count: c.int, instances: c.int) ---
+	rlDrawVertexArrayElementsInstanced :: proc(offset: c.int, count: c.int, buffer: rawptr, instances: c.int) ---
+
+	// Textures management
+	rlLoadTexture          :: proc(data: rawptr, width, height: c.int, format: c.int, mipmapCount: c.int) -> u32 ---  // Load texture in GPU
+	rlLoadTextureDepth     :: proc(width, height: c.int, useRenderBuffer: bool) -> u32 ---                            // Load depth texture/renderbuffer (to be attached to fbo)
+	rlLoadTextureCubemap   :: proc(data: rawptr, size: c.int, format: c.int) -> u32 ---                               // Load texture cubemap
+	rlUpdateTexture        :: proc(id: u32, offsetX, offsetY, width, height: c.int, format: c.int, data: rawptr) ---  // Update GPU texture with new data
+	rlGetGlTextureFormats  :: proc(format: c.int, glInternalFormat: ^u32, glFormat: ^u32, glType: ^u32) ---           // Get OpenGL internal formats
+	rlUnloadTexture        :: proc(id: u32) ---                                                                       // Unload texture from GPU memory
+	rlGenerateMipmaps      :: proc(texture: ^Texture2D) ---                                                           // Generate mipmap data for selected texture
+	rlReadTexturePixels    :: proc(texture: Texture2D) -> rawptr ---                                                  // Read texture pixel data
+	rlReadScreenPixels     :: proc(width, height: c.int) -> [^]u8 ---                                                 // Read screen pixel data (color buffer)
+
+	// Framebuffer management (fbo)
+	rlLoadFramebuffer     :: proc(width, height: c.int) -> u32 ---                                                // Load an empty framebuffer
+	rlFramebufferAttach   :: proc(fboId: u32, texId: u32, attachType: c.int, texType: c.int, mipLevel: c.int) --- // Attach texture/renderbuffer to a framebuffer
+	rlFramebufferComplete :: proc(id: u32) -> bool ---                                                            // Verify framebuffer is complete
+	rlUnloadFramebuffer   :: proc(id: u32) ---                                                                    // Delete framebuffer from GPU
+
+	// Shaders management
+	rlLoadShaderCode      :: proc(vsCode, fsCode: cstring) -> u32 ---                                   // Load shader from code strings
+	rlCompileShader       :: proc(shaderCode: cstring, type: c.int) -> u32 ---                          // Compile custom shader and return shader id (type: GL_VERTEX_SHADER, GL_FRAGMENT_SHADER)
+	rlLoadShaderProgram   :: proc(vShaderId, fShaderId: u32) -> u32 ---                                 // Load custom shader program
+	rlUnloadShaderProgram :: proc(id: u32) ---                                                          // Unload shader program
+	rlGetLocationUniform  :: proc(shaderId: u32, uniformName: cstring) -> c.int ---                     // Get shader location uniform
+	rlGetLocationAttrib   :: proc(shaderId: u32, attribName: cstring) -> c.int ---                      // Get shader location attribute
+	rlSetUniform          :: proc(locIndex: c.int, value: rawptr, uniformType: c.int, count: c.int) --- // Set shader value uniform
+	rlSetUniformMatrix    :: proc(locIndex: c.int, mat: Matrix) ---                                     // Set shader value matrix
+	rlSetUniformSampler   :: proc(locIndex: c.int, textureId: u32) ---                                  // Set shader value sampler
+	rlSetShader           :: proc(shader: Shader) ---                                                   // Set shader currently active
+
+	// Matrix state management
+	rlGetMatrixModelview        :: proc() -> Matrix ---           // Get internal modelview matrix
+	rlGetMatrixProjection       :: proc() -> Matrix ---           // Get internal projection matrix
+	rlGetMatrixTransform        :: proc() -> Matrix ---           // Get internal accumulated transform matrix
+	rlGetMatrixProjectionStereo :: proc(eye: c.int) -> Matrix --- // Get internal projection matrix for stereo render (selected eye)
+	rlGetMatrixViewOffsetStereo :: proc(eye: c.int) -> Matrix --- // Get internal view offset matrix for stereo render (selected eye)
+	rlSetMatrixProjection       :: proc(proj: Matrix) ---         // Set a custom projection matrix (replaces internal projection matrix)
+	rlSetMatrixModelview        :: proc(view: Matrix) ---         // Set a custom modelview matrix (replaces internal modelview matrix)
+	rlSetMatrixProjectionStereo :: proc(right, left: Matrix) ---  // Set eyes projection matrices for stereo rendering
+	rlSetMatrixViewOffsetStereo :: proc(right, left: Matrix) ---  // Set eyes view offsets matrices for stereo rendering
+
+	// Quick and dirty cube/quad buffers load->draw->unload
+	rlLoadDrawCube :: proc() --- // Load and draw a cube
+	rlLoadDrawQuad :: proc() --- // Load and draw a quad
+}