# C API

The goal of the C API is make usage as similar to the original C as CFFI will allow. The example programs are very, very similar to the C originals.

Example program:

    from raylib import *

    InitWindow(800, 450, b"Hello Raylib")
    SetTargetFPS(60)

    camera = ffi.new("struct Camera3D *", [[18.0, 16.0, 18.0], [0.0, 0.0, 0.0], [0.0, 1.0, 0.0], 45.0, 0])
    SetCameraMode(camera[0], CAMERA_ORBITAL)

    while not WindowShouldClose():
        UpdateCamera(camera)
        BeginDrawing()
        ClearBackground(RAYWHITE)
        BeginMode3D(camera[0])
        DrawGrid(20, 1.0)
        EndMode3D()
        DrawText(b"Hellow World", 190, 200, 20, VIOLET)
        EndDrawing()
    CloseWindow()

If you want to be more portable (i.e. same code will work with dynamic bindings) you can prefix the functions like this:

    from raylib import ffi, rl, colors

    rl.InitWindow(800, 450, b"Hello Raylib")
    rl.SetTargetFPS(60)

    ...

See also https://github.com/electronstudio/raylib-python-cffi/blob/master/tests/test_static.py

Note

Whenever you need to convert stuff between C and Python see https://cffi.readthedocs.io

Important

Your primary reference should always be the official Raylib docs

However, here is a list of available functions:

## Functions API reference

`raylib.``ARROWS_SIZE`

`raylib.``ARROWS_VISIBLE`

`raylib.``ARROW_PADDING`

`raylib.``AudioStream`

`raylib.``BACKGROUND_COLOR`

`raylib.``BASE_COLOR_DISABLED`

`raylib.``BASE_COLOR_FOCUSED`

`raylib.``BASE_COLOR_NORMAL`

`raylib.``BASE_COLOR_PRESSED`

`raylib.``BLEND_ADDITIVE`

`raylib.``BLEND_ADD_COLORS`

`raylib.``BLEND_ALPHA`

`raylib.``BLEND_CUSTOM`

`raylib.``BLEND_MULTIPLIED`

`raylib.``BLEND_SUBTRACT_COLORS`

`raylib.``BORDER_COLOR_DISABLED`

`raylib.``BORDER_COLOR_FOCUSED`

`raylib.``BORDER_COLOR_NORMAL`

`raylib.``BORDER_COLOR_PRESSED`

`raylib.``BORDER_WIDTH`

`raylib.``BUTTON`

`raylib.``BeginBlendMode`(mode: int)

  Begin blending mode (alpha, additive, multiplied, subtract, custom)

`raylib.``BeginDrawing`()

  Setup canvas (framebuffer) to start drawing

`raylib.``BeginMode2D`(camera: Camera2D)

  Begin 2D mode with custom camera (2D)

`raylib.``BeginMode3D`(camera: Camera3D)

  Begin 3D mode with custom camera (3D)

`raylib.``BeginScissorMode`(x: int, y: int, width: int, height: int)

  Begin scissor mode (define screen area for following drawing)

`raylib.``BeginShaderMode`(shader: Shader)

  Begin custom shader drawing

`raylib.``BeginTextureMode`(target: RenderTexture)

  Begin drawing to render texture

`raylib.``BeginVrStereoMode`(config: VrStereoConfig)

  Begin stereo rendering (requires VR simulator)

`raylib.``BlendMode`

`raylib.``BoneInfo`

`raylib.``BoundingBox`

`raylib.``CAMERA_CUSTOM`

`raylib.``CAMERA_FIRST_PERSON`

`raylib.``CAMERA_FREE`

`raylib.``CAMERA_ORBITAL`

`raylib.``CAMERA_ORTHOGRAPHIC`

`raylib.``CAMERA_PERSPECTIVE`

`raylib.``CAMERA_THIRD_PERSON`

`raylib.``CHECKBOX`

`raylib.``CHECK_PADDING`

`raylib.``COLORPICKER`

`raylib.``COLOR_SELECTED_BG`

`raylib.``COLOR_SELECTED_FG`

`raylib.``COLOR_SELECTOR_SIZE`

`raylib.``COMBOBOX`

`raylib.``COMBO_BUTTON_PADDING`

`raylib.``COMBO_BUTTON_WIDTH`

`raylib.``CUBEMAP_LAYOUT_AUTO_DETECT`

`raylib.``CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE`

`raylib.``CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR`

`raylib.``CUBEMAP_LAYOUT_LINE_HORIZONTAL`

`raylib.``CUBEMAP_LAYOUT_LINE_VERTICAL`

`raylib.``CUBEMAP_LAYOUT_PANORAMA`

`raylib.``Camera`

`raylib.``Camera2D`

`raylib.``Camera3D`

`raylib.``CameraMode`

`raylib.``CameraProjection`

`raylib.``ChangeDirectory`(dir: str)

  Change working directory, return true on success

`raylib.``CheckCollisionBoxSphere`(box: BoundingBox, center: Vector3, radius: float)

  Check collision between box and sphere

`raylib.``CheckCollisionBoxes`(box1: BoundingBox, box2: BoundingBox)

  Check collision between two bounding boxes

`raylib.``CheckCollisionCircleRec`(center: Vector2, radius: float, rec: Rectangle)

  Check collision between circle and rectangle

`raylib.``CheckCollisionCircles`(center1: Vector2, radius1: float, center2: Vector2, radius2: float)

  Check collision between two circles

`raylib.``CheckCollisionLines`(startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: Any)

  Check the collision between two lines defined by two points each, returns collision point by reference

`raylib.``CheckCollisionPointCircle`(point: Vector2, center: Vector2, radius: float)

  Check if point is inside circle

`raylib.``CheckCollisionPointLine`(point: Vector2, p1: Vector2, p2: Vector2, threshold: int)

  Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]

`raylib.``CheckCollisionPointRec`(point: Vector2, rec: Rectangle)

  Check if point is inside rectangle

`raylib.``CheckCollisionPointTriangle`(point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2)

  Check if point is inside a triangle

`raylib.``CheckCollisionRecs`(rec1: Rectangle, rec2: Rectangle)

  Check collision between two rectangles

`raylib.``CheckCollisionSpheres`(center1: Vector3, radius1: float, center2: Vector3, radius2: float)

  Check collision between two spheres

`raylib.``ClearBackground`(color: Color)

  Set background color (framebuffer clear color)

`raylib.``ClearDirectoryFiles`()

  Clear directory files paths buffers (free memory)

`raylib.``ClearDroppedFiles`()

  Clear dropped files paths buffer (free memory)

`raylib.``ClearWindowState`(flags: int)

  Clear window configuration state flags

`raylib.``CloseAudioDevice`()

  Close the audio device and context

`raylib.``ClosePhysics`()

  void ClosePhysics();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``CloseWindow`()

  Close window and unload OpenGL context

`raylib.``CodepointToUTF8`(codepoint: int, byteSize: Any)

  Encode one codepoint into UTF-8 byte array (array length returned as parameter)

`raylib.``Color`

`raylib.``ColorAlpha`(color: Color, alpha: float)

  Get color with alpha applied, alpha goes from 0.0f to 1.0f

`raylib.``ColorAlphaBlend`(dst: Color, src: Color, tint: Color)

  Get src alpha-blended into dst color with tint

`raylib.``ColorFromHSV`(hue: float, saturation: float, value: float)

  Get a Color from HSV values, hue [0..360], saturation/value [0..1]

`raylib.``ColorFromNormalized`(normalized: Vector4)

  Get Color from normalized values [0..1]

`raylib.``ColorNormalize`(color: Color)

  Get Color normalized as float [0..1]

`raylib.``ColorToHSV`(color: Color)

  Get HSV values for a Color, hue [0..360], saturation/value [0..1]

`raylib.``ColorToInt`(color: Color)

  Get hexadecimal value for a Color

`raylib.``CompressData`(data: str, dataLength: int, compDataLength: Any)

  Compress data (DEFLATE algorithm)

`raylib.``ConfigFlags`

`raylib.``CreatePhysicsBodyCircle`(Vector2_0: Vector2, float_1: float, float_2: float)

  struct PhysicsBodyData *CreatePhysicsBodyCircle(struct Vector2, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``CreatePhysicsBodyPolygon`(Vector2_0: Vector2, float_1: float, int_2: int, float_3: float)

  struct PhysicsBodyData *CreatePhysicsBodyPolygon(struct Vector2, float, int, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``CreatePhysicsBodyRectangle`(Vector2_0: Vector2, float_1: float, float_2: float, float_3: float)

  struct PhysicsBodyData *CreatePhysicsBodyRectangle(struct Vector2, float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``CubemapLayout`

`raylib.``DEFAULT`

`raylib.``DROPDOWNBOX`

`raylib.``DROPDOWN_ITEMS_PADDING`

`raylib.``DecodeDataBase64`(data: str, outputLength: Any)

  Decode Base64 string data

`raylib.``DecompressData`(compData: str, compDataLength: int, dataLength: Any)

  Decompress data (DEFLATE algorithm)

`raylib.``DestroyPhysicsBody`(PhysicsBodyData_pointer_0: Any)

  void DestroyPhysicsBody(struct PhysicsBodyData *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``DirectoryExists`(dirPath: str)

  Check if a directory path exists

`raylib.``DisableCursor`()

  Disables cursor (lock cursor)

`raylib.``DrawBillboard`(camera: Camera3D, texture: Texture, position: Vector3, size: float, tint: Color)

  Draw a billboard texture

`raylib.``DrawBillboardPro`(camera: Camera3D, texture: Texture, source: Rectangle, position: Vector3, up: Vector3, size: Vector2, origin: Vector2, rotation: float, tint: Color)

  Draw a billboard texture defined by source and rotation

`raylib.``DrawBillboardRec`(camera: Camera3D, texture: Texture, source: Rectangle, position: Vector3, size: Vector2, tint: Color)

  Draw a billboard texture defined by source

`raylib.``DrawBoundingBox`(box: BoundingBox, color: Color)

  Draw bounding box (wires)

`raylib.``DrawCircle`(centerX: int, centerY: int, radius: float, color: Color)

  Draw a color-filled circle

`raylib.``DrawCircle3D`(center: Vector3, radius: float, rotationAxis: Vector3, rotationAngle: float, color: Color)

  Draw a circle in 3D world space

`raylib.``DrawCircleGradient`(centerX: int, centerY: int, radius: float, color1: Color, color2: Color)

  Draw a gradient-filled circle

`raylib.``DrawCircleLines`(centerX: int, centerY: int, radius: float, color: Color)

  Draw circle outline

`raylib.``DrawCircleSector`(center: Vector2, radius: float, startAngle: float, endAngle: float, segments: int, color: Color)

  Draw a piece of a circle

`raylib.``DrawCircleSectorLines`(center: Vector2, radius: float, startAngle: float, endAngle: float, segments: int, color: Color)

  Draw circle sector outline

`raylib.``DrawCircleV`(center: Vector2, radius: float, color: Color)

  Draw a color-filled circle (Vector version)

`raylib.``DrawCube`(position: Vector3, width: float, height: float, length: float, color: Color)

  Draw cube

`raylib.``DrawCubeTexture`(texture: Texture, position: Vector3, width: float, height: float, length: float, color: Color)

  Draw cube textured

`raylib.``DrawCubeTextureRec`(texture: Texture, source: Rectangle, position: Vector3, width: float, height: float, length: float, color: Color)

  Draw cube with a region of a texture

`raylib.``DrawCubeV`(position: Vector3, size: Vector3, color: Color)

  Draw cube (Vector version)

`raylib.``DrawCubeWires`(position: Vector3, width: float, height: float, length: float, color: Color)

  Draw cube wires

`raylib.``DrawCubeWiresV`(position: Vector3, size: Vector3, color: Color)

  Draw cube wires (Vector version)

`raylib.``DrawCylinder`(position: Vector3, radiusTop: float, radiusBottom: float, height: float, slices: int, color: Color)

  Draw a cylinder/cone

`raylib.``DrawCylinderEx`(startPos: Vector3, endPos: Vector3, startRadius: float, endRadius: float, sides: int, color: Color)

  Draw a cylinder with base at startPos and top at endPos

`raylib.``DrawCylinderWires`(position: Vector3, radiusTop: float, radiusBottom: float, height: float, slices: int, color: Color)

  Draw a cylinder/cone wires

`raylib.``DrawCylinderWiresEx`(startPos: Vector3, endPos: Vector3, startRadius: float, endRadius: float, sides: int, color: Color)

  Draw a cylinder wires with base at startPos and top at endPos

`raylib.``DrawEllipse`(centerX: int, centerY: int, radiusH: float, radiusV: float, color: Color)

  Draw ellipse

`raylib.``DrawEllipseLines`(centerX: int, centerY: int, radiusH: float, radiusV: float, color: Color)

  Draw ellipse outline

`raylib.``DrawFPS`(posX: int, posY: int)

  Draw current FPS

`raylib.``DrawGrid`(slices: int, spacing: float)

  Draw a grid (centered at (0, 0, 0))

`raylib.``DrawLine`(startPosX: int, startPosY: int, endPosX: int, endPosY: int, color: Color)

  Draw a line

`raylib.``DrawLine3D`(startPos: Vector3, endPos: Vector3, color: Color)

  Draw a line in 3D world space

`raylib.``DrawLineBezier`(startPos: Vector2, endPos: Vector2, thick: float, color: Color)

  Draw a line using cubic-bezier curves in-out

`raylib.``DrawLineBezierCubic`(startPos: Vector2, endPos: Vector2, startControlPos: Vector2, endControlPos: Vector2, thick: float, color: Color)

  Draw line using cubic bezier curves with 2 control points

`raylib.``DrawLineBezierQuad`(startPos: Vector2, endPos: Vector2, controlPos: Vector2, thick: float, color: Color)

  Draw line using quadratic bezier curves with a control point

`raylib.``DrawLineEx`(startPos: Vector2, endPos: Vector2, thick: float, color: Color)

  Draw a line defining thickness

`raylib.``DrawLineStrip`(points: Any, pointCount: int, color: Color)

  Draw lines sequence

`raylib.``DrawLineV`(startPos: Vector2, endPos: Vector2, color: Color)

  Draw a line (Vector version)

`raylib.``DrawMesh`(mesh: Mesh, material: Material, transform: Matrix)

  Draw a 3d mesh with material and transform

`raylib.``DrawMeshInstanced`(mesh: Mesh, material: Material, transforms: Any, instances: int)

  Draw multiple mesh instances with material and different transforms

`raylib.``DrawModel`(model: Model, position: Vector3, scale: float, tint: Color)

  Draw a model (with texture if set)

`raylib.``DrawModelEx`(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color)

  Draw a model with extended parameters

`raylib.``DrawModelWires`(model: Model, position: Vector3, scale: float, tint: Color)

  Draw a model wires (with texture if set)

`raylib.``DrawModelWiresEx`(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color)

  Draw a model wires (with texture if set) with extended parameters

`raylib.``DrawPixel`(posX: int, posY: int, color: Color)

  Draw a pixel

`raylib.``DrawPixelV`(position: Vector2, color: Color)

  Draw a pixel (Vector version)

`raylib.``DrawPlane`(centerPos: Vector3, size: Vector2, color: Color)

  Draw a plane XZ

`raylib.``DrawPoint3D`(position: Vector3, color: Color)

  Draw a point in 3D space, actually a small line

`raylib.``DrawPoly`(center: Vector2, sides: int, radius: float, rotation: float, color: Color)

  Draw a regular polygon (Vector version)

`raylib.``DrawPolyLines`(center: Vector2, sides: int, radius: float, rotation: float, color: Color)

  Draw a polygon outline of n sides

`raylib.``DrawPolyLinesEx`(center: Vector2, sides: int, radius: float, rotation: float, lineThick: float, color: Color)

  Draw a polygon outline of n sides with extended parameters

`raylib.``DrawRay`(ray: Ray, color: Color)

  Draw a ray line

`raylib.``DrawRectangle`(posX: int, posY: int, width: int, height: int, color: Color)

  Draw a color-filled rectangle

`raylib.``DrawRectangleGradientEx`(rec: Rectangle, col1: Color, col2: Color, col3: Color, col4: Color)

  Draw a gradient-filled rectangle with custom vertex colors

`raylib.``DrawRectangleGradientH`(posX: int, posY: int, width: int, height: int, color1: Color, color2: Color)

  Draw a horizontal-gradient-filled rectangle

`raylib.``DrawRectangleGradientV`(posX: int, posY: int, width: int, height: int, color1: Color, color2: Color)

  Draw a vertical-gradient-filled rectangle

`raylib.``DrawRectangleLines`(posX: int, posY: int, width: int, height: int, color: Color)

  Draw rectangle outline

`raylib.``DrawRectangleLinesEx`(rec: Rectangle, lineThick: float, color: Color)

  Draw rectangle outline with extended parameters

`raylib.``DrawRectanglePro`(rec: Rectangle, origin: Vector2, rotation: float, color: Color)

  Draw a color-filled rectangle with pro parameters

`raylib.``DrawRectangleRec`(rec: Rectangle, color: Color)

  Draw a color-filled rectangle

`raylib.``DrawRectangleRounded`(rec: Rectangle, roundness: float, segments: int, color: Color)

  Draw rectangle with rounded edges

`raylib.``DrawRectangleRoundedLines`(rec: Rectangle, roundness: float, segments: int, lineThick: float, color: Color)

  Draw rectangle with rounded edges outline

`raylib.``DrawRectangleV`(position: Vector2, size: Vector2, color: Color)

  Draw a color-filled rectangle (Vector version)

`raylib.``DrawRing`(center: Vector2, innerRadius: float, outerRadius: float, startAngle: float, endAngle: float, segments: int, color: Color)

  Draw ring

`raylib.``DrawRingLines`(center: Vector2, innerRadius: float, outerRadius: float, startAngle: float, endAngle: float, segments: int, color: Color)

  Draw ring outline

`raylib.``DrawSphere`(centerPos: Vector3, radius: float, color: Color)

  Draw sphere

`raylib.``DrawSphereEx`(centerPos: Vector3, radius: float, rings: int, slices: int, color: Color)

  Draw sphere with extended parameters

`raylib.``DrawSphereWires`(centerPos: Vector3, radius: float, rings: int, slices: int, color: Color)

  Draw sphere wires

`raylib.``DrawText`(text: str, posX: int, posY: int, fontSize: int, color: Color)

  Draw text (using default font)

`raylib.``DrawTextCodepoint`(font: Font, codepoint: int, position: Vector2, fontSize: float, tint: Color)

  Draw one character (codepoint)

`raylib.``DrawTextEx`(font: Font, text: str, position: Vector2, fontSize: float, spacing: float, tint: Color)

  Draw text using font and additional parameters

`raylib.``DrawTextPro`(font: Font, text: str, position: Vector2, origin: Vector2, rotation: float, fontSize: float, spacing: float, tint: Color)

  Draw text using Font and pro parameters (rotation)

`raylib.``DrawTexture`(texture: Texture, posX: int, posY: int, tint: Color)

  Draw a Texture2D

`raylib.``DrawTextureEx`(texture: Texture, position: Vector2, rotation: float, scale: float, tint: Color)

  Draw a Texture2D with extended parameters

`raylib.``DrawTextureNPatch`(texture: Texture, nPatchInfo: NPatchInfo, dest: Rectangle, origin: Vector2, rotation: float, tint: Color)

  Draws a texture (or part of it) that stretches or shrinks nicely

`raylib.``DrawTexturePoly`(texture: Texture, center: Vector2, points: Any, texcoords: Any, pointCount: int, tint: Color)

  Draw a textured polygon

`raylib.``DrawTexturePro`(texture: Texture, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: float, tint: Color)

  Draw a part of a texture defined by a rectangle with ‘pro’ parameters

`raylib.``DrawTextureQuad`(texture: Texture, tiling: Vector2, offset: Vector2, quad: Rectangle, tint: Color)

  Draw texture quad with tiling and offset parameters

`raylib.``DrawTextureRec`(texture: Texture, source: Rectangle, position: Vector2, tint: Color)

  Draw a part of a texture defined by a rectangle

`raylib.``DrawTextureTiled`(texture: Texture, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: float, scale: float, tint: Color)

  Draw part of a texture (defined by a rectangle) with rotation and scale tiled into dest.

`raylib.``DrawTextureV`(texture: Texture, position: Vector2, tint: Color)

  Draw a Texture2D with position defined as Vector2

`raylib.``DrawTriangle`(v1: Vector2, v2: Vector2, v3: Vector2, color: Color)

  Draw a color-filled triangle (vertex in counter-clockwise order!)

`raylib.``DrawTriangle3D`(v1: Vector3, v2: Vector3, v3: Vector3, color: Color)

  Draw a color-filled triangle (vertex in counter-clockwise order!)

`raylib.``DrawTriangleFan`(points: Any, pointCount: int, color: Color)

  Draw a triangle fan defined by points (first vertex is the center)

`raylib.``DrawTriangleLines`(v1: Vector2, v2: Vector2, v3: Vector2, color: Color)

  Draw triangle outline (vertex in counter-clockwise order!)

`raylib.``DrawTriangleStrip`(points: Any, pointCount: int, color: Color)

  Draw a triangle strip defined by points

`raylib.``DrawTriangleStrip3D`(points: Any, pointCount: int, color: Color)

  Draw a triangle strip defined by points

`raylib.``EnableCursor`()

  Enables cursor (unlock cursor)

`raylib.``EncodeDataBase64`(data: str, dataLength: int, outputLength: Any)

  Encode data to Base64 string

`raylib.``EndBlendMode`()

  End blending mode (reset to default: alpha blending)

`raylib.``EndDrawing`()

  End canvas drawing and swap buffers (double buffering)

`raylib.``EndMode2D`()

  Ends 2D mode with custom camera

`raylib.``EndMode3D`()

  Ends 3D mode and returns to default 2D orthographic mode

`raylib.``EndScissorMode`()

  End scissor mode

`raylib.``EndShaderMode`()

  End custom shader drawing (use default shader)

`raylib.``EndTextureMode`()

  Ends drawing to render texture

`raylib.``EndVrStereoMode`()

  End stereo rendering (requires VR simulator)

`raylib.``ExportImage`(image: Image, fileName: str)

  Export image data to file, returns true on success

`raylib.``ExportImageAsCode`(image: Image, fileName: str)

  Export image as code file defining an array of bytes, returns true on success

`raylib.``ExportMesh`(mesh: Mesh, fileName: str)

  Export mesh data to file, returns true on success

`raylib.``ExportWave`(wave: Wave, fileName: str)

  Export wave data to file, returns true on success

`raylib.``ExportWaveAsCode`(wave: Wave, fileName: str)

  Export wave sample data to code (.h), returns true on success

`raylib.``FLAG_FULLSCREEN_MODE`

`raylib.``FLAG_INTERLACED_HINT`

`raylib.``FLAG_MSAA_4X_HINT`

`raylib.``FLAG_VSYNC_HINT`

`raylib.``FLAG_WINDOW_ALWAYS_RUN`

`raylib.``FLAG_WINDOW_HIDDEN`

`raylib.``FLAG_WINDOW_HIGHDPI`

`raylib.``FLAG_WINDOW_MAXIMIZED`

`raylib.``FLAG_WINDOW_MINIMIZED`

`raylib.``FLAG_WINDOW_RESIZABLE`

`raylib.``FLAG_WINDOW_TOPMOST`

`raylib.``FLAG_WINDOW_TRANSPARENT`

`raylib.``FLAG_WINDOW_UNDECORATED`

`raylib.``FLAG_WINDOW_UNFOCUSED`

`raylib.``FONT_BITMAP`

`raylib.``FONT_DEFAULT`

`raylib.``FONT_SDF`

`raylib.``Fade`(color: Color, alpha: float)

  Get color with alpha applied, alpha goes from 0.0f to 1.0f

`raylib.``FileExists`(fileName: str)

  Check if file exists

`raylib.``Font`

`raylib.``FontType`

`raylib.``GAMEPAD_AXIS_LEFT_TRIGGER`

`raylib.``GAMEPAD_AXIS_LEFT_X`

`raylib.``GAMEPAD_AXIS_LEFT_Y`

`raylib.``GAMEPAD_AXIS_RIGHT_TRIGGER`

`raylib.``GAMEPAD_AXIS_RIGHT_X`

`raylib.``GAMEPAD_AXIS_RIGHT_Y`

`raylib.``GAMEPAD_BUTTON_LEFT_FACE_DOWN`

`raylib.``GAMEPAD_BUTTON_LEFT_FACE_LEFT`

`raylib.``GAMEPAD_BUTTON_LEFT_FACE_RIGHT`

`raylib.``GAMEPAD_BUTTON_LEFT_FACE_UP`

`raylib.``GAMEPAD_BUTTON_LEFT_THUMB`

`raylib.``GAMEPAD_BUTTON_LEFT_TRIGGER_1`

`raylib.``GAMEPAD_BUTTON_LEFT_TRIGGER_2`

`raylib.``GAMEPAD_BUTTON_MIDDLE`

`raylib.``GAMEPAD_BUTTON_MIDDLE_LEFT`

`raylib.``GAMEPAD_BUTTON_MIDDLE_RIGHT`

`raylib.``GAMEPAD_BUTTON_RIGHT_FACE_DOWN`

`raylib.``GAMEPAD_BUTTON_RIGHT_FACE_LEFT`

`raylib.``GAMEPAD_BUTTON_RIGHT_FACE_RIGHT`

`raylib.``GAMEPAD_BUTTON_RIGHT_FACE_UP`

`raylib.``GAMEPAD_BUTTON_RIGHT_THUMB`

`raylib.``GAMEPAD_BUTTON_RIGHT_TRIGGER_1`

`raylib.``GAMEPAD_BUTTON_RIGHT_TRIGGER_2`

`raylib.``GAMEPAD_BUTTON_UNKNOWN`

`raylib.``GESTURE_DOUBLETAP`

`raylib.``GESTURE_DRAG`

`raylib.``GESTURE_HOLD`

`raylib.``GESTURE_NONE`

`raylib.``GESTURE_PINCH_IN`

`raylib.``GESTURE_PINCH_OUT`

`raylib.``GESTURE_SWIPE_DOWN`

`raylib.``GESTURE_SWIPE_LEFT`

`raylib.``GESTURE_SWIPE_RIGHT`

`raylib.``GESTURE_SWIPE_UP`

`raylib.``GESTURE_TAP`

`raylib.``GROUP_PADDING`

`raylib.``GUI_STATE_DISABLED`

`raylib.``GUI_STATE_FOCUSED`

`raylib.``GUI_STATE_NORMAL`

`raylib.``GUI_STATE_PRESSED`

`raylib.``GUI_TEXT_ALIGN_CENTER`

`raylib.``GUI_TEXT_ALIGN_LEFT`

`raylib.``GUI_TEXT_ALIGN_RIGHT`

`raylib.``GamepadAxis`

`raylib.``GamepadButton`

`raylib.``GenImageCellular`(width: int, height: int, tileSize: int)

  Generate image: cellular algorithm, bigger tileSize means bigger cells

`raylib.``GenImageChecked`(width: int, height: int, checksX: int, checksY: int, col1: Color, col2: Color)

  Generate image: checked

`raylib.``GenImageColor`(width: int, height: int, color: Color)

  Generate image: plain color

`raylib.``GenImageFontAtlas`(chars: Any, recs: Any, glyphCount: int, fontSize: int, padding: int, packMethod: int)

  Generate image font atlas using chars info

`raylib.``GenImageGradientH`(width: int, height: int, left: Color, right: Color)

  Generate image: horizontal gradient

`raylib.``GenImageGradientRadial`(width: int, height: int, density: float, inner: Color, outer: Color)

  Generate image: radial gradient

`raylib.``GenImageGradientV`(width: int, height: int, top: Color, bottom: Color)

  Generate image: vertical gradient

`raylib.``GenImageWhiteNoise`(width: int, height: int, factor: float)

  Generate image: white noise

`raylib.``GenMeshBinormals`(mesh: Any)

  Compute mesh binormals

`raylib.``GenMeshCone`(radius: float, height: float, slices: int)

  Generate cone/pyramid mesh

`raylib.``GenMeshCube`(width: float, height: float, length: float)

  Generate cuboid mesh

`raylib.``GenMeshCubicmap`(cubicmap: Image, cubeSize: Vector3)

  Generate cubes-based map mesh from image data

`raylib.``GenMeshCylinder`(radius: float, height: float, slices: int)

  Generate cylinder mesh

`raylib.``GenMeshHeightmap`(heightmap: Image, size: Vector3)

  Generate heightmap mesh from image data

`raylib.``GenMeshHemiSphere`(radius: float, rings: int, slices: int)

  Generate half-sphere mesh (no bottom cap)

`raylib.``GenMeshKnot`(radius: float, size: float, radSeg: int, sides: int)

  Generate trefoil knot mesh

`raylib.``GenMeshPlane`(width: float, length: float, resX: int, resZ: int)

  Generate plane mesh (with subdivisions)

`raylib.``GenMeshPoly`(sides: int, radius: float)

  Generate polygonal mesh

`raylib.``GenMeshSphere`(radius: float, rings: int, slices: int)

  Generate sphere mesh (standard sphere)

`raylib.``GenMeshTangents`(mesh: Any)

  Compute mesh tangents

`raylib.``GenMeshTorus`(radius: float, size: float, radSeg: int, sides: int)

  Generate torus mesh

`raylib.``GenTextureMipmaps`(texture: Any)

  Generate GPU mipmaps for a texture

`raylib.``Gesture`

`raylib.``GetCameraMatrix`(camera: Camera3D)

  Get camera transform matrix (view matrix)

`raylib.``GetCameraMatrix2D`(camera: Camera2D)

  Get camera 2d transform matrix

`raylib.``GetCharPressed`()

  Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty

`raylib.``GetClipboardText`()

  Get clipboard text content

`raylib.``GetCodepoint`(text: str, bytesProcessed: Any)

  Get next codepoint in a UTF-8 encoded string, 0x3f(‘?’) is returned on failure

`raylib.``GetCodepointCount`(text: str)

  Get total number of codepoints in a UTF-8 encoded string

`raylib.``GetCollisionRec`(rec1: Rectangle, rec2: Rectangle)

  Get collision rectangle for two rectangles collision

`raylib.``GetColor`(hexValue: int)

  Get Color structure from hexadecimal value

`raylib.``GetCurrentMonitor`()

  Get current connected monitor

`raylib.``GetDirectoryFiles`(dirPath: str, count: Any)

  Get filenames in a directory path (memory should be freed)

`raylib.``GetDirectoryPath`(filePath: str)

  Get full path for a given fileName with path (uses static string)

`raylib.``GetDroppedFiles`(count: Any)

  Get dropped files names (memory should be freed)

`raylib.``GetFPS`()

  Get current FPS

`raylib.``GetFileExtension`(fileName: str)

  Get pointer to extension for a filename string (includes dot: ‘.png’)

`raylib.``GetFileModTime`(fileName: str)

  Get file modification time (last write time)

`raylib.``GetFileName`(filePath: str)

  Get pointer to filename for a path string

`raylib.``GetFileNameWithoutExt`(filePath: str)

  Get filename string without extension (uses static string)

`raylib.``GetFontDefault`()

  Get the default Font

`raylib.``GetFrameTime`()

  Get time in seconds for last frame drawn (delta time)

`raylib.``GetGamepadAxisCount`(gamepad: int)

  Get gamepad axis count for a gamepad

`raylib.``GetGamepadAxisMovement`(gamepad: int, axis: int)

  Get axis movement value for a gamepad axis

`raylib.``GetGamepadButtonPressed`()

  Get the last gamepad button pressed

`raylib.``GetGamepadName`(gamepad: int)

  Get gamepad internal name id

`raylib.``GetGestureDetected`()

  Get latest detected gesture

`raylib.``GetGestureDragAngle`()

  Get gesture drag angle

`raylib.``GetGestureDragVector`()

  Get gesture drag vector

`raylib.``GetGestureHoldDuration`()

  Get gesture hold time in milliseconds

`raylib.``GetGesturePinchAngle`()

  Get gesture pinch angle

`raylib.``GetGesturePinchVector`()

  Get gesture pinch delta

`raylib.``GetGlyphAtlasRec`(font: Font, codepoint: int)

  Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to ‘?’ if not found

`raylib.``GetGlyphIndex`(font: Font, codepoint: int)

  Get glyph index position in font for a codepoint (unicode character), fallback to ‘?’ if not found

`raylib.``GetGlyphInfo`(font: Font, codepoint: int)

  Get glyph font info data for a codepoint (unicode character), fallback to ‘?’ if not found

`raylib.``GetImageAlphaBorder`(image: Image, threshold: float)

  Get image alpha border rectangle

`raylib.``GetImageColor`(image: Image, x: int, y: int)

  Get image pixel color at (x, y) position

`raylib.``GetKeyPressed`()

  Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty

`raylib.``GetMeshBoundingBox`(mesh: Mesh)

  Compute mesh bounding box limits

`raylib.``GetModelBoundingBox`(model: Model)

  Compute model bounding box limits (considers all meshes)

`raylib.``GetMonitorCount`()

  Get number of connected monitors

`raylib.``GetMonitorHeight`(monitor: int)

  Get specified monitor height (max available by monitor)

`raylib.``GetMonitorName`(monitor: int)

  Get the human-readable, UTF-8 encoded name of the primary monitor

`raylib.``GetMonitorPhysicalHeight`(monitor: int)

  Get specified monitor physical height in millimetres

`raylib.``GetMonitorPhysicalWidth`(monitor: int)

  Get specified monitor physical width in millimetres

`raylib.``GetMonitorPosition`(monitor: int)

  Get specified monitor position

`raylib.``GetMonitorRefreshRate`(monitor: int)

  Get specified monitor refresh rate

`raylib.``GetMonitorWidth`(monitor: int)

  Get specified monitor width (max available by monitor)

`raylib.``GetMouseDelta`()

  Get mouse delta between frames

`raylib.``GetMousePosition`()

  Get mouse position XY

`raylib.``GetMouseRay`(mousePosition: Vector2, camera: Camera3D)

  Get a ray trace from mouse position

`raylib.``GetMouseWheelMove`()

  Get mouse wheel movement Y

`raylib.``GetMouseX`()

  Get mouse position X

`raylib.``GetMouseY`()

  Get mouse position Y

`raylib.``GetMusicTimeLength`(music: Music)

  Get music time length (in seconds)

`raylib.``GetMusicTimePlayed`(music: Music)

  Get current music time played (in seconds)

`raylib.``GetPhysicsBodiesCount`()

  int GetPhysicsBodiesCount();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GetPhysicsBody`(int_0: int)

  struct PhysicsBodyData *GetPhysicsBody(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GetPhysicsShapeType`(int_0: int)

  int GetPhysicsShapeType(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GetPhysicsShapeVertex`(PhysicsBodyData_pointer_0: Any, int_1: int)

  struct Vector2 GetPhysicsShapeVertex(struct PhysicsBodyData *, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GetPhysicsShapeVerticesCount`(int_0: int)

  int GetPhysicsShapeVerticesCount(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GetPixelColor`(srcPtr: Any, format: int)

  Get Color from a source pixel pointer of certain format

`raylib.``GetPixelDataSize`(width: int, height: int, format: int)

  Get pixel data size in bytes for certain format

`raylib.``GetPrevDirectoryPath`(dirPath: str)

  Get previous directory path for a given path (uses static string)

`raylib.``GetRandomValue`(min: int, max: int)

  Get a random value between min and max (both included)

`raylib.``GetRayCollisionBox`(ray: Ray, box: BoundingBox)

  Get collision info between ray and box

`raylib.``GetRayCollisionMesh`(ray: Ray, mesh: Mesh, transform: Matrix)

  Get collision info between ray and mesh

`raylib.``GetRayCollisionModel`(ray: Ray, model: Model)

  Get collision info between ray and model

`raylib.``GetRayCollisionQuad`(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3)

  Get collision info between ray and quad

`raylib.``GetRayCollisionSphere`(ray: Ray, center: Vector3, radius: float)

  Get collision info between ray and sphere

`raylib.``GetRayCollisionTriangle`(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3)

  Get collision info between ray and triangle

`raylib.``GetScreenHeight`()

  Get current screen height

`raylib.``GetScreenToWorld2D`(position: Vector2, camera: Camera2D)

  Get the world space position for a 2d camera screen space position

`raylib.``GetScreenWidth`()

  Get current screen width

`raylib.``GetShaderLocation`(shader: Shader, uniformName: str)

  Get shader uniform location

`raylib.``GetShaderLocationAttrib`(shader: Shader, attribName: str)

  Get shader attribute location

`raylib.``GetSoundsPlaying`()

  Get number of sounds playing in the multichannel

`raylib.``GetTime`()

  Get elapsed time in seconds since InitWindow()

`raylib.``GetTouchPointCount`()

  Get number of touch points

`raylib.``GetTouchPointId`(index: int)

  Get touch point identifier for given index

`raylib.``GetTouchPosition`(index: int)

  Get touch position XY for a touch point index (relative to screen size)

`raylib.``GetTouchX`()

  Get touch position X for touch point 0 (relative to screen size)

`raylib.``GetTouchY`()

  Get touch position Y for touch point 0 (relative to screen size)

`raylib.``GetWindowHandle`()

  Get native window handle

`raylib.``GetWindowPosition`()

  Get window position XY on monitor

`raylib.``GetWindowScaleDPI`()

  Get window scale DPI factor

`raylib.``GetWorkingDirectory`()

  Get current working directory (uses static string)

`raylib.``GetWorldToScreen`(position: Vector3, camera: Camera3D)

  Get the screen space position for a 3d world space position

`raylib.``GetWorldToScreen2D`(position: Vector2, camera: Camera2D)

  Get the screen space position for a 2d camera world space position

`raylib.``GetWorldToScreenEx`(position: Vector3, camera: Camera3D, width: int, height: int)

  Get size position for a 3d world space position

`raylib.``GlyphInfo`

`raylib.``GuiButton`(Rectangle_0: Rectangle, str_1: str)

  _Bool GuiButton(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiCheckBox`(Rectangle_0: Rectangle, str_1: str, _Bool_2: bool)

  _Bool GuiCheckBox(struct Rectangle, char *, _Bool);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiCheckBoxProperty`

`raylib.``GuiCheckIconPixel`(int_0: int, int_1: int, int_2: int)

  _Bool GuiCheckIconPixel(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiClearIconPixel`(int_0: int, int_1: int, int_2: int)

  void GuiClearIconPixel(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiColorBarAlpha`(Rectangle_0: Rectangle, float_1: float)

  float GuiColorBarAlpha(struct Rectangle, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiColorBarHue`(Rectangle_0: Rectangle, float_1: float)

  float GuiColorBarHue(struct Rectangle, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiColorPanel`(Rectangle_0: Rectangle, Color_1: Color)

  struct Color GuiColorPanel(struct Rectangle, struct Color);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiColorPicker`(Rectangle_0: Rectangle, Color_1: Color)

  struct Color GuiColorPicker(struct Rectangle, struct Color);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiColorPickerProperty`

`raylib.``GuiComboBox`(Rectangle_0: Rectangle, str_1: str, int_2: int)

  int GuiComboBox(struct Rectangle, char *, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiComboBoxProperty`

`raylib.``GuiControl`

`raylib.``GuiControlProperty`

`raylib.``GuiControlState`

`raylib.``GuiDefaultProperty`

`raylib.``GuiDisable`()

  void GuiDisable();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiDrawIcon`(int_0: int, int_1: int, int_2: int, int_3: int, Color_4: Color)

  void GuiDrawIcon(int, int, int, int, struct Color);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiDropdownBox`(Rectangle_0: Rectangle, str_1: str, int_pointer_2: Any, _Bool_3: bool)

  _Bool GuiDropdownBox(struct Rectangle, char *, int *, _Bool);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiDropdownBoxProperty`

`raylib.``GuiDummyRec`(Rectangle_0: Rectangle, str_1: str)

  void GuiDummyRec(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiEnable`()

  void GuiEnable();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiFade`(float_0: float)

  void GuiFade(float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiGetFont`()

  struct Font GuiGetFont();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiGetIconData`(int_0: int)

  unsigned int *GuiGetIconData(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiGetIcons`()

  unsigned int *GuiGetIcons();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiGetState`()

  int GuiGetState();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiGetStyle`(int_0: int, int_1: int)

  int GuiGetStyle(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiGrid`(Rectangle_0: Rectangle, float_1: float, int_2: int)

  struct Vector2 GuiGrid(struct Rectangle, float, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiGroupBox`(Rectangle_0: Rectangle, str_1: str)

  void GuiGroupBox(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiIconText`(int_0: int, str_1: str)

  char *GuiIconText(int, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiIsLocked`()

  _Bool GuiIsLocked();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiLabel`(Rectangle_0: Rectangle, str_1: str)

  void GuiLabel(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiLabelButton`(Rectangle_0: Rectangle, str_1: str)

  _Bool GuiLabelButton(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiLine`(Rectangle_0: Rectangle, str_1: str)

  void GuiLine(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiListView`(Rectangle_0: Rectangle, str_1: str, int_pointer_2: Any, int_3: int)

  int GuiListView(struct Rectangle, char *, int *, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiListViewEx`(Rectangle_0: Rectangle, str_pointer_1: str, int_2: int, int_pointer_3: Any, int_pointer_4: Any, int_5: int)

  int GuiListViewEx(struct Rectangle, char * *, int, int *, int *, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiListViewProperty`

`raylib.``GuiLoadStyle`(str_0: str)

  void GuiLoadStyle(char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiLoadStyleDefault`()

  void GuiLoadStyleDefault();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiLock`()

  void GuiLock();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiMessageBox`(Rectangle_0: Rectangle, str_1: str, str_2: str, str_3: str)

  int GuiMessageBox(struct Rectangle, char *, char *, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiPanel`(Rectangle_0: Rectangle)

  void GuiPanel(struct Rectangle);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiProgressBar`(Rectangle_0: Rectangle, str_1: str, str_2: str, float_3: float, float_4: float, float_5: float)

  float GuiProgressBar(struct Rectangle, char *, char *, float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiProgressBarProperty`

`raylib.``GuiScrollBar`(Rectangle_0: Rectangle, int_1: int, int_2: int, int_3: int)

  int GuiScrollBar(struct Rectangle, int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiScrollBarProperty`

`raylib.``GuiScrollBarSide`

`raylib.``GuiScrollPanel`(Rectangle_0: Rectangle, Rectangle_1: Rectangle, Vector2_pointer_2: Any)

  struct Rectangle GuiScrollPanel(struct Rectangle, struct Rectangle, struct Vector2 *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiSetFont`(Font_0: Font)

  void GuiSetFont(struct Font);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiSetIconData`(int_0: int, unsignedint_pointer_1: Any)

  void GuiSetIconData(int, unsigned int *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiSetIconPixel`(int_0: int, int_1: int, int_2: int)

  void GuiSetIconPixel(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiSetState`(int_0: int)

  void GuiSetState(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiSetStyle`(int_0: int, int_1: int, int_2: int)

  void GuiSetStyle(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiSlider`(Rectangle_0: Rectangle, str_1: str, str_2: str, float_3: float, float_4: float, float_5: float)

  float GuiSlider(struct Rectangle, char *, char *, float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiSliderBar`(Rectangle_0: Rectangle, str_1: str, str_2: str, float_3: float, float_4: float, float_5: float)

  float GuiSliderBar(struct Rectangle, char *, char *, float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiSliderProperty`

`raylib.``GuiSpinner`(Rectangle_0: Rectangle, str_1: str, int_pointer_2: Any, int_3: int, int_4: int, _Bool_5: bool)

  _Bool GuiSpinner(struct Rectangle, char *, int *, int, int, _Bool);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiSpinnerProperty`

`raylib.``GuiStatusBar`(Rectangle_0: Rectangle, str_1: str)

  void GuiStatusBar(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiStyleProp`

`raylib.``GuiTextAlignment`

`raylib.``GuiTextBox`(Rectangle_0: Rectangle, str_1: str, int_2: int, _Bool_3: bool)

  _Bool GuiTextBox(struct Rectangle, char *, int, _Bool);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiTextBoxMulti`(Rectangle_0: Rectangle, str_1: str, int_2: int, _Bool_3: bool)

  _Bool GuiTextBoxMulti(struct Rectangle, char *, int, _Bool);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiTextBoxProperty`

`raylib.``GuiTextInputBox`(Rectangle_0: Rectangle, str_1: str, str_2: str, str_3: str, str_4: str)

  int GuiTextInputBox(struct Rectangle, char *, char *, char *, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiToggle`(Rectangle_0: Rectangle, str_1: str, _Bool_2: bool)

  _Bool GuiToggle(struct Rectangle, char *, _Bool);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiToggleGroup`(Rectangle_0: Rectangle, str_1: str, int_2: int)

  int GuiToggleGroup(struct Rectangle, char *, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiToggleProperty`

`raylib.``GuiUnlock`()

  void GuiUnlock();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiValueBox`(Rectangle_0: Rectangle, str_1: str, int_pointer_2: Any, int_3: int, int_4: int, _Bool_5: bool)

  _Bool GuiValueBox(struct Rectangle, char *, int *, int, int, _Bool);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GuiWindowBox`(Rectangle_0: Rectangle, str_1: str)

  _Bool GuiWindowBox(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``HUEBAR_PADDING`

`raylib.``HUEBAR_SELECTOR_HEIGHT`

`raylib.``HUEBAR_SELECTOR_OVERFLOW`

`raylib.``HUEBAR_WIDTH`

`raylib.``HideCursor`()

  Hides cursor

`raylib.``Image`

`raylib.``ImageAlphaClear`(image: Any, color: Color, threshold: float)

  Clear alpha channel to desired color

`raylib.``ImageAlphaCrop`(image: Any, threshold: float)

  Crop image depending on alpha value

`raylib.``ImageAlphaMask`(image: Any, alphaMask: Image)

  Apply alpha mask to image

`raylib.``ImageAlphaPremultiply`(image: Any)

  Premultiply alpha channel

`raylib.``ImageClearBackground`(dst: Any, color: Color)

  Clear image background with given color

`raylib.``ImageColorBrightness`(image: Any, brightness: int)

  Modify image color: brightness (-255 to 255)

`raylib.``ImageColorContrast`(image: Any, contrast: float)

  Modify image color: contrast (-100 to 100)

`raylib.``ImageColorGrayscale`(image: Any)

  Modify image color: grayscale

`raylib.``ImageColorInvert`(image: Any)

  Modify image color: invert

`raylib.``ImageColorReplace`(image: Any, color: Color, replace: Color)

  Modify image color: replace color

`raylib.``ImageColorTint`(image: Any, color: Color)

  Modify image color: tint

`raylib.``ImageCopy`(image: Image)

  Create an image duplicate (useful for transformations)

`raylib.``ImageCrop`(image: Any, crop: Rectangle)

  Crop an image to a defined rectangle

`raylib.``ImageDither`(image: Any, rBpp: int, gBpp: int, bBpp: int, aBpp: int)

  Dither image data to 16bpp or lower (Floyd-Steinberg dithering)

`raylib.``ImageDraw`(dst: Any, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color)

  Draw a source image within a destination image (tint applied to source)

`raylib.``ImageDrawCircle`(dst: Any, centerX: int, centerY: int, radius: int, color: Color)

  Draw circle within an image

`raylib.``ImageDrawCircleV`(dst: Any, center: Vector2, radius: int, color: Color)

  Draw circle within an image (Vector version)

`raylib.``ImageDrawLine`(dst: Any, startPosX: int, startPosY: int, endPosX: int, endPosY: int, color: Color)

  Draw line within an image

`raylib.``ImageDrawLineV`(dst: Any, start: Vector2, end: Vector2, color: Color)

  Draw line within an image (Vector version)

`raylib.``ImageDrawPixel`(dst: Any, posX: int, posY: int, color: Color)

  Draw pixel within an image

`raylib.``ImageDrawPixelV`(dst: Any, position: Vector2, color: Color)

  Draw pixel within an image (Vector version)

`raylib.``ImageDrawRectangle`(dst: Any, posX: int, posY: int, width: int, height: int, color: Color)

  Draw rectangle within an image

`raylib.``ImageDrawRectangleLines`(dst: Any, rec: Rectangle, thick: int, color: Color)

  Draw rectangle lines within an image

`raylib.``ImageDrawRectangleRec`(dst: Any, rec: Rectangle, color: Color)

  Draw rectangle within an image

`raylib.``ImageDrawRectangleV`(dst: Any, position: Vector2, size: Vector2, color: Color)

  Draw rectangle within an image (Vector version)

`raylib.``ImageDrawText`(dst: Any, text: str, posX: int, posY: int, fontSize: int, color: Color)

  Draw text (using default font) within an image (destination)

`raylib.``ImageDrawTextEx`(dst: Any, font: Font, text: str, position: Vector2, fontSize: float, spacing: float, tint: Color)

  Draw text (custom sprite font) within an image (destination)

`raylib.``ImageFlipHorizontal`(image: Any)

  Flip image horizontally

`raylib.``ImageFlipVertical`(image: Any)

  Flip image vertically

`raylib.``ImageFormat`(image: Any, newFormat: int)

  Convert image data to desired format

`raylib.``ImageFromImage`(image: Image, rec: Rectangle)

  Create an image from another image piece

`raylib.``ImageMipmaps`(image: Any)

  Compute all mipmap levels for a provided image

`raylib.``ImageResize`(image: Any, newWidth: int, newHeight: int)

  Resize image (Bicubic scaling algorithm)

`raylib.``ImageResizeCanvas`(image: Any, newWidth: int, newHeight: int, offsetX: int, offsetY: int, fill: Color)

  Resize canvas and fill with color

`raylib.``ImageResizeNN`(image: Any, newWidth: int, newHeight: int)

  Resize image (Nearest-Neighbor scaling algorithm)

`raylib.``ImageRotateCCW`(image: Any)

  Rotate image counter-clockwise 90deg

`raylib.``ImageRotateCW`(image: Any)

  Rotate image clockwise 90deg

`raylib.``ImageText`(text: str, fontSize: int, color: Color)

  Create an image from text (default font)

`raylib.``ImageTextEx`(font: Font, text: str, fontSize: float, spacing: float, tint: Color)

  Create an image from text (custom sprite font)

`raylib.``ImageToPOT`(image: Any, fill: Color)

  Convert image to POT (power-of-two)

`raylib.``InitAudioDevice`()

  Initialize audio device and context

`raylib.``InitPhysics`()

  void InitPhysics();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``InitWindow`(width: int, height: int, title: str)

  Initialize window and OpenGL context

`raylib.``IsAudioDeviceReady`()

  Check if audio device has been initialized successfully

`raylib.``IsAudioStreamPlaying`(stream: AudioStream)

  Check if audio stream is playing

`raylib.``IsAudioStreamProcessed`(stream: AudioStream)

  Check if any audio stream buffers requires refill

`raylib.``IsCursorHidden`()

  Check if cursor is not visible

`raylib.``IsCursorOnScreen`()

  Check if cursor is on the screen

`raylib.``IsFileDropped`()

  Check if a file has been dropped into window

`raylib.``IsFileExtension`(fileName: str, ext: str)

  Check file extension (including point: .png, .wav)

`raylib.``IsGamepadAvailable`(gamepad: int)

  Check if a gamepad is available

`raylib.``IsGamepadButtonDown`(gamepad: int, button: int)

  Check if a gamepad button is being pressed

`raylib.``IsGamepadButtonPressed`(gamepad: int, button: int)

  Check if a gamepad button has been pressed once

`raylib.``IsGamepadButtonReleased`(gamepad: int, button: int)

  Check if a gamepad button has been released once

`raylib.``IsGamepadButtonUp`(gamepad: int, button: int)

  Check if a gamepad button is NOT being pressed

`raylib.``IsGestureDetected`(gesture: int)

  Check if a gesture have been detected

`raylib.``IsKeyDown`(key: int)

  Check if a key is being pressed

`raylib.``IsKeyPressed`(key: int)

  Check if a key has been pressed once

`raylib.``IsKeyReleased`(key: int)

  Check if a key has been released once

`raylib.``IsKeyUp`(key: int)

  Check if a key is NOT being pressed

`raylib.``IsModelAnimationValid`(model: Model, anim: ModelAnimation)

  Check model animation skeleton match

`raylib.``IsMouseButtonDown`(button: int)

  Check if a mouse button is being pressed

`raylib.``IsMouseButtonPressed`(button: int)

  Check if a mouse button has been pressed once

`raylib.``IsMouseButtonReleased`(button: int)

  Check if a mouse button has been released once

`raylib.``IsMouseButtonUp`(button: int)

  Check if a mouse button is NOT being pressed

`raylib.``IsMusicStreamPlaying`(music: Music)

  Check if music is playing

`raylib.``IsSoundPlaying`(sound: Sound)

  Check if a sound is currently playing

`raylib.``IsWindowFocused`()

  Check if window is currently focused (only PLATFORM_DESKTOP)

`raylib.``IsWindowFullscreen`()

  Check if window is currently fullscreen

`raylib.``IsWindowHidden`()

  Check if window is currently hidden (only PLATFORM_DESKTOP)

`raylib.``IsWindowMaximized`()

  Check if window is currently maximized (only PLATFORM_DESKTOP)

`raylib.``IsWindowMinimized`()

  Check if window is currently minimized (only PLATFORM_DESKTOP)

`raylib.``IsWindowReady`()

  Check if window has been initialized successfully

`raylib.``IsWindowResized`()

  Check if window has been resized last frame

`raylib.``IsWindowState`(flag: int)

  Check if one specific window flag is enabled

`raylib.``KEY_A`

`raylib.``KEY_APOSTROPHE`

`raylib.``KEY_B`

`raylib.``KEY_BACK`

`raylib.``KEY_BACKSLASH`

`raylib.``KEY_BACKSPACE`

`raylib.``KEY_C`

`raylib.``KEY_CAPS_LOCK`

`raylib.``KEY_COMMA`

`raylib.``KEY_D`

`raylib.``KEY_DELETE`

`raylib.``KEY_DOWN`

`raylib.``KEY_E`

`raylib.``KEY_EIGHT`

`raylib.``KEY_END`

`raylib.``KEY_ENTER`

`raylib.``KEY_EQUAL`

`raylib.``KEY_ESCAPE`

`raylib.``KEY_F`

`raylib.``KEY_F1`

`raylib.``KEY_F10`

`raylib.``KEY_F11`

`raylib.``KEY_F12`

`raylib.``KEY_F2`

`raylib.``KEY_F3`

`raylib.``KEY_F4`

`raylib.``KEY_F5`

`raylib.``KEY_F6`

`raylib.``KEY_F7`

`raylib.``KEY_F8`

`raylib.``KEY_F9`

`raylib.``KEY_FIVE`

`raylib.``KEY_FOUR`

`raylib.``KEY_G`

`raylib.``KEY_GRAVE`

`raylib.``KEY_H`

`raylib.``KEY_HOME`

`raylib.``KEY_I`

`raylib.``KEY_INSERT`

`raylib.``KEY_J`

`raylib.``KEY_K`

`raylib.``KEY_KB_MENU`

`raylib.``KEY_KP_0`

`raylib.``KEY_KP_1`

`raylib.``KEY_KP_2`

`raylib.``KEY_KP_3`

`raylib.``KEY_KP_4`

`raylib.``KEY_KP_5`

`raylib.``KEY_KP_6`

`raylib.``KEY_KP_7`

`raylib.``KEY_KP_8`

`raylib.``KEY_KP_9`

`raylib.``KEY_KP_ADD`

`raylib.``KEY_KP_DECIMAL`

`raylib.``KEY_KP_DIVIDE`

`raylib.``KEY_KP_ENTER`

`raylib.``KEY_KP_EQUAL`

`raylib.``KEY_KP_MULTIPLY`

`raylib.``KEY_KP_SUBTRACT`

`raylib.``KEY_L`

`raylib.``KEY_LEFT`

`raylib.``KEY_LEFT_ALT`

`raylib.``KEY_LEFT_BRACKET`

`raylib.``KEY_LEFT_CONTROL`

`raylib.``KEY_LEFT_SHIFT`

`raylib.``KEY_LEFT_SUPER`

`raylib.``KEY_M`

`raylib.``KEY_MENU`

`raylib.``KEY_MINUS`

`raylib.``KEY_N`

`raylib.``KEY_NINE`

`raylib.``KEY_NULL`

`raylib.``KEY_NUM_LOCK`

`raylib.``KEY_O`

`raylib.``KEY_ONE`

`raylib.``KEY_P`

`raylib.``KEY_PAGE_DOWN`

`raylib.``KEY_PAGE_UP`

`raylib.``KEY_PAUSE`

`raylib.``KEY_PERIOD`

`raylib.``KEY_PRINT_SCREEN`

`raylib.``KEY_Q`

`raylib.``KEY_R`

`raylib.``KEY_RIGHT`

`raylib.``KEY_RIGHT_ALT`

`raylib.``KEY_RIGHT_BRACKET`

`raylib.``KEY_RIGHT_CONTROL`

`raylib.``KEY_RIGHT_SHIFT`

`raylib.``KEY_RIGHT_SUPER`

`raylib.``KEY_S`

`raylib.``KEY_SCROLL_LOCK`

`raylib.``KEY_SEMICOLON`

`raylib.``KEY_SEVEN`

`raylib.``KEY_SIX`

`raylib.``KEY_SLASH`

`raylib.``KEY_SPACE`

`raylib.``KEY_T`

`raylib.``KEY_TAB`

`raylib.``KEY_THREE`

`raylib.``KEY_TWO`

`raylib.``KEY_U`

`raylib.``KEY_UP`

`raylib.``KEY_V`

`raylib.``KEY_VOLUME_DOWN`

`raylib.``KEY_VOLUME_UP`

`raylib.``KEY_W`

`raylib.``KEY_X`

`raylib.``KEY_Y`

`raylib.``KEY_Z`

`raylib.``KEY_ZERO`

`raylib.``KeyboardKey`

`raylib.``LABEL`

`raylib.``LINE_COLOR`

`raylib.``LISTVIEW`

`raylib.``LIST_ITEMS_HEIGHT`

`raylib.``LIST_ITEMS_PADDING`

`raylib.``LOG_ALL`

`raylib.``LOG_DEBUG`

`raylib.``LOG_ERROR`

`raylib.``LOG_FATAL`

`raylib.``LOG_INFO`

`raylib.``LOG_NONE`

`raylib.``LOG_TRACE`

`raylib.``LOG_WARNING`

`raylib.``LoadAudioStream`(sampleRate: int, sampleSize: int, channels: int)

  Load audio stream (to stream raw audio pcm data)

`raylib.``LoadCodepoints`(text: str, count: Any)

  Load all codepoints from a UTF-8 text string, codepoints count returned by parameter

`raylib.``LoadFileData`(fileName: str, bytesRead: Any)

  Load file data as byte array (read)

`raylib.``LoadFileText`(fileName: str)

  Load text data from file (read), returns a ‘ 0’ terminated string

`raylib.``LoadFont`(fileName: str)

  Load font from file into GPU memory (VRAM)

`raylib.``LoadFontData`(fileData: str, dataSize: int, fontSize: int, fontChars: Any, glyphCount: int, type: int)

  Load font data for further use

`raylib.``LoadFontEx`(fileName: str, fontSize: int, fontChars: Any, glyphCount: int)

  Load font from file with extended parameters

`raylib.``LoadFontFromImage`(image: Image, key: Color, firstChar: int)

  Load font from Image (XNA style)

`raylib.``LoadFontFromMemory`(fileType: str, fileData: str, dataSize: int, fontSize: int, fontChars: Any, glyphCount: int)

  Load font from memory buffer, fileType refers to extension: i.e. ‘.ttf’

`raylib.``LoadImage`(fileName: str)

  Load image from file into CPU memory (RAM)

`raylib.``LoadImageAnim`(fileName: str, frames: Any)

  Load image sequence from file (frames appended to image.data)

`raylib.``LoadImageColors`(image: Image)

  Load color data from image as a Color array (RGBA - 32bit)

`raylib.``LoadImageFromMemory`(fileType: str, fileData: str, dataSize: int)

  Load image from memory buffer, fileType refers to extension: i.e. ‘.png’

`raylib.``LoadImageFromScreen`()

  Load image from screen buffer and (screenshot)

`raylib.``LoadImageFromTexture`(texture: Texture)

  Load image from GPU texture data

`raylib.``LoadImagePalette`(image: Image, maxPaletteSize: int, colorCount: Any)

  Load colors palette from image as a Color array (RGBA - 32bit)

`raylib.``LoadImageRaw`(fileName: str, width: int, height: int, format: int, headerSize: int)

  Load image from RAW file data

`raylib.``LoadMaterialDefault`()

  Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)

`raylib.``LoadMaterials`(fileName: str, materialCount: Any)

  Load materials from model file

`raylib.``LoadModel`(fileName: str)

  Load model from files (meshes and materials)

`raylib.``LoadModelAnimations`(fileName: str, animCount: Any)

  Load model animations from file

`raylib.``LoadModelFromMesh`(mesh: Mesh)

  Load model from generated mesh (default material)

`raylib.``LoadMusicStream`(fileName: str)

  Load music stream from file

`raylib.``LoadMusicStreamFromMemory`(fileType: str, data: str, dataSize: int)

  Load music stream from data

`raylib.``LoadRenderTexture`(width: int, height: int)

  Load texture for rendering (framebuffer)

`raylib.``LoadShader`(vsFileName: str, fsFileName: str)

  Load shader from files and bind default locations

`raylib.``LoadShaderFromMemory`(vsCode: str, fsCode: str)

  Load shader from code strings and bind default locations

`raylib.``LoadSound`(fileName: str)

  Load sound from file

`raylib.``LoadSoundFromWave`(wave: Wave)

  Load sound from wave data

`raylib.``LoadStorageValue`(position: int)

  Load integer value from storage file (from defined position)

`raylib.``LoadTexture`(fileName: str)

  Load texture from file into GPU memory (VRAM)

`raylib.``LoadTextureCubemap`(image: Image, layout: int)

  Load cubemap from image, multiple image cubemap layouts supported

`raylib.``LoadTextureFromImage`(image: Image)

  Load texture from image data

`raylib.``LoadVrStereoConfig`(device: VrDeviceInfo)

  Load VR stereo config for VR simulator device parameters

`raylib.``LoadWave`(fileName: str)

  Load wave data from file

`raylib.``LoadWaveFromMemory`(fileType: str, fileData: str, dataSize: int)

  Load wave from memory buffer, fileType refers to extension: i.e. ‘.wav’

`raylib.``LoadWaveSamples`(wave: Wave)

  Load samples data from wave as a floats array

`raylib.``MATERIAL_MAP_ALBEDO`

`raylib.``MATERIAL_MAP_BRDF`

`raylib.``MATERIAL_MAP_CUBEMAP`

`raylib.``MATERIAL_MAP_EMISSION`

`raylib.``MATERIAL_MAP_HEIGHT`

`raylib.``MATERIAL_MAP_IRRADIANCE`

`raylib.``MATERIAL_MAP_METALNESS`

`raylib.``MATERIAL_MAP_NORMAL`

`raylib.``MATERIAL_MAP_OCCLUSION`

`raylib.``MATERIAL_MAP_PREFILTER`

`raylib.``MATERIAL_MAP_ROUGHNESS`

`raylib.``MOUSE_BUTTON_BACK`

`raylib.``MOUSE_BUTTON_EXTRA`

`raylib.``MOUSE_BUTTON_FORWARD`

`raylib.``MOUSE_BUTTON_LEFT`

`raylib.``MOUSE_BUTTON_MIDDLE`

`raylib.``MOUSE_BUTTON_RIGHT`

`raylib.``MOUSE_BUTTON_SIDE`

`raylib.``MOUSE_CURSOR_ARROW`

`raylib.``MOUSE_CURSOR_CROSSHAIR`

`raylib.``MOUSE_CURSOR_DEFAULT`

`raylib.``MOUSE_CURSOR_IBEAM`

`raylib.``MOUSE_CURSOR_NOT_ALLOWED`

`raylib.``MOUSE_CURSOR_POINTING_HAND`

`raylib.``MOUSE_CURSOR_RESIZE_ALL`

`raylib.``MOUSE_CURSOR_RESIZE_EW`

`raylib.``MOUSE_CURSOR_RESIZE_NESW`

`raylib.``MOUSE_CURSOR_RESIZE_NS`

`raylib.``MOUSE_CURSOR_RESIZE_NWSE`

`raylib.``Material`

`raylib.``MaterialMap`

`raylib.``MaterialMapIndex`

`raylib.``Matrix`

`raylib.``Matrix2x2`

`raylib.``MaximizeWindow`()

  Set window state: maximized, if resizable (only PLATFORM_DESKTOP)

`raylib.``MeasureText`(text: str, fontSize: int)

  Measure string width for default font

`raylib.``MeasureTextEx`(font: Font, text: str, fontSize: float, spacing: float)

  Measure string size for Font

`raylib.``MemAlloc`(size: int)

  Internal memory allocator

`raylib.``MemFree`(ptr: Any)

  Internal memory free

`raylib.``MemRealloc`(ptr: Any, size: int)

  Internal memory reallocator

`raylib.``Mesh`

`raylib.``MinimizeWindow`()

  Set window state: minimized, if resizable (only PLATFORM_DESKTOP)

`raylib.``Model`

`raylib.``ModelAnimation`

`raylib.``MouseButton`

`raylib.``MouseCursor`

`raylib.``Music`

`raylib.``NPATCH_NINE_PATCH`

`raylib.``NPATCH_THREE_PATCH_HORIZONTAL`

`raylib.``NPATCH_THREE_PATCH_VERTICAL`

`raylib.``NPatchInfo`

`raylib.``NPatchLayout`

`raylib.``OPENGL_11`

`raylib.``OPENGL_21`

`raylib.``OPENGL_33`

`raylib.``OPENGL_43`

`raylib.``OPENGL_ES_20`

`raylib.``OpenURL`(url: str)

  Open URL with default system browser (if available)

`raylib.``PHYSICS_CIRCLE`

`raylib.``PHYSICS_POLYGON`

`raylib.``PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_DXT1_RGB`

`raylib.``PIXELFORMAT_COMPRESSED_DXT1_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_DXT3_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_DXT5_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_ETC1_RGB`

`raylib.``PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_ETC2_RGB`

`raylib.``PIXELFORMAT_COMPRESSED_PVRT_RGB`

`raylib.``PIXELFORMAT_COMPRESSED_PVRT_RGBA`

`raylib.``PIXELFORMAT_UNCOMPRESSED_GRAYSCALE`

`raylib.``PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R32`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R32G32B32`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R32G32B32A32`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R4G4B4A4`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R5G5B5A1`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R5G6B5`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R8G8B8`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R8G8B8A8`

`raylib.``PROGRESSBAR`

`raylib.``PROGRESS_PADDING`

`raylib.``PauseAudioStream`(stream: AudioStream)

  Pause audio stream

`raylib.``PauseMusicStream`(music: Music)

  Pause music playing

`raylib.``PauseSound`(sound: Sound)

  Pause a sound

`raylib.``PhysicsAddForce`(PhysicsBodyData_pointer_0: Any, Vector2_1: Vector2)

  void PhysicsAddForce(struct PhysicsBodyData *, struct Vector2);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``PhysicsAddTorque`(PhysicsBodyData_pointer_0: Any, float_1: float)

  void PhysicsAddTorque(struct PhysicsBodyData *, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``PhysicsBodyData`

`raylib.``PhysicsManifoldData`

`raylib.``PhysicsShape`

`raylib.``PhysicsShapeType`

`raylib.``PhysicsShatter`(PhysicsBodyData_pointer_0: Any, Vector2_1: Vector2, float_2: float)

  void PhysicsShatter(struct PhysicsBodyData *, struct Vector2, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``PhysicsVertexData`

`raylib.``PixelFormat`

`raylib.``PlayAudioStream`(stream: AudioStream)

  Play audio stream

`raylib.``PlayMusicStream`(music: Music)

  Start music playing

`raylib.``PlaySound`(sound: Sound)

  Play a sound

`raylib.``PlaySoundMulti`(sound: Sound)

  Play a sound (using multichannel buffer pool)

`raylib.``PollInputEvents`()

  Register all input events

`raylib.``Quaternion`

`raylib.``RESERVED`

`raylib.``RL_ATTACHMENT_COLOR_CHANNEL0`

`raylib.``RL_ATTACHMENT_COLOR_CHANNEL1`

`raylib.``RL_ATTACHMENT_COLOR_CHANNEL2`

`raylib.``RL_ATTACHMENT_COLOR_CHANNEL3`

`raylib.``RL_ATTACHMENT_COLOR_CHANNEL4`

`raylib.``RL_ATTACHMENT_COLOR_CHANNEL5`

`raylib.``RL_ATTACHMENT_COLOR_CHANNEL6`

`raylib.``RL_ATTACHMENT_COLOR_CHANNEL7`

`raylib.``RL_ATTACHMENT_CUBEMAP_NEGATIVE_X`

`raylib.``RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y`

`raylib.``RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z`

`raylib.``RL_ATTACHMENT_CUBEMAP_POSITIVE_X`

`raylib.``RL_ATTACHMENT_CUBEMAP_POSITIVE_Y`

`raylib.``RL_ATTACHMENT_CUBEMAP_POSITIVE_Z`

`raylib.``RL_ATTACHMENT_DEPTH`

`raylib.``RL_ATTACHMENT_RENDERBUFFER`

`raylib.``RL_ATTACHMENT_STENCIL`

`raylib.``RL_ATTACHMENT_TEXTURE2D`

`raylib.``RL_BLEND_ADDITIVE`

`raylib.``RL_BLEND_ADD_COLORS`

`raylib.``RL_BLEND_ALPHA`

`raylib.``RL_BLEND_CUSTOM`

`raylib.``RL_BLEND_MULTIPLIED`

`raylib.``RL_BLEND_SUBTRACT_COLORS`

`raylib.``RL_LOG_ALL`

`raylib.``RL_LOG_DEBUG`

`raylib.``RL_LOG_ERROR`

`raylib.``RL_LOG_FATAL`

`raylib.``RL_LOG_INFO`

`raylib.``RL_LOG_NONE`

`raylib.``RL_LOG_TRACE`

`raylib.``RL_LOG_WARNING`

`raylib.``RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA`

`raylib.``RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA`

`raylib.``RL_PIXELFORMAT_COMPRESSED_DXT1_RGB`

`raylib.``RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA`

`raylib.``RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA`

`raylib.``RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA`

`raylib.``RL_PIXELFORMAT_COMPRESSED_ETC1_RGB`

`raylib.``RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA`

`raylib.``RL_PIXELFORMAT_COMPRESSED_ETC2_RGB`

`raylib.``RL_PIXELFORMAT_COMPRESSED_PVRT_RGB`

`raylib.``RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA`

`raylib.``RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE`

`raylib.``RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA`

`raylib.``RL_PIXELFORMAT_UNCOMPRESSED_R32`

`raylib.``RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32`

`raylib.``RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32`

`raylib.``RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4`

`raylib.``RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1`

`raylib.``RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5`

`raylib.``RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8`

`raylib.``RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8`

`raylib.``RL_SHADER_ATTRIB_FLOAT`

`raylib.``RL_SHADER_ATTRIB_VEC2`

`raylib.``RL_SHADER_ATTRIB_VEC3`

`raylib.``RL_SHADER_ATTRIB_VEC4`

`raylib.``RL_SHADER_LOC_COLOR_AMBIENT`

`raylib.``RL_SHADER_LOC_COLOR_DIFFUSE`

`raylib.``RL_SHADER_LOC_COLOR_SPECULAR`

`raylib.``RL_SHADER_LOC_MAP_ALBEDO`

`raylib.``RL_SHADER_LOC_MAP_BRDF`

`raylib.``RL_SHADER_LOC_MAP_CUBEMAP`

`raylib.``RL_SHADER_LOC_MAP_EMISSION`

`raylib.``RL_SHADER_LOC_MAP_HEIGHT`

`raylib.``RL_SHADER_LOC_MAP_IRRADIANCE`

`raylib.``RL_SHADER_LOC_MAP_METALNESS`

`raylib.``RL_SHADER_LOC_MAP_NORMAL`

`raylib.``RL_SHADER_LOC_MAP_OCCLUSION`

`raylib.``RL_SHADER_LOC_MAP_PREFILTER`

`raylib.``RL_SHADER_LOC_MAP_ROUGHNESS`

`raylib.``RL_SHADER_LOC_MATRIX_MODEL`

`raylib.``RL_SHADER_LOC_MATRIX_MVP`

`raylib.``RL_SHADER_LOC_MATRIX_NORMAL`

`raylib.``RL_SHADER_LOC_MATRIX_PROJECTION`

`raylib.``RL_SHADER_LOC_MATRIX_VIEW`

`raylib.``RL_SHADER_LOC_VECTOR_VIEW`

`raylib.``RL_SHADER_LOC_VERTEX_COLOR`

`raylib.``RL_SHADER_LOC_VERTEX_NORMAL`

`raylib.``RL_SHADER_LOC_VERTEX_POSITION`

`raylib.``RL_SHADER_LOC_VERTEX_TANGENT`

`raylib.``RL_SHADER_LOC_VERTEX_TEXCOORD01`

`raylib.``RL_SHADER_LOC_VERTEX_TEXCOORD02`

`raylib.``RL_SHADER_UNIFORM_FLOAT`

`raylib.``RL_SHADER_UNIFORM_INT`

`raylib.``RL_SHADER_UNIFORM_IVEC2`

`raylib.``RL_SHADER_UNIFORM_IVEC3`

`raylib.``RL_SHADER_UNIFORM_IVEC4`

`raylib.``RL_SHADER_UNIFORM_SAMPLER2D`

`raylib.``RL_SHADER_UNIFORM_VEC2`

`raylib.``RL_SHADER_UNIFORM_VEC3`

`raylib.``RL_SHADER_UNIFORM_VEC4`

`raylib.``RL_TEXTURE_FILTER_ANISOTROPIC_16X`

`raylib.``RL_TEXTURE_FILTER_ANISOTROPIC_4X`

`raylib.``RL_TEXTURE_FILTER_ANISOTROPIC_8X`

`raylib.``RL_TEXTURE_FILTER_BILINEAR`

`raylib.``RL_TEXTURE_FILTER_POINT`

`raylib.``RL_TEXTURE_FILTER_TRILINEAR`

`raylib.``Ray`

`raylib.``RayCollision`

`raylib.``Rectangle`

`raylib.``RenderTexture`

`raylib.``RenderTexture2D`

`raylib.``ResetPhysics`()

  void ResetPhysics();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``RestoreWindow`()

  Set window state: not minimized/maximized (only PLATFORM_DESKTOP)

`raylib.``ResumeAudioStream`(stream: AudioStream)

  Resume audio stream

`raylib.``ResumeMusicStream`(music: Music)

  Resume playing paused music

`raylib.``ResumeSound`(sound: Sound)

  Resume a paused sound

`raylib.``SCROLLBAR`

`raylib.``SCROLLBAR_LEFT_SIDE`

`raylib.``SCROLLBAR_RIGHT_SIDE`

`raylib.``SCROLLBAR_SIDE`

`raylib.``SCROLLBAR_WIDTH`

`raylib.``SCROLL_PADDING`

`raylib.``SCROLL_SLIDER_PADDING`

`raylib.``SCROLL_SLIDER_SIZE`

`raylib.``SCROLL_SPEED`

`raylib.``SHADER_ATTRIB_FLOAT`

`raylib.``SHADER_ATTRIB_VEC2`

`raylib.``SHADER_ATTRIB_VEC3`

`raylib.``SHADER_ATTRIB_VEC4`

`raylib.``SHADER_LOC_COLOR_AMBIENT`

`raylib.``SHADER_LOC_COLOR_DIFFUSE`

`raylib.``SHADER_LOC_COLOR_SPECULAR`

`raylib.``SHADER_LOC_MAP_ALBEDO`

`raylib.``SHADER_LOC_MAP_BRDF`

`raylib.``SHADER_LOC_MAP_CUBEMAP`

`raylib.``SHADER_LOC_MAP_EMISSION`

`raylib.``SHADER_LOC_MAP_HEIGHT`

`raylib.``SHADER_LOC_MAP_IRRADIANCE`

`raylib.``SHADER_LOC_MAP_METALNESS`

`raylib.``SHADER_LOC_MAP_NORMAL`

`raylib.``SHADER_LOC_MAP_OCCLUSION`

`raylib.``SHADER_LOC_MAP_PREFILTER`

`raylib.``SHADER_LOC_MAP_ROUGHNESS`

`raylib.``SHADER_LOC_MATRIX_MODEL`

`raylib.``SHADER_LOC_MATRIX_MVP`

`raylib.``SHADER_LOC_MATRIX_NORMAL`

`raylib.``SHADER_LOC_MATRIX_PROJECTION`

`raylib.``SHADER_LOC_MATRIX_VIEW`

`raylib.``SHADER_LOC_VECTOR_VIEW`

`raylib.``SHADER_LOC_VERTEX_COLOR`

`raylib.``SHADER_LOC_VERTEX_NORMAL`

`raylib.``SHADER_LOC_VERTEX_POSITION`

`raylib.``SHADER_LOC_VERTEX_TANGENT`

`raylib.``SHADER_LOC_VERTEX_TEXCOORD01`

`raylib.``SHADER_LOC_VERTEX_TEXCOORD02`

`raylib.``SHADER_UNIFORM_FLOAT`

`raylib.``SHADER_UNIFORM_INT`

`raylib.``SHADER_UNIFORM_IVEC2`

`raylib.``SHADER_UNIFORM_IVEC3`

`raylib.``SHADER_UNIFORM_IVEC4`

`raylib.``SHADER_UNIFORM_SAMPLER2D`

`raylib.``SHADER_UNIFORM_VEC2`

`raylib.``SHADER_UNIFORM_VEC3`

`raylib.``SHADER_UNIFORM_VEC4`

`raylib.``SLIDER`

`raylib.``SLIDER_PADDING`

`raylib.``SLIDER_WIDTH`

`raylib.``SPINNER`

`raylib.``SPIN_BUTTON_PADDING`

`raylib.``SPIN_BUTTON_WIDTH`

`raylib.``STATUSBAR`

`raylib.``SaveFileData`(fileName: str, data: Any, bytesToWrite: int)

  Save data to file from byte array (write), returns true on success

`raylib.``SaveFileText`(fileName: str, text: str)

  Save text data to file (write), string must be ‘ 0’ terminated, returns true on success

`raylib.``SaveStorageValue`(position: int, value: int)

  Save integer value to storage file (to defined position), returns true on success

`raylib.``SeekMusicStream`(music: Music, position: float)

  Seek music to a position (in seconds)

`raylib.``SetAudioStreamBufferSizeDefault`(size: int)

  Default size for new audio streams

`raylib.``SetAudioStreamPitch`(stream: AudioStream, pitch: float)

  Set pitch for audio stream (1.0 is base level)

`raylib.``SetAudioStreamVolume`(stream: AudioStream, volume: float)

  Set volume for audio stream (1.0 is max level)

`raylib.``SetCameraAltControl`(keyAlt: int)

  Set camera alt key to combine with mouse movement (free camera)

`raylib.``SetCameraMode`(camera: Camera3D, mode: int)

  Set camera mode (multiple camera modes available)

`raylib.``SetCameraMoveControls`(keyFront: int, keyBack: int, keyRight: int, keyLeft: int, keyUp: int, keyDown: int)

  Set camera move controls (1st person and 3rd person cameras)

`raylib.``SetCameraPanControl`(keyPan: int)

  Set camera pan key to combine with mouse movement (free camera)

`raylib.``SetCameraSmoothZoomControl`(keySmoothZoom: int)

  Set camera smooth zoom key to combine with mouse (free camera)

`raylib.``SetClipboardText`(text: str)

  Set clipboard text content

`raylib.``SetConfigFlags`(flags: int)

  Setup init configuration flags (view FLAGS)

`raylib.``SetExitKey`(key: int)

  Set a custom key to exit program (default is ESC)

`raylib.``SetGamepadMappings`(mappings: str)

  Set internal gamepad mappings (SDL_GameControllerDB)

`raylib.``SetGesturesEnabled`(flags: int)

  Enable a set of gestures using flags

`raylib.``SetLoadFileDataCallback`(callback: str)

  Set custom file binary data loader

`raylib.``SetLoadFileTextCallback`(callback: str)

  Set custom file text data loader

`raylib.``SetMasterVolume`(volume: float)

  Set master volume (listener)

`raylib.``SetMaterialTexture`(material: Any, mapType: int, texture: Texture)

  Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR…)

`raylib.``SetModelMeshMaterial`(model: Any, meshId: int, materialId: int)

  Set material for a mesh

`raylib.``SetMouseCursor`(cursor: int)

  Set mouse cursor

`raylib.``SetMouseOffset`(offsetX: int, offsetY: int)

  Set mouse offset

`raylib.``SetMousePosition`(x: int, y: int)

  Set mouse position XY

`raylib.``SetMouseScale`(scaleX: float, scaleY: float)

  Set mouse scaling

`raylib.``SetMusicPitch`(music: Music, pitch: float)

  Set pitch for a music (1.0 is base level)

`raylib.``SetMusicVolume`(music: Music, volume: float)

  Set volume for music (1.0 is max level)

`raylib.``SetPhysicsBodyRotation`(PhysicsBodyData_pointer_0: Any, float_1: float)

  void SetPhysicsBodyRotation(struct PhysicsBodyData *, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``SetPhysicsGravity`(float_0: float, float_1: float)

  void SetPhysicsGravity(float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``SetPhysicsTimeStep`(double_0: float)

  void SetPhysicsTimeStep(double);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``SetPixelColor`(dstPtr: Any, color: Color, format: int)

  Set color formatted into destination pixel pointer

`raylib.``SetRandomSeed`(seed: int)

  Set the seed for the random number generator

`raylib.``SetSaveFileDataCallback`(callback: str)

  Set custom file binary data saver

`raylib.``SetSaveFileTextCallback`(callback: str)

  Set custom file text data saver

`raylib.``SetShaderValue`(shader: Shader, locIndex: int, value: Any, uniformType: int)

  Set shader uniform value

`raylib.``SetShaderValueMatrix`(shader: Shader, locIndex: int, mat: Matrix)

  Set shader uniform value (matrix 4x4)

`raylib.``SetShaderValueTexture`(shader: Shader, locIndex: int, texture: Texture)

  Set shader uniform value for texture (sampler2d)

`raylib.``SetShaderValueV`(shader: Shader, locIndex: int, value: Any, uniformType: int, count: int)

  Set shader uniform value vector

`raylib.``SetShapesTexture`(texture: Texture, source: Rectangle)

  Set texture and rectangle to be used on shapes drawing

`raylib.``SetSoundPitch`(sound: Sound, pitch: float)

  Set pitch for a sound (1.0 is base level)

`raylib.``SetSoundVolume`(sound: Sound, volume: float)

  Set volume for a sound (1.0 is max level)

`raylib.``SetTargetFPS`(fps: int)

  Set target FPS (maximum)

`raylib.``SetTextureFilter`(texture: Texture, filter: int)

  Set texture scaling filter mode

`raylib.``SetTextureWrap`(texture: Texture, wrap: int)

  Set texture wrapping mode

`raylib.``SetTraceLogCallback`(callback: str)

  Set custom trace log

`raylib.``SetTraceLogLevel`(logLevel: int)

  Set the current threshold (minimum) log level

`raylib.``SetWindowIcon`(image: Image)

  Set icon for window (only PLATFORM_DESKTOP)

`raylib.``SetWindowMinSize`(width: int, height: int)

  Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)

`raylib.``SetWindowMonitor`(monitor: int)

  Set monitor for the current window (fullscreen mode)

`raylib.``SetWindowPosition`(x: int, y: int)

  Set window position on screen (only PLATFORM_DESKTOP)

`raylib.``SetWindowSize`(width: int, height: int)

  Set window dimensions

`raylib.``SetWindowState`(flags: int)

  Set window configuration state using flags

`raylib.``SetWindowTitle`(title: str)

  Set title for window (only PLATFORM_DESKTOP)

`raylib.``Shader`

`raylib.``ShaderAttributeDataType`

`raylib.``ShaderLocationIndex`

`raylib.``ShaderUniformDataType`

`raylib.``ShowCursor`()

  Shows cursor

`raylib.``Sound`

`raylib.``StopAudioStream`(stream: AudioStream)

  Stop audio stream

`raylib.``StopMusicStream`(music: Music)

  Stop music playing

`raylib.``StopSound`(sound: Sound)

  Stop playing a sound

`raylib.``StopSoundMulti`()

  Stop any sound playing (using multichannel buffer pool)

`raylib.``SwapScreenBuffer`()

  Swap back buffer with front buffer (screen drawing)

`raylib.``TEXTBOX`

`raylib.``TEXTURE_FILTER_ANISOTROPIC_16X`

`raylib.``TEXTURE_FILTER_ANISOTROPIC_4X`

`raylib.``TEXTURE_FILTER_ANISOTROPIC_8X`

`raylib.``TEXTURE_FILTER_BILINEAR`

`raylib.``TEXTURE_FILTER_POINT`

`raylib.``TEXTURE_FILTER_TRILINEAR`

`raylib.``TEXTURE_WRAP_CLAMP`

`raylib.``TEXTURE_WRAP_MIRROR_CLAMP`

`raylib.``TEXTURE_WRAP_MIRROR_REPEAT`

`raylib.``TEXTURE_WRAP_REPEAT`

`raylib.``TEXT_ALIGNMENT`

`raylib.``TEXT_COLOR_DISABLED`

`raylib.``TEXT_COLOR_FOCUSED`

`raylib.``TEXT_COLOR_NORMAL`

`raylib.``TEXT_COLOR_PRESSED`

`raylib.``TEXT_INNER_PADDING`

`raylib.``TEXT_LINES_PADDING`

`raylib.``TEXT_PADDING`

`raylib.``TEXT_SIZE`

`raylib.``TEXT_SPACING`

`raylib.``TOGGLE`

`raylib.``TakeScreenshot`(fileName: str)

  Takes a screenshot of current screen (filename extension defines format)

`raylib.``TextAppend`(text: str, append: str, position: Any)

  Append text at specific position and move cursor!

`raylib.``TextCodepointsToUTF8`(codepoints: Any, length: int)

  Encode text as codepoints array into UTF-8 text string (WARNING: memory must be freed!)

`raylib.``TextCopy`(dst: str, src: str)

  Copy one string to another, returns bytes copied

`raylib.``TextFindIndex`(text: str, find: str)

  Find first text occurrence within a string

`raylib.``TextFormat`(*args)

  VARARG FUNCTION - MAY NOT BE SUPPORTED BY CFFI

`raylib.``TextInsert`(text: str, insert: str, position: int)

  Insert text in a position (WARNING: memory must be freed!)

`raylib.``TextIsEqual`(text1: str, text2: str)

  Check if two text string are equal

`raylib.``TextJoin`(textList: str, count: int, delimiter: str)

  Join text strings with delimiter

`raylib.``TextLength`(text: str)

  Get text length, checks for ‘ 0’ ending

`raylib.``TextReplace`(text: str, replace: str, by: str)

  Replace text string (WARNING: memory must be freed!)

`raylib.``TextSplit`(text: str, delimiter: str, count: Any)

  Split text into multiple strings

`raylib.``TextSubtext`(text: str, position: int, length: int)

  Get a piece of a text string

`raylib.``TextToInteger`(text: str)

  Get integer value from text (negative values not supported)

`raylib.``TextToLower`(text: str)

  Get lower case version of provided string

`raylib.``TextToPascal`(text: str)

  Get Pascal case notation version of provided string

`raylib.``TextToUpper`(text: str)

  Get upper case version of provided string

`raylib.``Texture`

`raylib.``Texture2D`

`raylib.``TextureCubemap`

`raylib.``TextureFilter`

`raylib.``TextureWrap`

`raylib.``ToggleFullscreen`()

  Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)

`raylib.``TraceLog`(*args)

  VARARG FUNCTION - MAY NOT BE SUPPORTED BY CFFI

`raylib.``TraceLogLevel`

`raylib.``Transform`

`raylib.``UnloadAudioStream`(stream: AudioStream)

  Unload audio stream and free memory

`raylib.``UnloadCodepoints`(codepoints: Any)

  Unload codepoints data from memory

`raylib.``UnloadFileData`(data: str)

  Unload file data allocated by LoadFileData()

`raylib.``UnloadFileText`(text: str)

  Unload file text data allocated by LoadFileText()

`raylib.``UnloadFont`(font: Font)

  Unload Font from GPU memory (VRAM)

`raylib.``UnloadFontData`(chars: Any, glyphCount: int)

  Unload font chars info data (RAM)

`raylib.``UnloadImage`(image: Image)

  Unload image from CPU memory (RAM)

`raylib.``UnloadImageColors`(colors: Any)

  Unload color data loaded with LoadImageColors()

`raylib.``UnloadImagePalette`(colors: Any)

  Unload colors palette loaded with LoadImagePalette()

`raylib.``UnloadMaterial`(material: Material)

  Unload material from GPU memory (VRAM)

`raylib.``UnloadMesh`(mesh: Mesh)

  Unload mesh data from CPU and GPU

`raylib.``UnloadModel`(model: Model)

  Unload model (including meshes) from memory (RAM and/or VRAM)

`raylib.``UnloadModelAnimation`(anim: ModelAnimation)

  Unload animation data

`raylib.``UnloadModelAnimations`(animations: Any, count: int)

  Unload animation array data

`raylib.``UnloadModelKeepMeshes`(model: Model)

  Unload model (but not meshes) from memory (RAM and/or VRAM)

`raylib.``UnloadMusicStream`(music: Music)

  Unload music stream

`raylib.``UnloadRenderTexture`(target: RenderTexture)

  Unload render texture from GPU memory (VRAM)

`raylib.``UnloadShader`(shader: Shader)

  Unload shader from GPU memory (VRAM)

`raylib.``UnloadSound`(sound: Sound)

  Unload sound

`raylib.``UnloadTexture`(texture: Texture)

  Unload texture from GPU memory (VRAM)

`raylib.``UnloadVrStereoConfig`(config: VrStereoConfig)

  Unload VR stereo config

`raylib.``UnloadWave`(wave: Wave)

  Unload wave data

`raylib.``UnloadWaveSamples`(samples: Any)

  Unload samples data loaded with LoadWaveSamples()

`raylib.``UpdateAudioStream`(stream: AudioStream, data: Any, frameCount: int)

  Update audio stream buffers with data

`raylib.``UpdateCamera`(camera: Any)

  Update camera position for selected mode

`raylib.``UpdateMeshBuffer`(mesh: Mesh, index: int, data: Any, dataSize: int, offset: int)

  Update mesh vertex data in GPU for a specific buffer index

`raylib.``UpdateModelAnimation`(model: Model, anim: ModelAnimation, frame: int)

  Update model animation pose

`raylib.``UpdateMusicStream`(music: Music)

  Updates buffers for music streaming

`raylib.``UpdatePhysics`()

  void UpdatePhysics();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``UpdateSound`(sound: Sound, data: Any, sampleCount: int)

  Update sound buffer with new data

`raylib.``UpdateTexture`(texture: Texture, pixels: Any)

  Update GPU texture with new data

`raylib.``UpdateTextureRec`(texture: Texture, rec: Rectangle, pixels: Any)

  Update GPU texture rectangle with new data

`raylib.``UploadMesh`(mesh: Any, dynamic: bool)

  Upload mesh vertex data in GPU and provide VAO/VBO ids

`raylib.``VALUEBOX`

`raylib.``Vector2`

`raylib.``Vector3`

`raylib.``Vector4`

`raylib.``VrDeviceInfo`

`raylib.``VrStereoConfig`

`raylib.``WaitTime`(ms: float)

  Wait for some milliseconds (halt program execution)

`raylib.``Wave`

`raylib.``WaveCopy`(wave: Wave)

  Copy a wave to a new wave

`raylib.``WaveCrop`(wave: Any, initSample: int, finalSample: int)

  Crop a wave to defined samples range

`raylib.``WaveFormat`(wave: Any, sampleRate: int, sampleSize: int, channels: int)

  Convert wave data to desired format

`raylib.``WindowShouldClose`()

  Check if KEY_ESCAPE pressed or Close icon pressed

`raylib.``rAudioBuffer`

`raylib.``rlActiveDrawBuffers`(int_0: int)

  void rlActiveDrawBuffers(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlActiveTextureSlot`(int_0: int)

  void rlActiveTextureSlot(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlBegin`(int_0: int)

  void rlBegin(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlBindImageTexture`(unsignedint_0: int, unsignedint_1: int, unsignedint_2: int, int_3: int)

  void rlBindImageTexture(unsigned int, unsigned int, unsigned int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlBindShaderBuffer`(unsignedint_0: int, unsignedint_1: int)

  void rlBindShaderBuffer(unsigned int, unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlBlendMode`

`raylib.``rlCheckErrors`()

  void rlCheckErrors();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlCheckRenderBatchLimit`(int_0: int)

  _Bool rlCheckRenderBatchLimit(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlClearColor`(unsignedchar_0: str, unsignedchar_1: str, unsignedchar_2: str, unsignedchar_3: str)

  void rlClearColor(unsigned char, unsigned char, unsigned char, unsigned char);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlClearScreenBuffers`()

  void rlClearScreenBuffers();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlColor3f`(float_0: float, float_1: float, float_2: float)

  void rlColor3f(float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlColor4f`(float_0: float, float_1: float, float_2: float, float_3: float)

  void rlColor4f(float, float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlColor4ub`(unsignedchar_0: str, unsignedchar_1: str, unsignedchar_2: str, unsignedchar_3: str)

  void rlColor4ub(unsigned char, unsigned char, unsigned char, unsigned char);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlCompileShader`(str_0: str, int_1: int)

  unsigned int rlCompileShader(char *, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlComputeShaderDispatch`(unsignedint_0: int, unsignedint_1: int, unsignedint_2: int)

  void rlComputeShaderDispatch(unsigned int, unsigned int, unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlCopyBuffersElements`(unsignedint_0: int, unsignedint_1: int, unsignedlonglong_2: int, unsignedlonglong_3: int, unsignedlonglong_4: int)

  void rlCopyBuffersElements(unsigned int, unsigned int, unsigned long long, unsigned long long, unsigned long long);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableBackfaceCulling`()

  void rlDisableBackfaceCulling();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableColorBlend`()

  void rlDisableColorBlend();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableDepthMask`()

  void rlDisableDepthMask();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableDepthTest`()

  void rlDisableDepthTest();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableFramebuffer`()

  void rlDisableFramebuffer();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableScissorTest`()

  void rlDisableScissorTest();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableShader`()

  void rlDisableShader();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableSmoothLines`()

  void rlDisableSmoothLines();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableStereoRender`()

  void rlDisableStereoRender();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableTexture`()

  void rlDisableTexture();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableTextureCubemap`()

  void rlDisableTextureCubemap();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableVertexArray`()

  void rlDisableVertexArray();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableVertexAttribute`(unsignedint_0: int)

  void rlDisableVertexAttribute(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableVertexBuffer`()

  void rlDisableVertexBuffer();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableVertexBufferElement`()

  void rlDisableVertexBufferElement();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDisableWireMode`()

  void rlDisableWireMode();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDrawCall`

`raylib.``rlDrawRenderBatch`(rlRenderBatch_pointer_0: Any)

  void rlDrawRenderBatch(struct rlRenderBatch *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDrawRenderBatchActive`()

  void rlDrawRenderBatchActive();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDrawVertexArray`(int_0: int, int_1: int)

  void rlDrawVertexArray(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDrawVertexArrayElements`(int_0: int, int_1: int, void_pointer_2: Any)

  void rlDrawVertexArrayElements(int, int, void *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDrawVertexArrayElementsInstanced`(int_0: int, int_1: int, void_pointer_2: Any, int_3: int)

  void rlDrawVertexArrayElementsInstanced(int, int, void *, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlDrawVertexArrayInstanced`(int_0: int, int_1: int, int_2: int)

  void rlDrawVertexArrayInstanced(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableBackfaceCulling`()

  void rlEnableBackfaceCulling();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableColorBlend`()

  void rlEnableColorBlend();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableDepthMask`()

  void rlEnableDepthMask();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableDepthTest`()

  void rlEnableDepthTest();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableFramebuffer`(unsignedint_0: int)

  void rlEnableFramebuffer(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableScissorTest`()

  void rlEnableScissorTest();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableShader`(unsignedint_0: int)

  void rlEnableShader(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableSmoothLines`()

  void rlEnableSmoothLines();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableStereoRender`()

  void rlEnableStereoRender();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableTexture`(unsignedint_0: int)

  void rlEnableTexture(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableTextureCubemap`(unsignedint_0: int)

  void rlEnableTextureCubemap(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableVertexArray`(unsignedint_0: int)

  _Bool rlEnableVertexArray(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableVertexAttribute`(unsignedint_0: int)

  void rlEnableVertexAttribute(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableVertexBuffer`(unsignedint_0: int)

  void rlEnableVertexBuffer(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableVertexBufferElement`(unsignedint_0: int)

  void rlEnableVertexBufferElement(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnableWireMode`()

  void rlEnableWireMode();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlEnd`()

  void rlEnd();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlFramebufferAttach`(unsignedint_0: int, unsignedint_1: int, int_2: int, int_3: int, int_4: int)

  void rlFramebufferAttach(unsigned int, unsigned int, int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlFramebufferAttachTextureType`

`raylib.``rlFramebufferAttachType`

`raylib.``rlFramebufferComplete`(unsignedint_0: int)

  _Bool rlFramebufferComplete(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlFrustum`(double_0: float, double_1: float, double_2: float, double_3: float, double_4: float, double_5: float)

  void rlFrustum(double, double, double, double, double, double);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGenTextureMipmaps`(unsignedint_0: int, int_1: int, int_2: int, int_3: int, int_pointer_4: Any)

  void rlGenTextureMipmaps(unsigned int, int, int, int, int *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetFramebufferHeight`()

  int rlGetFramebufferHeight();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetFramebufferWidth`()

  int rlGetFramebufferWidth();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetGlTextureFormats`(int_0: int, int_pointer_1: Any, int_pointer_2: Any, int_pointer_3: Any)

  void rlGetGlTextureFormats(int, int *, int *, int *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetLineWidth`()

  float rlGetLineWidth();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetLocationAttrib`(unsignedint_0: int, str_1: str)

  int rlGetLocationAttrib(unsigned int, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetLocationUniform`(unsignedint_0: int, str_1: str)

  int rlGetLocationUniform(unsigned int, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetMatrixModelview`()

  struct Matrix rlGetMatrixModelview();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetMatrixProjection`()

  struct Matrix rlGetMatrixProjection();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetMatrixProjectionStereo`(int_0: int)

  struct Matrix rlGetMatrixProjectionStereo(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetMatrixTransform`()

  struct Matrix rlGetMatrixTransform();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetMatrixViewOffsetStereo`(int_0: int)

  struct Matrix rlGetMatrixViewOffsetStereo(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetPixelFormatName`(unsignedint_0: int)

  char *rlGetPixelFormatName(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetShaderBufferSize`(unsignedint_0: int)

  unsigned long long rlGetShaderBufferSize(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetShaderIdDefault`()

  unsigned int rlGetShaderIdDefault();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetShaderLocsDefault`()

  int *rlGetShaderLocsDefault();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetTextureIdDefault`()

  unsigned int rlGetTextureIdDefault();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGetVersion`()

  int rlGetVersion();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlGlVersion`

`raylib.``rlIsStereoRenderEnabled`()

  _Bool rlIsStereoRenderEnabled();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadComputeShaderProgram`(unsignedint_0: int)

  unsigned int rlLoadComputeShaderProgram(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadDrawCube`()

  void rlLoadDrawCube();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadDrawQuad`()

  void rlLoadDrawQuad();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadExtensions`(void_pointer_0: Any)

  void rlLoadExtensions(void *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadFramebuffer`(int_0: int, int_1: int)

  unsigned int rlLoadFramebuffer(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadIdentity`()

  void rlLoadIdentity();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadRenderBatch`(int_0: int, int_1: int)

  struct rlRenderBatch rlLoadRenderBatch(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadShaderBuffer`(unsignedlonglong_0: int, void_pointer_1: Any, int_2: int)

  unsigned int rlLoadShaderBuffer(unsigned long long, void *, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadShaderCode`(str_0: str, str_1: str)

  unsigned int rlLoadShaderCode(char *, char *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadShaderProgram`(unsignedint_0: int, unsignedint_1: int)

  unsigned int rlLoadShaderProgram(unsigned int, unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadTexture`(void_pointer_0: Any, int_1: int, int_2: int, int_3: int, int_4: int)

  unsigned int rlLoadTexture(void *, int, int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadTextureCubemap`(void_pointer_0: Any, int_1: int, int_2: int)

  unsigned int rlLoadTextureCubemap(void *, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadTextureDepth`(int_0: int, int_1: int, _Bool_2: bool)

  unsigned int rlLoadTextureDepth(int, int, _Bool);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadVertexArray`()

  unsigned int rlLoadVertexArray();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadVertexBuffer`(void_pointer_0: Any, int_1: int, _Bool_2: bool)

  unsigned int rlLoadVertexBuffer(void *, int, _Bool);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlLoadVertexBufferElement`(void_pointer_0: Any, int_1: int, _Bool_2: bool)

  unsigned int rlLoadVertexBufferElement(void *, int, _Bool);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlMatrixMode`(int_0: int)

  void rlMatrixMode(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlMultMatrixf`(float_pointer_0: Any)

  void rlMultMatrixf(float *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlNormal3f`(float_0: float, float_1: float, float_2: float)

  void rlNormal3f(float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlOrtho`(double_0: float, double_1: float, double_2: float, double_3: float, double_4: float, double_5: float)

  void rlOrtho(double, double, double, double, double, double);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlPixelFormat`

`raylib.``rlPopMatrix`()

  void rlPopMatrix();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlPushMatrix`()

  void rlPushMatrix();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlReadScreenPixels`(int_0: int, int_1: int)

  unsigned char *rlReadScreenPixels(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlReadShaderBufferElements`(unsignedint_0: int, void_pointer_1: Any, unsignedlonglong_2: int, unsignedlonglong_3: int)

  void rlReadShaderBufferElements(unsigned int, void *, unsigned long long, unsigned long long);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlReadTexturePixels`(unsignedint_0: int, int_1: int, int_2: int, int_3: int)

  void *rlReadTexturePixels(unsigned int, int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlRenderBatch`

`raylib.``rlRotatef`(float_0: float, float_1: float, float_2: float, float_3: float)

  void rlRotatef(float, float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlScalef`(float_0: float, float_1: float, float_2: float)

  void rlScalef(float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlScissor`(int_0: int, int_1: int, int_2: int, int_3: int)

  void rlScissor(int, int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetBlendFactors`(int_0: int, int_1: int, int_2: int)

  void rlSetBlendFactors(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetBlendMode`(int_0: int)

  void rlSetBlendMode(int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetLineWidth`(float_0: float)

  void rlSetLineWidth(float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetMatrixModelview`(Matrix_0: Matrix)

  void rlSetMatrixModelview(struct Matrix);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetMatrixProjection`(Matrix_0: Matrix)

  void rlSetMatrixProjection(struct Matrix);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetMatrixProjectionStereo`(Matrix_0: Matrix, Matrix_1: Matrix)

  void rlSetMatrixProjectionStereo(struct Matrix, struct Matrix);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetMatrixViewOffsetStereo`(Matrix_0: Matrix, Matrix_1: Matrix)

  void rlSetMatrixViewOffsetStereo(struct Matrix, struct Matrix);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetRenderBatchActive`(rlRenderBatch_pointer_0: Any)

  void rlSetRenderBatchActive(struct rlRenderBatch *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetShader`(unsignedint_0: int, int_pointer_1: Any)

  void rlSetShader(unsigned int, int *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetTexture`(unsignedint_0: int)

  void rlSetTexture(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetUniform`(int_0: int, void_pointer_1: Any, int_2: int, int_3: int)

  void rlSetUniform(int, void *, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetUniformMatrix`(int_0: int, Matrix_1: Matrix)

  void rlSetUniformMatrix(int, struct Matrix);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetUniformSampler`(int_0: int, unsignedint_1: int)

  void rlSetUniformSampler(int, unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetVertexAttribute`(unsignedint_0: int, int_1: int, int_2: int, _Bool_3: bool, int_4: int, void_pointer_5: Any)

  void rlSetVertexAttribute(unsigned int, int, int, _Bool, int, void *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetVertexAttributeDefault`(int_0: int, void_pointer_1: Any, int_2: int, int_3: int)

  void rlSetVertexAttributeDefault(int, void *, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlSetVertexAttributeDivisor`(unsignedint_0: int, int_1: int)

  void rlSetVertexAttributeDivisor(unsigned int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlShaderAttributeDataType`

`raylib.``rlShaderLocationIndex`

`raylib.``rlShaderUniformDataType`

`raylib.``rlTexCoord2f`(float_0: float, float_1: float)

  void rlTexCoord2f(float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlTextureFilter`

`raylib.``rlTextureParameters`(unsignedint_0: int, int_1: int, int_2: int)

  void rlTextureParameters(unsigned int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlTraceLogLevel`

`raylib.``rlTranslatef`(float_0: float, float_1: float, float_2: float)

  void rlTranslatef(float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlUnloadFramebuffer`(unsignedint_0: int)

  void rlUnloadFramebuffer(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlUnloadRenderBatch`(rlRenderBatch_0: rlRenderBatch)

  void rlUnloadRenderBatch(struct rlRenderBatch);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlUnloadShaderBuffer`(unsignedint_0: int)

  void rlUnloadShaderBuffer(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlUnloadShaderProgram`(unsignedint_0: int)

  void rlUnloadShaderProgram(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlUnloadTexture`(unsignedint_0: int)

  void rlUnloadTexture(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlUnloadVertexArray`(unsignedint_0: int)

  void rlUnloadVertexArray(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlUnloadVertexBuffer`(unsignedint_0: int)

  void rlUnloadVertexBuffer(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlUpdateShaderBufferElements`(unsignedint_0: int, void_pointer_1: Any, unsignedlonglong_2: int, unsignedlonglong_3: int)

  void rlUpdateShaderBufferElements(unsigned int, void *, unsigned long long, unsigned long long);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlUpdateTexture`(unsignedint_0: int, int_1: int, int_2: int, int_3: int, int_4: int, int_5: int, void_pointer_6: Any)

  void rlUpdateTexture(unsigned int, int, int, int, int, int, void *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlUpdateVertexBuffer`(unsignedint_0: int, void_pointer_1: Any, int_2: int, int_3: int)

  void rlUpdateVertexBuffer(unsigned int, void *, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlVertex2f`(float_0: float, float_1: float)

  void rlVertex2f(float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlVertex2i`(int_0: int, int_1: int)

  void rlVertex2i(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlVertex3f`(float_0: float, float_1: float, float_2: float)

  void rlVertex3f(float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlVertexBuffer`

`raylib.``rlViewport`(int_0: int, int_1: int, int_2: int, int_3: int)

  void rlViewport(int, int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlglClose`()

  void rlglClose();

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``rlglInit`(int_0: int, int_1: int)

  void rlglInit(int, int);

  CFFI C function from raylib._raylib_cffi.lib

class `raylib.``struct`