# Python API

This is a wrapper around the C API with some syntactic sugar.

The API is still the same as Raylib, so you should still reply on the official Raylib docs, except:

- the function names are in snake_case.

- Some string and pointer conversions are handled automatically.

- There are some helper functions to create structures.

Example program:

    import pyray as pr

    pr.init_window(800, 450, "Hello Pyray")
    pr.set_target_fps(60)

    camera = pr.Camera3D([18.0, 16.0, 18.0], [0.0, 0.0, 0.0], [0.0, 1.0, 0.0], 45.0, 0)
    pr.set_camera_mode(camera, pr.CAMERA_ORBITAL)

    while not pr.window_should_close():
        pr.update_camera(camera)
        pr.begin_drawing()
        pr.clear_background(pr.RAYWHITE)
        pr.begin_mode_3d(camera)
        pr.draw_grid(20, 1.0)
        pr.end_mode_3d()
        pr.draw_text("Hello world", 190, 200, 20, pr.VIOLET)
        pr.end_drawing()
    pr.close_window()

Tip

New in 3.7.0.post9:

You can also now import the functions with no prefix:

    from pyray import *

    init_window(800, 450, "Raylib texture test")
    ...

You don’t need to use the PyRay() class anymore.

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

## API reference

class `pyray.``AudioStream`(buffer, sampleRate, sampleSize, channels)

  struct

class `pyray.``BlendMode`

  Enum where members are also (and must be) ints

  `BLEND_ADDITIVE` = 1
  `BLEND_ADD_COLORS` = 3
  `BLEND_ALPHA` = 0
  `BLEND_CUSTOM` = 5
  `BLEND_MULTIPLIED` = 2
  `BLEND_SUBTRACT_COLORS` = 4

class `pyray.``BoneInfo`(name, parent)

  struct

class `pyray.``BoundingBox`(min, max)

  struct

class `pyray.``Camera`(position, target, up, fovy, projection)

  struct

class `pyray.``Camera2D`(offset, target, rotation, zoom)

  struct

class `pyray.``Camera3D`(position, target, up, fovy, projection)

  struct

class `pyray.``CameraMode`

  Enum where members are also (and must be) ints

  `CAMERA_CUSTOM` = 0
  `CAMERA_FIRST_PERSON` = 3
  `CAMERA_FREE` = 1
  `CAMERA_ORBITAL` = 2
  `CAMERA_THIRD_PERSON` = 4

class `pyray.``CameraProjection`

  Enum where members are also (and must be) ints

  `CAMERA_ORTHOGRAPHIC` = 1
  `CAMERA_PERSPECTIVE` = 0

class `pyray.``Color`(r, g, b, a)

  struct

class `pyray.``ConfigFlags`

  Enum where members are also (and must be) ints

  `FLAG_FULLSCREEN_MODE` = 2
  `FLAG_INTERLACED_HINT` = 65536
  `FLAG_MSAA_4X_HINT` = 32
  `FLAG_VSYNC_HINT` = 64
  `FLAG_WINDOW_ALWAYS_RUN` = 256
  `FLAG_WINDOW_HIDDEN` = 128
  `FLAG_WINDOW_HIGHDPI` = 8192
  `FLAG_WINDOW_MAXIMIZED` = 1024
  `FLAG_WINDOW_MINIMIZED` = 512
  `FLAG_WINDOW_RESIZABLE` = 4
  `FLAG_WINDOW_TOPMOST` = 4096
  `FLAG_WINDOW_TRANSPARENT` = 16
  `FLAG_WINDOW_UNDECORATED` = 8
  `FLAG_WINDOW_UNFOCUSED` = 2048

class `pyray.``CubemapLayout`

  Enum where members are also (and must be) ints

  `CUBEMAP_LAYOUT_AUTO_DETECT` = 0
  `CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE` = 4
  `CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR` = 3
  `CUBEMAP_LAYOUT_LINE_HORIZONTAL` = 2
  `CUBEMAP_LAYOUT_LINE_VERTICAL` = 1
  `CUBEMAP_LAYOUT_PANORAMA` = 5

class `pyray.``Font`(baseSize, glyphCount, glyphPadding, texture, recs, glyphs)

  struct

class `pyray.``FontType`

  Enum where members are also (and must be) ints

  `FONT_BITMAP` = 1
  `FONT_DEFAULT` = 0
  `FONT_SDF` = 2

class `pyray.``GamepadAxis`

  Enum where members are also (and must be) ints

  `GAMEPAD_AXIS_LEFT_TRIGGER` = 4
  `GAMEPAD_AXIS_LEFT_X` = 0
  `GAMEPAD_AXIS_LEFT_Y` = 1
  `GAMEPAD_AXIS_RIGHT_TRIGGER` = 5
  `GAMEPAD_AXIS_RIGHT_X` = 2
  `GAMEPAD_AXIS_RIGHT_Y` = 3

class `pyray.``GamepadButton`

  Enum where members are also (and must be) ints

  `GAMEPAD_BUTTON_LEFT_FACE_DOWN` = 3
  `GAMEPAD_BUTTON_LEFT_FACE_LEFT` = 4
  `GAMEPAD_BUTTON_LEFT_FACE_RIGHT` = 2
  `GAMEPAD_BUTTON_LEFT_FACE_UP` = 1
  `GAMEPAD_BUTTON_LEFT_THUMB` = 16
  `GAMEPAD_BUTTON_LEFT_TRIGGER_1` = 9
  `GAMEPAD_BUTTON_LEFT_TRIGGER_2` = 10
  `GAMEPAD_BUTTON_MIDDLE` = 14
  `GAMEPAD_BUTTON_MIDDLE_LEFT` = 13
  `GAMEPAD_BUTTON_MIDDLE_RIGHT` = 15
  `GAMEPAD_BUTTON_RIGHT_FACE_DOWN` = 7
  `GAMEPAD_BUTTON_RIGHT_FACE_LEFT` = 8
  `GAMEPAD_BUTTON_RIGHT_FACE_RIGHT` = 6
  `GAMEPAD_BUTTON_RIGHT_FACE_UP` = 5
  `GAMEPAD_BUTTON_RIGHT_THUMB` = 17
  `GAMEPAD_BUTTON_RIGHT_TRIGGER_1` = 11
  `GAMEPAD_BUTTON_RIGHT_TRIGGER_2` = 12
  `GAMEPAD_BUTTON_UNKNOWN` = 0

class `pyray.``Gesture`

  Enum where members are also (and must be) ints

  `GESTURE_DOUBLETAP` = 2
  `GESTURE_DRAG` = 8
  `GESTURE_HOLD` = 4
  `GESTURE_NONE` = 0
  `GESTURE_PINCH_IN` = 256
  `GESTURE_PINCH_OUT` = 512
  `GESTURE_SWIPE_DOWN` = 128
  `GESTURE_SWIPE_LEFT` = 32
  `GESTURE_SWIPE_RIGHT` = 16
  `GESTURE_SWIPE_UP` = 64
  `GESTURE_TAP` = 1

class `pyray.``GlyphInfo`(value, offsetX, offsetY, advanceX, image)

  struct

class `pyray.``GuiCheckBoxProperty`

  Enum where members are also (and must be) ints

  `CHECK_PADDING` = 16

class `pyray.``GuiColorPickerProperty`

  Enum where members are also (and must be) ints

  `COLOR_SELECTOR_SIZE` = 16
  `HUEBAR_PADDING` = 18
  `HUEBAR_SELECTOR_HEIGHT` = 19
  `HUEBAR_SELECTOR_OVERFLOW` = 20
  `HUEBAR_WIDTH` = 17

class `pyray.``GuiComboBoxProperty`

  Enum where members are also (and must be) ints

  `COMBO_BUTTON_PADDING` = 17
  `COMBO_BUTTON_WIDTH` = 16

class `pyray.``GuiControl`

  Enum where members are also (and must be) ints

  `BUTTON` = 2
  `CHECKBOX` = 6
  `COLORPICKER` = 13
  `COMBOBOX` = 7
  `DEFAULT` = 0
  `DROPDOWNBOX` = 8
  `LABEL` = 1
  `LISTVIEW` = 12
  `PROGRESSBAR` = 5
  `SCROLLBAR` = 14
  `SLIDER` = 4
  `SPINNER` = 11
  `STATUSBAR` = 15
  `TEXTBOX` = 9
  `TOGGLE` = 3
  `VALUEBOX` = 10

class `pyray.``GuiControlProperty`

  Enum where members are also (and must be) ints

  `BASE_COLOR_DISABLED` = 10
  `BASE_COLOR_FOCUSED` = 4
  `BASE_COLOR_NORMAL` = 1
  `BASE_COLOR_PRESSED` = 7
  `BORDER_COLOR_DISABLED` = 9
  `BORDER_COLOR_FOCUSED` = 3
  `BORDER_COLOR_NORMAL` = 0
  `BORDER_COLOR_PRESSED` = 6
  `BORDER_WIDTH` = 12
  `RESERVED` = 15
  `TEXT_ALIGNMENT` = 14
  `TEXT_COLOR_DISABLED` = 11
  `TEXT_COLOR_FOCUSED` = 5
  `TEXT_COLOR_NORMAL` = 2
  `TEXT_COLOR_PRESSED` = 8
  `TEXT_PADDING` = 13

class `pyray.``GuiControlState`

  Enum where members are also (and must be) ints

  `GUI_STATE_DISABLED` = 3
  `GUI_STATE_FOCUSED` = 1
  `GUI_STATE_NORMAL` = 0
  `GUI_STATE_PRESSED` = 2

class `pyray.``GuiDefaultProperty`

  Enum where members are also (and must be) ints

  `BACKGROUND_COLOR` = 19
  `LINE_COLOR` = 18
  `TEXT_SIZE` = 16
  `TEXT_SPACING` = 17

class `pyray.``GuiDropdownBoxProperty`

  Enum where members are also (and must be) ints

  `ARROW_PADDING` = 16
  `DROPDOWN_ITEMS_PADDING` = 17

class `pyray.``GuiListViewProperty`

  Enum where members are also (and must be) ints

  `LIST_ITEMS_HEIGHT` = 16
  `LIST_ITEMS_PADDING` = 17
  `SCROLLBAR_SIDE` = 19
  `SCROLLBAR_WIDTH` = 18

class `pyray.``GuiProgressBarProperty`

  Enum where members are also (and must be) ints

  `PROGRESS_PADDING` = 16

class `pyray.``GuiScrollBarProperty`

  Enum where members are also (and must be) ints

  `ARROWS_SIZE` = 16
  `ARROWS_VISIBLE` = 17
  `SCROLL_PADDING` = 20
  `SCROLL_SLIDER_PADDING` = 18
  `SCROLL_SLIDER_SIZE` = 19
  `SCROLL_SPEED` = 21

class `pyray.``GuiScrollBarSide`

  Enum where members are also (and must be) ints

  `SCROLLBAR_LEFT_SIDE` = 0
  `SCROLLBAR_RIGHT_SIDE` = 1

class `pyray.``GuiSliderProperty`

  Enum where members are also (and must be) ints

  `SLIDER_PADDING` = 17
  `SLIDER_WIDTH` = 16

class `pyray.``GuiSpinnerProperty`

  Enum where members are also (and must be) ints

  `SPIN_BUTTON_PADDING` = 17
  `SPIN_BUTTON_WIDTH` = 16

class `pyray.``GuiStyleProp`(controlId, propertyId, propertyValue)

  struct

class `pyray.``GuiTextAlignment`

  Enum where members are also (and must be) ints

  `GUI_TEXT_ALIGN_CENTER` = 1
  `GUI_TEXT_ALIGN_LEFT` = 0
  `GUI_TEXT_ALIGN_RIGHT` = 2

class `pyray.``GuiTextBoxProperty`

  Enum where members are also (and must be) ints

  `COLOR_SELECTED_BG` = 19
  `COLOR_SELECTED_FG` = 18
  `TEXT_INNER_PADDING` = 16
  `TEXT_LINES_PADDING` = 17

class `pyray.``GuiToggleProperty`

  Enum where members are also (and must be) ints

  `GROUP_PADDING` = 16

class `pyray.``Image`(data, width, height, mipmaps, format)

  struct

class `pyray.``KeyboardKey`

  Enum where members are also (and must be) ints

  `KEY_A` = 65
  `KEY_APOSTROPHE` = 39
  `KEY_B` = 66
  `KEY_BACK` = 4
  `KEY_BACKSLASH` = 92
  `KEY_BACKSPACE` = 259
  `KEY_C` = 67
  `KEY_CAPS_LOCK` = 280
  `KEY_COMMA` = 44
  `KEY_D` = 68
  `KEY_DELETE` = 261
  `KEY_DOWN` = 264
  `KEY_E` = 69
  `KEY_EIGHT` = 56
  `KEY_END` = 269
  `KEY_ENTER` = 257
  `KEY_EQUAL` = 61
  `KEY_ESCAPE` = 256
  `KEY_F` = 70
  `KEY_F1` = 290
  `KEY_F10` = 299
  `KEY_F11` = 300
  `KEY_F12` = 301
  `KEY_F2` = 291
  `KEY_F3` = 292
  `KEY_F4` = 293
  `KEY_F5` = 294
  `KEY_F6` = 295
  `KEY_F7` = 296
  `KEY_F8` = 297
  `KEY_F9` = 298
  `KEY_FIVE` = 53
  `KEY_FOUR` = 52
  `KEY_G` = 71
  `KEY_GRAVE` = 96
  `KEY_H` = 72
  `KEY_HOME` = 268
  `KEY_I` = 73
  `KEY_INSERT` = 260
  `KEY_J` = 74
  `KEY_K` = 75
  `KEY_KB_MENU` = 348
  `KEY_KP_0` = 320
  `KEY_KP_1` = 321
  `KEY_KP_2` = 322
  `KEY_KP_3` = 323
  `KEY_KP_4` = 324
  `KEY_KP_5` = 325
  `KEY_KP_6` = 326
  `KEY_KP_7` = 327
  `KEY_KP_8` = 328
  `KEY_KP_9` = 329
  `KEY_KP_ADD` = 334
  `KEY_KP_DECIMAL` = 330
  `KEY_KP_DIVIDE` = 331
  `KEY_KP_ENTER` = 335
  `KEY_KP_EQUAL` = 336
  `KEY_KP_MULTIPLY` = 332
  `KEY_KP_SUBTRACT` = 333
  `KEY_L` = 76
  `KEY_LEFT` = 263
  `KEY_LEFT_ALT` = 342
  `KEY_LEFT_BRACKET` = 91
  `KEY_LEFT_CONTROL` = 341
  `KEY_LEFT_SHIFT` = 340
  `KEY_LEFT_SUPER` = 343
  `KEY_M` = 77
  `KEY_MENU` = 82
  `KEY_MINUS` = 45
  `KEY_N` = 78
  `KEY_NINE` = 57
  `KEY_NULL` = 0
  `KEY_NUM_LOCK` = 282
  `KEY_O` = 79
  `KEY_ONE` = 49
  `KEY_P` = 80
  `KEY_PAGE_DOWN` = 267
  `KEY_PAGE_UP` = 266
  `KEY_PAUSE` = 284
  `KEY_PERIOD` = 46
  `KEY_PRINT_SCREEN` = 283
  `KEY_Q` = 81
  `KEY_R` = 82
  `KEY_RIGHT` = 262
  `KEY_RIGHT_ALT` = 346
  `KEY_RIGHT_BRACKET` = 93
  `KEY_RIGHT_CONTROL` = 345
  `KEY_RIGHT_SHIFT` = 344
  `KEY_RIGHT_SUPER` = 347
  `KEY_S` = 83
  `KEY_SCROLL_LOCK` = 281
  `KEY_SEMICOLON` = 59
  `KEY_SEVEN` = 55
  `KEY_SIX` = 54
  `KEY_SLASH` = 47
  `KEY_SPACE` = 32
  `KEY_T` = 84
  `KEY_TAB` = 258
  `KEY_THREE` = 51
  `KEY_TWO` = 50
  `KEY_U` = 85
  `KEY_UP` = 265
  `KEY_V` = 86
  `KEY_VOLUME_DOWN` = 25
  `KEY_VOLUME_UP` = 24
  `KEY_W` = 87
  `KEY_X` = 88
  `KEY_Y` = 89
  `KEY_Z` = 90
  `KEY_ZERO` = 48

class `pyray.``Material`(shader, maps, params)

  struct

class `pyray.``MaterialMap`(texture, color, value)

  struct

class `pyray.``MaterialMapIndex`

  Enum where members are also (and must be) ints

  `MATERIAL_MAP_ALBEDO` = 0
  `MATERIAL_MAP_BRDF` = 10
  `MATERIAL_MAP_CUBEMAP` = 7
  `MATERIAL_MAP_EMISSION` = 5
  `MATERIAL_MAP_HEIGHT` = 6
  `MATERIAL_MAP_IRRADIANCE` = 8
  `MATERIAL_MAP_METALNESS` = 1
  `MATERIAL_MAP_NORMAL` = 2
  `MATERIAL_MAP_OCCLUSION` = 4
  `MATERIAL_MAP_PREFILTER` = 9
  `MATERIAL_MAP_ROUGHNESS` = 3

class `pyray.``Matrix`(m0, m4, m8, m12, m1, m5, m9, m13, m2, m6, m10, m14, m3, m7, m11, m15)

  struct

class `pyray.``Matrix2x2`(m00, m01, m10, m11)

  struct

class `pyray.``Mesh`(vertexCount, triangleCount, vertices, texcoords, texcoords2, normals, tangents, colors, indices, animVertices, animNormals, boneIds, boneWeights, vaoId, vboId)

  struct

class `pyray.``Model`(transform, meshCount, materialCount, meshes, materials, meshMaterial, boneCount, bones, bindPose)

  struct

class `pyray.``ModelAnimation`(boneCount, frameCount, bones, framePoses)

  struct

class `pyray.``MouseButton`

  Enum where members are also (and must be) ints

  `MOUSE_BUTTON_BACK` = 6
  `MOUSE_BUTTON_EXTRA` = 4
  `MOUSE_BUTTON_FORWARD` = 5
  `MOUSE_BUTTON_LEFT` = 0
  `MOUSE_BUTTON_MIDDLE` = 2
  `MOUSE_BUTTON_RIGHT` = 1
  `MOUSE_BUTTON_SIDE` = 3

class `pyray.``MouseCursor`

  Enum where members are also (and must be) ints

  `MOUSE_CURSOR_ARROW` = 1
  `MOUSE_CURSOR_CROSSHAIR` = 3
  `MOUSE_CURSOR_DEFAULT` = 0
  `MOUSE_CURSOR_IBEAM` = 2
  `MOUSE_CURSOR_NOT_ALLOWED` = 10
  `MOUSE_CURSOR_POINTING_HAND` = 4
  `MOUSE_CURSOR_RESIZE_ALL` = 9
  `MOUSE_CURSOR_RESIZE_EW` = 5
  `MOUSE_CURSOR_RESIZE_NESW` = 8
  `MOUSE_CURSOR_RESIZE_NS` = 6
  `MOUSE_CURSOR_RESIZE_NWSE` = 7

class `pyray.``Music`(stream, frameCount, looping, ctxType, ctxData)

  struct

class `pyray.``NPatchInfo`(source, left, top, right, bottom, layout)

  struct

class `pyray.``NPatchLayout`

  Enum where members are also (and must be) ints

  `NPATCH_NINE_PATCH` = 0
  `NPATCH_THREE_PATCH_HORIZONTAL` = 2
  `NPATCH_THREE_PATCH_VERTICAL` = 1

class `pyray.``PhysicsBodyData`(id, enabled, position, velocity, force, angularVelocity, torque, orient, inertia, inverseInertia, mass, inverseMass, staticFriction, dynamicFriction, restitution, useGravity, isGrounded, freezeOrient, shape)

  struct

class `pyray.``PhysicsManifoldData`(id, bodyA, bodyB, penetration, normal, contacts, contactsCount, restitution, dynamicFriction, staticFriction)

  struct

class `pyray.``PhysicsShape`(type, body, vertexData, radius, transform)

  struct

class `pyray.``PhysicsVertexData`(vertexCount, positions, normals)

  struct

class `pyray.``PixelFormat`

  Enum where members are also (and must be) ints

  `PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA` = 20
  `PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA` = 21
  `PIXELFORMAT_COMPRESSED_DXT1_RGB` = 11
  `PIXELFORMAT_COMPRESSED_DXT1_RGBA` = 12
  `PIXELFORMAT_COMPRESSED_DXT3_RGBA` = 13
  `PIXELFORMAT_COMPRESSED_DXT5_RGBA` = 14
  `PIXELFORMAT_COMPRESSED_ETC1_RGB` = 15
  `PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA` = 17
  `PIXELFORMAT_COMPRESSED_ETC2_RGB` = 16
  `PIXELFORMAT_COMPRESSED_PVRT_RGB` = 18
  `PIXELFORMAT_COMPRESSED_PVRT_RGBA` = 19
  `PIXELFORMAT_UNCOMPRESSED_GRAYSCALE` = 1
  `PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA` = 2
  `PIXELFORMAT_UNCOMPRESSED_R32` = 8
  `PIXELFORMAT_UNCOMPRESSED_R32G32B32` = 9
  `PIXELFORMAT_UNCOMPRESSED_R32G32B32A32` = 10
  `PIXELFORMAT_UNCOMPRESSED_R4G4B4A4` = 6
  `PIXELFORMAT_UNCOMPRESSED_R5G5B5A1` = 5
  `PIXELFORMAT_UNCOMPRESSED_R5G6B5` = 3
  `PIXELFORMAT_UNCOMPRESSED_R8G8B8` = 4
  `PIXELFORMAT_UNCOMPRESSED_R8G8B8A8` = 7

class `pyray.``Quaternion`(x, y, z, w)

  struct

class `pyray.``Ray`(position, direction)

  struct

class `pyray.``RayCollision`(hit, distance, point, normal)

  struct

class `pyray.``Rectangle`(x, y, width, height)

  struct

class `pyray.``RenderTexture`(id, texture, depth)

  struct

class `pyray.``RenderTexture2D`(id, texture, depth)

  struct

class `pyray.``Shader`(id, locs)

  struct

class `pyray.``ShaderAttributeDataType`

  Enum where members are also (and must be) ints

  `SHADER_ATTRIB_FLOAT` = 0
  `SHADER_ATTRIB_VEC2` = 1
  `SHADER_ATTRIB_VEC3` = 2
  `SHADER_ATTRIB_VEC4` = 3

class `pyray.``ShaderLocationIndex`

  Enum where members are also (and must be) ints

  `SHADER_LOC_COLOR_AMBIENT` = 14
  `SHADER_LOC_COLOR_DIFFUSE` = 12
  `SHADER_LOC_COLOR_SPECULAR` = 13
  `SHADER_LOC_MAP_ALBEDO` = 15
  `SHADER_LOC_MAP_BRDF` = 25
  `SHADER_LOC_MAP_CUBEMAP` = 22
  `SHADER_LOC_MAP_EMISSION` = 20
  `SHADER_LOC_MAP_HEIGHT` = 21
  `SHADER_LOC_MAP_IRRADIANCE` = 23
  `SHADER_LOC_MAP_METALNESS` = 16
  `SHADER_LOC_MAP_NORMAL` = 17
  `SHADER_LOC_MAP_OCCLUSION` = 19
  `SHADER_LOC_MAP_PREFILTER` = 24
  `SHADER_LOC_MAP_ROUGHNESS` = 18
  `SHADER_LOC_MATRIX_MODEL` = 9
  `SHADER_LOC_MATRIX_MVP` = 6
  `SHADER_LOC_MATRIX_NORMAL` = 10
  `SHADER_LOC_MATRIX_PROJECTION` = 8
  `SHADER_LOC_MATRIX_VIEW` = 7
  `SHADER_LOC_VECTOR_VIEW` = 11
  `SHADER_LOC_VERTEX_COLOR` = 5
  `SHADER_LOC_VERTEX_NORMAL` = 3
  `SHADER_LOC_VERTEX_POSITION` = 0
  `SHADER_LOC_VERTEX_TANGENT` = 4
  `SHADER_LOC_VERTEX_TEXCOORD01` = 1
  `SHADER_LOC_VERTEX_TEXCOORD02` = 2

class `pyray.``ShaderUniformDataType`

  Enum where members are also (and must be) ints

  `SHADER_UNIFORM_FLOAT` = 0
  `SHADER_UNIFORM_INT` = 4
  `SHADER_UNIFORM_IVEC2` = 5
  `SHADER_UNIFORM_IVEC3` = 6
  `SHADER_UNIFORM_IVEC4` = 7
  `SHADER_UNIFORM_SAMPLER2D` = 8
  `SHADER_UNIFORM_VEC2` = 1
  `SHADER_UNIFORM_VEC3` = 2
  `SHADER_UNIFORM_VEC4` = 3

class `pyray.``Sound`(stream, frameCount)

  struct

class `pyray.``Texture`(id, width, height, mipmaps, format)

  struct

class `pyray.``Texture2D`(id, width, height, mipmaps, format)

  struct

class `pyray.``TextureCubemap`(id, width, height, mipmaps, format)

  struct

class `pyray.``TextureFilter`

  Enum where members are also (and must be) ints

  `TEXTURE_FILTER_ANISOTROPIC_16X` = 5
  `TEXTURE_FILTER_ANISOTROPIC_4X` = 3
  `TEXTURE_FILTER_ANISOTROPIC_8X` = 4
  `TEXTURE_FILTER_BILINEAR` = 1
  `TEXTURE_FILTER_POINT` = 0
  `TEXTURE_FILTER_TRILINEAR` = 2

class `pyray.``TextureWrap`

  Enum where members are also (and must be) ints

  `TEXTURE_WRAP_CLAMP` = 1
  `TEXTURE_WRAP_MIRROR_CLAMP` = 3
  `TEXTURE_WRAP_MIRROR_REPEAT` = 2
  `TEXTURE_WRAP_REPEAT` = 0

class `pyray.``TraceLogLevel`

  Enum where members are also (and must be) ints

  `LOG_ALL` = 0
  `LOG_DEBUG` = 2
  `LOG_ERROR` = 5
  `LOG_FATAL` = 6
  `LOG_INFO` = 3
  `LOG_NONE` = 7
  `LOG_TRACE` = 1
  `LOG_WARNING` = 4

class `pyray.``Transform`(translation, rotation, scale)

  struct

class `pyray.``Vector2`(x, y)

  struct

class `pyray.``Vector3`(x, y, z)

  struct

class `pyray.``Vector4`(x, y, z, w)

  struct

class `pyray.``VrDeviceInfo`(hResolution, vResolution, hScreenSize, vScreenSize, vScreenCenter, eyeToScreenDistance, lensSeparationDistance, interpupillaryDistance, lensDistortionValues, chromaAbCorrection)

  struct

class `pyray.``VrStereoConfig`(projection, viewOffset, leftLensCenter, rightLensCenter, leftScreenCenter, rightScreenCenter, scale, scaleIn)

  struct

class `pyray.``Wave`(frameCount, sampleRate, sampleSize, channels, data)

  struct

`pyray.``begin_blend_mode`(mode: int)

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

`pyray.``begin_drawing`()

  Setup canvas (framebuffer) to start drawing

`pyray.``begin_mode_2d`(camera: Camera2D)

  Begin 2D mode with custom camera (2D)

`pyray.``begin_mode_3d`(camera: Camera3D)

  Begin 3D mode with custom camera (3D)

`pyray.``begin_scissor_mode`(x: int, y: int, width: int, height: int)

  Begin scissor mode (define screen area for following drawing)

`pyray.``begin_shader_mode`(shader: Shader)

  Begin custom shader drawing

`pyray.``begin_texture_mode`(target: RenderTexture)

  Begin drawing to render texture

`pyray.``begin_vr_stereo_mode`(config: VrStereoConfig)

  Begin stereo rendering (requires VR simulator)

`pyray.``change_directory`(dir: str)

  Change working directory, return true on success

`pyray.``check_collision_box_sphere`(box: BoundingBox, center: Vector3, radius: float)

  Check collision between box and sphere

`pyray.``check_collision_boxes`(box1: BoundingBox, box2: BoundingBox)

  Check collision between two bounding boxes

`pyray.``check_collision_circle_rec`(center: Vector2, radius: float, rec: Rectangle)

  Check collision between circle and rectangle

`pyray.``check_collision_circles`(center1: Vector2, radius1: float, center2: Vector2, radius2: float)

  Check collision between two circles

`pyray.``check_collision_lines`(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

`pyray.``check_collision_point_circle`(point: Vector2, center: Vector2, radius: float)

  Check if point is inside circle

`pyray.``check_collision_point_line`(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]

`pyray.``check_collision_point_rec`(point: Vector2, rec: Rectangle)

  Check if point is inside rectangle

`pyray.``check_collision_point_triangle`(point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2)

  Check if point is inside a triangle

`pyray.``check_collision_recs`(rec1: Rectangle, rec2: Rectangle)

  Check collision between two rectangles

`pyray.``check_collision_spheres`(center1: Vector3, radius1: float, center2: Vector3, radius2: float)

  Check collision between two spheres

`pyray.``clear_background`(color: Color)

  Set background color (framebuffer clear color)

`pyray.``clear_directory_files`()

  Clear directory files paths buffers (free memory)

`pyray.``clear_dropped_files`()

  Clear dropped files paths buffer (free memory)

`pyray.``clear_window_state`(flags: int)

  Clear window configuration state flags

`pyray.``close_audio_device`()

  Close the audio device and context

`pyray.``close_physics`()

  void ClosePhysics();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``close_window`()

  Close window and unload OpenGL context

`pyray.``codepoint_to_utf8`(codepoint: int, byteSize: Any)

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

`pyray.``color_alpha`(color: Color, alpha: float)

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

`pyray.``color_alpha_blend`(dst: Color, src: Color, tint: Color)

  Get src alpha-blended into dst color with tint

`pyray.``color_from_hsv`(hue: float, saturation: float, value: float)

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

`pyray.``color_from_normalized`(normalized: Vector4)

  Get Color from normalized values [0..1]

`pyray.``color_normalize`(color: Color)

  Get Color normalized as float [0..1]

`pyray.``color_to_hsv`(color: Color)

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

`pyray.``color_to_int`(color: Color)

  Get hexadecimal value for a Color

`pyray.``compress_data`(data: str, dataLength: int, compDataLength: Any)

  Compress data (DEFLATE algorithm)

`pyray.``create_physics_body_circle`(Vector2_0: Vector2, float_1: float, float_2: float)

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

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``create_physics_body_polygon`(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

`pyray.``create_physics_body_rectangle`(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

`pyray.``decode_data_base64`(data: str, outputLength: Any)

  Decode Base64 string data

`pyray.``decompress_data`(compData: str, compDataLength: int, dataLength: Any)

  Decompress data (DEFLATE algorithm)

`pyray.``destroy_physics_body`(PhysicsBodyData_pointer_0: Any)

  void DestroyPhysicsBody(struct PhysicsBodyData *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``directory_exists`(dirPath: str)

  Check if a directory path exists

`pyray.``disable_cursor`()

  Disables cursor (lock cursor)

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

  Draw a billboard texture

`pyray.``draw_billboard_pro`(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

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

  Draw a billboard texture defined by source

`pyray.``draw_bounding_box`(box: BoundingBox, color: Color)

  Draw bounding box (wires)

`pyray.``draw_circle`(centerX: int, centerY: int, radius: float, color: Color)

  Draw a color-filled circle

`pyray.``draw_circle_3d`(center: Vector3, radius: float, rotationAxis: Vector3, rotationAngle: float, color: Color)

  Draw a circle in 3D world space

`pyray.``draw_circle_gradient`(centerX: int, centerY: int, radius: float, color1: Color, color2: Color)

  Draw a gradient-filled circle

`pyray.``draw_circle_lines`(centerX: int, centerY: int, radius: float, color: Color)

  Draw circle outline

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

  Draw a piece of a circle

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

  Draw circle sector outline

`pyray.``draw_circle_v`(center: Vector2, radius: float, color: Color)

  Draw a color-filled circle (Vector version)

`pyray.``draw_cube`(position: Vector3, width: float, height: float, length: float, color: Color)

  Draw cube

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

  Draw cube textured

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

  Draw cube with a region of a texture

`pyray.``draw_cube_v`(position: Vector3, size: Vector3, color: Color)

  Draw cube (Vector version)

`pyray.``draw_cube_wires`(position: Vector3, width: float, height: float, length: float, color: Color)

  Draw cube wires

`pyray.``draw_cube_wires_v`(position: Vector3, size: Vector3, color: Color)

  Draw cube wires (Vector version)

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

  Draw a cylinder/cone

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

  Draw a cylinder with base at startPos and top at endPos

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

  Draw a cylinder/cone wires

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

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

`pyray.``draw_ellipse`(centerX: int, centerY: int, radiusH: float, radiusV: float, color: Color)

  Draw ellipse

`pyray.``draw_ellipse_lines`(centerX: int, centerY: int, radiusH: float, radiusV: float, color: Color)

  Draw ellipse outline

`pyray.``draw_fps`(posX: int, posY: int)

  Draw current FPS

`pyray.``draw_grid`(slices: int, spacing: float)

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

`pyray.``draw_line`(startPosX: int, startPosY: int, endPosX: int, endPosY: int, color: Color)

  Draw a line

`pyray.``draw_line_3d`(startPos: Vector3, endPos: Vector3, color: Color)

  Draw a line in 3D world space

`pyray.``draw_line_bezier`(startPos: Vector2, endPos: Vector2, thick: float, color: Color)

  Draw a line using cubic-bezier curves in-out

`pyray.``draw_line_bezier_cubic`(startPos: Vector2, endPos: Vector2, startControlPos: Vector2, endControlPos: Vector2, thick: float, color: Color)

  Draw line using cubic bezier curves with 2 control points

`pyray.``draw_line_bezier_quad`(startPos: Vector2, endPos: Vector2, controlPos: Vector2, thick: float, color: Color)

  Draw line using quadratic bezier curves with a control point

`pyray.``draw_line_ex`(startPos: Vector2, endPos: Vector2, thick: float, color: Color)

  Draw a line defining thickness

`pyray.``draw_line_strip`(points: Any, pointCount: int, color: Color)

  Draw lines sequence

`pyray.``draw_line_v`(startPos: Vector2, endPos: Vector2, color: Color)

  Draw a line (Vector version)

`pyray.``draw_mesh`(mesh: Mesh, material: Material, transform: Matrix)

  Draw a 3d mesh with material and transform

`pyray.``draw_mesh_instanced`(mesh: Mesh, material: Material, transforms: Any, instances: int)

  Draw multiple mesh instances with material and different transforms

`pyray.``draw_model`(model: Model, position: Vector3, scale: float, tint: Color)

  Draw a model (with texture if set)

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

  Draw a model with extended parameters

`pyray.``draw_model_wires`(model: Model, position: Vector3, scale: float, tint: Color)

  Draw a model wires (with texture if set)

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

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

`pyray.``draw_pixel`(posX: int, posY: int, color: Color)

  Draw a pixel

`pyray.``draw_pixel_v`(position: Vector2, color: Color)

  Draw a pixel (Vector version)

`pyray.``draw_plane`(centerPos: Vector3, size: Vector2, color: Color)

  Draw a plane XZ

`pyray.``draw_point_3d`(position: Vector3, color: Color)

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

`pyray.``draw_poly`(center: Vector2, sides: int, radius: float, rotation: float, color: Color)

  Draw a regular polygon (Vector version)

`pyray.``draw_poly_lines`(center: Vector2, sides: int, radius: float, rotation: float, color: Color)

  Draw a polygon outline of n sides

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

  Draw a polygon outline of n sides with extended parameters

`pyray.``draw_ray`(ray: Ray, color: Color)

  Draw a ray line

`pyray.``draw_rectangle`(posX: int, posY: int, width: int, height: int, color: Color)

  Draw a color-filled rectangle

`pyray.``draw_rectangle_gradient_ex`(rec: Rectangle, col1: Color, col2: Color, col3: Color, col4: Color)

  Draw a gradient-filled rectangle with custom vertex colors

`pyray.``draw_rectangle_gradient_h`(posX: int, posY: int, width: int, height: int, color1: Color, color2: Color)

  Draw a horizontal-gradient-filled rectangle

`pyray.``draw_rectangle_gradient_v`(posX: int, posY: int, width: int, height: int, color1: Color, color2: Color)

  Draw a vertical-gradient-filled rectangle

`pyray.``draw_rectangle_lines`(posX: int, posY: int, width: int, height: int, color: Color)

  Draw rectangle outline

`pyray.``draw_rectangle_lines_ex`(rec: Rectangle, lineThick: float, color: Color)

  Draw rectangle outline with extended parameters

`pyray.``draw_rectangle_pro`(rec: Rectangle, origin: Vector2, rotation: float, color: Color)

  Draw a color-filled rectangle with pro parameters

`pyray.``draw_rectangle_rec`(rec: Rectangle, color: Color)

  Draw a color-filled rectangle

`pyray.``draw_rectangle_rounded`(rec: Rectangle, roundness: float, segments: int, color: Color)

  Draw rectangle with rounded edges

`pyray.``draw_rectangle_rounded_lines`(rec: Rectangle, roundness: float, segments: int, lineThick: float, color: Color)

  Draw rectangle with rounded edges outline

`pyray.``draw_rectangle_v`(position: Vector2, size: Vector2, color: Color)

  Draw a color-filled rectangle (Vector version)

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

  Draw ring

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

  Draw ring outline

`pyray.``draw_sphere`(centerPos: Vector3, radius: float, color: Color)

  Draw sphere

`pyray.``draw_sphere_ex`(centerPos: Vector3, radius: float, rings: int, slices: int, color: Color)

  Draw sphere with extended parameters

`pyray.``draw_sphere_wires`(centerPos: Vector3, radius: float, rings: int, slices: int, color: Color)

  Draw sphere wires

`pyray.``draw_text`(text: str, posX: int, posY: int, fontSize: int, color: Color)

  Draw text (using default font)

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

  Draw one character (codepoint)

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

  Draw text using font and additional parameters

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

  Draw text using Font and pro parameters (rotation)

`pyray.``draw_texture`(texture: Texture, posX: int, posY: int, tint: Color)

  Draw a Texture2D

`pyray.``draw_texture_ex`(texture: Texture, position: Vector2, rotation: float, scale: float, tint: Color)

  Draw a Texture2D with extended parameters

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

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

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

  Draw a textured polygon

`pyray.``draw_texture_pro`(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

`pyray.``draw_texture_quad`(texture: Texture, tiling: Vector2, offset: Vector2, quad: Rectangle, tint: Color)

  Draw texture quad with tiling and offset parameters

`pyray.``draw_texture_rec`(texture: Texture, source: Rectangle, position: Vector2, tint: Color)

  Draw a part of a texture defined by a rectangle

`pyray.``draw_texture_tiled`(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.

`pyray.``draw_texture_v`(texture: Texture, position: Vector2, tint: Color)

  Draw a Texture2D with position defined as Vector2

`pyray.``draw_triangle`(v1: Vector2, v2: Vector2, v3: Vector2, color: Color)

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

`pyray.``draw_triangle_3d`(v1: Vector3, v2: Vector3, v3: Vector3, color: Color)

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

`pyray.``draw_triangle_fan`(points: Any, pointCount: int, color: Color)

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

`pyray.``draw_triangle_lines`(v1: Vector2, v2: Vector2, v3: Vector2, color: Color)

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

`pyray.``draw_triangle_strip`(points: Any, pointCount: int, color: Color)

  Draw a triangle strip defined by points

`pyray.``draw_triangle_strip_3d`(points: Any, pointCount: int, color: Color)

  Draw a triangle strip defined by points

`pyray.``enable_cursor`()

  Enables cursor (unlock cursor)

`pyray.``encode_data_base64`(data: str, dataLength: int, outputLength: Any)

  Encode data to Base64 string

`pyray.``end_blend_mode`()

  End blending mode (reset to default: alpha blending)

`pyray.``end_drawing`()

  End canvas drawing and swap buffers (double buffering)

`pyray.``end_mode_2d`()

  Ends 2D mode with custom camera

`pyray.``end_mode_3d`()

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

`pyray.``end_scissor_mode`()

  End scissor mode

`pyray.``end_shader_mode`()

  End custom shader drawing (use default shader)

`pyray.``end_texture_mode`()

  Ends drawing to render texture

`pyray.``end_vr_stereo_mode`()

  End stereo rendering (requires VR simulator)

`pyray.``export_image`(image: Image, fileName: str)

  Export image data to file, returns true on success

`pyray.``export_image_as_code`(image: Image, fileName: str)

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

`pyray.``export_mesh`(mesh: Mesh, fileName: str)

  Export mesh data to file, returns true on success

`pyray.``export_wave`(wave: Wave, fileName: str)

  Export wave data to file, returns true on success

`pyray.``export_wave_as_code`(wave: Wave, fileName: str)

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

`pyray.``fade`(color: Color, alpha: float)

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

`pyray.``file_exists`(fileName: str)

  Check if file exists

`pyray.``gen_image_cellular`(width: int, height: int, tileSize: int)

  Generate image: cellular algorithm, bigger tileSize means bigger cells

`pyray.``gen_image_checked`(width: int, height: int, checksX: int, checksY: int, col1: Color, col2: Color)

  Generate image: checked

`pyray.``gen_image_color`(width: int, height: int, color: Color)

  Generate image: plain color

`pyray.``gen_image_font_atlas`(chars: Any, recs: Any, glyphCount: int, fontSize: int, padding: int, packMethod: int)

  Generate image font atlas using chars info

`pyray.``gen_image_gradient_h`(width: int, height: int, left: Color, right: Color)

  Generate image: horizontal gradient

`pyray.``gen_image_gradient_radial`(width: int, height: int, density: float, inner: Color, outer: Color)

  Generate image: radial gradient

`pyray.``gen_image_gradient_v`(width: int, height: int, top: Color, bottom: Color)

  Generate image: vertical gradient

`pyray.``gen_image_white_noise`(width: int, height: int, factor: float)

  Generate image: white noise

`pyray.``gen_mesh_binormals`(mesh: Any)

  Compute mesh binormals

`pyray.``gen_mesh_cone`(radius: float, height: float, slices: int)

  Generate cone/pyramid mesh

`pyray.``gen_mesh_cube`(width: float, height: float, length: float)

  Generate cuboid mesh

`pyray.``gen_mesh_cubicmap`(cubicmap: Image, cubeSize: Vector3)

  Generate cubes-based map mesh from image data

`pyray.``gen_mesh_cylinder`(radius: float, height: float, slices: int)

  Generate cylinder mesh

`pyray.``gen_mesh_heightmap`(heightmap: Image, size: Vector3)

  Generate heightmap mesh from image data

`pyray.``gen_mesh_hemi_sphere`(radius: float, rings: int, slices: int)

  Generate half-sphere mesh (no bottom cap)

`pyray.``gen_mesh_knot`(radius: float, size: float, radSeg: int, sides: int)

  Generate trefoil knot mesh

`pyray.``gen_mesh_plane`(width: float, length: float, resX: int, resZ: int)

  Generate plane mesh (with subdivisions)

`pyray.``gen_mesh_poly`(sides: int, radius: float)

  Generate polygonal mesh

`pyray.``gen_mesh_sphere`(radius: float, rings: int, slices: int)

  Generate sphere mesh (standard sphere)

`pyray.``gen_mesh_tangents`(mesh: Any)

  Compute mesh tangents

`pyray.``gen_mesh_torus`(radius: float, size: float, radSeg: int, sides: int)

  Generate torus mesh

`pyray.``gen_texture_mipmaps`(texture: Any)

  Generate GPU mipmaps for a texture

`pyray.``get_camera_matrix`(camera: Camera3D)

  Get camera transform matrix (view matrix)

`pyray.``get_camera_matrix_2d`(camera: Camera2D)

  Get camera 2d transform matrix

`pyray.``get_char_pressed`()

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

`pyray.``get_clipboard_text`()

  Get clipboard text content

`pyray.``get_codepoint`(text: str, bytesProcessed: Any)

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

`pyray.``get_codepoint_count`(text: str)

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

`pyray.``get_collision_rec`(rec1: Rectangle, rec2: Rectangle)

  Get collision rectangle for two rectangles collision

`pyray.``get_color`(hexValue: int)

  Get Color structure from hexadecimal value

`pyray.``get_current_monitor`()

  Get current connected monitor

`pyray.``get_directory_files`(dirPath: str, count: Any)

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

`pyray.``get_directory_path`(filePath: str)

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

`pyray.``get_dropped_files`(count: Any)

  Get dropped files names (memory should be freed)

`pyray.``get_file_extension`(fileName: str)

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

`pyray.``get_file_mod_time`(fileName: str)

  Get file modification time (last write time)

`pyray.``get_file_name`(filePath: str)

  Get pointer to filename for a path string

`pyray.``get_file_name_without_ext`(filePath: str)

  Get filename string without extension (uses static string)

`pyray.``get_font_default`()

  Get the default Font

`pyray.``get_fps`()

  Get current FPS

`pyray.``get_frame_time`()

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

`pyray.``get_gamepad_axis_count`(gamepad: int)

  Get gamepad axis count for a gamepad

`pyray.``get_gamepad_axis_movement`(gamepad: int, axis: int)

  Get axis movement value for a gamepad axis

`pyray.``get_gamepad_button_pressed`()

  Get the last gamepad button pressed

`pyray.``get_gamepad_name`(gamepad: int)

  Get gamepad internal name id

`pyray.``get_gesture_detected`()

  Get latest detected gesture

`pyray.``get_gesture_drag_angle`()

  Get gesture drag angle

`pyray.``get_gesture_drag_vector`()

  Get gesture drag vector

`pyray.``get_gesture_hold_duration`()

  Get gesture hold time in milliseconds

`pyray.``get_gesture_pinch_angle`()

  Get gesture pinch angle

`pyray.``get_gesture_pinch_vector`()

  Get gesture pinch delta

`pyray.``get_glyph_atlas_rec`(font: Font, codepoint: int)

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

`pyray.``get_glyph_index`(font: Font, codepoint: int)

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

`pyray.``get_glyph_info`(font: Font, codepoint: int)

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

`pyray.``get_image_alpha_border`(image: Image, threshold: float)

  Get image alpha border rectangle

`pyray.``get_image_color`(image: Image, x: int, y: int)

  Get image pixel color at (x, y) position

`pyray.``get_key_pressed`()

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

`pyray.``get_mesh_bounding_box`(mesh: Mesh)

  Compute mesh bounding box limits

`pyray.``get_model_bounding_box`(model: Model)

  Compute model bounding box limits (considers all meshes)

`pyray.``get_monitor_count`()

  Get number of connected monitors

`pyray.``get_monitor_height`(monitor: int)

  Get specified monitor height (max available by monitor)

`pyray.``get_monitor_name`(monitor: int)

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

`pyray.``get_monitor_physical_height`(monitor: int)

  Get specified monitor physical height in millimetres

`pyray.``get_monitor_physical_width`(monitor: int)

  Get specified monitor physical width in millimetres

`pyray.``get_monitor_position`(monitor: int)

  Get specified monitor position

`pyray.``get_monitor_refresh_rate`(monitor: int)

  Get specified monitor refresh rate

`pyray.``get_monitor_width`(monitor: int)

  Get specified monitor width (max available by monitor)

`pyray.``get_mouse_delta`()

  Get mouse delta between frames

`pyray.``get_mouse_position`()

  Get mouse position XY

`pyray.``get_mouse_ray`(mousePosition: Vector2, camera: Camera3D)

  Get a ray trace from mouse position

`pyray.``get_mouse_wheel_move`()

  Get mouse wheel movement Y

`pyray.``get_mouse_x`()

  Get mouse position X

`pyray.``get_mouse_y`()

  Get mouse position Y

`pyray.``get_music_time_length`(music: Music)

  Get music time length (in seconds)

`pyray.``get_music_time_played`(music: Music)

  Get current music time played (in seconds)

`pyray.``get_physics_bodies_count`()

  int GetPhysicsBodiesCount();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``get_physics_body`(int_0: int)

  struct PhysicsBodyData *GetPhysicsBody(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``get_physics_shape_type`(int_0: int)

  int GetPhysicsShapeType(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``get_physics_shape_vertex`(PhysicsBodyData_pointer_0: Any, int_1: int)

  struct Vector2 GetPhysicsShapeVertex(struct PhysicsBodyData *, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``get_physics_shape_vertices_count`(int_0: int)

  int GetPhysicsShapeVerticesCount(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``get_pixel_color`(srcPtr: Any, format: int)

  Get Color from a source pixel pointer of certain format

`pyray.``get_pixel_data_size`(width: int, height: int, format: int)

  Get pixel data size in bytes for certain format

`pyray.``get_prev_directory_path`(dirPath: str)

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

`pyray.``get_random_value`(min: int, max: int)

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

`pyray.``get_ray_collision_box`(ray: Ray, box: BoundingBox)

  Get collision info between ray and box

`pyray.``get_ray_collision_mesh`(ray: Ray, mesh: Mesh, transform: Matrix)

  Get collision info between ray and mesh

`pyray.``get_ray_collision_model`(ray: Ray, model: Model)

  Get collision info between ray and model

`pyray.``get_ray_collision_quad`(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3, p4: Vector3)

  Get collision info between ray and quad

`pyray.``get_ray_collision_sphere`(ray: Ray, center: Vector3, radius: float)

  Get collision info between ray and sphere

`pyray.``get_ray_collision_triangle`(ray: Ray, p1: Vector3, p2: Vector3, p3: Vector3)

  Get collision info between ray and triangle

`pyray.``get_screen_height`()

  Get current screen height

`pyray.``get_screen_to_world_2d`(position: Vector2, camera: Camera2D)

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

`pyray.``get_screen_width`()

  Get current screen width

`pyray.``get_shader_location`(shader: Shader, uniformName: str)

  Get shader uniform location

`pyray.``get_shader_location_attrib`(shader: Shader, attribName: str)

  Get shader attribute location

`pyray.``get_sounds_playing`()

  Get number of sounds playing in the multichannel

`pyray.``get_time`()

  Get elapsed time in seconds since InitWindow()

`pyray.``get_touch_point_count`()

  Get number of touch points

`pyray.``get_touch_point_id`(index: int)

  Get touch point identifier for given index

`pyray.``get_touch_position`(index: int)

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

`pyray.``get_touch_x`()

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

`pyray.``get_touch_y`()

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

`pyray.``get_window_handle`()

  Get native window handle

`pyray.``get_window_position`()

  Get window position XY on monitor

`pyray.``get_window_scale_dpi`()

  Get window scale DPI factor

`pyray.``get_working_directory`()

  Get current working directory (uses static string)

`pyray.``get_world_to_screen`(position: Vector3, camera: Camera3D)

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

`pyray.``get_world_to_screen_2d`(position: Vector2, camera: Camera2D)

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

`pyray.``get_world_to_screen_ex`(position: Vector3, camera: Camera3D, width: int, height: int)

  Get size position for a 3d world space position

class `pyray.``guiIconName`

  Enum where members are also (and must be) ints

  `RICON_1UP` = 148
  `RICON_200` = 200
  `RICON_201` = 201
  `RICON_202` = 202
  `RICON_203` = 203
  `RICON_204` = 204
  `RICON_205` = 205
  `RICON_206` = 206
  `RICON_207` = 207
  `RICON_208` = 208
  `RICON_209` = 209
  `RICON_210` = 210
  `RICON_211` = 211
  `RICON_212` = 212
  `RICON_213` = 213
  `RICON_214` = 214
  `RICON_215` = 215
  `RICON_216` = 216
  `RICON_217` = 217
  `RICON_218` = 218
  `RICON_219` = 219
  `RICON_220` = 220
  `RICON_221` = 221
  `RICON_222` = 222
  `RICON_223` = 223
  `RICON_224` = 224
  `RICON_225` = 225
  `RICON_226` = 226
  `RICON_227` = 227
  `RICON_228` = 228
  `RICON_229` = 229
  `RICON_230` = 230
  `RICON_231` = 231
  `RICON_232` = 232
  `RICON_233` = 233
  `RICON_234` = 234
  `RICON_235` = 235
  `RICON_236` = 236
  `RICON_237` = 237
  `RICON_238` = 238
  `RICON_239` = 239
  `RICON_240` = 240
  `RICON_241` = 241
  `RICON_242` = 242
  `RICON_243` = 243
  `RICON_244` = 244
  `RICON_245` = 245
  `RICON_246` = 246
  `RICON_247` = 247
  `RICON_248` = 248
  `RICON_249` = 249
  `RICON_250` = 250
  `RICON_251` = 251
  `RICON_252` = 252
  `RICON_253` = 253
  `RICON_254` = 254
  `RICON_255` = 255
  `RICON_ALPHA_CLEAR` = 93
  `RICON_ALPHA_MULTIPLY` = 92
  `RICON_ARROW_DOWN` = 116
  `RICON_ARROW_DOWN_FILL` = 120
  `RICON_ARROW_LEFT` = 114
  `RICON_ARROW_LEFT_FILL` = 118
  `RICON_ARROW_RIGHT` = 115
  `RICON_ARROW_RIGHT_FILL` = 119
  `RICON_ARROW_UP` = 117
  `RICON_ARROW_UP_FILL` = 121
  `RICON_AUDIO` = 122
  `RICON_BIN` = 143
  `RICON_BOX` = 80
  `RICON_BOX_BOTTOM` = 85
  `RICON_BOX_BOTTOM_LEFT` = 86
  `RICON_BOX_BOTTOM_RIGHT` = 84
  `RICON_BOX_CENTER` = 89
  `RICON_BOX_CIRCLE_MASK` = 90
  `RICON_BOX_CONCENTRIC` = 110
  `RICON_BOX_CORNERS_BIG` = 99
  `RICON_BOX_CORNERS_SMALL` = 98
  `RICON_BOX_DOTS_BIG` = 109
  `RICON_BOX_DOTS_SMALL` = 108
  `RICON_BOX_GRID` = 96
  `RICON_BOX_GRID_BIG` = 111
  `RICON_BOX_LEFT` = 87
  `RICON_BOX_MULTISIZE` = 102
  `RICON_BOX_RIGHT` = 83
  `RICON_BOX_TOP` = 81
  `RICON_BOX_TOP_LEFT` = 88
  `RICON_BOX_TOP_RIGHT` = 82
  `RICON_BRUSH_CLASSIC` = 24
  `RICON_BRUSH_PAINTER` = 25
  `RICON_CAMERA` = 169
  `RICON_CLOCK` = 139
  `RICON_COIN` = 146
  `RICON_COLOR_BUCKET` = 29
  `RICON_COLOR_PICKER` = 27
  `RICON_CORNER` = 187
  `RICON_CRACK` = 155
  `RICON_CRACK_POINTS` = 156
  `RICON_CROP` = 36
  `RICON_CROP_ALPHA` = 37
  `RICON_CROSS` = 113
  `RICON_CROSSLINE` = 192
  `RICON_CROSS_SMALL` = 128
  `RICON_CUBE` = 162
  `RICON_CUBE_FACE_BACK` = 168
  `RICON_CUBE_FACE_BOTTOM` = 166
  `RICON_CUBE_FACE_FRONT` = 165
  `RICON_CUBE_FACE_LEFT` = 164
  `RICON_CUBE_FACE_RIGHT` = 167
  `RICON_CUBE_FACE_TOP` = 163
  `RICON_CURSOR_CLASSIC` = 21
  `RICON_CURSOR_HAND` = 19
  `RICON_CURSOR_MOVE` = 52
  `RICON_CURSOR_MOVE_FILL` = 68
  `RICON_CURSOR_POINTER` = 20
  `RICON_CURSOR_SCALE` = 53
  `RICON_CURSOR_SCALE_FILL` = 69
  `RICON_CURSOR_SCALE_LEFT` = 55
  `RICON_CURSOR_SCALE_LEFT_FILL` = 71
  `RICON_CURSOR_SCALE_RIGHT` = 54
  `RICON_CURSOR_SCALE_RIGHT_FILL` = 70
  `RICON_DEMON` = 152
  `RICON_DITHERING` = 94
  `RICON_DOOR` = 158
  `RICON_EMPTYBOX` = 63
  `RICON_EMPTYBOX_SMALL` = 79
  `RICON_EXIT` = 159
  `RICON_EXPLOSION` = 147
  `RICON_EYE_OFF` = 45
  `RICON_EYE_ON` = 44
  `RICON_FILETYPE_ALPHA` = 194
  `RICON_FILETYPE_AUDIO` = 11
  `RICON_FILETYPE_HOME` = 195
  `RICON_FILETYPE_IMAGE` = 12
  `RICON_FILETYPE_INFO` = 15
  `RICON_FILETYPE_PLAY` = 13
  `RICON_FILETYPE_TEXT` = 10
  `RICON_FILETYPE_VIDEO` = 14
  `RICON_FILE_COPY` = 16
  `RICON_FILE_CUT` = 17
  `RICON_FILE_DELETE` = 9
  `RICON_FILE_EXPORT` = 7
  `RICON_FILE_NEW` = 8
  `RICON_FILE_OPEN` = 5
  `RICON_FILE_PASTE` = 18
  `RICON_FILE_SAVE` = 6
  `RICON_FILE_SAVE_CLASSIC` = 2
  `RICON_FILTER` = 47
  `RICON_FILTER_BILINEAR` = 35
  `RICON_FILTER_POINT` = 34
  `RICON_FILTER_TOP` = 46
  `RICON_FOLDER_FILE_OPEN` = 1
  `RICON_FOLDER_OPEN` = 3
  `RICON_FOLDER_SAVE` = 4
  `RICON_FOUR_BOXES` = 100
  `RICON_FX` = 123
  `RICON_GEAR` = 141
  `RICON_GEAR_BIG` = 142
  `RICON_GEAR_EX` = 154
  `RICON_GRID` = 97
  `RICON_GRID_FILL` = 101
  `RICON_HAND_POINTER` = 144
  `RICON_HEART` = 186
  `RICON_HELP` = 193
  `RICON_HIDPI` = 199
  `RICON_HOUSE` = 185
  `RICON_INFO` = 191
  `RICON_KEY` = 151
  `RICON_LASER` = 145
  `RICON_LAYERS` = 197
  `RICON_LAYERS_VISIBLE` = 196
  `RICON_LENS` = 42
  `RICON_LENS_BIG` = 43
  `RICON_LIFE_BARS` = 190
  `RICON_LINK` = 174
  `RICON_LINK_BOXES` = 172
  `RICON_LINK_BROKE` = 175
  `RICON_LINK_MULTI` = 173
  `RICON_LINK_NET` = 171
  `RICON_LOCK_CLOSE` = 137
  `RICON_LOCK_OPEN` = 138
  `RICON_MAGNET` = 136
  `RICON_MAILBOX` = 180
  `RICON_MIPMAPS` = 95
  `RICON_MODE_2D` = 160
  `RICON_MODE_3D` = 161
  `RICON_MONITOR` = 181
  `RICON_MUTATE` = 59
  `RICON_MUTATE_FILL` = 75
  `RICON_NONE` = 0
  `RICON_NOTEBOOK` = 177
  `RICON_OK_TICK` = 112
  `RICON_PENCIL` = 22
  `RICON_PENCIL_BIG` = 23
  `RICON_PHOTO_CAMERA` = 183
  `RICON_PHOTO_CAMERA_FLASH` = 184
  `RICON_PLAYER` = 149
  `RICON_PLAYER_JUMP` = 150
  `RICON_PLAYER_NEXT` = 134
  `RICON_PLAYER_PAUSE` = 132
  `RICON_PLAYER_PLAY` = 131
  `RICON_PLAYER_PLAY_BACK` = 130
  `RICON_PLAYER_PREVIOUS` = 129
  `RICON_PLAYER_RECORD` = 135
  `RICON_PLAYER_STOP` = 133
  `RICON_POT` = 91
  `RICON_PRINTER` = 182
  `RICON_REDO` = 57
  `RICON_REDO_FILL` = 73
  `RICON_REPEAT` = 61
  `RICON_REPEAT_FILL` = 77
  `RICON_REREDO` = 58
  `RICON_REREDO_FILL` = 74
  `RICON_RESIZE` = 33
  `RICON_ROTATE` = 60
  `RICON_ROTATE_FILL` = 76
  `RICON_RUBBER` = 28
  `RICON_SCALE` = 32
  `RICON_SHUFFLE` = 62
  `RICON_SHUFFLE_FILL` = 78
  `RICON_SPECIAL` = 170
  `RICON_SQUARE_TOGGLE` = 38
  `RICON_STAR` = 157
  `RICON_SUITCASE` = 178
  `RICON_SUITCASE_ZIP` = 179
  `RICON_SYMMETRY` = 39
  `RICON_SYMMETRY_HORIZONTAL` = 40
  `RICON_SYMMETRY_VERTICAL` = 41
  `RICON_TARGET` = 64
  `RICON_TARGET_BIG` = 50
  `RICON_TARGET_BIG_FILL` = 66
  `RICON_TARGET_MOVE` = 51
  `RICON_TARGET_MOVE_FILL` = 67
  `RICON_TARGET_POINT` = 48
  `RICON_TARGET_SMALL` = 49
  `RICON_TARGET_SMALL_FILL` = 65
  `RICON_TEXT_A` = 31
  `RICON_TEXT_NOTES` = 176
  `RICON_TEXT_POPUP` = 153
  `RICON_TEXT_T` = 30
  `RICON_TOOLS` = 140
  `RICON_UNDO` = 56
  `RICON_UNDO_FILL` = 72
  `RICON_VERTICAL_BARS` = 188
  `RICON_VERTICAL_BARS_FILL` = 189
  `RICON_WATER_DROP` = 26
  `RICON_WAVE` = 124
  `RICON_WAVE_SINUS` = 125
  `RICON_WAVE_SQUARE` = 126
  `RICON_WAVE_TRIANGULAR` = 127
  `RICON_WINDOW` = 198
  `RICON_ZOOM_ALL` = 106
  `RICON_ZOOM_BIG` = 105
  `RICON_ZOOM_CENTER` = 107
  `RICON_ZOOM_MEDIUM` = 104
  `RICON_ZOOM_SMALL` = 103

`pyray.``gui_button`(Rectangle_0: Rectangle, str_1: str)

  _Bool GuiButton(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_check_box`(Rectangle_0: Rectangle, str_1: str, _Bool_2: bool)

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

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_check_icon_pixel`(int_0: int, int_1: int, int_2: int)

  _Bool GuiCheckIconPixel(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_clear_icon_pixel`(int_0: int, int_1: int, int_2: int)

  void GuiClearIconPixel(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_color_bar_alpha`(Rectangle_0: Rectangle, float_1: float)

  float GuiColorBarAlpha(struct Rectangle, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_color_bar_hue`(Rectangle_0: Rectangle, float_1: float)

  float GuiColorBarHue(struct Rectangle, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_color_panel`(Rectangle_0: Rectangle, Color_1: Color)

  struct Color GuiColorPanel(struct Rectangle, struct Color);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_color_picker`(Rectangle_0: Rectangle, Color_1: Color)

  struct Color GuiColorPicker(struct Rectangle, struct Color);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_combo_box`(Rectangle_0: Rectangle, str_1: str, int_2: int)

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

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_disable`()

  void GuiDisable();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_draw_icon`(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

`pyray.``gui_dropdown_box`(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

`pyray.``gui_dummy_rec`(Rectangle_0: Rectangle, str_1: str)

  void GuiDummyRec(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_enable`()

  void GuiEnable();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_fade`(float_0: float)

  void GuiFade(float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_get_font`()

  struct Font GuiGetFont();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_get_icon_data`(int_0: int)

  unsigned int *GuiGetIconData(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_get_icons`()

  unsigned int *GuiGetIcons();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_get_state`()

  int GuiGetState();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_get_style`(int_0: int, int_1: int)

  int GuiGetStyle(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_grid`(Rectangle_0: Rectangle, float_1: float, int_2: int)

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

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_group_box`(Rectangle_0: Rectangle, str_1: str)

  void GuiGroupBox(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_icon_text`(int_0: int, str_1: str)

  char *GuiIconText(int, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_is_locked`()

  _Bool GuiIsLocked();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_label`(Rectangle_0: Rectangle, str_1: str)

  void GuiLabel(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_label_button`(Rectangle_0: Rectangle, str_1: str)

  _Bool GuiLabelButton(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_line`(Rectangle_0: Rectangle, str_1: str)

  void GuiLine(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_list_view`(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

`pyray.``gui_list_view_ex`(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

`pyray.``gui_load_style`(str_0: str)

  void GuiLoadStyle(char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_load_style_default`()

  void GuiLoadStyleDefault();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_lock`()

  void GuiLock();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_message_box`(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

`pyray.``gui_panel`(Rectangle_0: Rectangle)

  void GuiPanel(struct Rectangle);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_progress_bar`(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

`pyray.``gui_scroll_bar`(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

`pyray.``gui_scroll_panel`(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

`pyray.``gui_set_font`(Font_0: Font)

  void GuiSetFont(struct Font);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_set_icon_data`(int_0: int, unsignedint_pointer_1: Any)

  void GuiSetIconData(int, unsigned int *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_set_icon_pixel`(int_0: int, int_1: int, int_2: int)

  void GuiSetIconPixel(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_set_state`(int_0: int)

  void GuiSetState(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_set_style`(int_0: int, int_1: int, int_2: int)

  void GuiSetStyle(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_slider`(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

`pyray.``gui_slider_bar`(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

`pyray.``gui_spinner`(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

`pyray.``gui_status_bar`(Rectangle_0: Rectangle, str_1: str)

  void GuiStatusBar(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_text_box`(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

`pyray.``gui_text_box_multi`(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

`pyray.``gui_text_input_box`(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

`pyray.``gui_toggle`(Rectangle_0: Rectangle, str_1: str, _Bool_2: bool)

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

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_toggle_group`(Rectangle_0: Rectangle, str_1: str, int_2: int)

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

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_unlock`()

  void GuiUnlock();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``gui_value_box`(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

`pyray.``gui_window_box`(Rectangle_0: Rectangle, str_1: str)

  _Bool GuiWindowBox(struct Rectangle, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``hide_cursor`()

  Hides cursor

`pyray.``image_alpha_clear`(image: Any, color: Color, threshold: float)

  Clear alpha channel to desired color

`pyray.``image_alpha_crop`(image: Any, threshold: float)

  Crop image depending on alpha value

`pyray.``image_alpha_mask`(image: Any, alphaMask: Image)

  Apply alpha mask to image

`pyray.``image_alpha_premultiply`(image: Any)

  Premultiply alpha channel

`pyray.``image_clear_background`(dst: Any, color: Color)

  Clear image background with given color

`pyray.``image_color_brightness`(image: Any, brightness: int)

  Modify image color: brightness (-255 to 255)

`pyray.``image_color_contrast`(image: Any, contrast: float)

  Modify image color: contrast (-100 to 100)

`pyray.``image_color_grayscale`(image: Any)

  Modify image color: grayscale

`pyray.``image_color_invert`(image: Any)

  Modify image color: invert

`pyray.``image_color_replace`(image: Any, color: Color, replace: Color)

  Modify image color: replace color

`pyray.``image_color_tint`(image: Any, color: Color)

  Modify image color: tint

`pyray.``image_copy`(image: Image)

  Create an image duplicate (useful for transformations)

`pyray.``image_crop`(image: Any, crop: Rectangle)

  Crop an image to a defined rectangle

`pyray.``image_dither`(image: Any, rBpp: int, gBpp: int, bBpp: int, aBpp: int)

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

`pyray.``image_draw`(dst: Any, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color)

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

`pyray.``image_draw_circle`(dst: Any, centerX: int, centerY: int, radius: int, color: Color)

  Draw circle within an image

`pyray.``image_draw_circle_v`(dst: Any, center: Vector2, radius: int, color: Color)

  Draw circle within an image (Vector version)

`pyray.``image_draw_line`(dst: Any, startPosX: int, startPosY: int, endPosX: int, endPosY: int, color: Color)

  Draw line within an image

`pyray.``image_draw_line_v`(dst: Any, start: Vector2, end: Vector2, color: Color)

  Draw line within an image (Vector version)

`pyray.``image_draw_pixel`(dst: Any, posX: int, posY: int, color: Color)

  Draw pixel within an image

`pyray.``image_draw_pixel_v`(dst: Any, position: Vector2, color: Color)

  Draw pixel within an image (Vector version)

`pyray.``image_draw_rectangle`(dst: Any, posX: int, posY: int, width: int, height: int, color: Color)

  Draw rectangle within an image

`pyray.``image_draw_rectangle_lines`(dst: Any, rec: Rectangle, thick: int, color: Color)

  Draw rectangle lines within an image

`pyray.``image_draw_rectangle_rec`(dst: Any, rec: Rectangle, color: Color)

  Draw rectangle within an image

`pyray.``image_draw_rectangle_v`(dst: Any, position: Vector2, size: Vector2, color: Color)

  Draw rectangle within an image (Vector version)

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

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

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

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

`pyray.``image_flip_horizontal`(image: Any)

  Flip image horizontally

`pyray.``image_flip_vertical`(image: Any)

  Flip image vertically

`pyray.``image_format`(image: Any, newFormat: int)

  Convert image data to desired format

`pyray.``image_from_image`(image: Image, rec: Rectangle)

  Create an image from another image piece

`pyray.``image_mipmaps`(image: Any)

  Compute all mipmap levels for a provided image

`pyray.``image_resize`(image: Any, newWidth: int, newHeight: int)

  Resize image (Bicubic scaling algorithm)

`pyray.``image_resize_canvas`(image: Any, newWidth: int, newHeight: int, offsetX: int, offsetY: int, fill: Color)

  Resize canvas and fill with color

`pyray.``image_resize_nn`(image: Any, newWidth: int, newHeight: int)

  Resize image (Nearest-Neighbor scaling algorithm)

`pyray.``image_rotate_ccw`(image: Any)

  Rotate image counter-clockwise 90deg

`pyray.``image_rotate_cw`(image: Any)

  Rotate image clockwise 90deg

`pyray.``image_text`(text: str, fontSize: int, color: Color)

  Create an image from text (default font)

`pyray.``image_text_ex`(font: Font, text: str, fontSize: float, spacing: float, tint: Color)

  Create an image from text (custom sprite font)

`pyray.``image_to_pot`(image: Any, fill: Color)

  Convert image to POT (power-of-two)

`pyray.``init_audio_device`()

  Initialize audio device and context

`pyray.``init_physics`()

  void InitPhysics();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``init_window`(width: int, height: int, title: str)

  Initialize window and OpenGL context

`pyray.``is_audio_device_ready`()

  Check if audio device has been initialized successfully

`pyray.``is_audio_stream_playing`(stream: AudioStream)

  Check if audio stream is playing

`pyray.``is_audio_stream_processed`(stream: AudioStream)

  Check if any audio stream buffers requires refill

`pyray.``is_cursor_hidden`()

  Check if cursor is not visible

`pyray.``is_cursor_on_screen`()

  Check if cursor is on the screen

`pyray.``is_file_dropped`()

  Check if a file has been dropped into window

`pyray.``is_file_extension`(fileName: str, ext: str)

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

`pyray.``is_gamepad_available`(gamepad: int)

  Check if a gamepad is available

`pyray.``is_gamepad_button_down`(gamepad: int, button: int)

  Check if a gamepad button is being pressed

`pyray.``is_gamepad_button_pressed`(gamepad: int, button: int)

  Check if a gamepad button has been pressed once

`pyray.``is_gamepad_button_released`(gamepad: int, button: int)

  Check if a gamepad button has been released once

`pyray.``is_gamepad_button_up`(gamepad: int, button: int)

  Check if a gamepad button is NOT being pressed

`pyray.``is_gesture_detected`(gesture: int)

  Check if a gesture have been detected

`pyray.``is_key_down`(key: int)

  Check if a key is being pressed

`pyray.``is_key_pressed`(key: int)

  Check if a key has been pressed once

`pyray.``is_key_released`(key: int)

  Check if a key has been released once

`pyray.``is_key_up`(key: int)

  Check if a key is NOT being pressed

`pyray.``is_model_animation_valid`(model: Model, anim: ModelAnimation)

  Check model animation skeleton match

`pyray.``is_mouse_button_down`(button: int)

  Check if a mouse button is being pressed

`pyray.``is_mouse_button_pressed`(button: int)

  Check if a mouse button has been pressed once

`pyray.``is_mouse_button_released`(button: int)

  Check if a mouse button has been released once

`pyray.``is_mouse_button_up`(button: int)

  Check if a mouse button is NOT being pressed

`pyray.``is_music_stream_playing`(music: Music)

  Check if music is playing

`pyray.``is_sound_playing`(sound: Sound)

  Check if a sound is currently playing

`pyray.``is_window_focused`()

  Check if window is currently focused (only PLATFORM_DESKTOP)

`pyray.``is_window_fullscreen`()

  Check if window is currently fullscreen

`pyray.``is_window_hidden`()

  Check if window is currently hidden (only PLATFORM_DESKTOP)

`pyray.``is_window_maximized`()

  Check if window is currently maximized (only PLATFORM_DESKTOP)

`pyray.``is_window_minimized`()

  Check if window is currently minimized (only PLATFORM_DESKTOP)

`pyray.``is_window_ready`()

  Check if window has been initialized successfully

`pyray.``is_window_resized`()

  Check if window has been resized last frame

`pyray.``is_window_state`(flag: int)

  Check if one specific window flag is enabled

`pyray.``load_audio_stream`(sampleRate: int, sampleSize: int, channels: int)

  Load audio stream (to stream raw audio pcm data)

`pyray.``load_codepoints`(text: str, count: Any)

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

`pyray.``load_file_data`(fileName: str, bytesRead: Any)

  Load file data as byte array (read)

`pyray.``load_file_text`(fileName: str)

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

`pyray.``load_font`(fileName: str)

  Load font from file into GPU memory (VRAM)

`pyray.``load_font_data`(fileData: str, dataSize: int, fontSize: int, fontChars: Any, glyphCount: int, type: int)

  Load font data for further use

`pyray.``load_font_ex`(fileName: str, fontSize: int, fontChars: Any, glyphCount: int)

  Load font from file with extended parameters

`pyray.``load_font_from_image`(image: Image, key: Color, firstChar: int)

  Load font from Image (XNA style)

`pyray.``load_font_from_memory`(fileType: str, fileData: str, dataSize: int, fontSize: int, fontChars: Any, glyphCount: int)

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

`pyray.``load_image`(fileName: str)

  Load image from file into CPU memory (RAM)

`pyray.``load_image_anim`(fileName: str, frames: Any)

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

`pyray.``load_image_colors`(image: Image)

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

`pyray.``load_image_from_memory`(fileType: str, fileData: str, dataSize: int)

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

`pyray.``load_image_from_screen`()

  Load image from screen buffer and (screenshot)

`pyray.``load_image_from_texture`(texture: Texture)

  Load image from GPU texture data

`pyray.``load_image_palette`(image: Image, maxPaletteSize: int, colorCount: Any)

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

`pyray.``load_image_raw`(fileName: str, width: int, height: int, format: int, headerSize: int)

  Load image from RAW file data

`pyray.``load_material_default`()

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

`pyray.``load_materials`(fileName: str, materialCount: Any)

  Load materials from model file

`pyray.``load_model`(fileName: str)

  Load model from files (meshes and materials)

`pyray.``load_model_animations`(fileName: str, animCount: Any)

  Load model animations from file

`pyray.``load_model_from_mesh`(mesh: Mesh)

  Load model from generated mesh (default material)

`pyray.``load_music_stream`(fileName: str)

  Load music stream from file

`pyray.``load_music_stream_from_memory`(fileType: str, data: str, dataSize: int)

  Load music stream from data

`pyray.``load_render_texture`(width: int, height: int)

  Load texture for rendering (framebuffer)

`pyray.``load_shader`(vsFileName: str, fsFileName: str)

  Load shader from files and bind default locations

`pyray.``load_shader_from_memory`(vsCode: str, fsCode: str)

  Load shader from code strings and bind default locations

`pyray.``load_sound`(fileName: str)

  Load sound from file

`pyray.``load_sound_from_wave`(wave: Wave)

  Load sound from wave data

`pyray.``load_storage_value`(position: int)

  Load integer value from storage file (from defined position)

`pyray.``load_texture`(fileName: str)

  Load texture from file into GPU memory (VRAM)

`pyray.``load_texture_cubemap`(image: Image, layout: int)

  Load cubemap from image, multiple image cubemap layouts supported

`pyray.``load_texture_from_image`(image: Image)

  Load texture from image data

`pyray.``load_vr_stereo_config`(device: VrDeviceInfo)

  Load VR stereo config for VR simulator device parameters

`pyray.``load_wave`(fileName: str)

  Load wave data from file

`pyray.``load_wave_from_memory`(fileType: str, fileData: str, dataSize: int)

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

`pyray.``load_wave_samples`(wave: Wave)

  Load samples data from wave as a floats array

`pyray.``maximize_window`()

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

`pyray.``measure_text`(text: str, fontSize: int)

  Measure string width for default font

`pyray.``measure_text_ex`(font: Font, text: str, fontSize: float, spacing: float)

  Measure string size for Font

`pyray.``mem_alloc`(size: int)

  Internal memory allocator

`pyray.``mem_free`(ptr: Any)

  Internal memory free

`pyray.``mem_realloc`(ptr: Any, size: int)

  Internal memory reallocator

`pyray.``minimize_window`()

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

`pyray.``open_url`(url: str)

  Open URL with default system browser (if available)

`pyray.``pause_audio_stream`(stream: AudioStream)

  Pause audio stream

`pyray.``pause_music_stream`(music: Music)

  Pause music playing

`pyray.``pause_sound`(sound: Sound)

  Pause a sound

`pyray.``physics_add_force`(PhysicsBodyData_pointer_0: Any, Vector2_1: Vector2)

  void PhysicsAddForce(struct PhysicsBodyData *, struct Vector2);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``physics_add_torque`(PhysicsBodyData_pointer_0: Any, float_1: float)

  void PhysicsAddTorque(struct PhysicsBodyData *, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``physics_shatter`(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

`pyray.``play_audio_stream`(stream: AudioStream)

  Play audio stream

`pyray.``play_music_stream`(music: Music)

  Start music playing

`pyray.``play_sound`(sound: Sound)

  Play a sound

`pyray.``play_sound_multi`(sound: Sound)

  Play a sound (using multichannel buffer pool)

`pyray.``pointer`(struct)

`pyray.``poll_input_events`()

  Register all input events

`pyray.``reset_physics`()

  void ResetPhysics();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``restore_window`()

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

`pyray.``resume_audio_stream`(stream: AudioStream)

  Resume audio stream

`pyray.``resume_music_stream`(music: Music)

  Resume playing paused music

`pyray.``resume_sound`(sound: Sound)

  Resume a paused sound

`pyray.``rl_active_draw_buffers`(int_0: int)

  void rlActiveDrawBuffers(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_active_texture_slot`(int_0: int)

  void rlActiveTextureSlot(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_begin`(int_0: int)

  void rlBegin(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_bind_image_texture`(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

`pyray.``rl_bind_shader_buffer`(unsignedint_0: int, unsignedint_1: int)

  void rlBindShaderBuffer(unsigned int, unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_check_errors`()

  void rlCheckErrors();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_check_render_batch_limit`(int_0: int)

  _Bool rlCheckRenderBatchLimit(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_clear_color`(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

`pyray.``rl_clear_screen_buffers`()

  void rlClearScreenBuffers();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_color3f`(float_0: float, float_1: float, float_2: float)

  void rlColor3f(float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_color4f`(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

`pyray.``rl_color4ub`(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

`pyray.``rl_compile_shader`(str_0: str, int_1: int)

  unsigned int rlCompileShader(char *, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_compute_shader_dispatch`(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

`pyray.``rl_copy_buffers_elements`(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

`pyray.``rl_disable_backface_culling`()

  void rlDisableBackfaceCulling();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_color_blend`()

  void rlDisableColorBlend();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_depth_mask`()

  void rlDisableDepthMask();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_depth_test`()

  void rlDisableDepthTest();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_framebuffer`()

  void rlDisableFramebuffer();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_scissor_test`()

  void rlDisableScissorTest();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_shader`()

  void rlDisableShader();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_smooth_lines`()

  void rlDisableSmoothLines();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_stereo_render`()

  void rlDisableStereoRender();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_texture`()

  void rlDisableTexture();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_texture_cubemap`()

  void rlDisableTextureCubemap();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_vertex_array`()

  void rlDisableVertexArray();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_vertex_attribute`(unsignedint_0: int)

  void rlDisableVertexAttribute(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_vertex_buffer`()

  void rlDisableVertexBuffer();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_vertex_buffer_element`()

  void rlDisableVertexBufferElement();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_disable_wire_mode`()

  void rlDisableWireMode();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_draw_render_batch`(rlRenderBatch_pointer_0: Any)

  void rlDrawRenderBatch(struct rlRenderBatch *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_draw_render_batch_active`()

  void rlDrawRenderBatchActive();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_draw_vertex_array`(int_0: int, int_1: int)

  void rlDrawVertexArray(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_draw_vertex_array_elements`(int_0: int, int_1: int, void_pointer_2: Any)

  void rlDrawVertexArrayElements(int, int, void *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_draw_vertex_array_elements_instanced`(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

`pyray.``rl_draw_vertex_array_instanced`(int_0: int, int_1: int, int_2: int)

  void rlDrawVertexArrayInstanced(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_backface_culling`()

  void rlEnableBackfaceCulling();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_color_blend`()

  void rlEnableColorBlend();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_depth_mask`()

  void rlEnableDepthMask();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_depth_test`()

  void rlEnableDepthTest();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_framebuffer`(unsignedint_0: int)

  void rlEnableFramebuffer(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_scissor_test`()

  void rlEnableScissorTest();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_shader`(unsignedint_0: int)

  void rlEnableShader(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_smooth_lines`()

  void rlEnableSmoothLines();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_stereo_render`()

  void rlEnableStereoRender();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_texture`(unsignedint_0: int)

  void rlEnableTexture(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_texture_cubemap`(unsignedint_0: int)

  void rlEnableTextureCubemap(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_vertex_array`(unsignedint_0: int)

  _Bool rlEnableVertexArray(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_vertex_attribute`(unsignedint_0: int)

  void rlEnableVertexAttribute(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_vertex_buffer`(unsignedint_0: int)

  void rlEnableVertexBuffer(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_vertex_buffer_element`(unsignedint_0: int)

  void rlEnableVertexBufferElement(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_enable_wire_mode`()

  void rlEnableWireMode();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_end`()

  void rlEnd();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_framebuffer_attach`(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

`pyray.``rl_framebuffer_complete`(unsignedint_0: int)

  _Bool rlFramebufferComplete(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_frustum`(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

`pyray.``rl_gen_texture_mipmaps`(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

`pyray.``rl_get_framebuffer_height`()

  int rlGetFramebufferHeight();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_framebuffer_width`()

  int rlGetFramebufferWidth();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_gl_texture_formats`(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

`pyray.``rl_get_line_width`()

  float rlGetLineWidth();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_location_attrib`(unsignedint_0: int, str_1: str)

  int rlGetLocationAttrib(unsigned int, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_location_uniform`(unsignedint_0: int, str_1: str)

  int rlGetLocationUniform(unsigned int, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_matrix_modelview`()

  struct Matrix rlGetMatrixModelview();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_matrix_projection`()

  struct Matrix rlGetMatrixProjection();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_matrix_projection_stereo`(int_0: int)

  struct Matrix rlGetMatrixProjectionStereo(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_matrix_transform`()

  struct Matrix rlGetMatrixTransform();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_matrix_view_offset_stereo`(int_0: int)

  struct Matrix rlGetMatrixViewOffsetStereo(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_pixel_format_name`(unsignedint_0: int)

  char *rlGetPixelFormatName(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_shader_buffer_size`(unsignedint_0: int)

  unsigned long long rlGetShaderBufferSize(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_shader_id_default`()

  unsigned int rlGetShaderIdDefault();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_shader_locs_default`()

  int *rlGetShaderLocsDefault();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_texture_id_default`()

  unsigned int rlGetTextureIdDefault();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_get_version`()

  int rlGetVersion();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_is_stereo_render_enabled`()

  _Bool rlIsStereoRenderEnabled();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_compute_shader_program`(unsignedint_0: int)

  unsigned int rlLoadComputeShaderProgram(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_draw_cube`()

  void rlLoadDrawCube();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_draw_quad`()

  void rlLoadDrawQuad();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_extensions`(void_pointer_0: Any)

  void rlLoadExtensions(void *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_framebuffer`(int_0: int, int_1: int)

  unsigned int rlLoadFramebuffer(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_identity`()

  void rlLoadIdentity();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_render_batch`(int_0: int, int_1: int)

  struct rlRenderBatch rlLoadRenderBatch(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_shader_buffer`(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

`pyray.``rl_load_shader_code`(str_0: str, str_1: str)

  unsigned int rlLoadShaderCode(char *, char *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_shader_program`(unsignedint_0: int, unsignedint_1: int)

  unsigned int rlLoadShaderProgram(unsigned int, unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_texture`(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

`pyray.``rl_load_texture_cubemap`(void_pointer_0: Any, int_1: int, int_2: int)

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

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_texture_depth`(int_0: int, int_1: int, _Bool_2: bool)

  unsigned int rlLoadTextureDepth(int, int, _Bool);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_vertex_array`()

  unsigned int rlLoadVertexArray();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_vertex_buffer`(void_pointer_0: Any, int_1: int, _Bool_2: bool)

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

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_load_vertex_buffer_element`(void_pointer_0: Any, int_1: int, _Bool_2: bool)

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

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_matrix_mode`(int_0: int)

  void rlMatrixMode(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_mult_matrixf`(float_pointer_0: Any)

  void rlMultMatrixf(float *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_normal3f`(float_0: float, float_1: float, float_2: float)

  void rlNormal3f(float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_ortho`(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

`pyray.``rl_pop_matrix`()

  void rlPopMatrix();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_push_matrix`()

  void rlPushMatrix();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_read_screen_pixels`(int_0: int, int_1: int)

  unsigned char *rlReadScreenPixels(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_read_shader_buffer_elements`(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

`pyray.``rl_read_texture_pixels`(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

`pyray.``rl_rotatef`(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

`pyray.``rl_scalef`(float_0: float, float_1: float, float_2: float)

  void rlScalef(float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_scissor`(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

`pyray.``rl_set_blend_factors`(int_0: int, int_1: int, int_2: int)

  void rlSetBlendFactors(int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_blend_mode`(int_0: int)

  void rlSetBlendMode(int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_line_width`(float_0: float)

  void rlSetLineWidth(float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_matrix_modelview`(Matrix_0: Matrix)

  void rlSetMatrixModelview(struct Matrix);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_matrix_projection`(Matrix_0: Matrix)

  void rlSetMatrixProjection(struct Matrix);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_matrix_projection_stereo`(Matrix_0: Matrix, Matrix_1: Matrix)

  void rlSetMatrixProjectionStereo(struct Matrix, struct Matrix);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_matrix_view_offset_stereo`(Matrix_0: Matrix, Matrix_1: Matrix)

  void rlSetMatrixViewOffsetStereo(struct Matrix, struct Matrix);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_render_batch_active`(rlRenderBatch_pointer_0: Any)

  void rlSetRenderBatchActive(struct rlRenderBatch *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_shader`(unsignedint_0: int, int_pointer_1: Any)

  void rlSetShader(unsigned int, int *);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_texture`(unsignedint_0: int)

  void rlSetTexture(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_uniform`(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

`pyray.``rl_set_uniform_matrix`(int_0: int, Matrix_1: Matrix)

  void rlSetUniformMatrix(int, struct Matrix);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_uniform_sampler`(int_0: int, unsignedint_1: int)

  void rlSetUniformSampler(int, unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_set_vertex_attribute`(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

`pyray.``rl_set_vertex_attribute_default`(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

`pyray.``rl_set_vertex_attribute_divisor`(unsignedint_0: int, int_1: int)

  void rlSetVertexAttributeDivisor(unsigned int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_tex_coord2f`(float_0: float, float_1: float)

  void rlTexCoord2f(float, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_texture_parameters`(unsignedint_0: int, int_1: int, int_2: int)

  void rlTextureParameters(unsigned int, int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_translatef`(float_0: float, float_1: float, float_2: float)

  void rlTranslatef(float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_unload_framebuffer`(unsignedint_0: int)

  void rlUnloadFramebuffer(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_unload_render_batch`(rlRenderBatch_0: rlRenderBatch)

  void rlUnloadRenderBatch(struct rlRenderBatch);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_unload_shader_buffer`(unsignedint_0: int)

  void rlUnloadShaderBuffer(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_unload_shader_program`(unsignedint_0: int)

  void rlUnloadShaderProgram(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_unload_texture`(unsignedint_0: int)

  void rlUnloadTexture(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_unload_vertex_array`(unsignedint_0: int)

  void rlUnloadVertexArray(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_unload_vertex_buffer`(unsignedint_0: int)

  void rlUnloadVertexBuffer(unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_update_shader_buffer_elements`(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

`pyray.``rl_update_texture`(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

`pyray.``rl_update_vertex_buffer`(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

`pyray.``rl_vertex2f`(float_0: float, float_1: float)

  void rlVertex2f(float, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_vertex2i`(int_0: int, int_1: int)

  void rlVertex2i(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_vertex3f`(float_0: float, float_1: float, float_2: float)

  void rlVertex3f(float, float, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rl_viewport`(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

`pyray.``rlgl_close`()

  void rlglClose();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``rlgl_init`(int_0: int, int_1: int)

  void rlglInit(int, int);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``save_file_data`(fileName: str, data: Any, bytesToWrite: int)

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

`pyray.``save_file_text`(fileName: str, text: str)

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

`pyray.``save_storage_value`(position: int, value: int)

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

`pyray.``seek_music_stream`(music: Music, position: float)

  Seek music to a position (in seconds)

`pyray.``set_audio_stream_buffer_size_default`(size: int)

  Default size for new audio streams

`pyray.``set_audio_stream_pitch`(stream: AudioStream, pitch: float)

  Set pitch for audio stream (1.0 is base level)

`pyray.``set_audio_stream_volume`(stream: AudioStream, volume: float)

  Set volume for audio stream (1.0 is max level)

`pyray.``set_camera_alt_control`(keyAlt: int)

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

`pyray.``set_camera_mode`(camera: Camera3D, mode: int)

  Set camera mode (multiple camera modes available)

`pyray.``set_camera_move_controls`(keyFront: int, keyBack: int, keyRight: int, keyLeft: int, keyUp: int, keyDown: int)

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

`pyray.``set_camera_pan_control`(keyPan: int)

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

`pyray.``set_camera_smooth_zoom_control`(keySmoothZoom: int)

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

`pyray.``set_clipboard_text`(text: str)

  Set clipboard text content

`pyray.``set_config_flags`(flags: int)

  Setup init configuration flags (view FLAGS)

`pyray.``set_exit_key`(key: int)

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

`pyray.``set_gamepad_mappings`(mappings: str)

  Set internal gamepad mappings (SDL_GameControllerDB)

`pyray.``set_gestures_enabled`(flags: int)

  Enable a set of gestures using flags

`pyray.``set_load_file_data_callback`(callback: str)

  Set custom file binary data loader

`pyray.``set_load_file_text_callback`(callback: str)

  Set custom file text data loader

`pyray.``set_master_volume`(volume: float)

  Set master volume (listener)

`pyray.``set_material_texture`(material: Any, mapType: int, texture: Texture)

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

`pyray.``set_model_mesh_material`(model: Any, meshId: int, materialId: int)

  Set material for a mesh

`pyray.``set_mouse_cursor`(cursor: int)

  Set mouse cursor

`pyray.``set_mouse_offset`(offsetX: int, offsetY: int)

  Set mouse offset

`pyray.``set_mouse_position`(x: int, y: int)

  Set mouse position XY

`pyray.``set_mouse_scale`(scaleX: float, scaleY: float)

  Set mouse scaling

`pyray.``set_music_pitch`(music: Music, pitch: float)

  Set pitch for a music (1.0 is base level)

`pyray.``set_music_volume`(music: Music, volume: float)

  Set volume for music (1.0 is max level)

`pyray.``set_physics_body_rotation`(PhysicsBodyData_pointer_0: Any, float_1: float)

  void SetPhysicsBodyRotation(struct PhysicsBodyData *, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``set_physics_gravity`(float_0: float, float_1: float)

  void SetPhysicsGravity(float, float);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``set_physics_time_step`(double_0: float)

  void SetPhysicsTimeStep(double);

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``set_pixel_color`(dstPtr: Any, color: Color, format: int)

  Set color formatted into destination pixel pointer

`pyray.``set_random_seed`(seed: int)

  Set the seed for the random number generator

`pyray.``set_save_file_data_callback`(callback: str)

  Set custom file binary data saver

`pyray.``set_save_file_text_callback`(callback: str)

  Set custom file text data saver

`pyray.``set_shader_value`(shader: Shader, locIndex: int, value: Any, uniformType: int)

  Set shader uniform value

`pyray.``set_shader_value_matrix`(shader: Shader, locIndex: int, mat: Matrix)

  Set shader uniform value (matrix 4x4)

`pyray.``set_shader_value_texture`(shader: Shader, locIndex: int, texture: Texture)

  Set shader uniform value for texture (sampler2d)

`pyray.``set_shader_value_v`(shader: Shader, locIndex: int, value: Any, uniformType: int, count: int)

  Set shader uniform value vector

`pyray.``set_shapes_texture`(texture: Texture, source: Rectangle)

  Set texture and rectangle to be used on shapes drawing

`pyray.``set_sound_pitch`(sound: Sound, pitch: float)

  Set pitch for a sound (1.0 is base level)

`pyray.``set_sound_volume`(sound: Sound, volume: float)

  Set volume for a sound (1.0 is max level)

`pyray.``set_target_fps`(fps: int)

  Set target FPS (maximum)

`pyray.``set_texture_filter`(texture: Texture, filter: int)

  Set texture scaling filter mode

`pyray.``set_texture_wrap`(texture: Texture, wrap: int)

  Set texture wrapping mode

`pyray.``set_trace_log_callback`(callback: str)

  Set custom trace log

`pyray.``set_trace_log_level`(logLevel: int)

  Set the current threshold (minimum) log level

`pyray.``set_window_icon`(image: Image)

  Set icon for window (only PLATFORM_DESKTOP)

`pyray.``set_window_min_size`(width: int, height: int)

  Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)

`pyray.``set_window_monitor`(monitor: int)

  Set monitor for the current window (fullscreen mode)

`pyray.``set_window_position`(x: int, y: int)

  Set window position on screen (only PLATFORM_DESKTOP)

`pyray.``set_window_size`(width: int, height: int)

  Set window dimensions

`pyray.``set_window_state`(flags: int)

  Set window configuration state using flags

`pyray.``set_window_title`(title: str)

  Set title for window (only PLATFORM_DESKTOP)

`pyray.``show_cursor`()

  Shows cursor

`pyray.``stop_audio_stream`(stream: AudioStream)

  Stop audio stream

`pyray.``stop_music_stream`(music: Music)

  Stop music playing

`pyray.``stop_sound`(sound: Sound)

  Stop playing a sound

`pyray.``stop_sound_multi`()

  Stop any sound playing (using multichannel buffer pool)

`pyray.``swap_screen_buffer`()

  Swap back buffer with front buffer (screen drawing)

`pyray.``take_screenshot`(fileName: str)

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

`pyray.``text_append`(text: str, append: str, position: Any)

  Append text at specific position and move cursor!

`pyray.``text_codepoints_to_utf8`(codepoints: Any, length: int)

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

`pyray.``text_copy`(dst: str, src: str)

  Copy one string to another, returns bytes copied

`pyray.``text_find_index`(text: str, find: str)

  Find first text occurrence within a string

`pyray.``text_format`(*args)

  VARARG FUNCTION - MAY NOT BE SUPPORTED BY CFFI

`pyray.``text_insert`(text: str, insert: str, position: int)

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

`pyray.``text_is_equal`(text1: str, text2: str)

  Check if two text string are equal

`pyray.``text_join`(textList: str, count: int, delimiter: str)

  Join text strings with delimiter

`pyray.``text_length`(text: str)

  Get text length, checks for ‘ 0’ ending

`pyray.``text_replace`(text: str, replace: str, by: str)

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

`pyray.``text_split`(text: str, delimiter: str, count: Any)

  Split text into multiple strings

`pyray.``text_subtext`(text: str, position: int, length: int)

  Get a piece of a text string

`pyray.``text_to_integer`(text: str)

  Get integer value from text (negative values not supported)

`pyray.``text_to_lower`(text: str)

  Get lower case version of provided string

`pyray.``text_to_pascal`(text: str)

  Get Pascal case notation version of provided string

`pyray.``text_to_upper`(text: str)

  Get upper case version of provided string

`pyray.``toggle_fullscreen`()

  Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)

`pyray.``trace_log`(*args)

  VARARG FUNCTION - MAY NOT BE SUPPORTED BY CFFI

`pyray.``unload_audio_stream`(stream: AudioStream)

  Unload audio stream and free memory

`pyray.``unload_codepoints`(codepoints: Any)

  Unload codepoints data from memory

`pyray.``unload_file_data`(data: str)

  Unload file data allocated by LoadFileData()

`pyray.``unload_file_text`(text: str)

  Unload file text data allocated by LoadFileText()

`pyray.``unload_font`(font: Font)

  Unload Font from GPU memory (VRAM)

`pyray.``unload_font_data`(chars: Any, glyphCount: int)

  Unload font chars info data (RAM)

`pyray.``unload_image`(image: Image)

  Unload image from CPU memory (RAM)

`pyray.``unload_image_colors`(colors: Any)

  Unload color data loaded with LoadImageColors()

`pyray.``unload_image_palette`(colors: Any)

  Unload colors palette loaded with LoadImagePalette()

`pyray.``unload_material`(material: Material)

  Unload material from GPU memory (VRAM)

`pyray.``unload_mesh`(mesh: Mesh)

  Unload mesh data from CPU and GPU

`pyray.``unload_model`(model: Model)

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

`pyray.``unload_model_animation`(anim: ModelAnimation)

  Unload animation data

`pyray.``unload_model_animations`(animations: Any, count: int)

  Unload animation array data

`pyray.``unload_model_keep_meshes`(model: Model)

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

`pyray.``unload_music_stream`(music: Music)

  Unload music stream

`pyray.``unload_render_texture`(target: RenderTexture)

  Unload render texture from GPU memory (VRAM)

`pyray.``unload_shader`(shader: Shader)

  Unload shader from GPU memory (VRAM)

`pyray.``unload_sound`(sound: Sound)

  Unload sound

`pyray.``unload_texture`(texture: Texture)

  Unload texture from GPU memory (VRAM)

`pyray.``unload_vr_stereo_config`(config: VrStereoConfig)

  Unload VR stereo config

`pyray.``unload_wave`(wave: Wave)

  Unload wave data

`pyray.``unload_wave_samples`(samples: Any)

  Unload samples data loaded with LoadWaveSamples()

`pyray.``update_audio_stream`(stream: AudioStream, data: Any, frameCount: int)

  Update audio stream buffers with data

`pyray.``update_camera`(camera: Any)

  Update camera position for selected mode

`pyray.``update_mesh_buffer`(mesh: Mesh, index: int, data: Any, dataSize: int, offset: int)

  Update mesh vertex data in GPU for a specific buffer index

`pyray.``update_model_animation`(model: Model, anim: ModelAnimation, frame: int)

  Update model animation pose

`pyray.``update_music_stream`(music: Music)

  Updates buffers for music streaming

`pyray.``update_physics`()

  void UpdatePhysics();

  CFFI C function from raylib._raylib_cffi.lib

`pyray.``update_sound`(sound: Sound, data: Any, sampleCount: int)

  Update sound buffer with new data

`pyray.``update_texture`(texture: Texture, pixels: Any)

  Update GPU texture with new data

`pyray.``update_texture_rec`(texture: Texture, rec: Rectangle, pixels: Any)

  Update GPU texture rectangle with new data

`pyray.``upload_mesh`(mesh: Any, dynamic: bool)

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

`pyray.``wait_time`(ms: float)

  Wait for some milliseconds (halt program execution)

`pyray.``wave_copy`(wave: Wave)

  Copy a wave to a new wave

`pyray.``wave_crop`(wave: Any, initSample: int, finalSample: int)

  Crop a wave to defined samples range

`pyray.``wave_format`(wave: Any, sampleRate: int, sampleSize: int, channels: int)

  Convert wave data to desired format

`pyray.``window_should_close`()

  Check if KEY_ESCAPE pressed or Close icon pressed