From 027d69678aa9a2b2e95da8f94ea3d7600a478604 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Wed, 8 Sep 2021 19:40:18 +0100 Subject: [PATCH] Add vendor/raylib/rlgl.odin --- vendor/raylib/rlgl.odin | 337 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 337 insertions(+) create mode 100644 vendor/raylib/rlgl.odin diff --git a/vendor/raylib/rlgl.odin b/vendor/raylib/rlgl.odin new file mode 100644 index 000000000..87921f8b0 --- /dev/null +++ b/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 +} \ No newline at end of file