Module: Raylib

Extended by:

FFI::Library

Defined in:

lib/raylib_helper.rb,
lib/rlgl.rb,
lib/config.rb,
lib/physac.rb,
lib/raylib.rb,
lib/raymath.rb,
lib/rcamera.rb,
lib/raygui_main.rb,
lib/raylib_main.rb,
lib/raygui_helper.rb

Overview

Yet another raylib wrapper for Ruby

• github.com/vaiorabbit/raylib-bindings

Defined Under Namespace

Classes: AudioStream, AutomationEvent, AutomationEventList, BoneInfo, BoundingBox, Camera2D, Camera3D, Color, FilePathList, Float16, Float3, Font, GlyphInfo, GuiStyleProp, Image, Material, MaterialMap, Matrix, Matrix2x2, Mesh, Model, ModelAnimation, ModelAnimations, Music, NPatchInfo, PhysicsBodyData, PhysicsManifoldData, PhysicsShape, PhysicsVertexData, Quaternion, Ray, RayCollision, Rectangle, RenderTexture, RlDrawCall, RlRenderBatch, RlVertexBuffer, Shader, Sound, Texture, Transform, Vector2, Vector3, Vector4, VrDeviceInfo, VrStereoConfig, Wave

Constant Summary

RLGL_VERSION =

Define/Macro

"5.0"

RL_DEFAULT_BATCH_BUFFER_ELEMENTS =

8192

RL_TEXTURE_WRAP_S =

GL_TEXTURE_WRAP_S

0x2802

RL_TEXTURE_WRAP_T =

GL_TEXTURE_WRAP_T

0x2803

RL_TEXTURE_MAG_FILTER =

GL_TEXTURE_MAG_FILTER

0x2800

RL_TEXTURE_MIN_FILTER =

GL_TEXTURE_MIN_FILTER

0x2801

RL_TEXTURE_FILTER_NEAREST =

GL_NEAREST

0x2600

RL_TEXTURE_FILTER_LINEAR =

GL_LINEAR

0x2601

RL_TEXTURE_FILTER_MIP_NEAREST =

GL_NEAREST_MIPMAP_NEAREST

0x2700

RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR =

GL_NEAREST_MIPMAP_LINEAR

0x2702

RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST =

GL_LINEAR_MIPMAP_NEAREST

0x2701

RL_TEXTURE_FILTER_MIP_LINEAR =

GL_LINEAR_MIPMAP_LINEAR

0x2703

RL_TEXTURE_FILTER_ANISOTROPIC =

Anisotropic filter (custom identifier)

0x3000

RL_TEXTURE_MIPMAP_BIAS_RATIO =

Texture mipmap bias, percentage ratio (custom identifier)

0x4000

RL_TEXTURE_WRAP_REPEAT =

GL_REPEAT

0x2901

RL_TEXTURE_WRAP_CLAMP =

GL_CLAMP_TO_EDGE

0x812F

RL_TEXTURE_WRAP_MIRROR_REPEAT =

GL_MIRRORED_REPEAT

0x8370

RL_TEXTURE_WRAP_MIRROR_CLAMP =

GL_MIRROR_CLAMP_EXT

0x8742

RL_MODELVIEW =

GL_MODELVIEW

0x1700

RL_PROJECTION =

GL_PROJECTION

0x1701

RL_TEXTURE =

GL_TEXTURE

0x1702

RL_LINES =

GL_LINES

0x0001

RL_TRIANGLES =

GL_TRIANGLES

0x0004

RL_QUADS =

GL_QUADS

0x0007

RL_UNSIGNED_BYTE =

GL_UNSIGNED_BYTE

0x1401

RL_FLOAT =

GL_FLOAT

0x1406

RL_STREAM_DRAW =

GL_STREAM_DRAW

0x88E0

RL_STREAM_READ =

GL_STREAM_READ

0x88E1

RL_STREAM_COPY =

GL_STREAM_COPY

0x88E2

RL_STATIC_DRAW =

GL_STATIC_DRAW

0x88E4

RL_STATIC_READ =

GL_STATIC_READ

0x88E5

RL_STATIC_COPY =

GL_STATIC_COPY

0x88E6

RL_DYNAMIC_DRAW =

GL_DYNAMIC_DRAW

0x88E8

RL_DYNAMIC_READ =

GL_DYNAMIC_READ

0x88E9

RL_DYNAMIC_COPY =

GL_DYNAMIC_COPY

0x88EA

RL_FRAGMENT_SHADER =

GL_FRAGMENT_SHADER

0x8B30

RL_VERTEX_SHADER =

GL_VERTEX_SHADER

0x8B31

RL_COMPUTE_SHADER =

GL_COMPUTE_SHADER

0x91B9

RL_ZERO =

GL_ZERO

0

RL_ONE =

GL_ONE

1

RL_SRC_COLOR =

GL_SRC_COLOR

0x0300

RL_ONE_MINUS_SRC_COLOR =

GL_ONE_MINUS_SRC_COLOR

0x0301

RL_SRC_ALPHA =

GL_SRC_ALPHA

0x0302

RL_ONE_MINUS_SRC_ALPHA =

GL_ONE_MINUS_SRC_ALPHA

0x0303

RL_DST_ALPHA =

GL_DST_ALPHA

0x0304

RL_ONE_MINUS_DST_ALPHA =

GL_ONE_MINUS_DST_ALPHA

0x0305

RL_DST_COLOR =

GL_DST_COLOR

0x0306

RL_ONE_MINUS_DST_COLOR =

GL_ONE_MINUS_DST_COLOR

0x0307

RL_SRC_ALPHA_SATURATE =

GL_SRC_ALPHA_SATURATE

0x0308

RL_CONSTANT_COLOR =

GL_CONSTANT_COLOR

0x8001

RL_ONE_MINUS_CONSTANT_COLOR =

GL_ONE_MINUS_CONSTANT_COLOR

0x8002

RL_CONSTANT_ALPHA =

GL_CONSTANT_ALPHA

0x8003

RL_ONE_MINUS_CONSTANT_ALPHA =

GL_ONE_MINUS_CONSTANT_ALPHA

0x8004

RL_FUNC_ADD =

GL_FUNC_ADD

0x8006

RL_MIN =

GL_MIN

0x8007

RL_MAX =

GL_MAX

0x8008

RL_FUNC_SUBTRACT =

GL_FUNC_SUBTRACT

0x800A

RL_FUNC_REVERSE_SUBTRACT =

GL_FUNC_REVERSE_SUBTRACT

0x800B

RL_BLEND_EQUATION =

GL_BLEND_EQUATION

0x8009

RL_BLEND_EQUATION_RGB =

GL_BLEND_EQUATION_RGB // (Same as BLEND_EQUATION)

0x8009

RL_BLEND_EQUATION_ALPHA =

GL_BLEND_EQUATION_ALPHA

0x883D

RL_BLEND_DST_RGB =

GL_BLEND_DST_RGB

0x80C8

RL_BLEND_SRC_RGB =

GL_BLEND_SRC_RGB

0x80C9

RL_BLEND_DST_ALPHA =

GL_BLEND_DST_ALPHA

0x80CA

RL_BLEND_SRC_ALPHA =

GL_BLEND_SRC_ALPHA

0x80CB

RL_BLEND_COLOR =

GL_BLEND_COLOR

0x8005

RL_READ_FRAMEBUFFER =

GL_READ_FRAMEBUFFER

0x8CA8

RL_DRAW_FRAMEBUFFER =

GL_DRAW_FRAMEBUFFER

0x8CA9

RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCE_TX =

9

RL_OPENGL_11 =

enum rlGlVersion OpenGL version

1

RL_OPENGL_21 =

OpenGL 1.1

2

RL_OPENGL_33 =

OpenGL 2.1 (GLSL 120)

3

RL_OPENGL_43 =

OpenGL 3.3 (GLSL 330)

4

RL_OPENGL_ES_20 =

OpenGL 4.3 (using GLSL 330)

5

RL_OPENGL_ES_30 =

OpenGL ES 2.0 (GLSL 100)

6

RL_LOG_ALL =

enum rlTraceLogLevel Trace log level

0

RL_LOG_TRACE =

Display all logs

1

RL_LOG_DEBUG =

Trace logging, intended for internal use only

2

RL_LOG_INFO =

Debug logging, used for internal debugging, it should be disabled on release builds

3

RL_LOG_WARNING =

Info logging, used for program execution info

4

RL_LOG_ERROR =

Warning logging, used on recoverable failures

5

RL_LOG_FATAL =

Error logging, used on unrecoverable failures

6

RL_LOG_NONE =

Fatal logging, used to abort program: exit(EXIT_FAILURE)

7

RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE =

enum rlPixelFormat Texture pixel formats

1

RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA =

8 bit per pixel (no alpha)

2

RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5 =

8*2 bpp (2 channels)

3

RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8 =

16 bpp

4

RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 =

24 bpp

5

RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 =

16 bpp (1 bit alpha)

6

RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 =

16 bpp (4 bit alpha)

7

RL_PIXELFORMAT_UNCOMPRESSED_R32 =

32 bpp

8

RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32 =

32 bpp (1 channel - float)

9

RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 =

32*3 bpp (3 channels - float)

10

RL_PIXELFORMAT_UNCOMPRESSED_R16 =

32*4 bpp (4 channels - float)

11

RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16 =

16 bpp (1 channel - half float)

12

RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 =

16*3 bpp (3 channels - half float)

13

RL_PIXELFORMAT_COMPRESSED_DXT1_RGB =

16*4 bpp (4 channels - half float)

14

RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA =

4 bpp (no alpha)

15

RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA =

4 bpp (1 bit alpha)

16

RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA =

8 bpp

17

RL_PIXELFORMAT_COMPRESSED_ETC1_RGB =

8 bpp

18

RL_PIXELFORMAT_COMPRESSED_ETC2_RGB =

4 bpp

19

RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA =

4 bpp

20

RL_PIXELFORMAT_COMPRESSED_PVRT_RGB =

8 bpp

21

RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA =

4 bpp

22

RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA =

4 bpp

23

RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA =

8 bpp

24

RL_TEXTURE_FILTER_POINT =

enum rlTextureFilter Texture parameters: filter mode

0

RL_TEXTURE_FILTER_BILINEAR =

No filter, just pixel approximation

1

RL_TEXTURE_FILTER_TRILINEAR =

Linear filtering

2

RL_TEXTURE_FILTER_ANISOTROPIC_4X =

Trilinear filtering (linear with mipmaps)

3

RL_TEXTURE_FILTER_ANISOTROPIC_8X =

Anisotropic filtering 4x

4

RL_TEXTURE_FILTER_ANISOTROPIC_16X =

Anisotropic filtering 8x

5

RL_BLEND_ALPHA =

enum rlBlendMode Color blending modes (pre-defined)

0

RL_BLEND_ADDITIVE =

Blend textures considering alpha (default)

1

RL_BLEND_MULTIPLIED =

Blend textures adding colors

2

RL_BLEND_ADD_COLORS =

Blend textures multiplying colors

3

RL_BLEND_SUBTRACT_COLORS =

Blend textures adding colors (alternative)

4

RL_BLEND_ALPHA_PREMULTIPLY =

Blend textures subtracting colors (alternative)

5

RL_BLEND_CUSTOM =

Blend premultiplied textures considering alpha

6

RL_BLEND_CUSTOM_SEPARATE =

Blend textures using custom src/dst factors (use rlSetBlendFactors())

7

RL_SHADER_LOC_VERTEX_POSITION =

enum rlShaderLocationIndex Shader location point type

0

RL_SHADER_LOC_VERTEX_TEXCOORD01 =

Shader location: vertex attribute: position

1

RL_SHADER_LOC_VERTEX_TEXCOORD02 =

Shader location: vertex attribute: texcoord01

2

RL_SHADER_LOC_VERTEX_NORMAL =

Shader location: vertex attribute: texcoord02

3

RL_SHADER_LOC_VERTEX_TANGENT =

Shader location: vertex attribute: normal

4

RL_SHADER_LOC_VERTEX_COLOR =

Shader location: vertex attribute: tangent

5

RL_SHADER_LOC_MATRIX_MVP =

Shader location: vertex attribute: color

6

RL_SHADER_LOC_MATRIX_VIEW =

Shader location: matrix uniform: model-view-projection

7

RL_SHADER_LOC_MATRIX_PROJECTION =

Shader location: matrix uniform: view (camera transform)

8

RL_SHADER_LOC_MATRIX_MODEL =

Shader location: matrix uniform: projection

9

RL_SHADER_LOC_MATRIX_NORMAL =

Shader location: matrix uniform: model (transform)

10

RL_SHADER_LOC_VECTOR_VIEW =

Shader location: matrix uniform: normal

11

RL_SHADER_LOC_COLOR_DIFFUSE =

Shader location: vector uniform: view

12

RL_SHADER_LOC_COLOR_SPECULAR =

Shader location: vector uniform: diffuse color

13

RL_SHADER_LOC_COLOR_AMBIENT =

Shader location: vector uniform: specular color

14

RL_SHADER_LOC_MAP_ALBEDO =

Shader location: vector uniform: ambient color

15

RL_SHADER_LOC_MAP_METALNESS =

Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE)

16

RL_SHADER_LOC_MAP_NORMAL =

Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR)

17

RL_SHADER_LOC_MAP_ROUGHNESS =

Shader location: sampler2d texture: normal

18

RL_SHADER_LOC_MAP_OCCLUSION =

Shader location: sampler2d texture: roughness

19

RL_SHADER_LOC_MAP_EMISSION =

Shader location: sampler2d texture: occlusion

20

RL_SHADER_LOC_MAP_HEIGHT =

Shader location: sampler2d texture: emission

21

RL_SHADER_LOC_MAP_CUBEMAP =

Shader location: sampler2d texture: height

22

RL_SHADER_LOC_MAP_IRRADIANCE =

Shader location: samplerCube texture: cubemap

23

RL_SHADER_LOC_MAP_PREFILTER =

Shader location: samplerCube texture: irradiance

24

RL_SHADER_LOC_MAP_BRDF =

Shader location: samplerCube texture: prefilter

25

RL_SHADER_UNIFORM_FLOAT =

enum rlShaderUniformDataType Shader uniform data type

0

RL_SHADER_UNIFORM_VEC2 =

Shader uniform type: float

1

RL_SHADER_UNIFORM_VEC3 =

Shader uniform type: vec2 (2 float)

2

RL_SHADER_UNIFORM_VEC4 =

Shader uniform type: vec3 (3 float)

3

RL_SHADER_UNIFORM_INT =

Shader uniform type: vec4 (4 float)

4

RL_SHADER_UNIFORM_IVEC2 =

Shader uniform type: int

5

RL_SHADER_UNIFORM_IVEC3 =

Shader uniform type: ivec2 (2 int)

6

RL_SHADER_UNIFORM_IVEC4 =

Shader uniform type: ivec3 (3 int)

7

RL_SHADER_UNIFORM_UINT =

Shader uniform type: ivec4 (4 int)

8

RL_SHADER_UNIFORM_UIVEC2 =

Shader uniform type: unsigned int

9

RL_SHADER_UNIFORM_UIVEC3 =

Shader uniform type: uivec2 (2 unsigned int)

10

RL_SHADER_UNIFORM_UIVEC4 =

Shader uniform type: uivec3 (3 unsigned int)

11

RL_SHADER_UNIFORM_SAMPLER2D =

Shader uniform type: uivec4 (4 unsigned int)

12

RL_SHADER_ATTRIB_FLOAT =

enum rlShaderAttributeDataType Shader attribute data types

0

RL_SHADER_ATTRIB_VEC2 =

Shader attribute type: float

1

RL_SHADER_ATTRIB_VEC3 =

Shader attribute type: vec2 (2 float)

2

RL_SHADER_ATTRIB_VEC4 =

Shader attribute type: vec3 (3 float)

3

RL_ATTACHMENT_COLOR_CHANNEL0 =

enum rlFramebufferAttachType Framebuffer attachment type

0

RL_ATTACHMENT_COLOR_CHANNEL1 =

Framebuffer attachment type: color 0

1

RL_ATTACHMENT_COLOR_CHANNEL2 =

Framebuffer attachment type: color 1

2

RL_ATTACHMENT_COLOR_CHANNEL3 =

Framebuffer attachment type: color 2

3

RL_ATTACHMENT_COLOR_CHANNEL4 =

Framebuffer attachment type: color 3

4

RL_ATTACHMENT_COLOR_CHANNEL5 =

Framebuffer attachment type: color 4

5

RL_ATTACHMENT_COLOR_CHANNEL6 =

Framebuffer attachment type: color 5

6

RL_ATTACHMENT_COLOR_CHANNEL7 =

Framebuffer attachment type: color 6

7

RL_ATTACHMENT_DEPTH =

Framebuffer attachment type: color 7

100

RL_ATTACHMENT_STENCIL =

Framebuffer attachment type: depth

200

RL_ATTACHMENT_CUBEMAP_POSITIVE_X =

enum rlFramebufferAttachTextureType Framebuffer texture attachment type

0

RL_ATTACHMENT_CUBEMAP_NEGATIVE_X =

Framebuffer texture attachment type: cubemap, +X side

1

RL_ATTACHMENT_CUBEMAP_POSITIVE_Y =

Framebuffer texture attachment type: cubemap, -X side

2

RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y =

Framebuffer texture attachment type: cubemap, +Y side

3

RL_ATTACHMENT_CUBEMAP_POSITIVE_Z =

Framebuffer texture attachment type: cubemap, -Y side

4

RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z =

Framebuffer texture attachment type: cubemap, +Z side

5

RL_ATTACHMENT_TEXTURE2D =

Framebuffer texture attachment type: cubemap, -Z side

100

RL_ATTACHMENT_RENDERBUFFER =

Framebuffer texture attachment type: texture2d

200

RL_CULL_FACE_FRONT =

enum rlCullMode Face culling mode

0

RL_CULL_FACE_BACK =

1

SUPPORT_MODULE_RSHAPES =

Define/Macro

1

SUPPORT_MODULE_RTEXTURES =

1

SUPPORT_MODULE_RTEXT =

WARNING: It requires SUPPORT_MODULE_RTEXTURES to load sprite font textures

1

SUPPORT_MODULE_RMODELS =

1

SUPPORT_MODULE_RAUDIO =

1

SUPPORT_CAMERA_SYSTEM =

1

SUPPORT_GESTURES_SYSTEM =

1

SUPPORT_RPRAND_GENERATOR =

1

SUPPORT_MOUSE_GESTURES =

1

SUPPORT_SSH_KEYBOARD_RPI =

1

SUPPORT_WINMM_HIGHRES_TIMER =

1

SUPPORT_PARTIALBUSY_WAIT_LOOP =

1

SUPPORT_SCREEN_CAPTURE =

1

SUPPORT_GIF_RECORDING =

1

SUPPORT_COMPRESSION_API =

1

SUPPORT_AUTOMATION_EVENTS =

1

SUPPORT_CLIPBOARD_IMAGE =

1

SUPPORT_FILEFORMAT_BMP =

1

SUPPORT_FILEFORMAT_PNG =

1

SUPPORT_FILEFORMAT_JPG =

1

MAX_FILEPATH_CAPACITY =

Maximum file paths capacity

8192

MAX_FILEPATH_LENGTH =

Maximum length for filepaths (Linux PATH_MAX default value)

4096

MAX_KEYBOARD_KEYS =

Maximum number of keyboard keys supported

512

MAX_MOUSE_BUTTONS =

Maximum number of mouse buttons supported

8

MAX_GAMEPADS =

Maximum number of gamepads supported

4

MAX_GAMEPAD_AXIS =

Maximum number of axis supported (per gamepad)

8

MAX_GAMEPAD_BUTTONS =

Maximum number of buttons supported (per gamepad)

32

MAX_GAMEPAD_VIBRATION_TIME =

Maximum vibration time in seconds

2.0

MAX_TOUCH_POINTS =

Maximum number of touch points supported

8

MAX_KEY_PRESSED_QUEUE =

Maximum number of keys in the key input queue

16

MAX_CHAR_PRESSED_QUEUE =

Maximum number of characters in the char input queue

16

MAX_DECOMPRESSION_SIZE =

Max size allocated for decompression in MB

64

MAX_AUTOMATION_EVENTS =

Maximum number of automation events to record

16384

RL_SUPPORT_MESH_GPU_SKINNING =

GPU skinning, comment if your GPU does not support more than 8 VBOs

1

RL_DEFAULT_BATCH_BUFFERS =

Default number of batch buffers (multi-buffering)

1

RL_DEFAULT_BATCH_DRAWCALLS =

Default number of batch draw calls (by state changes: mode, texture)

256

RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS =

Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())

4

RL_MAX_MATRIX_STACK_SIZE =

Maximum size of internal Matrix stack

32

RL_MAX_SHADER_LOCATIONS =

Maximum number of shader locations supported

32

RL_CULL_DISTANCE_NEAR =

Default projection matrix near cull distance

0.01

RL_CULL_DISTANCE_FAR =

Default projection matrix far cull distance

1000.0

RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION =

0

RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD =

1

RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL =

2

RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR =

3

RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT =

4

RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2 =

5

RL_DEFAULT_SHADER_ATTRIB_LOCATION_INDICES =

6

RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEIDS =

7

RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS =

8

RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION =

Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION

"vertexPosition"

RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD =

Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD

"vertexTexCoord"

RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL =

Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL

"vertexNormal"

RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR =

Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR

"vertexColor"

RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT =

Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT

"vertexTangent"

RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 =

Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2

"vertexTexCoord2"

RL_DEFAULT_SHADER_UNIFORM_NAME_MVP =

model-view-projection matrix

"mvp"

RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW =

view matrix

"matView"

RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION =

projection matrix

"matProjection"

RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL =

model matrix

"matModel"

RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL =

normal matrix (transpose(inverse(matModelView))

"matNormal"

RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR =

color diffuse (base tint color, multiplied by texture color)

"colDiffuse"

RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 =

texture0 (texture slot active 0)

"texture0"

RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 =

texture1 (texture slot active 1)

"texture1"

RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 =

texture2 (texture slot active 2)

"texture2"

SUPPORT_QUADS_DRAW_MODE =

1

SPLINE_SEGMENT_DIVISIONS =

Spline segments subdivisions

24

SUPPORT_FILEFORMAT_GIF =

1

SUPPORT_FILEFORMAT_QOI =

1

SUPPORT_FILEFORMAT_DDS =

1

SUPPORT_IMAGE_EXPORT =

1

SUPPORT_IMAGE_GENERATION =

1

SUPPORT_IMAGE_MANIPULATION =

1

SUPPORT_DEFAULT_FONT =

1

SUPPORT_FILEFORMAT_TTF =

1

SUPPORT_FILEFORMAT_FNT =

1

SUPPORT_TEXT_MANIPULATION =

1

SUPPORT_FONT_ATLAS_WHITE_REC =

1

MAX_TEXT_BUFFER_LENGTH =

Size of internal static buffers used on some functions:

1024

MAX_TEXTSPLIT_COUNT =

Maximum number of substrings to split: TextSplit()

128

SUPPORT_FILEFORMAT_OBJ =

1

SUPPORT_FILEFORMAT_MTL =

1

SUPPORT_FILEFORMAT_IQM =

1

SUPPORT_FILEFORMAT_GLTF =

1

SUPPORT_FILEFORMAT_VOX =

1

SUPPORT_FILEFORMAT_M3D =

1

SUPPORT_MESH_GENERATION =

1

MAX_MATERIAL_MAPS =

Maximum number of shader maps supported

12

MAX_MESH_VERTEX_BUFFERS =

Maximum vertex buffers (VBO) per mesh

9

SUPPORT_FILEFORMAT_WAV =

1

SUPPORT_FILEFORMAT_OGG =

1

SUPPORT_FILEFORMAT_MP3 =

1

SUPPORT_FILEFORMAT_QOA =

1

SUPPORT_FILEFORMAT_XM =

1

SUPPORT_FILEFORMAT_MOD =

1

AUDIO_DEVICE_CHANNELS =

Device output channels: stereo

2

AUDIO_DEVICE_SAMPLE_RATE =

Device sample rate (device default)

0

MAX_AUDIO_BUFFER_POOL_CHANNELS =

Maximum number of audio pool channels

16

SUPPORT_STANDARD_FILEIO =

1

SUPPORT_TRACELOG =

1

MAX_TRACELOG_MSG_LENGTH =

Max length of one trace-log message

256

PHYSAC_MAX_BODIES =

Define/Macro

64

PHYSAC_MAX_MANIFOLDS =

Maximum number of physic bodies supported

4096

PHYSAC_MAX_VERTICES =

Maximum number of physic bodies interactions (64x64)

24

PHYSAC_DEFAULT_CIRCLE_VERTICES =

Maximum number of vertex for polygons shapes

24

PHYSAC_COLLISION_ITERATIONS =

Default number of vertices for circle shapes

100

PHYSAC_PENETRATION_ALLOWANCE =

0.05

PHYSAC_PENETRATION_CORRECTION =

0.4

PHYSICS_CIRCLE =

enum PhysicsShapeType

0

PHYSICS_POLYGON =

1

EPSILON =

Define/Macro

0.000001

RAYGUI_VERSION_MAJOR =

Define/Macro

4

RAYGUI_VERSION_MINOR =

5

RAYGUI_VERSION_PATCH =

0

RAYGUI_VERSION =

"4.5-dev"

SCROLLBAR_LEFT_SIDE =

0

SCROLLBAR_RIGHT_SIDE =

1

STATE_NORMAL =

enum GuiState Gui control state

0

STATE_FOCUSED =

1

STATE_PRESSED =

2

STATE_DISABLED =

3

TEXT_ALIGN_LEFT =

enum GuiTextAlignment Gui control text alignment

0

TEXT_ALIGN_CENTER =

1

TEXT_ALIGN_RIGHT =

2

TEXT_ALIGN_TOP =

enum GuiTextAlignmentVertical Gui control text alignment vertical

0

TEXT_ALIGN_MIDDLE =

1

TEXT_ALIGN_BOTTOM =

2

TEXT_WRAP_NONE =

enum GuiTextWrapMode Gui control text wrap mode

0

TEXT_WRAP_CHAR =

1

TEXT_WRAP_WORD =

2

DEFAULT =

enum GuiControl Gui controls

0

LABEL =

Used also for: LABELBUTTON

1

BUTTON =

2

TOGGLE =

Used also for: TOGGLEGROUP

3

SLIDER =

Used also for: SLIDERBAR, TOGGLESLIDER

4

PROGRESSBAR =

5

CHECKBOX =

6

COMBOBOX =

7

DROPDOWNBOX =

8

TEXTBOX =

Used also for: TEXTBOXMULTI

9

VALUEBOX =

10

SPINNER =

Uses: BUTTON, VALUEBOX

11

LISTVIEW =

12

COLORPICKER =

13

SCROLLBAR =

14

STATUSBAR =

15

BORDER_COLOR_NORMAL =

enum GuiControlProperty Gui base properties for every control

0

BASE_COLOR_NORMAL =

Control border color in STATE_NORMAL

1

TEXT_COLOR_NORMAL =

Control base color in STATE_NORMAL

2

BORDER_COLOR_FOCUSED =

Control text color in STATE_NORMAL

3

BASE_COLOR_FOCUSED =

Control border color in STATE_FOCUSED

4

TEXT_COLOR_FOCUSED =

Control base color in STATE_FOCUSED

5

BORDER_COLOR_PRESSED =

Control text color in STATE_FOCUSED

6

BASE_COLOR_PRESSED =

Control border color in STATE_PRESSED

7

TEXT_COLOR_PRESSED =

Control base color in STATE_PRESSED

8

BORDER_COLOR_DISABLED =

Control text color in STATE_PRESSED

9

BASE_COLOR_DISABLED =

Control border color in STATE_DISABLED

10

TEXT_COLOR_DISABLED =

Control base color in STATE_DISABLED

11

BORDER_WIDTH =

Control text color in STATE_DISABLED

12

TEXT_PADDING =

Control border size, 0 for no border

13

TEXT_ALIGNMENT =

Control text padding, not considering border

14

TEXT_SIZE =

enum GuiDefaultProperty DEFAULT extended properties

16

TEXT_SPACING =

Text size (glyphs max height)

17

LINE_COLOR =

Text spacing between glyphs

18

BACKGROUND_COLOR =

Line control color

19

TEXT_LINE_SPACING =

Background color

20

TEXT_ALIGNMENT_VERTICAL =

Text spacing between lines

21

TEXT_WRAP_MODE =

Text vertical alignment inside text bounds (after border and padding)

22

GROUP_PADDING =

enum GuiToggleProperty Toggle/ToggleGroup

16

SLIDER_WIDTH =

enum GuiSliderProperty Slider/SliderBar

16

SLIDER_PADDING =

Slider size of internal bar

17

PROGRESS_PADDING =

enum GuiProgressBarProperty ProgressBar

16

ARROWS_SIZE =

enum GuiScrollBarProperty ScrollBar

16

ARROWS_VISIBLE =

ScrollBar arrows size

17

SCROLL_SLIDER_PADDING =

ScrollBar arrows visible

18

SCROLL_SLIDER_SIZE =

ScrollBar slider internal padding

19

SCROLL_PADDING =

ScrollBar slider size

20

SCROLL_SPEED =

ScrollBar scroll padding from arrows

21

CHECK_PADDING =

enum GuiCheckBoxProperty CheckBox

16

COMBO_BUTTON_WIDTH =

enum GuiComboBoxProperty ComboBox

16

COMBO_BUTTON_SPACING =

ComboBox right button width

17

ARROW_PADDING =

enum GuiDropdownBoxProperty DropdownBox

16

DROPDOWN_ITEMS_SPACING =

DropdownBox arrow separation from border and items

17

DROPDOWN_ARROW_HIDDEN =

DropdownBox items separation

18

DROPDOWN_ROLL_UP =

DropdownBox arrow hidden

19

TEXT_READONLY =

enum GuiTextBoxProperty TextBox/TextBoxMulti/ValueBox/Spinner

16

SPIN_BUTTON_WIDTH =

enum GuiSpinnerProperty Spinner

16

SPIN_BUTTON_SPACING =

Spinner left/right buttons width

17

LIST_ITEMS_HEIGHT =

enum GuiListViewProperty ListView

16

LIST_ITEMS_SPACING =

ListView items height

17

SCROLLBAR_WIDTH =

ListView items separation

18

SCROLLBAR_SIDE =

ListView scrollbar size (usually width)

19

LIST_ITEMS_BORDER_WIDTH =

ListView scrollbar side (0-SCROLLBAR_LEFT_SIDE, 1-SCROLLBAR_RIGHT_SIDE)

20

COLOR_SELECTOR_SIZE =

enum GuiColorPickerProperty ColorPicker

16

HUEBAR_WIDTH =

ColorPicker right hue bar width

17

HUEBAR_PADDING =

ColorPicker right hue bar separation from panel

18

HUEBAR_SELECTOR_HEIGHT =

ColorPicker right hue bar selector height

19

HUEBAR_SELECTOR_OVERFLOW =

ColorPicker right hue bar selector overflow

20

ICON_NONE =

enum GuiIconName

0

ICON_FOLDER_FILE_OPEN =

1

ICON_FILE_SAVE_CLASSIC =

2

ICON_FOLDER_OPEN =

3

ICON_FOLDER_SAVE =

4

ICON_FILE_OPEN =

5

ICON_FILE_SAVE =

6

ICON_FILE_EXPORT =

7

ICON_FILE_ADD =

8

ICON_FILE_DELETE =

9

ICON_FILETYPE_TEXT =

10

ICON_FILETYPE_AUDIO =

11

ICON_FILETYPE_IMAGE =

12

ICON_FILETYPE_PLAY =

13

ICON_FILETYPE_VIDEO =

14

ICON_FILETYPE_INFO =

15

ICON_FILE_COPY =

16

ICON_FILE_CUT =

17

ICON_FILE_PASTE =

18

ICON_CURSOR_HAND =

19

ICON_CURSOR_POINTER =

20

ICON_CURSOR_CLASSIC =

21

ICON_PENCIL =

22

ICON_PENCIL_BIG =

23

ICON_BRUSH_CLASSIC =

24

ICON_BRUSH_PAINTER =

25

ICON_WATER_DROP =

26

ICON_COLOR_PICKER =

27

ICON_RUBBER =

28

ICON_COLOR_BUCKET =

29

ICON_TEXT_T =

30

ICON_TEXT_A =

31

ICON_SCALE =

32

ICON_RESIZE =

33

ICON_FILTER_POINT =

34

ICON_FILTER_BILINEAR =

35

ICON_CROP =

36

ICON_CROP_ALPHA =

37

ICON_SQUARE_TOGGLE =

38

ICON_SYMMETRY =

39

ICON_SYMMETRY_HORIZONTAL =

40

ICON_SYMMETRY_VERTICAL =

41

ICON_LENS =

42

ICON_LENS_BIG =

43

ICON_EYE_ON =

44

ICON_EYE_OFF =

45

ICON_FILTER_TOP =

46

ICON_FILTER =

47

ICON_TARGET_POINT =

48

ICON_TARGET_SMALL =

49

ICON_TARGET_BIG =

50

ICON_TARGET_MOVE =

51

ICON_CURSOR_MOVE =

52

ICON_CURSOR_SCALE =

53

ICON_CURSOR_SCALE_RIGHT =

54

ICON_CURSOR_SCALE_LEFT =

55

ICON_UNDO =

56

ICON_REDO =

57

ICON_REREDO =

58

ICON_MUTATE =

59

ICON_ROTATE =

60

ICON_REPEAT =

61

ICON_SHUFFLE =

62

ICON_EMPTYBOX =

63

ICON_TARGET =

64

ICON_TARGET_SMALL_FILL =

65

ICON_TARGET_BIG_FILL =

66

ICON_TARGET_MOVE_FILL =

67

ICON_CURSOR_MOVE_FILL =

68

ICON_CURSOR_SCALE_FILL =

69

ICON_CURSOR_SCALE_RIGHT_FILL =

70

ICON_CURSOR_SCALE_LEFT_FILL =

71

ICON_UNDO_FILL =

72

ICON_REDO_FILL =

73

ICON_REREDO_FILL =

74

ICON_MUTATE_FILL =

75

ICON_ROTATE_FILL =

76

ICON_REPEAT_FILL =

77

ICON_SHUFFLE_FILL =

78

ICON_EMPTYBOX_SMALL =

79

ICON_BOX =

80

ICON_BOX_TOP =

81

ICON_BOX_TOP_RIGHT =

82

ICON_BOX_RIGHT =

83

ICON_BOX_BOTTOM_RIGHT =

84

ICON_BOX_BOTTOM =

85

ICON_BOX_BOTTOM_LEFT =

86

ICON_BOX_LEFT =

87

ICON_BOX_TOP_LEFT =

88

ICON_BOX_CENTER =

89

ICON_BOX_CIRCLE_MASK =

90

ICON_POT =

91

ICON_ALPHA_MULTIPLY =

92

ICON_ALPHA_CLEAR =

93

ICON_DITHERING =

94

ICON_MIPMAPS =

95

ICON_BOX_GRID =

96

ICON_GRID =

97

ICON_BOX_CORNERS_SMALL =

98

ICON_BOX_CORNERS_BIG =

99

ICON_FOUR_BOXES =

100

ICON_GRID_FILL =

101

ICON_BOX_MULTISIZE =

102

ICON_ZOOM_SMALL =

103

ICON_ZOOM_MEDIUM =

104

ICON_ZOOM_BIG =

105

ICON_ZOOM_ALL =

106

ICON_ZOOM_CENTER =

107

ICON_BOX_DOTS_SMALL =

108

ICON_BOX_DOTS_BIG =

109

ICON_BOX_CONCENTRIC =

110

ICON_BOX_GRID_BIG =

111

ICON_OK_TICK =

112

ICON_CROSS =

113

ICON_ARROW_LEFT =

114

ICON_ARROW_RIGHT =

115

ICON_ARROW_DOWN =

116

ICON_ARROW_UP =

117

ICON_ARROW_LEFT_FILL =

118

ICON_ARROW_RIGHT_FILL =

119

ICON_ARROW_DOWN_FILL =

120

ICON_ARROW_UP_FILL =

121

ICON_AUDIO =

122

ICON_FX =

123

ICON_WAVE =

124

ICON_WAVE_SINUS =

125

ICON_WAVE_SQUARE =

126

ICON_WAVE_TRIANGULAR =

127

ICON_CROSS_SMALL =

128

ICON_PLAYER_PREVIOUS =

129

ICON_PLAYER_PLAY_BACK =

130

ICON_PLAYER_PLAY =

131

ICON_PLAYER_PAUSE =

132

ICON_PLAYER_STOP =

133

ICON_PLAYER_NEXT =

134

ICON_PLAYER_RECORD =

135

ICON_MAGNET =

136

ICON_LOCK_CLOSE =

137

ICON_LOCK_OPEN =

138

ICON_CLOCK =

139

ICON_TOOLS =

140

ICON_GEAR =

141

ICON_GEAR_BIG =

142

ICON_BIN =

143

ICON_HAND_POINTER =

144

ICON_LASER =

145

ICON_COIN =

146

ICON_EXPLOSION =

147

ICON_1UP =

148

ICON_PLAYER =

149

ICON_PLAYER_JUMP =

150

ICON_KEY =

151

ICON_DEMON =

152

ICON_TEXT_POPUP =

153

ICON_GEAR_EX =

154

ICON_CRACK =

155

ICON_CRACK_POINTS =

156

ICON_STAR =

157

ICON_DOOR =

158

ICON_EXIT =

159

ICON_MODE_2D =

160

ICON_MODE_3D =

161

ICON_CUBE =

162

ICON_CUBE_FACE_TOP =

163

ICON_CUBE_FACE_LEFT =

164

ICON_CUBE_FACE_FRONT =

165

ICON_CUBE_FACE_BOTTOM =

166

ICON_CUBE_FACE_RIGHT =

167

ICON_CUBE_FACE_BACK =

168

ICON_CAMERA =

169

ICON_SPECIAL =

170

ICON_LINK_NET =

171

ICON_LINK_BOXES =

172

ICON_LINK_MULTI =

173

ICON_LINK =

174

ICON_LINK_BROKE =

175

ICON_TEXT_NOTES =

176

ICON_NOTEBOOK =

177

ICON_SUITCASE =

178

ICON_SUITCASE_ZIP =

179

ICON_MAILBOX =

180

ICON_MONITOR =

181

ICON_PRINTER =

182

ICON_PHOTO_CAMERA =

183

ICON_PHOTO_CAMERA_FLASH =

184

ICON_HOUSE =

185

ICON_HEART =

186

ICON_CORNER =

187

ICON_VERTICAL_BARS =

188

ICON_VERTICAL_BARS_FILL =

189

ICON_LIFE_BARS =

190

ICON_INFO =

191

ICON_CROSSLINE =

192

ICON_HELP =

193

ICON_FILETYPE_ALPHA =

194

ICON_FILETYPE_HOME =

195

ICON_LAYERS_VISIBLE =

196

ICON_LAYERS =

197

ICON_WINDOW =

198

ICON_HIDPI =

199

ICON_FILETYPE_BINARY =

200

ICON_HEX =

201

ICON_SHIELD =

202

ICON_FILE_NEW =

203

ICON_FOLDER_ADD =

204

ICON_ALARM =

205

ICON_CPU =

206

ICON_ROM =

207

ICON_STEP_OVER =

208

ICON_STEP_INTO =

209

ICON_STEP_OUT =

210

ICON_RESTART =

211

ICON_BREAKPOINT_ON =

212

ICON_BREAKPOINT_OFF =

213

ICON_BURGER_MENU =

214

ICON_CASE_SENSITIVE =

215

ICON_REG_EXP =

216

ICON_FOLDER =

217

ICON_FILE =

218

ICON_SAND_TIMER =

219

ICON_WARNING =

220

ICON_HELP_BOX =

221

ICON_INFO_BOX =

222

ICON_PRIORITY =

223

ICON_LAYERS_ISO =

224

ICON_LAYERS2 =

225

ICON_MLAYERS =

226

ICON_MAPS =

227

ICON_HOT =

228

ICON_229 =

229

ICON_230 =

230

ICON_231 =

231

ICON_232 =

232

ICON_233 =

233

ICON_234 =

234

ICON_235 =

235

ICON_236 =

236

ICON_237 =

237

ICON_238 =

238

ICON_239 =

239

ICON_240 =

240

ICON_241 =

241

ICON_242 =

242

ICON_243 =

243

ICON_244 =

244

ICON_245 =

245

ICON_246 =

246

ICON_247 =

247

ICON_248 =

248

ICON_249 =

249

ICON_250 =

250

ICON_251 =

251

ICON_252 =

252

ICON_253 =

253

ICON_254 =

254

ICON_255 =

255

RAYLIB_VERSION_MAJOR =

Define/Macro

5

RAYLIB_VERSION_MINOR =

6

RAYLIB_VERSION_PATCH =

0

RAYLIB_VERSION =

"5.6-dev"

FLAG_VSYNC_HINT =

enum ConfigFlags System/Window config flags

64

FLAG_FULLSCREEN_MODE =

Set to try enabling V-Sync on GPU

2

FLAG_WINDOW_RESIZABLE =

Set to run program in fullscreen

4

FLAG_WINDOW_UNDECORATED =

Set to allow resizable window

8

FLAG_WINDOW_HIDDEN =

Set to disable window decoration (frame and buttons)

128

FLAG_WINDOW_MINIMIZED =

Set to hide window

512

FLAG_WINDOW_MAXIMIZED =

Set to minimize window (iconify)

1024

FLAG_WINDOW_UNFOCUSED =

Set to maximize window (expanded to monitor)

2048

FLAG_WINDOW_TOPMOST =

Set to window non focused

4096

FLAG_WINDOW_ALWAYS_RUN =

Set to window always on top

256

FLAG_WINDOW_TRANSPARENT =

Set to allow windows running while minimized

16

FLAG_WINDOW_HIGHDPI =

Set to allow transparent framebuffer

8192

FLAG_WINDOW_MOUSE_PASSTHROUGH =

Set to support HighDPI

16384

FLAG_BORDERLESS_WINDOWED_MODE =

Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED

32768

FLAG_MSAA_4X_HINT =

Set to run program in borderless windowed mode

32

FLAG_INTERLACED_HINT =

Set to try enabling MSAA 4X

65536

LOG_ALL =

enum TraceLogLevel Trace log level

0

LOG_TRACE =

Display all logs

1

LOG_DEBUG =

Trace logging, intended for internal use only

2

LOG_INFO =

Debug logging, used for internal debugging, it should be disabled on release builds

3

LOG_WARNING =

Info logging, used for program execution info

4

LOG_ERROR =

Warning logging, used on recoverable failures

5

LOG_FATAL =

Error logging, used on unrecoverable failures

6

LOG_NONE =

Fatal logging, used to abort program: exit(EXIT_FAILURE)

7

KEY_NULL =

enum KeyboardKey Keyboard keys (US keyboard layout)

0

KEY_APOSTROPHE =

Key: NULL, used for no key pressed

39

KEY_COMMA =

Key: ‘

44

KEY_MINUS =

Key: ,

45

KEY_PERIOD =

Key: -

46

KEY_SLASH =

Key: .

47

KEY_ZERO =

Key: /

48

KEY_ONE =

Key: 0

49

KEY_TWO =

Key: 1

50

KEY_THREE =

Key: 2

51

KEY_FOUR =

Key: 3

52

KEY_FIVE =

Key: 4

53

KEY_SIX =

Key: 5

54

KEY_SEVEN =

Key: 6

55

KEY_EIGHT =

Key: 7

56

KEY_NINE =

Key: 8

57

KEY_SEMICOLON =

Key: 9

59

KEY_EQUAL =

Key: ;

61

KEY_A =

Key: =

65

KEY_B =

Key: A | a

66

KEY_C =

Key: B | b

67

KEY_D =

Key: C | c

68

KEY_E =

Key: D | d

69

KEY_F =

Key: E | e

70

KEY_G =

Key: F | f

71

KEY_H =

Key: G | g

72

KEY_I =

Key: H | h

73

KEY_J =

Key: I | i

74

KEY_K =

Key: J | j

75

KEY_L =

Key: K | k

76

KEY_M =

Key: L | l

77

KEY_N =

Key: M | m

78

KEY_O =

Key: N | n

79

KEY_P =

Key: O | o

80

KEY_Q =

Key: P | p

81

KEY_R =

Key: Q | q

82

KEY_S =

Key: R | r

83

KEY_T =

Key: S | s

84

KEY_U =

Key: T | t

85

KEY_V =

Key: U | u

86

KEY_W =

Key: V | v

87

KEY_X =

Key: W | w

88

KEY_Y =

Key: X | x

89

KEY_Z =

Key: Y | y

90

KEY_LEFT_BRACKET =

Key: Z | z

91

KEY_BACKSLASH =

Key: [

92

KEY_RIGHT_BRACKET =

Key: ‘'

93

KEY_GRAVE =

Key: ]

96

KEY_SPACE =

Key: ‘

32

KEY_ESCAPE =

Key: Space

256

KEY_ENTER =

Key: Esc

257

KEY_TAB =

Key: Enter

258

KEY_BACKSPACE =

Key: Tab

259

KEY_INSERT =

Key: Backspace

260

KEY_DELETE =

Key: Ins

261

KEY_RIGHT =

Key: Del

262

KEY_LEFT =

Key: Cursor right

263

KEY_DOWN =

Key: Cursor left

264

KEY_UP =

Key: Cursor down

265

KEY_PAGE_UP =

Key: Cursor up

266

KEY_PAGE_DOWN =

Key: Page up

267

KEY_HOME =

Key: Page down

268

KEY_END =

Key: Home

269

KEY_CAPS_LOCK =

Key: End

280

KEY_SCROLL_LOCK =

Key: Caps lock

281

KEY_NUM_LOCK =

Key: Scroll down

282

KEY_PRINT_SCREEN =

Key: Num lock

283

KEY_PAUSE =

Key: Print screen

284

KEY_F1 =

Key: Pause

290

KEY_F2 =

Key: F1

291

KEY_F3 =

Key: F2

292

KEY_F4 =

Key: F3

293

KEY_F5 =

Key: F4

294

KEY_F6 =

Key: F5

295

KEY_F7 =

Key: F6

296

KEY_F8 =

Key: F7

297

KEY_F9 =

Key: F8

298

KEY_F10 =

Key: F9

299

KEY_F11 =

Key: F10

300

KEY_F12 =

Key: F11

301

KEY_LEFT_SHIFT =

Key: F12

340

KEY_LEFT_CONTROL =

Key: Shift left

341

KEY_LEFT_ALT =

Key: Control left

342

KEY_LEFT_SUPER =

Key: Alt left

343

KEY_RIGHT_SHIFT =

Key: Super left

344

KEY_RIGHT_CONTROL =

Key: Shift right

345

KEY_RIGHT_ALT =

Key: Control right

346

KEY_RIGHT_SUPER =

Key: Alt right

347

KEY_KB_MENU =

Key: Super right

348

KEY_KP_0 =

Key: KB menu

320

KEY_KP_1 =

Key: Keypad 0

321

KEY_KP_2 =

Key: Keypad 1

322

KEY_KP_3 =

Key: Keypad 2

323

KEY_KP_4 =

Key: Keypad 3

324

KEY_KP_5 =

Key: Keypad 4

325

KEY_KP_6 =

Key: Keypad 5

326

KEY_KP_7 =

Key: Keypad 6

327

KEY_KP_8 =

Key: Keypad 7

328

KEY_KP_9 =

Key: Keypad 8

329

KEY_KP_DECIMAL =

Key: Keypad 9

330

KEY_KP_DIVIDE =

Key: Keypad .

331

KEY_KP_MULTIPLY =

Key: Keypad /

332

KEY_KP_SUBTRACT =

Key: Keypad *

333

KEY_KP_ADD =

Key: Keypad -

334

KEY_KP_ENTER =

Key: Keypad +

335

KEY_KP_EQUAL =

Key: Keypad Enter

336

KEY_BACK =

Key: Keypad =

4

KEY_MENU =

Key: Android back button

5

KEY_VOLUME_UP =

Key: Android menu button

24

KEY_VOLUME_DOWN =

Key: Android volume up button

25

MOUSE_BUTTON_LEFT =

enum MouseButton Mouse buttons

0

MOUSE_BUTTON_RIGHT =

Mouse button left

1

MOUSE_BUTTON_MIDDLE =

Mouse button right

2

MOUSE_BUTTON_SIDE =

Mouse button middle (pressed wheel)

3

MOUSE_BUTTON_EXTRA =

Mouse button side (advanced mouse device)

4

MOUSE_BUTTON_FORWARD =

Mouse button extra (advanced mouse device)

5

MOUSE_BUTTON_BACK =

Mouse button forward (advanced mouse device)

6

MOUSE_CURSOR_DEFAULT =

enum MouseCursor Mouse cursor

0

MOUSE_CURSOR_ARROW =

Default pointer shape

1

MOUSE_CURSOR_IBEAM =

Arrow shape

2

MOUSE_CURSOR_CROSSHAIR =

Text writing cursor shape

3

MOUSE_CURSOR_POINTING_HAND =

Cross shape

4

MOUSE_CURSOR_RESIZE_EW =

Pointing hand cursor

5

MOUSE_CURSOR_RESIZE_NS =

Horizontal resize/move arrow shape

6

MOUSE_CURSOR_RESIZE_NWSE =

Vertical resize/move arrow shape

7

MOUSE_CURSOR_RESIZE_NESW =

Top-left to bottom-right diagonal resize/move arrow shape

8

MOUSE_CURSOR_RESIZE_ALL =

The top-right to bottom-left diagonal resize/move arrow shape

9

MOUSE_CURSOR_NOT_ALLOWED =

The omnidirectional resize/move cursor shape

10

GAMEPAD_BUTTON_UNKNOWN =

enum GamepadButton Gamepad buttons

0

GAMEPAD_BUTTON_LEFT_FACE_UP =

Unknown button, just for error checking

1

GAMEPAD_BUTTON_LEFT_FACE_RIGHT =

Gamepad left DPAD up button

2

GAMEPAD_BUTTON_LEFT_FACE_DOWN =

Gamepad left DPAD right button

3

GAMEPAD_BUTTON_LEFT_FACE_LEFT =

Gamepad left DPAD down button

4

GAMEPAD_BUTTON_RIGHT_FACE_UP =

Gamepad left DPAD left button

5

GAMEPAD_BUTTON_RIGHT_FACE_RIGHT =

Gamepad right button up (i.e. PS3: Triangle, Xbox: Y)

6

GAMEPAD_BUTTON_RIGHT_FACE_DOWN =

Gamepad right button right (i.e. PS3: Circle, Xbox: B)

7

GAMEPAD_BUTTON_RIGHT_FACE_LEFT =

Gamepad right button down (i.e. PS3: Cross, Xbox: A)

8

GAMEPAD_BUTTON_LEFT_TRIGGER_1 =

Gamepad right button left (i.e. PS3: Square, Xbox: X)

9

GAMEPAD_BUTTON_LEFT_TRIGGER_2 =

Gamepad top/back trigger left (first), it could be a trailing button

10

GAMEPAD_BUTTON_RIGHT_TRIGGER_1 =

Gamepad top/back trigger left (second), it could be a trailing button

11

GAMEPAD_BUTTON_RIGHT_TRIGGER_2 =

Gamepad top/back trigger right (first), it could be a trailing button

12

GAMEPAD_BUTTON_MIDDLE_LEFT =

Gamepad top/back trigger right (second), it could be a trailing button

13

GAMEPAD_BUTTON_MIDDLE =

Gamepad center buttons, left one (i.e. PS3: Select)

14

GAMEPAD_BUTTON_MIDDLE_RIGHT =

Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX)

15

GAMEPAD_BUTTON_LEFT_THUMB =

Gamepad center buttons, right one (i.e. PS3: Start)

16

GAMEPAD_BUTTON_RIGHT_THUMB =

Gamepad joystick pressed button left

17

GAMEPAD_AXIS_LEFT_X =

enum GamepadAxis Gamepad axis

0

GAMEPAD_AXIS_LEFT_Y =

Gamepad left stick X axis

1

GAMEPAD_AXIS_RIGHT_X =

Gamepad left stick Y axis

2

GAMEPAD_AXIS_RIGHT_Y =

Gamepad right stick X axis

3

GAMEPAD_AXIS_LEFT_TRIGGER =

Gamepad right stick Y axis

4

GAMEPAD_AXIS_RIGHT_TRIGGER =

Gamepad back trigger left, pressure level: [1..-1]

5

MATERIAL_MAP_ALBEDO =

enum MaterialMapIndex Material map index

0

MATERIAL_MAP_METALNESS =

Albedo material (same as: MATERIAL_MAP_DIFFUSE)

1

MATERIAL_MAP_NORMAL =

Metalness material (same as: MATERIAL_MAP_SPECULAR)

2

MATERIAL_MAP_ROUGHNESS =

Normal material

3

MATERIAL_MAP_OCCLUSION =

Roughness material

4

MATERIAL_MAP_EMISSION =

Ambient occlusion material

5

MATERIAL_MAP_HEIGHT =

Emission material

6

MATERIAL_MAP_CUBEMAP =

Heightmap material

7

MATERIAL_MAP_IRRADIANCE =

Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP)

8

MATERIAL_MAP_PREFILTER =

Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP)

9

MATERIAL_MAP_BRDF =

Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP)

10

SHADER_LOC_VERTEX_POSITION =

enum ShaderLocationIndex Shader location index

0

SHADER_LOC_VERTEX_TEXCOORD01 =

Shader location: vertex attribute: position

1

SHADER_LOC_VERTEX_TEXCOORD02 =

Shader location: vertex attribute: texcoord01

2

SHADER_LOC_VERTEX_NORMAL =

Shader location: vertex attribute: texcoord02

3

SHADER_LOC_VERTEX_TANGENT =

Shader location: vertex attribute: normal

4

SHADER_LOC_VERTEX_COLOR =

Shader location: vertex attribute: tangent

5

SHADER_LOC_MATRIX_MVP =

Shader location: vertex attribute: color

6

SHADER_LOC_MATRIX_VIEW =

Shader location: matrix uniform: model-view-projection

7

SHADER_LOC_MATRIX_PROJECTION =

Shader location: matrix uniform: view (camera transform)

8

SHADER_LOC_MATRIX_MODEL =

Shader location: matrix uniform: projection

9

SHADER_LOC_MATRIX_NORMAL =

Shader location: matrix uniform: model (transform)

10

SHADER_LOC_VECTOR_VIEW =

Shader location: matrix uniform: normal

11

SHADER_LOC_COLOR_DIFFUSE =

Shader location: vector uniform: view

12

SHADER_LOC_COLOR_SPECULAR =

Shader location: vector uniform: diffuse color

13

SHADER_LOC_COLOR_AMBIENT =

Shader location: vector uniform: specular color

14

SHADER_LOC_MAP_ALBEDO =

Shader location: vector uniform: ambient color

15

SHADER_LOC_MAP_METALNESS =

Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE)

16

SHADER_LOC_MAP_NORMAL =

Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR)

17

SHADER_LOC_MAP_ROUGHNESS =

Shader location: sampler2d texture: normal

18

SHADER_LOC_MAP_OCCLUSION =

Shader location: sampler2d texture: roughness

19

SHADER_LOC_MAP_EMISSION =

Shader location: sampler2d texture: occlusion

20

SHADER_LOC_MAP_HEIGHT =

Shader location: sampler2d texture: emission

21

SHADER_LOC_MAP_CUBEMAP =

Shader location: sampler2d texture: height

22

SHADER_LOC_MAP_IRRADIANCE =

Shader location: samplerCube texture: cubemap

23

SHADER_LOC_MAP_PREFILTER =

Shader location: samplerCube texture: irradiance

24

SHADER_LOC_MAP_BRDF =

Shader location: samplerCube texture: prefilter

25

SHADER_LOC_VERTEX_BONEIDS =

Shader location: sampler2d texture: brdf

26

SHADER_LOC_VERTEX_BONEWEIGHTS =

Shader location: vertex attribute: boneIds

27

SHADER_LOC_BONE_MATRICES =

Shader location: vertex attribute: boneWeights

28

SHADER_LOC_VERTEX_INSTANCE_TX =

Shader location: array of matrices uniform: boneMatrices

29

SHADER_UNIFORM_FLOAT =

enum ShaderUniformDataType Shader uniform data type

0

SHADER_UNIFORM_VEC2 =

Shader uniform type: float

1

SHADER_UNIFORM_VEC3 =

Shader uniform type: vec2 (2 float)

2

SHADER_UNIFORM_VEC4 =

Shader uniform type: vec3 (3 float)

3

SHADER_UNIFORM_INT =

Shader uniform type: vec4 (4 float)

4

SHADER_UNIFORM_IVEC2 =

Shader uniform type: int

5

SHADER_UNIFORM_IVEC3 =

Shader uniform type: ivec2 (2 int)

6

SHADER_UNIFORM_IVEC4 =

Shader uniform type: ivec3 (3 int)

7

SHADER_UNIFORM_UINT =

Shader uniform type: ivec4 (4 int)

8

SHADER_UNIFORM_UIVEC2 =

Shader uniform type: unsigned int

9

SHADER_UNIFORM_UIVEC3 =

Shader uniform type: uivec2 (2 unsigned int)

10

SHADER_UNIFORM_UIVEC4 =

Shader uniform type: uivec3 (3 unsigned int)

11

SHADER_UNIFORM_SAMPLER2D =

Shader uniform type: uivec4 (4 unsigned int)

12

SHADER_ATTRIB_FLOAT =

enum ShaderAttributeDataType Shader attribute data types

0

SHADER_ATTRIB_VEC2 =

Shader attribute type: float

1

SHADER_ATTRIB_VEC3 =

Shader attribute type: vec2 (2 float)

2

SHADER_ATTRIB_VEC4 =

Shader attribute type: vec3 (3 float)

3

PIXELFORMAT_UNCOMPRESSED_GRAYSCALE =

enum PixelFormat Pixel formats

1

PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA =

8 bit per pixel (no alpha)

2

PIXELFORMAT_UNCOMPRESSED_R5G6B5 =

8*2 bpp (2 channels)

3

PIXELFORMAT_UNCOMPRESSED_R8G8B8 =

16 bpp

4

PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 =

24 bpp

5

PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 =

16 bpp (1 bit alpha)

6

PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 =

16 bpp (4 bit alpha)

7

PIXELFORMAT_UNCOMPRESSED_R32 =

32 bpp

8

PIXELFORMAT_UNCOMPRESSED_R32G32B32 =

32 bpp (1 channel - float)

9

PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 =

32*3 bpp (3 channels - float)

10

PIXELFORMAT_UNCOMPRESSED_R16 =

32*4 bpp (4 channels - float)

11

PIXELFORMAT_UNCOMPRESSED_R16G16B16 =

16 bpp (1 channel - half float)

12

PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 =

16*3 bpp (3 channels - half float)

13

PIXELFORMAT_COMPRESSED_DXT1_RGB =

16*4 bpp (4 channels - half float)

14

PIXELFORMAT_COMPRESSED_DXT1_RGBA =

4 bpp (no alpha)

15

PIXELFORMAT_COMPRESSED_DXT3_RGBA =

4 bpp (1 bit alpha)

16

PIXELFORMAT_COMPRESSED_DXT5_RGBA =

8 bpp

17

PIXELFORMAT_COMPRESSED_ETC1_RGB =

8 bpp

18

PIXELFORMAT_COMPRESSED_ETC2_RGB =

4 bpp

19

PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA =

4 bpp

20

PIXELFORMAT_COMPRESSED_PVRT_RGB =

8 bpp

21

PIXELFORMAT_COMPRESSED_PVRT_RGBA =

4 bpp

22

PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA =

4 bpp

23

PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA =

8 bpp

24

TEXTURE_FILTER_POINT =

enum TextureFilter Texture parameters: filter mode

0

TEXTURE_FILTER_BILINEAR =

No filter, just pixel approximation

1

TEXTURE_FILTER_TRILINEAR =

Linear filtering

2

TEXTURE_FILTER_ANISOTROPIC_4X =

Trilinear filtering (linear with mipmaps)

3

TEXTURE_FILTER_ANISOTROPIC_8X =

Anisotropic filtering 4x

4

TEXTURE_FILTER_ANISOTROPIC_16X =

Anisotropic filtering 8x

5

TEXTURE_WRAP_REPEAT =

enum TextureWrap Texture parameters: wrap mode

0

TEXTURE_WRAP_CLAMP =

Repeats texture in tiled mode

1

TEXTURE_WRAP_MIRROR_REPEAT =

Clamps texture to edge pixel in tiled mode

2

TEXTURE_WRAP_MIRROR_CLAMP =

Mirrors and repeats the texture in tiled mode

3

CUBEMAP_LAYOUT_AUTO_DETECT =

enum CubemapLayout Cubemap layouts

0

CUBEMAP_LAYOUT_LINE_VERTICAL =

Automatically detect layout type

1

CUBEMAP_LAYOUT_LINE_HORIZONTAL =

Layout is defined by a vertical line with faces

2

CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR =

Layout is defined by a horizontal line with faces

3

CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE =

Layout is defined by a 3x4 cross with cubemap faces

4

FONT_DEFAULT =

enum FontType Font type, defines generation method

0

FONT_BITMAP =

Default font generation, anti-aliased

1

FONT_SDF =

Bitmap font generation, no anti-aliasing

2

BLEND_ALPHA =

enum BlendMode Color blending modes (pre-defined)

0

BLEND_ADDITIVE =

Blend textures considering alpha (default)

1

BLEND_MULTIPLIED =

Blend textures adding colors

2

BLEND_ADD_COLORS =

Blend textures multiplying colors

3

BLEND_SUBTRACT_COLORS =

Blend textures adding colors (alternative)

4

BLEND_ALPHA_PREMULTIPLY =

Blend textures subtracting colors (alternative)

5

BLEND_CUSTOM =

Blend premultiplied textures considering alpha

6

BLEND_CUSTOM_SEPARATE =

Blend textures using custom src/dst factors (use rlSetBlendFactors())

7

GESTURE_NONE =

enum Gesture Gesture

0

GESTURE_TAP =

No gesture

1

GESTURE_DOUBLETAP =

Tap gesture

2

GESTURE_HOLD =

Double tap gesture

4

GESTURE_DRAG =

Hold gesture

8

GESTURE_SWIPE_RIGHT =

Drag gesture

16

GESTURE_SWIPE_LEFT =

Swipe right gesture

32

GESTURE_SWIPE_UP =

Swipe left gesture

64

GESTURE_SWIPE_DOWN =

Swipe up gesture

128

GESTURE_PINCH_IN =

Swipe down gesture

256

GESTURE_PINCH_OUT =

Pinch in gesture

512

CAMERA_CUSTOM =

enum CameraMode Camera system modes

0

CAMERA_FREE =

Camera custom, controlled by user (UpdateCamera() does nothing)

1

CAMERA_ORBITAL =

Camera free mode

2

CAMERA_FIRST_PERSON =

Camera orbital, around target, zoom supported

3

CAMERA_THIRD_PERSON =

Camera first person

4

CAMERA_PERSPECTIVE =

enum CameraProjection Camera projection

0

CAMERA_ORTHOGRAPHIC =

Perspective projection

1

NPATCH_NINE_PATCH =

enum NPatchLayout N-patch layout

0

NPATCH_THREE_PATCH_VERTICAL =

Npatch layout: 3x3 tiles

1

NPATCH_THREE_PATCH_HORIZONTAL =

Npatch layout: 1x3 tiles

2

Texture2D =

Texture

TextureCubemap =

Texture

RenderTexture2D =

RenderTexture

Camera =

Camera3D

LIGHTGRAY =

Color.from_u8(200, 200, 200, 255)

GRAY =

Color.from_u8(130, 130, 130, 255)

DARKGRAY =

Color.from_u8(80, 80, 80, 255)

YELLOW =

Color.from_u8(253, 249, 0, 255)

GOLD =

Color.from_u8(255, 203, 0, 255)

ORANGE =

Color.from_u8(255, 161, 0, 255)

PINK =

Color.from_u8(255, 109, 194, 255)

RED =

Color.from_u8(230, 41, 55, 255)

MAROON =

Color.from_u8(190, 33, 55, 255)

GREEN =

Color.from_u8(0, 228, 48, 255)

LIME =

Color.from_u8(0, 158, 47, 255)

DARKGREEN =

Color.from_u8(0, 117, 44, 255)

SKYBLUE =

Color.from_u8(102, 191, 255, 255)

BLUE =

Color.from_u8(0, 121, 241, 255)

DARKBLUE =

Color.from_u8(0, 82, 172, 255)

PURPLE =

Color.from_u8(200, 122, 255, 255)

VIOLET =

Color.from_u8(135, 60, 190, 255)

DARKPURPLE =

Color.from_u8(112, 31, 126, 255)

BEIGE =

Color.from_u8(211, 176, 131, 255)

BROWN =

Color.from_u8(127, 106, 79, 255)

DARKBROWN =

Color.from_u8(76, 63, 47, 255)

WHITE =

Color.from_u8(255, 255, 255, 255)

BLACK =

Color.from_u8(0, 0, 0, 255)

BLANK =

Color.from_u8(0, 0, 0, 0)

MAGENTA =

Color.from_u8(255, 0, 255, 255)

RAYWHITE =

Color.from_u8(245, 245, 245, 255)

DEG2RAD =

Math helper

Math::PI / 180.0

RAD2DEG =

180.0 / Math::PI

Class Method Summary

• .load_lib(libpath, raygui_libpath: nil, physac_libpath: nil, method_naming: :original) ⇒ Object
• .setup_physac_symbols(method_naming: :original) ⇒ Object

  Function.

• .setup_raygui_symbols(method_naming: :original) ⇒ Object

  Function.

• .setup_raylib_symbols(method_naming: :original) ⇒ Object

  Function.

• .setup_raymath_symbols(method_naming: :original) ⇒ Object

  Function.

• .setup_rcamera_symbols(method_naming: :original) ⇒ Object

  Function.

• .setup_rlgl_symbols(method_naming: :original) ⇒ Object

  Function.

• .setup_symbols(method_naming: :original) ⇒ Object
• .template ⇒ Object

  Generate sample code.

Instance Method Summary

• #DrawModelEx(model, position, rotationAxis, rotationAngle, scale, tint) ⇒ void

  DrawModelEx : Draw a model with extended parameters.

• #LoadAndAllocateModelAnimations(fileName) ⇒ Object

  LoadAndAllocateModelAnimations : (ruby raylib original).

• #MatrixToFloat(mat) ⇒ Object
• #RGuiCheckBox(bounds, text, checked) ⇒ Object
• #RGuiColorBarAlpha(bounds, text, alpha) ⇒ Object
• #RGuiColorBarHue(bounds, text, value) ⇒ Object
• #RGuiComboBox(bounds, text, active) ⇒ Object
• #RGuiDropdownBox(bounds, text, active, editMode) ⇒ Object
• #RGuiListView(bounds, text, scrollIndex, active) ⇒ Object
• #RGuiListViewEx(bounds, text, count, scrollIndex, active, focus) ⇒ Object
• #RGuiProgressBar(bounds, textLeft, textRight, value, minValue, maxValue) ⇒ Object
• #RGuiSlider(bounds, textLeft, textRight, value, minValue, maxValue) ⇒ Object
• #RGuiSliderBar(bounds, textLeft, textRight, value, minValue, maxValue) ⇒ Object
• #RGuiSpinner(bounds, text, value, minValue, maxValue, editMode) ⇒ Object
• #RGuiTabBar(bounds, text, count, active) ⇒ Object
• #RGuiToggle(bounds, text, active) ⇒ Object
• #RGuiToggleGroup(bounds, text, active) ⇒ Object
• #RGuiToggleSlider(bounds, text, active) ⇒ Object
• #RGuiValueBox(bounds, text, value, minValue, maxValue, editMode) ⇒ Object
• #UnloadAndFreeModelAnimations(anims, anim_ptrs) ⇒ Object

  UnloadAndFreeModelAnimations : (ruby raylib original).

• #Vector3ToFloat(vec) ⇒ Object

Class Method Details

.load_lib(libpath, raygui_libpath: nil, physac_libpath: nil, method_naming: :original) ⇒ Object

# File 'lib/raylib.rb', line 20

def self.load_lib(libpath, raygui_libpath: nil, physac_libpath: nil, method_naming: :original)
  lib_paths = [libpath, raygui_libpath, physac_libpath].compact

  ffi_lib_flags :now, :global
  ffi_lib(*lib_paths)
  setup_symbols(method_naming: method_naming)

  setup_raygui_symbols(method_naming: method_naming) unless raygui_libpath.nil?
  setup_physac_symbols(method_naming: method_naming) unless physac_libpath.nil?
rescue LoadError => e
  warn e
end

.setup_physac_symbols(method_naming: :original) ⇒ Object

Function

# File 'lib/physac.rb', line 189

def self.setup_physac_symbols(method_naming: :original)
  entries = [

    # @!method InitPhysics()
    #   InitPhysics : Initializes physics system
    #   @return [void]
    [:InitPhysics, :InitPhysics, [], :void],

    # @!method UpdatePhysics()
    #   UpdatePhysics : Update physics system
    #   @return [void]
    [:UpdatePhysics, :UpdatePhysics, [], :void],

    # @!method ResetPhysics()
    #   ResetPhysics : Reset physics system (global variables)
    #   @return [void]
    [:ResetPhysics, :ResetPhysics, [], :void],

    # @!method ClosePhysics()
    #   ClosePhysics : Close physics system and unload used memory
    #   @return [void]
    [:ClosePhysics, :ClosePhysics, [], :void],

    # @!method SetPhysicsTimeStep(delta)
    #   SetPhysicsTimeStep : Sets physics fixed time step in milliseconds. 1.666666 by default
    #   @param delta [double]
    #   @return [void]
    [:SetPhysicsTimeStep, :SetPhysicsTimeStep, [:double], :void],

    # @!method SetPhysicsGravity(x, y)
    #   SetPhysicsGravity : Sets physics global gravity force
    #   @param x [float]
    #   @param y [float]
    #   @return [void]
    [:SetPhysicsGravity, :SetPhysicsGravity, [:float, :float], :void],

    # @!method CreatePhysicsBodyCircle(pos, radius, density)
    #   CreatePhysicsBodyCircle : Creates a new circle physics body with generic parameters
    #   @param pos [Vector2]
    #   @param radius [float]
    #   @param density [float]
    #   @return [PhysicsBody]
    [:CreatePhysicsBodyCircle, :CreatePhysicsBodyCircle, [Vector2.by_value, :float, :float], :pointer],

    # @!method CreatePhysicsBodyRectangle(pos, width, height, density)
    #   CreatePhysicsBodyRectangle : Creates a new rectangle physics body with generic parameters
    #   @param pos [Vector2]
    #   @param width [float]
    #   @param height [float]
    #   @param density [float]
    #   @return [PhysicsBody]
    [:CreatePhysicsBodyRectangle, :CreatePhysicsBodyRectangle, [Vector2.by_value, :float, :float, :float], :pointer],

    # @!method CreatePhysicsBodyPolygon(pos, radius, sides, density)
    #   CreatePhysicsBodyPolygon : Creates a new polygon physics body with generic parameters
    #   @param pos [Vector2]
    #   @param radius [float]
    #   @param sides [int]
    #   @param density [float]
    #   @return [PhysicsBody]
    [:CreatePhysicsBodyPolygon, :CreatePhysicsBodyPolygon, [Vector2.by_value, :float, :int, :float], :pointer],

    # @!method DestroyPhysicsBody(body)
    #   DestroyPhysicsBody : Destroy a physics body
    #   @param body [PhysicsBody]
    #   @return [void]
    [:DestroyPhysicsBody, :DestroyPhysicsBody, [:pointer], :void],

    # @!method PhysicsAddForce(body, force)
    #   PhysicsAddForce : Adds a force to a physics body
    #   @param body [PhysicsBody]
    #   @param force [Vector2]
    #   @return [void]
    [:PhysicsAddForce, :PhysicsAddForce, [:pointer, Vector2.by_value], :void],

    # @!method PhysicsAddTorque(body, amount)
    #   PhysicsAddTorque : Adds an angular force to a physics body
    #   @param body [PhysicsBody]
    #   @param amount [float]
    #   @return [void]
    [:PhysicsAddTorque, :PhysicsAddTorque, [:pointer, :float], :void],

    # @!method PhysicsShatter(body, position, force)
    #   PhysicsShatter : Shatters a polygon shape physics body to little physics bodies with explosion force
    #   @param body [PhysicsBody]
    #   @param position [Vector2]
    #   @param force [float]
    #   @return [void]
    [:PhysicsShatter, :PhysicsShatter, [:pointer, Vector2.by_value, :float], :void],

    # @!method SetPhysicsBodyRotation(body, radians)
    #   SetPhysicsBodyRotation : Sets physics body shape transform based on radians parameter
    #   @param body [PhysicsBody]
    #   @param radians [float]
    #   @return [void]
    [:SetPhysicsBodyRotation, :SetPhysicsBodyRotation, [:pointer, :float], :void],

    # @!method GetPhysicsBody(index)
    #   GetPhysicsBody : Returns a physics body of the bodies pool at a specific index
    #   @param index [int]
    #   @return [PhysicsBody]
    [:GetPhysicsBody, :GetPhysicsBody, [:int], :pointer],

    # @!method GetPhysicsBodiesCount()
    #   GetPhysicsBodiesCount : Returns the current amount of created physics bodies
    #   @return [int]
    [:GetPhysicsBodiesCount, :GetPhysicsBodiesCount, [], :int],

    # @!method GetPhysicsShapeType(index)
    #   GetPhysicsShapeType : Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
    #   @param index [int]
    #   @return [int]
    [:GetPhysicsShapeType, :GetPhysicsShapeType, [:int], :int],

    # @!method GetPhysicsShapeVerticesCount(index)
    #   GetPhysicsShapeVerticesCount : Returns the amount of vertices of a physics body shape
    #   @param index [int]
    #   @return [int]
    [:GetPhysicsShapeVerticesCount, :GetPhysicsShapeVerticesCount, [:int], :int],

    # @!method GetPhysicsShapeVertex(body, vertex)
    #   GetPhysicsShapeVertex : Returns transformed position of a body shape (body position + vertex transformed position)
    #   @param body [PhysicsBody]
    #   @param vertex [int]
    #   @return [Vector2]
    [:GetPhysicsShapeVertex, :GetPhysicsShapeVertex, [:pointer, :int], Vector2.by_value],
  ]
  entries.each do |entry|
    api_name = if method_naming == :snake_case
                 snake_case_name = entry[0].to_s.gsub(/([A-Z]+)([A-Z0-9][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z0-9])/, '\1_\2').downcase
                 snake_case_name.gsub!('vector_3', 'vector3_') if snake_case_name.include?('vector_3')
                 snake_case_name.gsub!('vector_2', 'vector2_') if snake_case_name.include?('vector_2')
                 snake_case_name.chop! if snake_case_name.end_with?('_')
                 snake_case_name.to_sym
               else
                 entry[0]
               end
    attach_function api_name, entry[1], entry[2], entry[3]
  rescue FFI::NotFoundError => e
    warn "[Warning] Failed to import #{entry[0]} (#{e})."
  end
end

.setup_raygui_symbols(method_naming: :original) ⇒ Object

Function

# File 'lib/raygui_main.rb', line 460

def self.setup_raygui_symbols(method_naming: :original)
  entries = [

    # @!method GuiEnable()
    #   GuiEnable : Enable gui controls (global state)
    #   @return [void]
    [:GuiEnable, :GuiEnable, [], :void],

    # @!method GuiDisable()
    #   GuiDisable : Disable gui controls (global state)
    #   @return [void]
    [:GuiDisable, :GuiDisable, [], :void],

    # @!method GuiLock()
    #   GuiLock : Lock gui controls (global state)
    #   @return [void]
    [:GuiLock, :GuiLock, [], :void],

    # @!method GuiUnlock()
    #   GuiUnlock : Unlock gui controls (global state)
    #   @return [void]
    [:GuiUnlock, :GuiUnlock, [], :void],

    # @!method GuiIsLocked()
    #   GuiIsLocked : Check if gui is locked (global state)
    #   @return [bool]
    [:GuiIsLocked, :GuiIsLocked, [], :bool],

    # @!method GuiSetAlpha(alpha)
    #   GuiSetAlpha : Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f
    #   @param alpha [float]
    #   @return [void]
    [:GuiSetAlpha, :GuiSetAlpha, [:float], :void],

    # @!method GuiSetState(state)
    #   GuiSetState : Set gui state (global state)
    #   @param state [int]
    #   @return [void]
    [:GuiSetState, :GuiSetState, [:int], :void],

    # @!method GuiGetState()
    #   GuiGetState : Get gui state (global state)
    #   @return [int]
    [:GuiGetState, :GuiGetState, [], :int],

    # @!method GuiSetFont(font)
    #   GuiSetFont : Set gui custom font (global state)
    #   @param font [Font]
    #   @return [void]
    [:GuiSetFont, :GuiSetFont, [Font.by_value], :void],

    # @!method GuiGetFont()
    #   GuiGetFont : Get gui custom font (global state)
    #   @return [Font]
    [:GuiGetFont, :GuiGetFont, [], Font.by_value],

    # @!method GuiSetStyle(control, property, value)
    #   GuiSetStyle : Set one style property
    #   @param control [int]
    #   @param property [int]
    #   @param value [int]
    #   @return [void]
    [:GuiSetStyle, :GuiSetStyle, [:int, :int, :int], :void],

    # @!method GuiGetStyle(control, property)
    #   GuiGetStyle : Get one style property
    #   @param control [int]
    #   @param property [int]
    #   @return [int]
    [:GuiGetStyle, :GuiGetStyle, [:int, :int], :int],

    # @!method GuiLoadStyle(fileName)
    #   GuiLoadStyle : Load style file over global style variable (.rgs)
    #   @param fileName [const char *]
    #   @return [void]
    [:GuiLoadStyle, :GuiLoadStyle, [:pointer], :void],

    # @!method GuiLoadStyleDefault()
    #   GuiLoadStyleDefault : Load style default over global style
    #   @return [void]
    [:GuiLoadStyleDefault, :GuiLoadStyleDefault, [], :void],

    # @!method GuiEnableTooltip()
    #   GuiEnableTooltip : Enable gui tooltips (global state)
    #   @return [void]
    [:GuiEnableTooltip, :GuiEnableTooltip, [], :void],

    # @!method GuiDisableTooltip()
    #   GuiDisableTooltip : Disable gui tooltips (global state)
    #   @return [void]
    [:GuiDisableTooltip, :GuiDisableTooltip, [], :void],

    # @!method GuiSetTooltip(tooltip)
    #   GuiSetTooltip : Set tooltip string
    #   @param tooltip [const char *]
    #   @return [void]
    [:GuiSetTooltip, :GuiSetTooltip, [:pointer], :void],

    # @!method GuiIconText(iconId, text)
    #   GuiIconText : Get text with icon id prepended (if supported)
    #   @param iconId [int]
    #   @param text [const char *]
    #   @return [const char *]
    [:GuiIconText, :GuiIconText, [:int, :pointer], :pointer],

    # @!method GuiSetIconScale(scale)
    #   GuiSetIconScale : Set default icon drawing size
    #   @param scale [int]
    #   @return [void]
    [:GuiSetIconScale, :GuiSetIconScale, [:int], :void],

    # @!method GuiGetIcons()
    #   GuiGetIcons : Get raygui icons data pointer
    #   @return [unsigned int *]
    [:GuiGetIcons, :GuiGetIcons, [], :pointer],

    # @!method GuiLoadIcons(fileName, loadIconsName)
    #   GuiLoadIcons : Load raygui icons file (.rgi) into internal icons data
    #   @param fileName [const char *]
    #   @param loadIconsName [bool]
    #   @return [char **]
    [:GuiLoadIcons, :GuiLoadIcons, [:pointer, :bool], :pointer],

    # @!method GuiDrawIcon(iconId, posX, posY, pixelSize, color)
    #   GuiDrawIcon : Draw icon using pixel size at specified position
    #   @param iconId [int]
    #   @param posX [int]
    #   @param posY [int]
    #   @param pixelSize [int]
    #   @param color [Color]
    #   @return [void]
    [:GuiDrawIcon, :GuiDrawIcon, [:int, :int, :int, :int, Color.by_value], :void],

    # @!method GuiWindowBox(bounds, title)
    #   GuiWindowBox : Window Box control, shows a window that can be closed
    #   @param bounds [Rectangle]
    #   @param title [const char *]
    #   @return [int]
    [:GuiWindowBox, :GuiWindowBox, [Rectangle.by_value, :pointer], :int],

    # @!method GuiGroupBox(bounds, text)
    #   GuiGroupBox : Group Box control with text name
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @return [int]
    [:GuiGroupBox, :GuiGroupBox, [Rectangle.by_value, :pointer], :int],

    # @!method GuiLine(bounds, text)
    #   GuiLine : Line separator control, could contain text
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @return [int]
    [:GuiLine, :GuiLine, [Rectangle.by_value, :pointer], :int],

    # @!method GuiPanel(bounds, text)
    #   GuiPanel : Panel control, useful to group controls
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @return [int]
    [:GuiPanel, :GuiPanel, [Rectangle.by_value, :pointer], :int],

    # @!method GuiTabBar(bounds, text, count, active)
    #   GuiTabBar : Tab Bar control, returns TAB to be closed or -1
    #   @param bounds [Rectangle]
    #   @param text [const char **]
    #   @param count [int]
    #   @param active [int *]
    #   @return [int]
    [:GuiTabBar, :GuiTabBar, [Rectangle.by_value, :pointer, :int, :pointer], :int],

    # @!method GuiScrollPanel(bounds, text, content, scroll, view)
    #   GuiScrollPanel : Scroll Panel control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param content [Rectangle]
    #   @param scroll [Vector2 *]
    #   @param view [Rectangle *]
    #   @return [int]
    [:GuiScrollPanel, :GuiScrollPanel, [Rectangle.by_value, :pointer, Rectangle.by_value, :pointer, :pointer], :int],

    # @!method GuiLabel(bounds, text)
    #   GuiLabel : Label control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @return [int]
    [:GuiLabel, :GuiLabel, [Rectangle.by_value, :pointer], :int],

    # @!method GuiButton(bounds, text)
    #   GuiButton : Button control, returns true when clicked
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @return [int]
    [:GuiButton, :GuiButton, [Rectangle.by_value, :pointer], :int],

    # @!method GuiLabelButton(bounds, text)
    #   GuiLabelButton : Label button control, returns true when clicked
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @return [int]
    [:GuiLabelButton, :GuiLabelButton, [Rectangle.by_value, :pointer], :int],

    # @!method GuiToggle(bounds, text, active)
    #   GuiToggle : Toggle Button control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param active [bool *]
    #   @return [int]
    [:GuiToggle, :GuiToggle, [Rectangle.by_value, :pointer, :pointer], :int],

    # @!method GuiToggleGroup(bounds, text, active)
    #   GuiToggleGroup : Toggle Group control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param active [int *]
    #   @return [int]
    [:GuiToggleGroup, :GuiToggleGroup, [Rectangle.by_value, :pointer, :pointer], :int],

    # @!method GuiToggleSlider(bounds, text, active)
    #   GuiToggleSlider : Toggle Slider control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param active [int *]
    #   @return [int]
    [:GuiToggleSlider, :GuiToggleSlider, [Rectangle.by_value, :pointer, :pointer], :int],

    # @!method GuiCheckBox(bounds, text, checked)
    #   GuiCheckBox : Check Box control, returns true when active
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param checked [bool *]
    #   @return [int]
    [:GuiCheckBox, :GuiCheckBox, [Rectangle.by_value, :pointer, :pointer], :int],

    # @!method GuiComboBox(bounds, text, active)
    #   GuiComboBox : Combo Box control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param active [int *]
    #   @return [int]
    [:GuiComboBox, :GuiComboBox, [Rectangle.by_value, :pointer, :pointer], :int],

    # @!method GuiDropdownBox(bounds, text, active, editMode)
    #   GuiDropdownBox : Dropdown Box control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param active [int *]
    #   @param editMode [bool]
    #   @return [int]
    [:GuiDropdownBox, :GuiDropdownBox, [Rectangle.by_value, :pointer, :pointer, :bool], :int],

    # @!method GuiSpinner(bounds, text, value, minValue, maxValue, editMode)
    #   GuiSpinner : Spinner control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param value [int *]
    #   @param minValue [int]
    #   @param maxValue [int]
    #   @param editMode [bool]
    #   @return [int]
    [:GuiSpinner, :GuiSpinner, [Rectangle.by_value, :pointer, :pointer, :int, :int, :bool], :int],

    # @!method GuiValueBox(bounds, text, value, minValue, maxValue, editMode)
    #   GuiValueBox : Value Box control, updates input text with numbers
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param value [int *]
    #   @param minValue [int]
    #   @param maxValue [int]
    #   @param editMode [bool]
    #   @return [int]
    [:GuiValueBox, :GuiValueBox, [Rectangle.by_value, :pointer, :pointer, :int, :int, :bool], :int],

    # @!method GuiValueBoxFloat(bounds, text, textValue, value, editMode)
    #   GuiValueBoxFloat : Value box control for float values
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param textValue [char *]
    #   @param value [float *]
    #   @param editMode [bool]
    #   @return [int]
    [:GuiValueBoxFloat, :GuiValueBoxFloat, [Rectangle.by_value, :pointer, :pointer, :pointer, :bool], :int],

    # @!method GuiTextBox(bounds, text, textSize, editMode)
    #   GuiTextBox : Text Box control, updates input text
    #   @param bounds [Rectangle]
    #   @param text [char *]
    #   @param textSize [int]
    #   @param editMode [bool]
    #   @return [int]
    [:GuiTextBox, :GuiTextBox, [Rectangle.by_value, :pointer, :int, :bool], :int],

    # @!method GuiSlider(bounds, textLeft, textRight, value, minValue, maxValue)
    #   GuiSlider : Slider control
    #   @param bounds [Rectangle]
    #   @param textLeft [const char *]
    #   @param textRight [const char *]
    #   @param value [float *]
    #   @param minValue [float]
    #   @param maxValue [float]
    #   @return [int]
    [:GuiSlider, :GuiSlider, [Rectangle.by_value, :pointer, :pointer, :pointer, :float, :float], :int],

    # @!method GuiSliderBar(bounds, textLeft, textRight, value, minValue, maxValue)
    #   GuiSliderBar : Slider Bar control
    #   @param bounds [Rectangle]
    #   @param textLeft [const char *]
    #   @param textRight [const char *]
    #   @param value [float *]
    #   @param minValue [float]
    #   @param maxValue [float]
    #   @return [int]
    [:GuiSliderBar, :GuiSliderBar, [Rectangle.by_value, :pointer, :pointer, :pointer, :float, :float], :int],

    # @!method GuiProgressBar(bounds, textLeft, textRight, value, minValue, maxValue)
    #   GuiProgressBar : Progress Bar control
    #   @param bounds [Rectangle]
    #   @param textLeft [const char *]
    #   @param textRight [const char *]
    #   @param value [float *]
    #   @param minValue [float]
    #   @param maxValue [float]
    #   @return [int]
    [:GuiProgressBar, :GuiProgressBar, [Rectangle.by_value, :pointer, :pointer, :pointer, :float, :float], :int],

    # @!method GuiStatusBar(bounds, text)
    #   GuiStatusBar : Status Bar control, shows info text
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @return [int]
    [:GuiStatusBar, :GuiStatusBar, [Rectangle.by_value, :pointer], :int],

    # @!method GuiDummyRec(bounds, text)
    #   GuiDummyRec : Dummy control for placeholders
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @return [int]
    [:GuiDummyRec, :GuiDummyRec, [Rectangle.by_value, :pointer], :int],

    # @!method GuiGrid(bounds, text, spacing, subdivs, mouseCell)
    #   GuiGrid : Grid control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param spacing [float]
    #   @param subdivs [int]
    #   @param mouseCell [Vector2 *]
    #   @return [int]
    [:GuiGrid, :GuiGrid, [Rectangle.by_value, :pointer, :float, :int, :pointer], :int],

    # @!method GuiListView(bounds, text, scrollIndex, active)
    #   GuiListView : List View control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param scrollIndex [int *]
    #   @param active [int *]
    #   @return [int]
    [:GuiListView, :GuiListView, [Rectangle.by_value, :pointer, :pointer, :pointer], :int],

    # @!method GuiListViewEx(bounds, text, count, scrollIndex, active, focus)
    #   GuiListViewEx : List View with extended parameters
    #   @param bounds [Rectangle]
    #   @param text [const char **]
    #   @param count [int]
    #   @param scrollIndex [int *]
    #   @param active [int *]
    #   @param focus [int *]
    #   @return [int]
    [:GuiListViewEx, :GuiListViewEx, [Rectangle.by_value, :pointer, :int, :pointer, :pointer, :pointer], :int],

    # @!method GuiMessageBox(bounds, title, message, buttons)
    #   GuiMessageBox : Message Box control, displays a message
    #   @param bounds [Rectangle]
    #   @param title [const char *]
    #   @param message [const char *]
    #   @param buttons [const char *]
    #   @return [int]
    [:GuiMessageBox, :GuiMessageBox, [Rectangle.by_value, :pointer, :pointer, :pointer], :int],

    # @!method GuiTextInputBox(bounds, title, message, buttons, text, textMaxSize, secretViewActive)
    #   GuiTextInputBox : Text Input Box control, ask for text, supports secret
    #   @param bounds [Rectangle]
    #   @param title [const char *]
    #   @param message [const char *]
    #   @param buttons [const char *]
    #   @param text [char *]
    #   @param textMaxSize [int]
    #   @param secretViewActive [bool *]
    #   @return [int]
    [:GuiTextInputBox, :GuiTextInputBox, [Rectangle.by_value, :pointer, :pointer, :pointer, :pointer, :int, :pointer], :int],

    # @!method GuiColorPicker(bounds, text, color)
    #   GuiColorPicker : Color Picker control (multiple color controls)
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param color [Color *]
    #   @return [int]
    [:GuiColorPicker, :GuiColorPicker, [Rectangle.by_value, :pointer, :pointer], :int],

    # @!method GuiColorPanel(bounds, text, color)
    #   GuiColorPanel : Color Panel control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param color [Color *]
    #   @return [int]
    [:GuiColorPanel, :GuiColorPanel, [Rectangle.by_value, :pointer, :pointer], :int],

    # @!method GuiColorBarAlpha(bounds, text, alpha)
    #   GuiColorBarAlpha : Color Bar Alpha control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param alpha [float *]
    #   @return [int]
    [:GuiColorBarAlpha, :GuiColorBarAlpha, [Rectangle.by_value, :pointer, :pointer], :int],

    # @!method GuiColorBarHue(bounds, text, value)
    #   GuiColorBarHue : Color Bar Hue control
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param value [float *]
    #   @return [int]
    [:GuiColorBarHue, :GuiColorBarHue, [Rectangle.by_value, :pointer, :pointer], :int],

    # @!method GuiColorPickerHSV(bounds, text, colorHsv)
    #   GuiColorPickerHSV : Color Picker control that avoids conversion to RGB on each call (multiple color controls)
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param colorHsv [Vector3 *]
    #   @return [int]
    [:GuiColorPickerHSV, :GuiColorPickerHSV, [Rectangle.by_value, :pointer, :pointer], :int],

    # @!method GuiColorPanelHSV(bounds, text, colorHsv)
    #   GuiColorPanelHSV : Color Panel control that updates Hue-Saturation-Value color value, used by GuiColorPickerHSV()
    #   @param bounds [Rectangle]
    #   @param text [const char *]
    #   @param colorHsv [Vector3 *]
    #   @return [int]
    [:GuiColorPanelHSV, :GuiColorPanelHSV, [Rectangle.by_value, :pointer, :pointer], :int],
  ]
  entries.each do |entry|
    api_name = if method_naming == :snake_case
                 snake_case_name = entry[0].to_s.gsub(/([A-Z]+)([A-Z0-9][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z0-9])/, '\1_\2').downcase
                 snake_case_name.gsub!('vector_3', 'vector3_') if snake_case_name.include?('vector_3')
                 snake_case_name.gsub!('vector_2', 'vector2_') if snake_case_name.include?('vector_2')
                 snake_case_name.chop! if snake_case_name.end_with?('_')
                 snake_case_name.to_sym
               else
                 entry[0]
               end
    attach_function api_name, entry[1], entry[2], entry[3]
  rescue FFI::NotFoundError => e
    warn "[Warning] Failed to import #{entry[0]} (#{e})."
  end
end

.setup_raylib_symbols(method_naming: :original) ⇒ Object

Function

# File 'lib/raylib_main.rb', line 1139

def self.setup_raylib_symbols(method_naming: :original)
  entries = [

    # @!method InitWindow(width, height, title)
    #   InitWindow : Initialize window and OpenGL context
    #   @param width [int]
    #   @param height [int]
    #   @param title [const char *]
    #   @return [void]
    [:InitWindow, :InitWindow, [:int, :int, :pointer], :void],

    # @!method CloseWindow()
    #   CloseWindow : Close window and unload OpenGL context
    #   @return [void]
    [:CloseWindow, :CloseWindow, [], :void],

    # @!method WindowShouldClose()
    #   WindowShouldClose : Check if application should close (KEY_ESCAPE pressed or windows close icon clicked)
    #   @return [bool]
    [:WindowShouldClose, :WindowShouldClose, [], :bool],

    # @!method IsWindowReady()
    #   IsWindowReady : Check if window has been initialized successfully
    #   @return [bool]
    [:IsWindowReady, :IsWindowReady, [], :bool],

    # @!method IsWindowFullscreen()
    #   IsWindowFullscreen : Check if window is currently fullscreen
    #   @return [bool]
    [:IsWindowFullscreen, :IsWindowFullscreen, [], :bool],

    # @!method IsWindowHidden()
    #   IsWindowHidden : Check if window is currently hidden
    #   @return [bool]
    [:IsWindowHidden, :IsWindowHidden, [], :bool],

    # @!method IsWindowMinimized()
    #   IsWindowMinimized : Check if window is currently minimized
    #   @return [bool]
    [:IsWindowMinimized, :IsWindowMinimized, [], :bool],

    # @!method IsWindowMaximized()
    #   IsWindowMaximized : Check if window is currently maximized
    #   @return [bool]
    [:IsWindowMaximized, :IsWindowMaximized, [], :bool],

    # @!method IsWindowFocused()
    #   IsWindowFocused : Check if window is currently focused
    #   @return [bool]
    [:IsWindowFocused, :IsWindowFocused, [], :bool],

    # @!method IsWindowResized()
    #   IsWindowResized : Check if window has been resized last frame
    #   @return [bool]
    [:IsWindowResized, :IsWindowResized, [], :bool],

    # @!method IsWindowState(flag)
    #   IsWindowState : Check if one specific window flag is enabled
    #   @param flag [unsigned int]
    #   @return [bool]
    [:IsWindowState, :IsWindowState, [:uint], :bool],

    # @!method SetWindowState(flags)
    #   SetWindowState : Set window configuration state using flags
    #   @param flags [unsigned int]
    #   @return [void]
    [:SetWindowState, :SetWindowState, [:uint], :void],

    # @!method ClearWindowState(flags)
    #   ClearWindowState : Clear window configuration state flags
    #   @param flags [unsigned int]
    #   @return [void]
    [:ClearWindowState, :ClearWindowState, [:uint], :void],

    # @!method ToggleFullscreen()
    #   ToggleFullscreen : Toggle window state: fullscreen/windowed, resizes monitor to match window resolution
    #   @return [void]
    [:ToggleFullscreen, :ToggleFullscreen, [], :void],

    # @!method ToggleBorderlessWindowed()
    #   ToggleBorderlessWindowed : Toggle window state: borderless windowed, resizes window to match monitor resolution
    #   @return [void]
    [:ToggleBorderlessWindowed, :ToggleBorderlessWindowed, [], :void],

    # @!method MaximizeWindow()
    #   MaximizeWindow : Set window state: maximized, if resizable
    #   @return [void]
    [:MaximizeWindow, :MaximizeWindow, [], :void],

    # @!method MinimizeWindow()
    #   MinimizeWindow : Set window state: minimized, if resizable
    #   @return [void]
    [:MinimizeWindow, :MinimizeWindow, [], :void],

    # @!method RestoreWindow()
    #   RestoreWindow : Set window state: not minimized/maximized
    #   @return [void]
    [:RestoreWindow, :RestoreWindow, [], :void],

    # @!method SetWindowIcon(image)
    #   SetWindowIcon : Set icon for window (single image, RGBA 32bit)
    #   @param image [Image]
    #   @return [void]
    [:SetWindowIcon, :SetWindowIcon, [Image.by_value], :void],

    # @!method SetWindowIcons(images, count)
    #   SetWindowIcons : Set icon for window (multiple images, RGBA 32bit)
    #   @param images [Image *]
    #   @param count [int]
    #   @return [void]
    [:SetWindowIcons, :SetWindowIcons, [:pointer, :int], :void],

    # @!method SetWindowTitle(title)
    #   SetWindowTitle : Set title for window
    #   @param title [const char *]
    #   @return [void]
    [:SetWindowTitle, :SetWindowTitle, [:pointer], :void],

    # @!method SetWindowPosition(x, y)
    #   SetWindowPosition : Set window position on screen
    #   @param x [int]
    #   @param y [int]
    #   @return [void]
    [:SetWindowPosition, :SetWindowPosition, [:int, :int], :void],

    # @!method SetWindowMonitor(monitor)
    #   SetWindowMonitor : Set monitor for the current window
    #   @param monitor [int]
    #   @return [void]
    [:SetWindowMonitor, :SetWindowMonitor, [:int], :void],

    # @!method SetWindowMinSize(width, height)
    #   SetWindowMinSize : Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
    #   @param width [int]
    #   @param height [int]
    #   @return [void]
    [:SetWindowMinSize, :SetWindowMinSize, [:int, :int], :void],

    # @!method SetWindowMaxSize(width, height)
    #   SetWindowMaxSize : Set window maximum dimensions (for FLAG_WINDOW_RESIZABLE)
    #   @param width [int]
    #   @param height [int]
    #   @return [void]
    [:SetWindowMaxSize, :SetWindowMaxSize, [:int, :int], :void],

    # @!method SetWindowSize(width, height)
    #   SetWindowSize : Set window dimensions
    #   @param width [int]
    #   @param height [int]
    #   @return [void]
    [:SetWindowSize, :SetWindowSize, [:int, :int], :void],

    # @!method SetWindowOpacity(opacity)
    #   SetWindowOpacity : Set window opacity [0.0f..1.0f]
    #   @param opacity [float]
    #   @return [void]
    [:SetWindowOpacity, :SetWindowOpacity, [:float], :void],

    # @!method SetWindowFocused()
    #   SetWindowFocused : Set window focused
    #   @return [void]
    [:SetWindowFocused, :SetWindowFocused, [], :void],

    # @!method GetWindowHandle()
    #   GetWindowHandle : Get native window handle
    #   @return [void *]
    [:GetWindowHandle, :GetWindowHandle, [], :pointer],

    # @!method GetScreenWidth()
    #   GetScreenWidth : Get current screen width
    #   @return [int]
    [:GetScreenWidth, :GetScreenWidth, [], :int],

    # @!method GetScreenHeight()
    #   GetScreenHeight : Get current screen height
    #   @return [int]
    [:GetScreenHeight, :GetScreenHeight, [], :int],

    # @!method GetRenderWidth()
    #   GetRenderWidth : Get current render width (it considers HiDPI)
    #   @return [int]
    [:GetRenderWidth, :GetRenderWidth, [], :int],

    # @!method GetRenderHeight()
    #   GetRenderHeight : Get current render height (it considers HiDPI)
    #   @return [int]
    [:GetRenderHeight, :GetRenderHeight, [], :int],

    # @!method GetMonitorCount()
    #   GetMonitorCount : Get number of connected monitors
    #   @return [int]
    [:GetMonitorCount, :GetMonitorCount, [], :int],

    # @!method GetCurrentMonitor()
    #   GetCurrentMonitor : Get current monitor where window is placed
    #   @return [int]
    [:GetCurrentMonitor, :GetCurrentMonitor, [], :int],

    # @!method GetMonitorPosition(monitor)
    #   GetMonitorPosition : Get specified monitor position
    #   @param monitor [int]
    #   @return [Vector2]
    [:GetMonitorPosition, :GetMonitorPosition, [:int], Vector2.by_value],

    # @!method GetMonitorWidth(monitor)
    #   GetMonitorWidth : Get specified monitor width (current video mode used by monitor)
    #   @param monitor [int]
    #   @return [int]
    [:GetMonitorWidth, :GetMonitorWidth, [:int], :int],

    # @!method GetMonitorHeight(monitor)
    #   GetMonitorHeight : Get specified monitor height (current video mode used by monitor)
    #   @param monitor [int]
    #   @return [int]
    [:GetMonitorHeight, :GetMonitorHeight, [:int], :int],

    # @!method GetMonitorPhysicalWidth(monitor)
    #   GetMonitorPhysicalWidth : Get specified monitor physical width in millimetres
    #   @param monitor [int]
    #   @return [int]
    [:GetMonitorPhysicalWidth, :GetMonitorPhysicalWidth, [:int], :int],

    # @!method GetMonitorPhysicalHeight(monitor)
    #   GetMonitorPhysicalHeight : Get specified monitor physical height in millimetres
    #   @param monitor [int]
    #   @return [int]
    [:GetMonitorPhysicalHeight, :GetMonitorPhysicalHeight, [:int], :int],

    # @!method GetMonitorRefreshRate(monitor)
    #   GetMonitorRefreshRate : Get specified monitor refresh rate
    #   @param monitor [int]
    #   @return [int]
    [:GetMonitorRefreshRate, :GetMonitorRefreshRate, [:int], :int],

    # @!method GetWindowPosition()
    #   GetWindowPosition : Get window position XY on monitor
    #   @return [Vector2]
    [:GetWindowPosition, :GetWindowPosition, [], Vector2.by_value],

    # @!method GetWindowScaleDPI()
    #   GetWindowScaleDPI : Get window scale DPI factor
    #   @return [Vector2]
    [:GetWindowScaleDPI, :GetWindowScaleDPI, [], Vector2.by_value],

    # @!method GetMonitorName(monitor)
    #   GetMonitorName : Get the human-readable, UTF-8 encoded name of the specified monitor
    #   @param monitor [int]
    #   @return [const char *]
    [:GetMonitorName, :GetMonitorName, [:int], :pointer],

    # @!method SetClipboardText(text)
    #   SetClipboardText : Set clipboard text content
    #   @param text [const char *]
    #   @return [void]
    [:SetClipboardText, :SetClipboardText, [:pointer], :void],

    # @!method GetClipboardText()
    #   GetClipboardText : Get clipboard text content
    #   @return [const char *]
    [:GetClipboardText, :GetClipboardText, [], :pointer],

    # @!method GetClipboardImage()
    #   GetClipboardImage : Get clipboard image content
    #   @return [Image]
    [:GetClipboardImage, :GetClipboardImage, [], Image.by_value],

    # @!method EnableEventWaiting()
    #   EnableEventWaiting : Enable waiting for events on EndDrawing(), no automatic event polling
    #   @return [void]
    [:EnableEventWaiting, :EnableEventWaiting, [], :void],

    # @!method DisableEventWaiting()
    #   DisableEventWaiting : Disable waiting for events on EndDrawing(), automatic events polling
    #   @return [void]
    [:DisableEventWaiting, :DisableEventWaiting, [], :void],

    # @!method ShowCursor()
    #   ShowCursor : Shows cursor
    #   @return [void]
    [:ShowCursor, :ShowCursor, [], :void],

    # @!method HideCursor()
    #   HideCursor : Hides cursor
    #   @return [void]
    [:HideCursor, :HideCursor, [], :void],

    # @!method IsCursorHidden()
    #   IsCursorHidden : Check if cursor is not visible
    #   @return [bool]
    [:IsCursorHidden, :IsCursorHidden, [], :bool],

    # @!method EnableCursor()
    #   EnableCursor : Enables cursor (unlock cursor)
    #   @return [void]
    [:EnableCursor, :EnableCursor, [], :void],

    # @!method DisableCursor()
    #   DisableCursor : Disables cursor (lock cursor)
    #   @return [void]
    [:DisableCursor, :DisableCursor, [], :void],

    # @!method IsCursorOnScreen()
    #   IsCursorOnScreen : Check if cursor is on the screen
    #   @return [bool]
    [:IsCursorOnScreen, :IsCursorOnScreen, [], :bool],

    # @!method ClearBackground(color)
    #   ClearBackground : Set background color (framebuffer clear color)
    #   @param color [Color]
    #   @return [void]
    [:ClearBackground, :ClearBackground, [Color.by_value], :void],

    # @!method BeginDrawing()
    #   BeginDrawing : Setup canvas (framebuffer) to start drawing
    #   @return [void]
    [:BeginDrawing, :BeginDrawing, [], :void],

    # @!method EndDrawing()
    #   EndDrawing : End canvas drawing and swap buffers (double buffering)
    #   @return [void]
    [:EndDrawing, :EndDrawing, [], :void],

    # @!method BeginMode2D(camera)
    #   BeginMode2D : Begin 2D mode with custom camera (2D)
    #   @param camera [Camera2D]
    #   @return [void]
    [:BeginMode2D, :BeginMode2D, [Camera2D.by_value], :void],

    # @!method EndMode2D()
    #   EndMode2D : Ends 2D mode with custom camera
    #   @return [void]
    [:EndMode2D, :EndMode2D, [], :void],

    # @!method BeginMode3D(camera)
    #   BeginMode3D : Begin 3D mode with custom camera (3D)
    #   @param camera [Camera3D]
    #   @return [void]
    [:BeginMode3D, :BeginMode3D, [Camera3D.by_value], :void],

    # @!method EndMode3D()
    #   EndMode3D : Ends 3D mode and returns to default 2D orthographic mode
    #   @return [void]
    [:EndMode3D, :EndMode3D, [], :void],

    # @!method BeginTextureMode(target)
    #   BeginTextureMode : Begin drawing to render texture
    #   @param target [RenderTexture2D]
    #   @return [void]
    [:BeginTextureMode, :BeginTextureMode, [RenderTexture2D.by_value], :void],

    # @!method EndTextureMode()
    #   EndTextureMode : Ends drawing to render texture
    #   @return [void]
    [:EndTextureMode, :EndTextureMode, [], :void],

    # @!method BeginShaderMode(shader)
    #   BeginShaderMode : Begin custom shader drawing
    #   @param shader [Shader]
    #   @return [void]
    [:BeginShaderMode, :BeginShaderMode, [Shader.by_value], :void],

    # @!method EndShaderMode()
    #   EndShaderMode : End custom shader drawing (use default shader)
    #   @return [void]
    [:EndShaderMode, :EndShaderMode, [], :void],

    # @!method BeginBlendMode(mode)
    #   BeginBlendMode : Begin blending mode (alpha, additive, multiplied, subtract, custom)
    #   @param mode [int]
    #   @return [void]
    [:BeginBlendMode, :BeginBlendMode, [:int], :void],

    # @!method EndBlendMode()
    #   EndBlendMode : End blending mode (reset to default: alpha blending)
    #   @return [void]
    [:EndBlendMode, :EndBlendMode, [], :void],

    # @!method BeginScissorMode(x, y, width, height)
    #   BeginScissorMode : Begin scissor mode (define screen area for following drawing)
    #   @param x [int]
    #   @param y [int]
    #   @param width [int]
    #   @param height [int]
    #   @return [void]
    [:BeginScissorMode, :BeginScissorMode, [:int, :int, :int, :int], :void],

    # @!method EndScissorMode()
    #   EndScissorMode : End scissor mode
    #   @return [void]
    [:EndScissorMode, :EndScissorMode, [], :void],

    # @!method BeginVrStereoMode(config)
    #   BeginVrStereoMode : Begin stereo rendering (requires VR simulator)
    #   @param config [VrStereoConfig]
    #   @return [void]
    [:BeginVrStereoMode, :BeginVrStereoMode, [VrStereoConfig.by_value], :void],

    # @!method EndVrStereoMode()
    #   EndVrStereoMode : End stereo rendering (requires VR simulator)
    #   @return [void]
    [:EndVrStereoMode, :EndVrStereoMode, [], :void],

    # @!method LoadVrStereoConfig(device)
    #   LoadVrStereoConfig : Load VR stereo config for VR simulator device parameters
    #   @param device [VrDeviceInfo]
    #   @return [VrStereoConfig]
    [:LoadVrStereoConfig, :LoadVrStereoConfig, [VrDeviceInfo.by_value], VrStereoConfig.by_value],

    # @!method UnloadVrStereoConfig(config)
    #   UnloadVrStereoConfig : Unload VR stereo config
    #   @param config [VrStereoConfig]
    #   @return [void]
    [:UnloadVrStereoConfig, :UnloadVrStereoConfig, [VrStereoConfig.by_value], :void],

    # @!method LoadShader(vsFileName, fsFileName)
    #   LoadShader : Load shader from files and bind default locations
    #   @param vsFileName [const char *]
    #   @param fsFileName [const char *]
    #   @return [Shader]
    [:LoadShader, :LoadShader, [:pointer, :pointer], Shader.by_value],

    # @!method LoadShaderFromMemory(vsCode, fsCode)
    #   LoadShaderFromMemory : Load shader from code strings and bind default locations
    #   @param vsCode [const char *]
    #   @param fsCode [const char *]
    #   @return [Shader]
    [:LoadShaderFromMemory, :LoadShaderFromMemory, [:pointer, :pointer], Shader.by_value],

    # @!method IsShaderValid(shader)
    #   IsShaderValid : Check if a shader is valid (loaded on GPU)
    #   @param shader [Shader]
    #   @return [bool]
    [:IsShaderValid, :IsShaderValid, [Shader.by_value], :bool],

    # @!method GetShaderLocation(shader, uniformName)
    #   GetShaderLocation : Get shader uniform location
    #   @param shader [Shader]
    #   @param uniformName [const char *]
    #   @return [int]
    [:GetShaderLocation, :GetShaderLocation, [Shader.by_value, :pointer], :int],

    # @!method GetShaderLocationAttrib(shader, attribName)
    #   GetShaderLocationAttrib : Get shader attribute location
    #   @param shader [Shader]
    #   @param attribName [const char *]
    #   @return [int]
    [:GetShaderLocationAttrib, :GetShaderLocationAttrib, [Shader.by_value, :pointer], :int],

    # @!method SetShaderValue(shader, locIndex, value, uniformType)
    #   SetShaderValue : Set shader uniform value
    #   @param shader [Shader]
    #   @param locIndex [int]
    #   @param value [const void *]
    #   @param uniformType [int]
    #   @return [void]
    [:SetShaderValue, :SetShaderValue, [Shader.by_value, :int, :pointer, :int], :void],

    # @!method SetShaderValueV(shader, locIndex, value, uniformType, count)
    #   SetShaderValueV : Set shader uniform value vector
    #   @param shader [Shader]
    #   @param locIndex [int]
    #   @param value [const void *]
    #   @param uniformType [int]
    #   @param count [int]
    #   @return [void]
    [:SetShaderValueV, :SetShaderValueV, [Shader.by_value, :int, :pointer, :int, :int], :void],

    # @!method SetShaderValueMatrix(shader, locIndex, mat)
    #   SetShaderValueMatrix : Set shader uniform value (matrix 4x4)
    #   @param shader [Shader]
    #   @param locIndex [int]
    #   @param mat [Matrix]
    #   @return [void]
    [:SetShaderValueMatrix, :SetShaderValueMatrix, [Shader.by_value, :int, Matrix.by_value], :void],

    # @!method SetShaderValueTexture(shader, locIndex, texture)
    #   SetShaderValueTexture : Set shader uniform value for texture (sampler2d)
    #   @param shader [Shader]
    #   @param locIndex [int]
    #   @param texture [Texture2D]
    #   @return [void]
    [:SetShaderValueTexture, :SetShaderValueTexture, [Shader.by_value, :int, Texture2D.by_value], :void],

    # @!method UnloadShader(shader)
    #   UnloadShader : Unload shader from GPU memory (VRAM)
    #   @param shader [Shader]
    #   @return [void]
    [:UnloadShader, :UnloadShader, [Shader.by_value], :void],

    # @!method GetScreenToWorldRay(position, camera)
    #   GetScreenToWorldRay : Get a ray trace from screen position (i.e mouse)
    #   @param position [Vector2]
    #   @param camera [Camera]
    #   @return [Ray]
    [:GetScreenToWorldRay, :GetScreenToWorldRay, [Vector2.by_value, Camera.by_value], Ray.by_value],

    # @!method GetScreenToWorldRayEx(position, camera, width, height)
    #   GetScreenToWorldRayEx : Get a ray trace from screen position (i.e mouse) in a viewport
    #   @param position [Vector2]
    #   @param camera [Camera]
    #   @param width [int]
    #   @param height [int]
    #   @return [Ray]
    [:GetScreenToWorldRayEx, :GetScreenToWorldRayEx, [Vector2.by_value, Camera.by_value, :int, :int], Ray.by_value],

    # @!method GetWorldToScreen(position, camera)
    #   GetWorldToScreen : Get the screen space position for a 3d world space position
    #   @param position [Vector3]
    #   @param camera [Camera]
    #   @return [Vector2]
    [:GetWorldToScreen, :GetWorldToScreen, [Vector3.by_value, Camera.by_value], Vector2.by_value],

    # @!method GetWorldToScreenEx(position, camera, width, height)
    #   GetWorldToScreenEx : Get size position for a 3d world space position
    #   @param position [Vector3]
    #   @param camera [Camera]
    #   @param width [int]
    #   @param height [int]
    #   @return [Vector2]
    [:GetWorldToScreenEx, :GetWorldToScreenEx, [Vector3.by_value, Camera.by_value, :int, :int], Vector2.by_value],

    # @!method GetWorldToScreen2D(position, camera)
    #   GetWorldToScreen2D : Get the screen space position for a 2d camera world space position
    #   @param position [Vector2]
    #   @param camera [Camera2D]
    #   @return [Vector2]
    [:GetWorldToScreen2D, :GetWorldToScreen2D, [Vector2.by_value, Camera2D.by_value], Vector2.by_value],

    # @!method GetScreenToWorld2D(position, camera)
    #   GetScreenToWorld2D : Get the world space position for a 2d camera screen space position
    #   @param position [Vector2]
    #   @param camera [Camera2D]
    #   @return [Vector2]
    [:GetScreenToWorld2D, :GetScreenToWorld2D, [Vector2.by_value, Camera2D.by_value], Vector2.by_value],

    # @!method GetCameraMatrix(camera)
    #   GetCameraMatrix : Get camera transform matrix (view matrix)
    #   @param camera [Camera]
    #   @return [Matrix]
    [:GetCameraMatrix, :GetCameraMatrix, [Camera.by_value], Matrix.by_value],

    # @!method GetCameraMatrix2D(camera)
    #   GetCameraMatrix2D : Get camera 2d transform matrix
    #   @param camera [Camera2D]
    #   @return [Matrix]
    [:GetCameraMatrix2D, :GetCameraMatrix2D, [Camera2D.by_value], Matrix.by_value],

    # @!method SetTargetFPS(fps)
    #   SetTargetFPS : Set target FPS (maximum)
    #   @param fps [int]
    #   @return [void]
    [:SetTargetFPS, :SetTargetFPS, [:int], :void],

    # @!method GetFrameTime()
    #   GetFrameTime : Get time in seconds for last frame drawn (delta time)
    #   @return [float]
    [:GetFrameTime, :GetFrameTime, [], :float],

    # @!method GetTime()
    #   GetTime : Get elapsed time in seconds since InitWindow()
    #   @return [double]
    [:GetTime, :GetTime, [], :double],

    # @!method GetFPS()
    #   GetFPS : Get current FPS
    #   @return [int]
    [:GetFPS, :GetFPS, [], :int],

    # @!method SwapScreenBuffer()
    #   SwapScreenBuffer : Swap back buffer with front buffer (screen drawing)
    #   @return [void]
    [:SwapScreenBuffer, :SwapScreenBuffer, [], :void],

    # @!method PollInputEvents()
    #   PollInputEvents : Register all input events
    #   @return [void]
    [:PollInputEvents, :PollInputEvents, [], :void],

    # @!method WaitTime(seconds)
    #   WaitTime : Wait for some time (halt program execution)
    #   @param seconds [double]
    #   @return [void]
    [:WaitTime, :WaitTime, [:double], :void],

    # @!method SetRandomSeed(seed)
    #   SetRandomSeed : Set the seed for the random number generator
    #   @param seed [unsigned int]
    #   @return [void]
    [:SetRandomSeed, :SetRandomSeed, [:uint], :void],

    # @!method GetRandomValue(min, max)
    #   GetRandomValue : Get a random value between min and max (both included)
    #   @param min [int]
    #   @param max [int]
    #   @return [int]
    [:GetRandomValue, :GetRandomValue, [:int, :int], :int],

    # @!method LoadRandomSequence(count, min, max)
    #   LoadRandomSequence : Load random values sequence, no values repeated
    #   @param count [unsigned int]
    #   @param min [int]
    #   @param max [int]
    #   @return [int *]
    [:LoadRandomSequence, :LoadRandomSequence, [:uint, :int, :int], :pointer],

    # @!method UnloadRandomSequence(sequence)
    #   UnloadRandomSequence : Unload random values sequence
    #   @param sequence [int *]
    #   @return [void]
    [:UnloadRandomSequence, :UnloadRandomSequence, [:pointer], :void],

    # @!method TakeScreenshot(fileName)
    #   TakeScreenshot : Takes a screenshot of current screen (filename extension defines format)
    #   @param fileName [const char *]
    #   @return [void]
    [:TakeScreenshot, :TakeScreenshot, [:pointer], :void],

    # @!method SetConfigFlags(flags)
    #   SetConfigFlags : Setup init configuration flags (view FLAGS)
    #   @param flags [unsigned int]
    #   @return [void]
    [:SetConfigFlags, :SetConfigFlags, [:uint], :void],

    # @!method OpenURL(url)
    #   OpenURL : Open URL with default system browser (if available)
    #   @param url [const char *]
    #   @return [void]
    [:OpenURL, :OpenURL, [:pointer], :void],

    # @!method TraceLog(logLevel, text, ...)
    #   TraceLog : Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)
    #   @param logLevel [int]
    #   @param text [const char *]
    #   @param args [...]
    #   @return [void]
    [:TraceLog, :TraceLog, [:int, :pointer, :varargs], :void],

    # @!method SetTraceLogLevel(logLevel)
    #   SetTraceLogLevel : Set the current threshold (minimum) log level
    #   @param logLevel [int]
    #   @return [void]
    [:SetTraceLogLevel, :SetTraceLogLevel, [:int], :void],

    # @!method MemAlloc(size)
    #   MemAlloc : Internal memory allocator
    #   @param size [unsigned int]
    #   @return [void *]
    [:MemAlloc, :MemAlloc, [:uint], :pointer],

    # @!method MemRealloc(ptr, size)
    #   MemRealloc : Internal memory reallocator
    #   @param ptr [void *]
    #   @param size [unsigned int]
    #   @return [void *]
    [:MemRealloc, :MemRealloc, [:pointer, :uint], :pointer],

    # @!method MemFree(ptr)
    #   MemFree : Internal memory free
    #   @param ptr [void *]
    #   @return [void]
    [:MemFree, :MemFree, [:pointer], :void],

    # @!method SetTraceLogCallback(callback)
    #   SetTraceLogCallback : Set custom trace log
    #   @param callback [TraceLogCallback]
    #   @return [void]
    [:SetTraceLogCallback, :SetTraceLogCallback, [:TraceLogCallback], :void],

    # @!method SetLoadFileDataCallback(callback)
    #   SetLoadFileDataCallback : Set custom file binary data loader
    #   @param callback [LoadFileDataCallback]
    #   @return [void]
    [:SetLoadFileDataCallback, :SetLoadFileDataCallback, [:LoadFileDataCallback], :void],

    # @!method SetSaveFileDataCallback(callback)
    #   SetSaveFileDataCallback : Set custom file binary data saver
    #   @param callback [SaveFileDataCallback]
    #   @return [void]
    [:SetSaveFileDataCallback, :SetSaveFileDataCallback, [:SaveFileDataCallback], :void],

    # @!method SetLoadFileTextCallback(callback)
    #   SetLoadFileTextCallback : Set custom file text data loader
    #   @param callback [LoadFileTextCallback]
    #   @return [void]
    [:SetLoadFileTextCallback, :SetLoadFileTextCallback, [:LoadFileTextCallback], :void],

    # @!method SetSaveFileTextCallback(callback)
    #   SetSaveFileTextCallback : Set custom file text data saver
    #   @param callback [SaveFileTextCallback]
    #   @return [void]
    [:SetSaveFileTextCallback, :SetSaveFileTextCallback, [:SaveFileTextCallback], :void],

    # @!method LoadFileData(fileName, dataSize)
    #   LoadFileData : Load file data as byte array (read)
    #   @param fileName [const char *]
    #   @param dataSize [int *]
    #   @return [unsigned char *]
    [:LoadFileData, :LoadFileData, [:pointer, :pointer], :pointer],

    # @!method UnloadFileData(data)
    #   UnloadFileData : Unload file data allocated by LoadFileData()
    #   @param data [unsigned char *]
    #   @return [void]
    [:UnloadFileData, :UnloadFileData, [:pointer], :void],

    # @!method SaveFileData(fileName, data, dataSize)
    #   SaveFileData : Save data to file from byte array (write), returns true on success
    #   @param fileName [const char *]
    #   @param data [void *]
    #   @param dataSize [int]
    #   @return [bool]
    [:SaveFileData, :SaveFileData, [:pointer, :pointer, :int], :bool],

    # @!method ExportDataAsCode(data, dataSize, fileName)
    #   ExportDataAsCode : Export data to code (.h), returns true on success
    #   @param data [const unsigned char *]
    #   @param dataSize [int]
    #   @param fileName [const char *]
    #   @return [bool]
    [:ExportDataAsCode, :ExportDataAsCode, [:pointer, :int, :pointer], :bool],

    # @!method LoadFileText(fileName)
    #   LoadFileText : Load text data from file (read), returns a '\0' terminated string
    #   @param fileName [const char *]
    #   @return [char *]
    [:LoadFileText, :LoadFileText, [:pointer], :pointer],

    # @!method UnloadFileText(text)
    #   UnloadFileText : Unload file text data allocated by LoadFileText()
    #   @param text [char *]
    #   @return [void]
    [:UnloadFileText, :UnloadFileText, [:pointer], :void],

    # @!method SaveFileText(fileName, text)
    #   SaveFileText : Save text data to file (write), string must be '\0' terminated, returns true on success
    #   @param fileName [const char *]
    #   @param text [char *]
    #   @return [bool]
    [:SaveFileText, :SaveFileText, [:pointer, :pointer], :bool],

    # @!method FileExists(fileName)
    #   FileExists : Check if file exists
    #   @param fileName [const char *]
    #   @return [bool]
    [:FileExists, :FileExists, [:pointer], :bool],

    # @!method DirectoryExists(dirPath)
    #   DirectoryExists : Check if a directory path exists
    #   @param dirPath [const char *]
    #   @return [bool]
    [:DirectoryExists, :DirectoryExists, [:pointer], :bool],

    # @!method IsFileExtension(fileName, ext)
    #   IsFileExtension : Check file extension (including point: .png, .wav)
    #   @param fileName [const char *]
    #   @param ext [const char *]
    #   @return [bool]
    [:IsFileExtension, :IsFileExtension, [:pointer, :pointer], :bool],

    # @!method GetFileLength(fileName)
    #   GetFileLength : Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)
    #   @param fileName [const char *]
    #   @return [int]
    [:GetFileLength, :GetFileLength, [:pointer], :int],

    # @!method GetFileExtension(fileName)
    #   GetFileExtension : Get pointer to extension for a filename string (includes dot: '.png')
    #   @param fileName [const char *]
    #   @return [const char *]
    [:GetFileExtension, :GetFileExtension, [:pointer], :pointer],

    # @!method GetFileName(filePath)
    #   GetFileName : Get pointer to filename for a path string
    #   @param filePath [const char *]
    #   @return [const char *]
    [:GetFileName, :GetFileName, [:pointer], :pointer],

    # @!method GetFileNameWithoutExt(filePath)
    #   GetFileNameWithoutExt : Get filename string without extension (uses static string)
    #   @param filePath [const char *]
    #   @return [const char *]
    [:GetFileNameWithoutExt, :GetFileNameWithoutExt, [:pointer], :pointer],

    # @!method GetDirectoryPath(filePath)
    #   GetDirectoryPath : Get full path for a given fileName with path (uses static string)
    #   @param filePath [const char *]
    #   @return [const char *]
    [:GetDirectoryPath, :GetDirectoryPath, [:pointer], :pointer],

    # @!method GetPrevDirectoryPath(dirPath)
    #   GetPrevDirectoryPath : Get previous directory path for a given path (uses static string)
    #   @param dirPath [const char *]
    #   @return [const char *]
    [:GetPrevDirectoryPath, :GetPrevDirectoryPath, [:pointer], :pointer],

    # @!method GetWorkingDirectory()
    #   GetWorkingDirectory : Get current working directory (uses static string)
    #   @return [const char *]
    [:GetWorkingDirectory, :GetWorkingDirectory, [], :pointer],

    # @!method GetApplicationDirectory()
    #   GetApplicationDirectory : Get the directory of the running application (uses static string)
    #   @return [const char *]
    [:GetApplicationDirectory, :GetApplicationDirectory, [], :pointer],

    # @!method MakeDirectory(dirPath)
    #   MakeDirectory : Create directories (including full path requested), returns 0 on success
    #   @param dirPath [const char *]
    #   @return [int]
    [:MakeDirectory, :MakeDirectory, [:pointer], :int],

    # @!method ChangeDirectory(dir)
    #   ChangeDirectory : Change working directory, return true on success
    #   @param dir [const char *]
    #   @return [bool]
    [:ChangeDirectory, :ChangeDirectory, [:pointer], :bool],

    # @!method IsPathFile(path)
    #   IsPathFile : Check if a given path is a file or a directory
    #   @param path [const char *]
    #   @return [bool]
    [:IsPathFile, :IsPathFile, [:pointer], :bool],

    # @!method IsFileNameValid(fileName)
    #   IsFileNameValid : Check if fileName is valid for the platform/OS
    #   @param fileName [const char *]
    #   @return [bool]
    [:IsFileNameValid, :IsFileNameValid, [:pointer], :bool],

    # @!method LoadDirectoryFiles(dirPath)
    #   LoadDirectoryFiles : Load directory filepaths
    #   @param dirPath [const char *]
    #   @return [FilePathList]
    [:LoadDirectoryFiles, :LoadDirectoryFiles, [:pointer], FilePathList.by_value],

    # @!method LoadDirectoryFilesEx(basePath, filter, scanSubdirs)
    #   LoadDirectoryFilesEx : Load directory filepaths with extension filtering and recursive directory scan. Use 'DIR' in the filter string to include directories in the result
    #   @param basePath [const char *]
    #   @param filter [const char *]
    #   @param scanSubdirs [bool]
    #   @return [FilePathList]
    [:LoadDirectoryFilesEx, :LoadDirectoryFilesEx, [:pointer, :pointer, :bool], FilePathList.by_value],

    # @!method UnloadDirectoryFiles(files)
    #   UnloadDirectoryFiles : Unload filepaths
    #   @param files [FilePathList]
    #   @return [void]
    [:UnloadDirectoryFiles, :UnloadDirectoryFiles, [FilePathList.by_value], :void],

    # @!method IsFileDropped()
    #   IsFileDropped : Check if a file has been dropped into window
    #   @return [bool]
    [:IsFileDropped, :IsFileDropped, [], :bool],

    # @!method LoadDroppedFiles()
    #   LoadDroppedFiles : Load dropped filepaths
    #   @return [FilePathList]
    [:LoadDroppedFiles, :LoadDroppedFiles, [], FilePathList.by_value],

    # @!method UnloadDroppedFiles(files)
    #   UnloadDroppedFiles : Unload dropped filepaths
    #   @param files [FilePathList]
    #   @return [void]
    [:UnloadDroppedFiles, :UnloadDroppedFiles, [FilePathList.by_value], :void],

    # @!method GetFileModTime(fileName)
    #   GetFileModTime : Get file modification time (last write time)
    #   @param fileName [const char *]
    #   @return [long]
    [:GetFileModTime, :GetFileModTime, [:pointer], :long],

    # @!method CompressData(data, dataSize, compDataSize)
    #   CompressData : Compress data (DEFLATE algorithm), memory must be MemFree()
    #   @param data [const unsigned char *]
    #   @param dataSize [int]
    #   @param compDataSize [int *]
    #   @return [unsigned char *]
    [:CompressData, :CompressData, [:pointer, :int, :pointer], :pointer],

    # @!method DecompressData(compData, compDataSize, dataSize)
    #   DecompressData : Decompress data (DEFLATE algorithm), memory must be MemFree()
    #   @param compData [const unsigned char *]
    #   @param compDataSize [int]
    #   @param dataSize [int *]
    #   @return [unsigned char *]
    [:DecompressData, :DecompressData, [:pointer, :int, :pointer], :pointer],

    # @!method EncodeDataBase64(data, dataSize, outputSize)
    #   EncodeDataBase64 : Encode data to Base64 string, memory must be MemFree()
    #   @param data [const unsigned char *]
    #   @param dataSize [int]
    #   @param outputSize [int *]
    #   @return [char *]
    [:EncodeDataBase64, :EncodeDataBase64, [:pointer, :int, :pointer], :pointer],

    # @!method DecodeDataBase64(data, outputSize)
    #   DecodeDataBase64 : Decode Base64 string data, memory must be MemFree()
    #   @param data [const unsigned char *]
    #   @param outputSize [int *]
    #   @return [unsigned char *]
    [:DecodeDataBase64, :DecodeDataBase64, [:pointer, :pointer], :pointer],

    # @!method ComputeCRC32(data, dataSize)
    #   ComputeCRC32 : Compute CRC32 hash code
    #   @param data [unsigned char *]
    #   @param dataSize [int]
    #   @return [unsigned int]
    [:ComputeCRC32, :ComputeCRC32, [:pointer, :int], :uint],

    # @!method ComputeMD5(data, dataSize)
    #   ComputeMD5 : Compute MD5 hash code, returns static int[4] (16 bytes)
    #   @param data [unsigned char *]
    #   @param dataSize [int]
    #   @return [unsigned int *]
    [:ComputeMD5, :ComputeMD5, [:pointer, :int], :pointer],

    # @!method ComputeSHA1(data, dataSize)
    #   ComputeSHA1 : Compute SHA1 hash code, returns static int[5] (20 bytes)
    #   @param data [unsigned char *]
    #   @param dataSize [int]
    #   @return [unsigned int *]
    [:ComputeSHA1, :ComputeSHA1, [:pointer, :int], :pointer],

    # @!method LoadAutomationEventList(fileName)
    #   LoadAutomationEventList : Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS
    #   @param fileName [const char *]
    #   @return [AutomationEventList]
    [:LoadAutomationEventList, :LoadAutomationEventList, [:pointer], AutomationEventList.by_value],

    # @!method UnloadAutomationEventList(list)
    #   UnloadAutomationEventList : Unload automation events list from file
    #   @param list [AutomationEventList]
    #   @return [void]
    [:UnloadAutomationEventList, :UnloadAutomationEventList, [AutomationEventList.by_value], :void],

    # @!method ExportAutomationEventList(list, fileName)
    #   ExportAutomationEventList : Export automation events list as text file
    #   @param list [AutomationEventList]
    #   @param fileName [const char *]
    #   @return [bool]
    [:ExportAutomationEventList, :ExportAutomationEventList, [AutomationEventList.by_value, :pointer], :bool],

    # @!method SetAutomationEventList(list)
    #   SetAutomationEventList : Set automation event list to record to
    #   @param list [AutomationEventList *]
    #   @return [void]
    [:SetAutomationEventList, :SetAutomationEventList, [:pointer], :void],

    # @!method SetAutomationEventBaseFrame(frame)
    #   SetAutomationEventBaseFrame : Set automation event internal base frame to start recording
    #   @param frame [int]
    #   @return [void]
    [:SetAutomationEventBaseFrame, :SetAutomationEventBaseFrame, [:int], :void],

    # @!method StartAutomationEventRecording()
    #   StartAutomationEventRecording : Start recording automation events (AutomationEventList must be set)
    #   @return [void]
    [:StartAutomationEventRecording, :StartAutomationEventRecording, [], :void],

    # @!method StopAutomationEventRecording()
    #   StopAutomationEventRecording : Stop recording automation events
    #   @return [void]
    [:StopAutomationEventRecording, :StopAutomationEventRecording, [], :void],

    # @!method PlayAutomationEvent(event)
    #   PlayAutomationEvent : Play a recorded automation event
    #   @param event [AutomationEvent]
    #   @return [void]
    [:PlayAutomationEvent, :PlayAutomationEvent, [AutomationEvent.by_value], :void],

    # @!method IsKeyPressed(key)
    #   IsKeyPressed : Check if a key has been pressed once
    #   @param key [int]
    #   @return [bool]
    [:IsKeyPressed, :IsKeyPressed, [:int], :bool],

    # @!method IsKeyPressedRepeat(key)
    #   IsKeyPressedRepeat : Check if a key has been pressed again
    #   @param key [int]
    #   @return [bool]
    [:IsKeyPressedRepeat, :IsKeyPressedRepeat, [:int], :bool],

    # @!method IsKeyDown(key)
    #   IsKeyDown : Check if a key is being pressed
    #   @param key [int]
    #   @return [bool]
    [:IsKeyDown, :IsKeyDown, [:int], :bool],

    # @!method IsKeyReleased(key)
    #   IsKeyReleased : Check if a key has been released once
    #   @param key [int]
    #   @return [bool]
    [:IsKeyReleased, :IsKeyReleased, [:int], :bool],

    # @!method IsKeyUp(key)
    #   IsKeyUp : Check if a key is NOT being pressed
    #   @param key [int]
    #   @return [bool]
    [:IsKeyUp, :IsKeyUp, [:int], :bool],

    # @!method GetKeyPressed()
    #   GetKeyPressed : Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty
    #   @return [int]
    [:GetKeyPressed, :GetKeyPressed, [], :int],

    # @!method GetCharPressed()
    #   GetCharPressed : Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty
    #   @return [int]
    [:GetCharPressed, :GetCharPressed, [], :int],

    # @!method GetKeyName(key)
    #   GetKeyName : Get name of a QWERTY key on the current keyboard layout (eg returns string 'q' for KEY_A on an AZERTY keyboard)
    #   @param key [int]
    #   @return [const char *]
    [:GetKeyName, :GetKeyName, [:int], :pointer],

    # @!method SetExitKey(key)
    #   SetExitKey : Set a custom key to exit program (default is ESC)
    #   @param key [int]
    #   @return [void]
    [:SetExitKey, :SetExitKey, [:int], :void],

    # @!method IsGamepadAvailable(gamepad)
    #   IsGamepadAvailable : Check if a gamepad is available
    #   @param gamepad [int]
    #   @return [bool]
    [:IsGamepadAvailable, :IsGamepadAvailable, [:int], :bool],

    # @!method GetGamepadName(gamepad)
    #   GetGamepadName : Get gamepad internal name id
    #   @param gamepad [int]
    #   @return [const char *]
    [:GetGamepadName, :GetGamepadName, [:int], :pointer],

    # @!method IsGamepadButtonPressed(gamepad, button)
    #   IsGamepadButtonPressed : Check if a gamepad button has been pressed once
    #   @param gamepad [int]
    #   @param button [int]
    #   @return [bool]
    [:IsGamepadButtonPressed, :IsGamepadButtonPressed, [:int, :int], :bool],

    # @!method IsGamepadButtonDown(gamepad, button)
    #   IsGamepadButtonDown : Check if a gamepad button is being pressed
    #   @param gamepad [int]
    #   @param button [int]
    #   @return [bool]
    [:IsGamepadButtonDown, :IsGamepadButtonDown, [:int, :int], :bool],

    # @!method IsGamepadButtonReleased(gamepad, button)
    #   IsGamepadButtonReleased : Check if a gamepad button has been released once
    #   @param gamepad [int]
    #   @param button [int]
    #   @return [bool]
    [:IsGamepadButtonReleased, :IsGamepadButtonReleased, [:int, :int], :bool],

    # @!method IsGamepadButtonUp(gamepad, button)
    #   IsGamepadButtonUp : Check if a gamepad button is NOT being pressed
    #   @param gamepad [int]
    #   @param button [int]
    #   @return [bool]
    [:IsGamepadButtonUp, :IsGamepadButtonUp, [:int, :int], :bool],

    # @!method GetGamepadButtonPressed()
    #   GetGamepadButtonPressed : Get the last gamepad button pressed
    #   @return [int]
    [:GetGamepadButtonPressed, :GetGamepadButtonPressed, [], :int],

    # @!method GetGamepadAxisCount(gamepad)
    #   GetGamepadAxisCount : Get gamepad axis count for a gamepad
    #   @param gamepad [int]
    #   @return [int]
    [:GetGamepadAxisCount, :GetGamepadAxisCount, [:int], :int],

    # @!method GetGamepadAxisMovement(gamepad, axis)
    #   GetGamepadAxisMovement : Get axis movement value for a gamepad axis
    #   @param gamepad [int]
    #   @param axis [int]
    #   @return [float]
    [:GetGamepadAxisMovement, :GetGamepadAxisMovement, [:int, :int], :float],

    # @!method SetGamepadMappings(mappings)
    #   SetGamepadMappings : Set internal gamepad mappings (SDL_GameControllerDB)
    #   @param mappings [const char *]
    #   @return [int]
    [:SetGamepadMappings, :SetGamepadMappings, [:pointer], :int],

    # @!method SetGamepadVibration(gamepad, leftMotor, rightMotor, duration)
    #   SetGamepadVibration : Set gamepad vibration for both motors (duration in seconds)
    #   @param gamepad [int]
    #   @param leftMotor [float]
    #   @param rightMotor [float]
    #   @param duration [float]
    #   @return [void]
    [:SetGamepadVibration, :SetGamepadVibration, [:int, :float, :float, :float], :void],

    # @!method IsMouseButtonPressed(button)
    #   IsMouseButtonPressed : Check if a mouse button has been pressed once
    #   @param button [int]
    #   @return [bool]
    [:IsMouseButtonPressed, :IsMouseButtonPressed, [:int], :bool],

    # @!method IsMouseButtonDown(button)
    #   IsMouseButtonDown : Check if a mouse button is being pressed
    #   @param button [int]
    #   @return [bool]
    [:IsMouseButtonDown, :IsMouseButtonDown, [:int], :bool],

    # @!method IsMouseButtonReleased(button)
    #   IsMouseButtonReleased : Check if a mouse button has been released once
    #   @param button [int]
    #   @return [bool]
    [:IsMouseButtonReleased, :IsMouseButtonReleased, [:int], :bool],

    # @!method IsMouseButtonUp(button)
    #   IsMouseButtonUp : Check if a mouse button is NOT being pressed
    #   @param button [int]
    #   @return [bool]
    [:IsMouseButtonUp, :IsMouseButtonUp, [:int], :bool],

    # @!method GetMouseX()
    #   GetMouseX : Get mouse position X
    #   @return [int]
    [:GetMouseX, :GetMouseX, [], :int],

    # @!method GetMouseY()
    #   GetMouseY : Get mouse position Y
    #   @return [int]
    [:GetMouseY, :GetMouseY, [], :int],

    # @!method GetMousePosition()
    #   GetMousePosition : Get mouse position XY
    #   @return [Vector2]
    [:GetMousePosition, :GetMousePosition, [], Vector2.by_value],

    # @!method GetMouseDelta()
    #   GetMouseDelta : Get mouse delta between frames
    #   @return [Vector2]
    [:GetMouseDelta, :GetMouseDelta, [], Vector2.by_value],

    # @!method SetMousePosition(x, y)
    #   SetMousePosition : Set mouse position XY
    #   @param x [int]
    #   @param y [int]
    #   @return [void]
    [:SetMousePosition, :SetMousePosition, [:int, :int], :void],

    # @!method SetMouseOffset(offsetX, offsetY)
    #   SetMouseOffset : Set mouse offset
    #   @param offsetX [int]
    #   @param offsetY [int]
    #   @return [void]
    [:SetMouseOffset, :SetMouseOffset, [:int, :int], :void],

    # @!method SetMouseScale(scaleX, scaleY)
    #   SetMouseScale : Set mouse scaling
    #   @param scaleX [float]
    #   @param scaleY [float]
    #   @return [void]
    [:SetMouseScale, :SetMouseScale, [:float, :float], :void],

    # @!method GetMouseWheelMove()
    #   GetMouseWheelMove : Get mouse wheel movement for X or Y, whichever is larger
    #   @return [float]
    [:GetMouseWheelMove, :GetMouseWheelMove, [], :float],

    # @!method GetMouseWheelMoveV()
    #   GetMouseWheelMoveV : Get mouse wheel movement for both X and Y
    #   @return [Vector2]
    [:GetMouseWheelMoveV, :GetMouseWheelMoveV, [], Vector2.by_value],

    # @!method SetMouseCursor(cursor)
    #   SetMouseCursor : Set mouse cursor
    #   @param cursor [int]
    #   @return [void]
    [:SetMouseCursor, :SetMouseCursor, [:int], :void],

    # @!method GetTouchX()
    #   GetTouchX : Get touch position X for touch point 0 (relative to screen size)
    #   @return [int]
    [:GetTouchX, :GetTouchX, [], :int],

    # @!method GetTouchY()
    #   GetTouchY : Get touch position Y for touch point 0 (relative to screen size)
    #   @return [int]
    [:GetTouchY, :GetTouchY, [], :int],

    # @!method GetTouchPosition(index)
    #   GetTouchPosition : Get touch position XY for a touch point index (relative to screen size)
    #   @param index [int]
    #   @return [Vector2]
    [:GetTouchPosition, :GetTouchPosition, [:int], Vector2.by_value],

    # @!method GetTouchPointId(index)
    #   GetTouchPointId : Get touch point identifier for given index
    #   @param index [int]
    #   @return [int]
    [:GetTouchPointId, :GetTouchPointId, [:int], :int],

    # @!method GetTouchPointCount()
    #   GetTouchPointCount : Get number of touch points
    #   @return [int]
    [:GetTouchPointCount, :GetTouchPointCount, [], :int],

    # @!method SetGesturesEnabled(flags)
    #   SetGesturesEnabled : Enable a set of gestures using flags
    #   @param flags [unsigned int]
    #   @return [void]
    [:SetGesturesEnabled, :SetGesturesEnabled, [:uint], :void],

    # @!method IsGestureDetected(gesture)
    #   IsGestureDetected : Check if a gesture have been detected
    #   @param gesture [unsigned int]
    #   @return [bool]
    [:IsGestureDetected, :IsGestureDetected, [:uint], :bool],

    # @!method GetGestureDetected()
    #   GetGestureDetected : Get latest detected gesture
    #   @return [int]
    [:GetGestureDetected, :GetGestureDetected, [], :int],

    # @!method GetGestureHoldDuration()
    #   GetGestureHoldDuration : Get gesture hold time in seconds
    #   @return [float]
    [:GetGestureHoldDuration, :GetGestureHoldDuration, [], :float],

    # @!method GetGestureDragVector()
    #   GetGestureDragVector : Get gesture drag vector
    #   @return [Vector2]
    [:GetGestureDragVector, :GetGestureDragVector, [], Vector2.by_value],

    # @!method GetGestureDragAngle()
    #   GetGestureDragAngle : Get gesture drag angle
    #   @return [float]
    [:GetGestureDragAngle, :GetGestureDragAngle, [], :float],

    # @!method GetGesturePinchVector()
    #   GetGesturePinchVector : Get gesture pinch delta
    #   @return [Vector2]
    [:GetGesturePinchVector, :GetGesturePinchVector, [], Vector2.by_value],

    # @!method GetGesturePinchAngle()
    #   GetGesturePinchAngle : Get gesture pinch angle
    #   @return [float]
    [:GetGesturePinchAngle, :GetGesturePinchAngle, [], :float],

    # @!method UpdateCamera(camera, mode)
    #   UpdateCamera : Update camera position for selected mode
    #   @param camera [Camera *]
    #   @param mode [int]
    #   @return [void]
    [:UpdateCamera, :UpdateCamera, [:pointer, :int], :void],

    # @!method UpdateCameraPro(camera, movement, rotation, zoom)
    #   UpdateCameraPro : Update camera movement/rotation
    #   @param camera [Camera *]
    #   @param movement [Vector3]
    #   @param rotation [Vector3]
    #   @param zoom [float]
    #   @return [void]
    [:UpdateCameraPro, :UpdateCameraPro, [:pointer, Vector3.by_value, Vector3.by_value, :float], :void],

    # @!method SetShapesTexture(texture, source)
    #   SetShapesTexture : Set texture and rectangle to be used on shapes drawing
    #   @param texture [Texture2D]
    #   @param source [Rectangle]
    #   @return [void]
    [:SetShapesTexture, :SetShapesTexture, [Texture2D.by_value, Rectangle.by_value], :void],

    # @!method GetShapesTexture()
    #   GetShapesTexture : Get texture that is used for shapes drawing
    #   @return [Texture2D]
    [:GetShapesTexture, :GetShapesTexture, [], Texture2D.by_value],

    # @!method GetShapesTextureRectangle()
    #   GetShapesTextureRectangle : Get texture source rectangle that is used for shapes drawing
    #   @return [Rectangle]
    [:GetShapesTextureRectangle, :GetShapesTextureRectangle, [], Rectangle.by_value],

    # @!method DrawPixel(posX, posY, color)
    #   DrawPixel : Draw a pixel using geometry [Can be slow, use with care]
    #   @param posX [int]
    #   @param posY [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawPixel, :DrawPixel, [:int, :int, Color.by_value], :void],

    # @!method DrawPixelV(position, color)
    #   DrawPixelV : Draw a pixel using geometry (Vector version) [Can be slow, use with care]
    #   @param position [Vector2]
    #   @param color [Color]
    #   @return [void]
    [:DrawPixelV, :DrawPixelV, [Vector2.by_value, Color.by_value], :void],

    # @!method DrawLine(startPosX, startPosY, endPosX, endPosY, color)
    #   DrawLine : Draw a line
    #   @param startPosX [int]
    #   @param startPosY [int]
    #   @param endPosX [int]
    #   @param endPosY [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawLine, :DrawLine, [:int, :int, :int, :int, Color.by_value], :void],

    # @!method DrawLineV(startPos, endPos, color)
    #   DrawLineV : Draw a line (using gl lines)
    #   @param startPos [Vector2]
    #   @param endPos [Vector2]
    #   @param color [Color]
    #   @return [void]
    [:DrawLineV, :DrawLineV, [Vector2.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method DrawLineEx(startPos, endPos, thick, color)
    #   DrawLineEx : Draw a line (using triangles/quads)
    #   @param startPos [Vector2]
    #   @param endPos [Vector2]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawLineEx, :DrawLineEx, [Vector2.by_value, Vector2.by_value, :float, Color.by_value], :void],

    # @!method DrawLineStrip(points, pointCount, color)
    #   DrawLineStrip : Draw lines sequence (using gl lines)
    #   @param points [const Vector2 *]
    #   @param pointCount [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawLineStrip, :DrawLineStrip, [:pointer, :int, Color.by_value], :void],

    # @!method DrawLineBezier(startPos, endPos, thick, color)
    #   DrawLineBezier : Draw line segment cubic-bezier in-out interpolation
    #   @param startPos [Vector2]
    #   @param endPos [Vector2]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawLineBezier, :DrawLineBezier, [Vector2.by_value, Vector2.by_value, :float, Color.by_value], :void],

    # @!method DrawCircle(centerX, centerY, radius, color)
    #   DrawCircle : Draw a color-filled circle
    #   @param centerX [int]
    #   @param centerY [int]
    #   @param radius [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawCircle, :DrawCircle, [:int, :int, :float, Color.by_value], :void],

    # @!method DrawCircleSector(center, radius, startAngle, endAngle, segments, color)
    #   DrawCircleSector : Draw a piece of a circle
    #   @param center [Vector2]
    #   @param radius [float]
    #   @param startAngle [float]
    #   @param endAngle [float]
    #   @param segments [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawCircleSector, :DrawCircleSector, [Vector2.by_value, :float, :float, :float, :int, Color.by_value], :void],

    # @!method DrawCircleSectorLines(center, radius, startAngle, endAngle, segments, color)
    #   DrawCircleSectorLines : Draw circle sector outline
    #   @param center [Vector2]
    #   @param radius [float]
    #   @param startAngle [float]
    #   @param endAngle [float]
    #   @param segments [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawCircleSectorLines, :DrawCircleSectorLines, [Vector2.by_value, :float, :float, :float, :int, Color.by_value], :void],

    # @!method DrawCircleGradient(centerX, centerY, radius, inner, outer)
    #   DrawCircleGradient : Draw a gradient-filled circle
    #   @param centerX [int]
    #   @param centerY [int]
    #   @param radius [float]
    #   @param inner [Color]
    #   @param outer [Color]
    #   @return [void]
    [:DrawCircleGradient, :DrawCircleGradient, [:int, :int, :float, Color.by_value, Color.by_value], :void],

    # @!method DrawCircleV(center, radius, color)
    #   DrawCircleV : Draw a color-filled circle (Vector version)
    #   @param center [Vector2]
    #   @param radius [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawCircleV, :DrawCircleV, [Vector2.by_value, :float, Color.by_value], :void],

    # @!method DrawCircleLines(centerX, centerY, radius, color)
    #   DrawCircleLines : Draw circle outline
    #   @param centerX [int]
    #   @param centerY [int]
    #   @param radius [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawCircleLines, :DrawCircleLines, [:int, :int, :float, Color.by_value], :void],

    # @!method DrawCircleLinesV(center, radius, color)
    #   DrawCircleLinesV : Draw circle outline (Vector version)
    #   @param center [Vector2]
    #   @param radius [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawCircleLinesV, :DrawCircleLinesV, [Vector2.by_value, :float, Color.by_value], :void],

    # @!method DrawEllipse(centerX, centerY, radiusH, radiusV, color)
    #   DrawEllipse : Draw ellipse
    #   @param centerX [int]
    #   @param centerY [int]
    #   @param radiusH [float]
    #   @param radiusV [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawEllipse, :DrawEllipse, [:int, :int, :float, :float, Color.by_value], :void],

    # @!method DrawEllipseLines(centerX, centerY, radiusH, radiusV, color)
    #   DrawEllipseLines : Draw ellipse outline
    #   @param centerX [int]
    #   @param centerY [int]
    #   @param radiusH [float]
    #   @param radiusV [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawEllipseLines, :DrawEllipseLines, [:int, :int, :float, :float, Color.by_value], :void],

    # @!method DrawRing(center, innerRadius, outerRadius, startAngle, endAngle, segments, color)
    #   DrawRing : Draw ring
    #   @param center [Vector2]
    #   @param innerRadius [float]
    #   @param outerRadius [float]
    #   @param startAngle [float]
    #   @param endAngle [float]
    #   @param segments [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawRing, :DrawRing, [Vector2.by_value, :float, :float, :float, :float, :int, Color.by_value], :void],

    # @!method DrawRingLines(center, innerRadius, outerRadius, startAngle, endAngle, segments, color)
    #   DrawRingLines : Draw ring outline
    #   @param center [Vector2]
    #   @param innerRadius [float]
    #   @param outerRadius [float]
    #   @param startAngle [float]
    #   @param endAngle [float]
    #   @param segments [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawRingLines, :DrawRingLines, [Vector2.by_value, :float, :float, :float, :float, :int, Color.by_value], :void],

    # @!method DrawRectangle(posX, posY, width, height, color)
    #   DrawRectangle : Draw a color-filled rectangle
    #   @param posX [int]
    #   @param posY [int]
    #   @param width [int]
    #   @param height [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawRectangle, :DrawRectangle, [:int, :int, :int, :int, Color.by_value], :void],

    # @!method DrawRectangleV(position, size, color)
    #   DrawRectangleV : Draw a color-filled rectangle (Vector version)
    #   @param position [Vector2]
    #   @param size [Vector2]
    #   @param color [Color]
    #   @return [void]
    [:DrawRectangleV, :DrawRectangleV, [Vector2.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method DrawRectangleRec(rec, color)
    #   DrawRectangleRec : Draw a color-filled rectangle
    #   @param rec [Rectangle]
    #   @param color [Color]
    #   @return [void]
    [:DrawRectangleRec, :DrawRectangleRec, [Rectangle.by_value, Color.by_value], :void],

    # @!method DrawRectanglePro(rec, origin, rotation, color)
    #   DrawRectanglePro : Draw a color-filled rectangle with pro parameters
    #   @param rec [Rectangle]
    #   @param origin [Vector2]
    #   @param rotation [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawRectanglePro, :DrawRectanglePro, [Rectangle.by_value, Vector2.by_value, :float, Color.by_value], :void],

    # @!method DrawRectangleGradientV(posX, posY, width, height, top, bottom)
    #   DrawRectangleGradientV : Draw a vertical-gradient-filled rectangle
    #   @param posX [int]
    #   @param posY [int]
    #   @param width [int]
    #   @param height [int]
    #   @param top [Color]
    #   @param bottom [Color]
    #   @return [void]
    [:DrawRectangleGradientV, :DrawRectangleGradientV, [:int, :int, :int, :int, Color.by_value, Color.by_value], :void],

    # @!method DrawRectangleGradientH(posX, posY, width, height, left, right)
    #   DrawRectangleGradientH : Draw a horizontal-gradient-filled rectangle
    #   @param posX [int]
    #   @param posY [int]
    #   @param width [int]
    #   @param height [int]
    #   @param left [Color]
    #   @param right [Color]
    #   @return [void]
    [:DrawRectangleGradientH, :DrawRectangleGradientH, [:int, :int, :int, :int, Color.by_value, Color.by_value], :void],

    # @!method DrawRectangleGradientEx(rec, topLeft, bottomLeft, topRight, bottomRight)
    #   DrawRectangleGradientEx : Draw a gradient-filled rectangle with custom vertex colors
    #   @param rec [Rectangle]
    #   @param topLeft [Color]
    #   @param bottomLeft [Color]
    #   @param topRight [Color]
    #   @param bottomRight [Color]
    #   @return [void]
    [:DrawRectangleGradientEx, :DrawRectangleGradientEx, [Rectangle.by_value, Color.by_value, Color.by_value, Color.by_value, Color.by_value], :void],

    # @!method DrawRectangleLines(posX, posY, width, height, color)
    #   DrawRectangleLines : Draw rectangle outline
    #   @param posX [int]
    #   @param posY [int]
    #   @param width [int]
    #   @param height [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawRectangleLines, :DrawRectangleLines, [:int, :int, :int, :int, Color.by_value], :void],

    # @!method DrawRectangleLinesEx(rec, lineThick, color)
    #   DrawRectangleLinesEx : Draw rectangle outline with extended parameters
    #   @param rec [Rectangle]
    #   @param lineThick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawRectangleLinesEx, :DrawRectangleLinesEx, [Rectangle.by_value, :float, Color.by_value], :void],

    # @!method DrawRectangleRounded(rec, roundness, segments, color)
    #   DrawRectangleRounded : Draw rectangle with rounded edges
    #   @param rec [Rectangle]
    #   @param roundness [float]
    #   @param segments [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawRectangleRounded, :DrawRectangleRounded, [Rectangle.by_value, :float, :int, Color.by_value], :void],

    # @!method DrawRectangleRoundedLines(rec, roundness, segments, color)
    #   DrawRectangleRoundedLines : Draw rectangle lines with rounded edges
    #   @param rec [Rectangle]
    #   @param roundness [float]
    #   @param segments [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawRectangleRoundedLines, :DrawRectangleRoundedLines, [Rectangle.by_value, :float, :int, Color.by_value], :void],

    # @!method DrawRectangleRoundedLinesEx(rec, roundness, segments, lineThick, color)
    #   DrawRectangleRoundedLinesEx : Draw rectangle with rounded edges outline
    #   @param rec [Rectangle]
    #   @param roundness [float]
    #   @param segments [int]
    #   @param lineThick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawRectangleRoundedLinesEx, :DrawRectangleRoundedLinesEx, [Rectangle.by_value, :float, :int, :float, Color.by_value], :void],

    # @!method DrawTriangle(v1, v2, v3, color)
    #   DrawTriangle : Draw a color-filled triangle (vertex in counter-clockwise order!)
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @param v3 [Vector2]
    #   @param color [Color]
    #   @return [void]
    [:DrawTriangle, :DrawTriangle, [Vector2.by_value, Vector2.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method DrawTriangleLines(v1, v2, v3, color)
    #   DrawTriangleLines : Draw triangle outline (vertex in counter-clockwise order!)
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @param v3 [Vector2]
    #   @param color [Color]
    #   @return [void]
    [:DrawTriangleLines, :DrawTriangleLines, [Vector2.by_value, Vector2.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method DrawTriangleFan(points, pointCount, color)
    #   DrawTriangleFan : Draw a triangle fan defined by points (first vertex is the center)
    #   @param points [const Vector2 *]
    #   @param pointCount [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawTriangleFan, :DrawTriangleFan, [:pointer, :int, Color.by_value], :void],

    # @!method DrawTriangleStrip(points, pointCount, color)
    #   DrawTriangleStrip : Draw a triangle strip defined by points
    #   @param points [const Vector2 *]
    #   @param pointCount [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawTriangleStrip, :DrawTriangleStrip, [:pointer, :int, Color.by_value], :void],

    # @!method DrawPoly(center, sides, radius, rotation, color)
    #   DrawPoly : Draw a regular polygon (Vector version)
    #   @param center [Vector2]
    #   @param sides [int]
    #   @param radius [float]
    #   @param rotation [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawPoly, :DrawPoly, [Vector2.by_value, :int, :float, :float, Color.by_value], :void],

    # @!method DrawPolyLines(center, sides, radius, rotation, color)
    #   DrawPolyLines : Draw a polygon outline of n sides
    #   @param center [Vector2]
    #   @param sides [int]
    #   @param radius [float]
    #   @param rotation [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawPolyLines, :DrawPolyLines, [Vector2.by_value, :int, :float, :float, Color.by_value], :void],

    # @!method DrawPolyLinesEx(center, sides, radius, rotation, lineThick, color)
    #   DrawPolyLinesEx : Draw a polygon outline of n sides with extended parameters
    #   @param center [Vector2]
    #   @param sides [int]
    #   @param radius [float]
    #   @param rotation [float]
    #   @param lineThick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawPolyLinesEx, :DrawPolyLinesEx, [Vector2.by_value, :int, :float, :float, :float, Color.by_value], :void],

    # @!method DrawSplineLinear(points, pointCount, thick, color)
    #   DrawSplineLinear : Draw spline: Linear, minimum 2 points
    #   @param points [const Vector2 *]
    #   @param pointCount [int]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawSplineLinear, :DrawSplineLinear, [:pointer, :int, :float, Color.by_value], :void],

    # @!method DrawSplineBasis(points, pointCount, thick, color)
    #   DrawSplineBasis : Draw spline: B-Spline, minimum 4 points
    #   @param points [const Vector2 *]
    #   @param pointCount [int]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawSplineBasis, :DrawSplineBasis, [:pointer, :int, :float, Color.by_value], :void],

    # @!method DrawSplineCatmullRom(points, pointCount, thick, color)
    #   DrawSplineCatmullRom : Draw spline: Catmull-Rom, minimum 4 points
    #   @param points [const Vector2 *]
    #   @param pointCount [int]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawSplineCatmullRom, :DrawSplineCatmullRom, [:pointer, :int, :float, Color.by_value], :void],

    # @!method DrawSplineBezierQuadratic(points, pointCount, thick, color)
    #   DrawSplineBezierQuadratic : Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...]
    #   @param points [const Vector2 *]
    #   @param pointCount [int]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawSplineBezierQuadratic, :DrawSplineBezierQuadratic, [:pointer, :int, :float, Color.by_value], :void],

    # @!method DrawSplineBezierCubic(points, pointCount, thick, color)
    #   DrawSplineBezierCubic : Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...]
    #   @param points [const Vector2 *]
    #   @param pointCount [int]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawSplineBezierCubic, :DrawSplineBezierCubic, [:pointer, :int, :float, Color.by_value], :void],

    # @!method DrawSplineSegmentLinear(p1, p2, thick, color)
    #   DrawSplineSegmentLinear : Draw spline segment: Linear, 2 points
    #   @param p1 [Vector2]
    #   @param p2 [Vector2]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawSplineSegmentLinear, :DrawSplineSegmentLinear, [Vector2.by_value, Vector2.by_value, :float, Color.by_value], :void],

    # @!method DrawSplineSegmentBasis(p1, p2, p3, p4, thick, color)
    #   DrawSplineSegmentBasis : Draw spline segment: B-Spline, 4 points
    #   @param p1 [Vector2]
    #   @param p2 [Vector2]
    #   @param p3 [Vector2]
    #   @param p4 [Vector2]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawSplineSegmentBasis, :DrawSplineSegmentBasis, [Vector2.by_value, Vector2.by_value, Vector2.by_value, Vector2.by_value, :float, Color.by_value], :void],

    # @!method DrawSplineSegmentCatmullRom(p1, p2, p3, p4, thick, color)
    #   DrawSplineSegmentCatmullRom : Draw spline segment: Catmull-Rom, 4 points
    #   @param p1 [Vector2]
    #   @param p2 [Vector2]
    #   @param p3 [Vector2]
    #   @param p4 [Vector2]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawSplineSegmentCatmullRom, :DrawSplineSegmentCatmullRom, [Vector2.by_value, Vector2.by_value, Vector2.by_value, Vector2.by_value, :float, Color.by_value], :void],

    # @!method DrawSplineSegmentBezierQuadratic(p1, c2, p3, thick, color)
    #   DrawSplineSegmentBezierQuadratic : Draw spline segment: Quadratic Bezier, 2 points, 1 control point
    #   @param p1 [Vector2]
    #   @param c2 [Vector2]
    #   @param p3 [Vector2]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawSplineSegmentBezierQuadratic, :DrawSplineSegmentBezierQuadratic, [Vector2.by_value, Vector2.by_value, Vector2.by_value, :float, Color.by_value], :void],

    # @!method DrawSplineSegmentBezierCubic(p1, c2, c3, p4, thick, color)
    #   DrawSplineSegmentBezierCubic : Draw spline segment: Cubic Bezier, 2 points, 2 control points
    #   @param p1 [Vector2]
    #   @param c2 [Vector2]
    #   @param c3 [Vector2]
    #   @param p4 [Vector2]
    #   @param thick [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawSplineSegmentBezierCubic, :DrawSplineSegmentBezierCubic, [Vector2.by_value, Vector2.by_value, Vector2.by_value, Vector2.by_value, :float, Color.by_value], :void],

    # @!method GetSplinePointLinear(startPos, endPos, t)
    #   GetSplinePointLinear : Get (evaluate) spline point: Linear
    #   @param startPos [Vector2]
    #   @param endPos [Vector2]
    #   @param t [float]
    #   @return [Vector2]
    [:GetSplinePointLinear, :GetSplinePointLinear, [Vector2.by_value, Vector2.by_value, :float], Vector2.by_value],

    # @!method GetSplinePointBasis(p1, p2, p3, p4, t)
    #   GetSplinePointBasis : Get (evaluate) spline point: B-Spline
    #   @param p1 [Vector2]
    #   @param p2 [Vector2]
    #   @param p3 [Vector2]
    #   @param p4 [Vector2]
    #   @param t [float]
    #   @return [Vector2]
    [:GetSplinePointBasis, :GetSplinePointBasis, [Vector2.by_value, Vector2.by_value, Vector2.by_value, Vector2.by_value, :float], Vector2.by_value],

    # @!method GetSplinePointCatmullRom(p1, p2, p3, p4, t)
    #   GetSplinePointCatmullRom : Get (evaluate) spline point: Catmull-Rom
    #   @param p1 [Vector2]
    #   @param p2 [Vector2]
    #   @param p3 [Vector2]
    #   @param p4 [Vector2]
    #   @param t [float]
    #   @return [Vector2]
    [:GetSplinePointCatmullRom, :GetSplinePointCatmullRom, [Vector2.by_value, Vector2.by_value, Vector2.by_value, Vector2.by_value, :float], Vector2.by_value],

    # @!method GetSplinePointBezierQuad(p1, c2, p3, t)
    #   GetSplinePointBezierQuad : Get (evaluate) spline point: Quadratic Bezier
    #   @param p1 [Vector2]
    #   @param c2 [Vector2]
    #   @param p3 [Vector2]
    #   @param t [float]
    #   @return [Vector2]
    [:GetSplinePointBezierQuad, :GetSplinePointBezierQuad, [Vector2.by_value, Vector2.by_value, Vector2.by_value, :float], Vector2.by_value],

    # @!method GetSplinePointBezierCubic(p1, c2, c3, p4, t)
    #   GetSplinePointBezierCubic : Get (evaluate) spline point: Cubic Bezier
    #   @param p1 [Vector2]
    #   @param c2 [Vector2]
    #   @param c3 [Vector2]
    #   @param p4 [Vector2]
    #   @param t [float]
    #   @return [Vector2]
    [:GetSplinePointBezierCubic, :GetSplinePointBezierCubic, [Vector2.by_value, Vector2.by_value, Vector2.by_value, Vector2.by_value, :float], Vector2.by_value],

    # @!method CheckCollisionRecs(rec1, rec2)
    #   CheckCollisionRecs : Check collision between two rectangles
    #   @param rec1 [Rectangle]
    #   @param rec2 [Rectangle]
    #   @return [bool]
    [:CheckCollisionRecs, :CheckCollisionRecs, [Rectangle.by_value, Rectangle.by_value], :bool],

    # @!method CheckCollisionCircles(center1, radius1, center2, radius2)
    #   CheckCollisionCircles : Check collision between two circles
    #   @param center1 [Vector2]
    #   @param radius1 [float]
    #   @param center2 [Vector2]
    #   @param radius2 [float]
    #   @return [bool]
    [:CheckCollisionCircles, :CheckCollisionCircles, [Vector2.by_value, :float, Vector2.by_value, :float], :bool],

    # @!method CheckCollisionCircleRec(center, radius, rec)
    #   CheckCollisionCircleRec : Check collision between circle and rectangle
    #   @param center [Vector2]
    #   @param radius [float]
    #   @param rec [Rectangle]
    #   @return [bool]
    [:CheckCollisionCircleRec, :CheckCollisionCircleRec, [Vector2.by_value, :float, Rectangle.by_value], :bool],

    # @!method CheckCollisionCircleLine(center, radius, p1, p2)
    #   CheckCollisionCircleLine : Check if circle collides with a line created betweeen two points [p1] and [p2]
    #   @param center [Vector2]
    #   @param radius [float]
    #   @param p1 [Vector2]
    #   @param p2 [Vector2]
    #   @return [bool]
    [:CheckCollisionCircleLine, :CheckCollisionCircleLine, [Vector2.by_value, :float, Vector2.by_value, Vector2.by_value], :bool],

    # @!method CheckCollisionPointRec(point, rec)
    #   CheckCollisionPointRec : Check if point is inside rectangle
    #   @param point [Vector2]
    #   @param rec [Rectangle]
    #   @return [bool]
    [:CheckCollisionPointRec, :CheckCollisionPointRec, [Vector2.by_value, Rectangle.by_value], :bool],

    # @!method CheckCollisionPointCircle(point, center, radius)
    #   CheckCollisionPointCircle : Check if point is inside circle
    #   @param point [Vector2]
    #   @param center [Vector2]
    #   @param radius [float]
    #   @return [bool]
    [:CheckCollisionPointCircle, :CheckCollisionPointCircle, [Vector2.by_value, Vector2.by_value, :float], :bool],

    # @!method CheckCollisionPointTriangle(point, p1, p2, p3)
    #   CheckCollisionPointTriangle : Check if point is inside a triangle
    #   @param point [Vector2]
    #   @param p1 [Vector2]
    #   @param p2 [Vector2]
    #   @param p3 [Vector2]
    #   @return [bool]
    [:CheckCollisionPointTriangle, :CheckCollisionPointTriangle, [Vector2.by_value, Vector2.by_value, Vector2.by_value, Vector2.by_value], :bool],

    # @!method CheckCollisionPointLine(point, p1, p2, threshold)
    #   CheckCollisionPointLine : Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]
    #   @param point [Vector2]
    #   @param p1 [Vector2]
    #   @param p2 [Vector2]
    #   @param threshold [int]
    #   @return [bool]
    [:CheckCollisionPointLine, :CheckCollisionPointLine, [Vector2.by_value, Vector2.by_value, Vector2.by_value, :int], :bool],

    # @!method CheckCollisionPointPoly(point, points, pointCount)
    #   CheckCollisionPointPoly : Check if point is within a polygon described by array of vertices
    #   @param point [Vector2]
    #   @param points [const Vector2 *]
    #   @param pointCount [int]
    #   @return [bool]
    [:CheckCollisionPointPoly, :CheckCollisionPointPoly, [Vector2.by_value, :pointer, :int], :bool],

    # @!method CheckCollisionLines(startPos1, endPos1, startPos2, endPos2, collisionPoint)
    #   CheckCollisionLines : Check the collision between two lines defined by two points each, returns collision point by reference
    #   @param startPos1 [Vector2]
    #   @param endPos1 [Vector2]
    #   @param startPos2 [Vector2]
    #   @param endPos2 [Vector2]
    #   @param collisionPoint [Vector2 *]
    #   @return [bool]
    [:CheckCollisionLines, :CheckCollisionLines, [Vector2.by_value, Vector2.by_value, Vector2.by_value, Vector2.by_value, :pointer], :bool],

    # @!method GetCollisionRec(rec1, rec2)
    #   GetCollisionRec : Get collision rectangle for two rectangles collision
    #   @param rec1 [Rectangle]
    #   @param rec2 [Rectangle]
    #   @return [Rectangle]
    [:GetCollisionRec, :GetCollisionRec, [Rectangle.by_value, Rectangle.by_value], Rectangle.by_value],

    # @!method LoadImage(fileName)
    #   LoadImage : Load image from file into CPU memory (RAM)
    #   @param fileName [const char *]
    #   @return [Image]
    [:LoadImage, :LoadImage, [:pointer], Image.by_value],

    # @!method LoadImageRaw(fileName, width, height, format, headerSize)
    #   LoadImageRaw : Load image from RAW file data
    #   @param fileName [const char *]
    #   @param width [int]
    #   @param height [int]
    #   @param format [int]
    #   @param headerSize [int]
    #   @return [Image]
    [:LoadImageRaw, :LoadImageRaw, [:pointer, :int, :int, :int, :int], Image.by_value],

    # @!method LoadImageAnim(fileName, frames)
    #   LoadImageAnim : Load image sequence from file (frames appended to image.data)
    #   @param fileName [const char *]
    #   @param frames [int *]
    #   @return [Image]
    [:LoadImageAnim, :LoadImageAnim, [:pointer, :pointer], Image.by_value],

    # @!method LoadImageAnimFromMemory(fileType, fileData, dataSize, frames)
    #   LoadImageAnimFromMemory : Load image sequence from memory buffer
    #   @param fileType [const char *]
    #   @param fileData [const unsigned char *]
    #   @param dataSize [int]
    #   @param frames [int *]
    #   @return [Image]
    [:LoadImageAnimFromMemory, :LoadImageAnimFromMemory, [:pointer, :pointer, :int, :pointer], Image.by_value],

    # @!method LoadImageFromMemory(fileType, fileData, dataSize)
    #   LoadImageFromMemory : Load image from memory buffer, fileType refers to extension: i.e. '.png'
    #   @param fileType [const char *]
    #   @param fileData [const unsigned char *]
    #   @param dataSize [int]
    #   @return [Image]
    [:LoadImageFromMemory, :LoadImageFromMemory, [:pointer, :pointer, :int], Image.by_value],

    # @!method LoadImageFromTexture(texture)
    #   LoadImageFromTexture : Load image from GPU texture data
    #   @param texture [Texture2D]
    #   @return [Image]
    [:LoadImageFromTexture, :LoadImageFromTexture, [Texture2D.by_value], Image.by_value],

    # @!method LoadImageFromScreen()
    #   LoadImageFromScreen : Load image from screen buffer and (screenshot)
    #   @return [Image]
    [:LoadImageFromScreen, :LoadImageFromScreen, [], Image.by_value],

    # @!method IsImageValid(image)
    #   IsImageValid : Check if an image is valid (data and parameters)
    #   @param image [Image]
    #   @return [bool]
    [:IsImageValid, :IsImageValid, [Image.by_value], :bool],

    # @!method UnloadImage(image)
    #   UnloadImage : Unload image from CPU memory (RAM)
    #   @param image [Image]
    #   @return [void]
    [:UnloadImage, :UnloadImage, [Image.by_value], :void],

    # @!method ExportImage(image, fileName)
    #   ExportImage : Export image data to file, returns true on success
    #   @param image [Image]
    #   @param fileName [const char *]
    #   @return [bool]
    [:ExportImage, :ExportImage, [Image.by_value, :pointer], :bool],

    # @!method ExportImageToMemory(image, fileType, fileSize)
    #   ExportImageToMemory : Export image to memory buffer
    #   @param image [Image]
    #   @param fileType [const char *]
    #   @param fileSize [int *]
    #   @return [unsigned char *]
    [:ExportImageToMemory, :ExportImageToMemory, [Image.by_value, :pointer, :pointer], :pointer],

    # @!method ExportImageAsCode(image, fileName)
    #   ExportImageAsCode : Export image as code file defining an array of bytes, returns true on success
    #   @param image [Image]
    #   @param fileName [const char *]
    #   @return [bool]
    [:ExportImageAsCode, :ExportImageAsCode, [Image.by_value, :pointer], :bool],

    # @!method GenImageColor(width, height, color)
    #   GenImageColor : Generate image: plain color
    #   @param width [int]
    #   @param height [int]
    #   @param color [Color]
    #   @return [Image]
    [:GenImageColor, :GenImageColor, [:int, :int, Color.by_value], Image.by_value],

    # @!method GenImageGradientLinear(width, height, direction, start, end)
    #   GenImageGradientLinear : Generate image: linear gradient, direction in degrees [0..360], 0=Vertical gradient
    #   @param width [int]
    #   @param height [int]
    #   @param direction [int]
    #   @param start [Color]
    #   @param end [Color]
    #   @return [Image]
    [:GenImageGradientLinear, :GenImageGradientLinear, [:int, :int, :int, Color.by_value, Color.by_value], Image.by_value],

    # @!method GenImageGradientRadial(width, height, density, inner, outer)
    #   GenImageGradientRadial : Generate image: radial gradient
    #   @param width [int]
    #   @param height [int]
    #   @param density [float]
    #   @param inner [Color]
    #   @param outer [Color]
    #   @return [Image]
    [:GenImageGradientRadial, :GenImageGradientRadial, [:int, :int, :float, Color.by_value, Color.by_value], Image.by_value],

    # @!method GenImageGradientSquare(width, height, density, inner, outer)
    #   GenImageGradientSquare : Generate image: square gradient
    #   @param width [int]
    #   @param height [int]
    #   @param density [float]
    #   @param inner [Color]
    #   @param outer [Color]
    #   @return [Image]
    [:GenImageGradientSquare, :GenImageGradientSquare, [:int, :int, :float, Color.by_value, Color.by_value], Image.by_value],

    # @!method GenImageChecked(width, height, checksX, checksY, col1, col2)
    #   GenImageChecked : Generate image: checked
    #   @param width [int]
    #   @param height [int]
    #   @param checksX [int]
    #   @param checksY [int]
    #   @param col1 [Color]
    #   @param col2 [Color]
    #   @return [Image]
    [:GenImageChecked, :GenImageChecked, [:int, :int, :int, :int, Color.by_value, Color.by_value], Image.by_value],

    # @!method GenImageWhiteNoise(width, height, factor)
    #   GenImageWhiteNoise : Generate image: white noise
    #   @param width [int]
    #   @param height [int]
    #   @param factor [float]
    #   @return [Image]
    [:GenImageWhiteNoise, :GenImageWhiteNoise, [:int, :int, :float], Image.by_value],

    # @!method GenImagePerlinNoise(width, height, offsetX, offsetY, scale)
    #   GenImagePerlinNoise : Generate image: perlin noise
    #   @param width [int]
    #   @param height [int]
    #   @param offsetX [int]
    #   @param offsetY [int]
    #   @param scale [float]
    #   @return [Image]
    [:GenImagePerlinNoise, :GenImagePerlinNoise, [:int, :int, :int, :int, :float], Image.by_value],

    # @!method GenImageCellular(width, height, tileSize)
    #   GenImageCellular : Generate image: cellular algorithm, bigger tileSize means bigger cells
    #   @param width [int]
    #   @param height [int]
    #   @param tileSize [int]
    #   @return [Image]
    [:GenImageCellular, :GenImageCellular, [:int, :int, :int], Image.by_value],

    # @!method GenImageText(width, height, text)
    #   GenImageText : Generate image: grayscale image from text data
    #   @param width [int]
    #   @param height [int]
    #   @param text [const char *]
    #   @return [Image]
    [:GenImageText, :GenImageText, [:int, :int, :pointer], Image.by_value],

    # @!method ImageCopy(image)
    #   ImageCopy : Create an image duplicate (useful for transformations)
    #   @param image [Image]
    #   @return [Image]
    [:ImageCopy, :ImageCopy, [Image.by_value], Image.by_value],

    # @!method ImageFromImage(image, rec)
    #   ImageFromImage : Create an image from another image piece
    #   @param image [Image]
    #   @param rec [Rectangle]
    #   @return [Image]
    [:ImageFromImage, :ImageFromImage, [Image.by_value, Rectangle.by_value], Image.by_value],

    # @!method ImageFromChannel(image, selectedChannel)
    #   ImageFromChannel : Create an image from a selected channel of another image (GRAYSCALE)
    #   @param image [Image]
    #   @param selectedChannel [int]
    #   @return [Image]
    [:ImageFromChannel, :ImageFromChannel, [Image.by_value, :int], Image.by_value],

    # @!method ImageText(text, fontSize, color)
    #   ImageText : Create an image from text (default font)
    #   @param text [const char *]
    #   @param fontSize [int]
    #   @param color [Color]
    #   @return [Image]
    [:ImageText, :ImageText, [:pointer, :int, Color.by_value], Image.by_value],

    # @!method ImageTextEx(font, text, fontSize, spacing, tint)
    #   ImageTextEx : Create an image from text (custom sprite font)
    #   @param font [Font]
    #   @param text [const char *]
    #   @param fontSize [float]
    #   @param spacing [float]
    #   @param tint [Color]
    #   @return [Image]
    [:ImageTextEx, :ImageTextEx, [Font.by_value, :pointer, :float, :float, Color.by_value], Image.by_value],

    # @!method ImageFormat(image, newFormat)
    #   ImageFormat : Convert image data to desired format
    #   @param image [Image *]
    #   @param newFormat [int]
    #   @return [void]
    [:ImageFormat, :ImageFormat, [:pointer, :int], :void],

    # @!method ImageToPOT(image, fill)
    #   ImageToPOT : Convert image to POT (power-of-two)
    #   @param image [Image *]
    #   @param fill [Color]
    #   @return [void]
    [:ImageToPOT, :ImageToPOT, [:pointer, Color.by_value], :void],

    # @!method ImageCrop(image, crop)
    #   ImageCrop : Crop an image to a defined rectangle
    #   @param image [Image *]
    #   @param crop [Rectangle]
    #   @return [void]
    [:ImageCrop, :ImageCrop, [:pointer, Rectangle.by_value], :void],

    # @!method ImageAlphaCrop(image, threshold)
    #   ImageAlphaCrop : Crop image depending on alpha value
    #   @param image [Image *]
    #   @param threshold [float]
    #   @return [void]
    [:ImageAlphaCrop, :ImageAlphaCrop, [:pointer, :float], :void],

    # @!method ImageAlphaClear(image, color, threshold)
    #   ImageAlphaClear : Clear alpha channel to desired color
    #   @param image [Image *]
    #   @param color [Color]
    #   @param threshold [float]
    #   @return [void]
    [:ImageAlphaClear, :ImageAlphaClear, [:pointer, Color.by_value, :float], :void],

    # @!method ImageAlphaMask(image, alphaMask)
    #   ImageAlphaMask : Apply alpha mask to image
    #   @param image [Image *]
    #   @param alphaMask [Image]
    #   @return [void]
    [:ImageAlphaMask, :ImageAlphaMask, [:pointer, Image.by_value], :void],

    # @!method ImageAlphaPremultiply(image)
    #   ImageAlphaPremultiply : Premultiply alpha channel
    #   @param image [Image *]
    #   @return [void]
    [:ImageAlphaPremultiply, :ImageAlphaPremultiply, [:pointer], :void],

    # @!method ImageBlurGaussian(image, blurSize)
    #   ImageBlurGaussian : Apply Gaussian blur using a box blur approximation
    #   @param image [Image *]
    #   @param blurSize [int]
    #   @return [void]
    [:ImageBlurGaussian, :ImageBlurGaussian, [:pointer, :int], :void],

    # @!method ImageKernelConvolution(image, kernel, kernelSize)
    #   ImageKernelConvolution : Apply custom square convolution kernel to image
    #   @param image [Image *]
    #   @param kernel [const float *]
    #   @param kernelSize [int]
    #   @return [void]
    [:ImageKernelConvolution, :ImageKernelConvolution, [:pointer, :pointer, :int], :void],

    # @!method ImageResize(image, newWidth, newHeight)
    #   ImageResize : Resize image (Bicubic scaling algorithm)
    #   @param image [Image *]
    #   @param newWidth [int]
    #   @param newHeight [int]
    #   @return [void]
    [:ImageResize, :ImageResize, [:pointer, :int, :int], :void],

    # @!method ImageResizeNN(image, newWidth, newHeight)
    #   ImageResizeNN : Resize image (Nearest-Neighbor scaling algorithm)
    #   @param image [Image *]
    #   @param newWidth [int]
    #   @param newHeight [int]
    #   @return [void]
    [:ImageResizeNN, :ImageResizeNN, [:pointer, :int, :int], :void],

    # @!method ImageResizeCanvas(image, newWidth, newHeight, offsetX, offsetY, fill)
    #   ImageResizeCanvas : Resize canvas and fill with color
    #   @param image [Image *]
    #   @param newWidth [int]
    #   @param newHeight [int]
    #   @param offsetX [int]
    #   @param offsetY [int]
    #   @param fill [Color]
    #   @return [void]
    [:ImageResizeCanvas, :ImageResizeCanvas, [:pointer, :int, :int, :int, :int, Color.by_value], :void],

    # @!method ImageMipmaps(image)
    #   ImageMipmaps : Compute all mipmap levels for a provided image
    #   @param image [Image *]
    #   @return [void]
    [:ImageMipmaps, :ImageMipmaps, [:pointer], :void],

    # @!method ImageDither(image, rBpp, gBpp, bBpp, aBpp)
    #   ImageDither : Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
    #   @param image [Image *]
    #   @param rBpp [int]
    #   @param gBpp [int]
    #   @param bBpp [int]
    #   @param aBpp [int]
    #   @return [void]
    [:ImageDither, :ImageDither, [:pointer, :int, :int, :int, :int], :void],

    # @!method ImageFlipVertical(image)
    #   ImageFlipVertical : Flip image vertically
    #   @param image [Image *]
    #   @return [void]
    [:ImageFlipVertical, :ImageFlipVertical, [:pointer], :void],

    # @!method ImageFlipHorizontal(image)
    #   ImageFlipHorizontal : Flip image horizontally
    #   @param image [Image *]
    #   @return [void]
    [:ImageFlipHorizontal, :ImageFlipHorizontal, [:pointer], :void],

    # @!method ImageRotate(image, degrees)
    #   ImageRotate : Rotate image by input angle in degrees (-359 to 359)
    #   @param image [Image *]
    #   @param degrees [int]
    #   @return [void]
    [:ImageRotate, :ImageRotate, [:pointer, :int], :void],

    # @!method ImageRotateCW(image)
    #   ImageRotateCW : Rotate image clockwise 90deg
    #   @param image [Image *]
    #   @return [void]
    [:ImageRotateCW, :ImageRotateCW, [:pointer], :void],

    # @!method ImageRotateCCW(image)
    #   ImageRotateCCW : Rotate image counter-clockwise 90deg
    #   @param image [Image *]
    #   @return [void]
    [:ImageRotateCCW, :ImageRotateCCW, [:pointer], :void],

    # @!method ImageColorTint(image, color)
    #   ImageColorTint : Modify image color: tint
    #   @param image [Image *]
    #   @param color [Color]
    #   @return [void]
    [:ImageColorTint, :ImageColorTint, [:pointer, Color.by_value], :void],

    # @!method ImageColorInvert(image)
    #   ImageColorInvert : Modify image color: invert
    #   @param image [Image *]
    #   @return [void]
    [:ImageColorInvert, :ImageColorInvert, [:pointer], :void],

    # @!method ImageColorGrayscale(image)
    #   ImageColorGrayscale : Modify image color: grayscale
    #   @param image [Image *]
    #   @return [void]
    [:ImageColorGrayscale, :ImageColorGrayscale, [:pointer], :void],

    # @!method ImageColorContrast(image, contrast)
    #   ImageColorContrast : Modify image color: contrast (-100 to 100)
    #   @param image [Image *]
    #   @param contrast [float]
    #   @return [void]
    [:ImageColorContrast, :ImageColorContrast, [:pointer, :float], :void],

    # @!method ImageColorBrightness(image, brightness)
    #   ImageColorBrightness : Modify image color: brightness (-255 to 255)
    #   @param image [Image *]
    #   @param brightness [int]
    #   @return [void]
    [:ImageColorBrightness, :ImageColorBrightness, [:pointer, :int], :void],

    # @!method ImageColorReplace(image, color, replace)
    #   ImageColorReplace : Modify image color: replace color
    #   @param image [Image *]
    #   @param color [Color]
    #   @param replace [Color]
    #   @return [void]
    [:ImageColorReplace, :ImageColorReplace, [:pointer, Color.by_value, Color.by_value], :void],

    # @!method LoadImageColors(image)
    #   LoadImageColors : Load color data from image as a Color array (RGBA - 32bit)
    #   @param image [Image]
    #   @return [Color *]
    [:LoadImageColors, :LoadImageColors, [Image.by_value], :pointer],

    # @!method LoadImagePalette(image, maxPaletteSize, colorCount)
    #   LoadImagePalette : Load colors palette from image as a Color array (RGBA - 32bit)
    #   @param image [Image]
    #   @param maxPaletteSize [int]
    #   @param colorCount [int *]
    #   @return [Color *]
    [:LoadImagePalette, :LoadImagePalette, [Image.by_value, :int, :pointer], :pointer],

    # @!method UnloadImageColors(colors)
    #   UnloadImageColors : Unload color data loaded with LoadImageColors()
    #   @param colors [Color *]
    #   @return [void]
    [:UnloadImageColors, :UnloadImageColors, [:pointer], :void],

    # @!method UnloadImagePalette(colors)
    #   UnloadImagePalette : Unload colors palette loaded with LoadImagePalette()
    #   @param colors [Color *]
    #   @return [void]
    [:UnloadImagePalette, :UnloadImagePalette, [:pointer], :void],

    # @!method GetImageAlphaBorder(image, threshold)
    #   GetImageAlphaBorder : Get image alpha border rectangle
    #   @param image [Image]
    #   @param threshold [float]
    #   @return [Rectangle]
    [:GetImageAlphaBorder, :GetImageAlphaBorder, [Image.by_value, :float], Rectangle.by_value],

    # @!method GetImageColor(image, x, y)
    #   GetImageColor : Get image pixel color at (x, y) position
    #   @param image [Image]
    #   @param x [int]
    #   @param y [int]
    #   @return [Color]
    [:GetImageColor, :GetImageColor, [Image.by_value, :int, :int], Color.by_value],

    # @!method ImageClearBackground(dst, color)
    #   ImageClearBackground : Clear image background with given color
    #   @param dst [Image *]
    #   @param color [Color]
    #   @return [void]
    [:ImageClearBackground, :ImageClearBackground, [:pointer, Color.by_value], :void],

    # @!method ImageDrawPixel(dst, posX, posY, color)
    #   ImageDrawPixel : Draw pixel within an image
    #   @param dst [Image *]
    #   @param posX [int]
    #   @param posY [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawPixel, :ImageDrawPixel, [:pointer, :int, :int, Color.by_value], :void],

    # @!method ImageDrawPixelV(dst, position, color)
    #   ImageDrawPixelV : Draw pixel within an image (Vector version)
    #   @param dst [Image *]
    #   @param position [Vector2]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawPixelV, :ImageDrawPixelV, [:pointer, Vector2.by_value, Color.by_value], :void],

    # @!method ImageDrawLine(dst, startPosX, startPosY, endPosX, endPosY, color)
    #   ImageDrawLine : Draw line within an image
    #   @param dst [Image *]
    #   @param startPosX [int]
    #   @param startPosY [int]
    #   @param endPosX [int]
    #   @param endPosY [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawLine, :ImageDrawLine, [:pointer, :int, :int, :int, :int, Color.by_value], :void],

    # @!method ImageDrawLineV(dst, start, end, color)
    #   ImageDrawLineV : Draw line within an image (Vector version)
    #   @param dst [Image *]
    #   @param start [Vector2]
    #   @param end [Vector2]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawLineV, :ImageDrawLineV, [:pointer, Vector2.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method ImageDrawLineEx(dst, start, end, thick, color)
    #   ImageDrawLineEx : Draw a line defining thickness within an image
    #   @param dst [Image *]
    #   @param start [Vector2]
    #   @param end [Vector2]
    #   @param thick [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawLineEx, :ImageDrawLineEx, [:pointer, Vector2.by_value, Vector2.by_value, :int, Color.by_value], :void],

    # @!method ImageDrawCircle(dst, centerX, centerY, radius, color)
    #   ImageDrawCircle : Draw a filled circle within an image
    #   @param dst [Image *]
    #   @param centerX [int]
    #   @param centerY [int]
    #   @param radius [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawCircle, :ImageDrawCircle, [:pointer, :int, :int, :int, Color.by_value], :void],

    # @!method ImageDrawCircleV(dst, center, radius, color)
    #   ImageDrawCircleV : Draw a filled circle within an image (Vector version)
    #   @param dst [Image *]
    #   @param center [Vector2]
    #   @param radius [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawCircleV, :ImageDrawCircleV, [:pointer, Vector2.by_value, :int, Color.by_value], :void],

    # @!method ImageDrawCircleLines(dst, centerX, centerY, radius, color)
    #   ImageDrawCircleLines : Draw circle outline within an image
    #   @param dst [Image *]
    #   @param centerX [int]
    #   @param centerY [int]
    #   @param radius [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawCircleLines, :ImageDrawCircleLines, [:pointer, :int, :int, :int, Color.by_value], :void],

    # @!method ImageDrawCircleLinesV(dst, center, radius, color)
    #   ImageDrawCircleLinesV : Draw circle outline within an image (Vector version)
    #   @param dst [Image *]
    #   @param center [Vector2]
    #   @param radius [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawCircleLinesV, :ImageDrawCircleLinesV, [:pointer, Vector2.by_value, :int, Color.by_value], :void],

    # @!method ImageDrawRectangle(dst, posX, posY, width, height, color)
    #   ImageDrawRectangle : Draw rectangle within an image
    #   @param dst [Image *]
    #   @param posX [int]
    #   @param posY [int]
    #   @param width [int]
    #   @param height [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawRectangle, :ImageDrawRectangle, [:pointer, :int, :int, :int, :int, Color.by_value], :void],

    # @!method ImageDrawRectangleV(dst, position, size, color)
    #   ImageDrawRectangleV : Draw rectangle within an image (Vector version)
    #   @param dst [Image *]
    #   @param position [Vector2]
    #   @param size [Vector2]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawRectangleV, :ImageDrawRectangleV, [:pointer, Vector2.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method ImageDrawRectangleRec(dst, rec, color)
    #   ImageDrawRectangleRec : Draw rectangle within an image
    #   @param dst [Image *]
    #   @param rec [Rectangle]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawRectangleRec, :ImageDrawRectangleRec, [:pointer, Rectangle.by_value, Color.by_value], :void],

    # @!method ImageDrawRectangleLines(dst, rec, thick, color)
    #   ImageDrawRectangleLines : Draw rectangle lines within an image
    #   @param dst [Image *]
    #   @param rec [Rectangle]
    #   @param thick [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawRectangleLines, :ImageDrawRectangleLines, [:pointer, Rectangle.by_value, :int, Color.by_value], :void],

    # @!method ImageDrawTriangle(dst, v1, v2, v3, color)
    #   ImageDrawTriangle : Draw triangle within an image
    #   @param dst [Image *]
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @param v3 [Vector2]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawTriangle, :ImageDrawTriangle, [:pointer, Vector2.by_value, Vector2.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method ImageDrawTriangleEx(dst, v1, v2, v3, c1, c2, c3)
    #   ImageDrawTriangleEx : Draw triangle with interpolated colors within an image
    #   @param dst [Image *]
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @param v3 [Vector2]
    #   @param c1 [Color]
    #   @param c2 [Color]
    #   @param c3 [Color]
    #   @return [void]
    [:ImageDrawTriangleEx, :ImageDrawTriangleEx, [:pointer, Vector2.by_value, Vector2.by_value, Vector2.by_value, Color.by_value, Color.by_value, Color.by_value], :void],

    # @!method ImageDrawTriangleLines(dst, v1, v2, v3, color)
    #   ImageDrawTriangleLines : Draw triangle outline within an image
    #   @param dst [Image *]
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @param v3 [Vector2]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawTriangleLines, :ImageDrawTriangleLines, [:pointer, Vector2.by_value, Vector2.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method ImageDrawTriangleFan(dst, points, pointCount, color)
    #   ImageDrawTriangleFan : Draw a triangle fan defined by points within an image (first vertex is the center)
    #   @param dst [Image *]
    #   @param points [Vector2 *]
    #   @param pointCount [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawTriangleFan, :ImageDrawTriangleFan, [:pointer, :pointer, :int, Color.by_value], :void],

    # @!method ImageDrawTriangleStrip(dst, points, pointCount, color)
    #   ImageDrawTriangleStrip : Draw a triangle strip defined by points within an image
    #   @param dst [Image *]
    #   @param points [Vector2 *]
    #   @param pointCount [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawTriangleStrip, :ImageDrawTriangleStrip, [:pointer, :pointer, :int, Color.by_value], :void],

    # @!method ImageDraw(dst, src, srcRec, dstRec, tint)
    #   ImageDraw : Draw a source image within a destination image (tint applied to source)
    #   @param dst [Image *]
    #   @param src [Image]
    #   @param srcRec [Rectangle]
    #   @param dstRec [Rectangle]
    #   @param tint [Color]
    #   @return [void]
    [:ImageDraw, :ImageDraw, [:pointer, Image.by_value, Rectangle.by_value, Rectangle.by_value, Color.by_value], :void],

    # @!method ImageDrawText(dst, text, posX, posY, fontSize, color)
    #   ImageDrawText : Draw text (using default font) within an image (destination)
    #   @param dst [Image *]
    #   @param text [const char *]
    #   @param posX [int]
    #   @param posY [int]
    #   @param fontSize [int]
    #   @param color [Color]
    #   @return [void]
    [:ImageDrawText, :ImageDrawText, [:pointer, :pointer, :int, :int, :int, Color.by_value], :void],

    # @!method ImageDrawTextEx(dst, font, text, position, fontSize, spacing, tint)
    #   ImageDrawTextEx : Draw text (custom sprite font) within an image (destination)
    #   @param dst [Image *]
    #   @param font [Font]
    #   @param text [const char *]
    #   @param position [Vector2]
    #   @param fontSize [float]
    #   @param spacing [float]
    #   @param tint [Color]
    #   @return [void]
    [:ImageDrawTextEx, :ImageDrawTextEx, [:pointer, Font.by_value, :pointer, Vector2.by_value, :float, :float, Color.by_value], :void],

    # @!method LoadTexture(fileName)
    #   LoadTexture : Load texture from file into GPU memory (VRAM)
    #   @param fileName [const char *]
    #   @return [Texture2D]
    [:LoadTexture, :LoadTexture, [:pointer], Texture2D.by_value],

    # @!method LoadTextureFromImage(image)
    #   LoadTextureFromImage : Load texture from image data
    #   @param image [Image]
    #   @return [Texture2D]
    [:LoadTextureFromImage, :LoadTextureFromImage, [Image.by_value], Texture2D.by_value],

    # @!method LoadTextureCubemap(image, layout)
    #   LoadTextureCubemap : Load cubemap from image, multiple image cubemap layouts supported
    #   @param image [Image]
    #   @param layout [int]
    #   @return [TextureCubemap]
    [:LoadTextureCubemap, :LoadTextureCubemap, [Image.by_value, :int], TextureCubemap.by_value],

    # @!method LoadRenderTexture(width, height)
    #   LoadRenderTexture : Load texture for rendering (framebuffer)
    #   @param width [int]
    #   @param height [int]
    #   @return [RenderTexture2D]
    [:LoadRenderTexture, :LoadRenderTexture, [:int, :int], RenderTexture2D.by_value],

    # @!method IsTextureValid(texture)
    #   IsTextureValid : Check if a texture is valid (loaded in GPU)
    #   @param texture [Texture2D]
    #   @return [bool]
    [:IsTextureValid, :IsTextureValid, [Texture2D.by_value], :bool],

    # @!method UnloadTexture(texture)
    #   UnloadTexture : Unload texture from GPU memory (VRAM)
    #   @param texture [Texture2D]
    #   @return [void]
    [:UnloadTexture, :UnloadTexture, [Texture2D.by_value], :void],

    # @!method IsRenderTextureValid(target)
    #   IsRenderTextureValid : Check if a render texture is valid (loaded in GPU)
    #   @param target [RenderTexture2D]
    #   @return [bool]
    [:IsRenderTextureValid, :IsRenderTextureValid, [RenderTexture2D.by_value], :bool],

    # @!method UnloadRenderTexture(target)
    #   UnloadRenderTexture : Unload render texture from GPU memory (VRAM)
    #   @param target [RenderTexture2D]
    #   @return [void]
    [:UnloadRenderTexture, :UnloadRenderTexture, [RenderTexture2D.by_value], :void],

    # @!method UpdateTexture(texture, pixels)
    #   UpdateTexture : Update GPU texture with new data
    #   @param texture [Texture2D]
    #   @param pixels [const void *]
    #   @return [void]
    [:UpdateTexture, :UpdateTexture, [Texture2D.by_value, :pointer], :void],

    # @!method UpdateTextureRec(texture, rec, pixels)
    #   UpdateTextureRec : Update GPU texture rectangle with new data
    #   @param texture [Texture2D]
    #   @param rec [Rectangle]
    #   @param pixels [const void *]
    #   @return [void]
    [:UpdateTextureRec, :UpdateTextureRec, [Texture2D.by_value, Rectangle.by_value, :pointer], :void],

    # @!method GenTextureMipmaps(texture)
    #   GenTextureMipmaps : Generate GPU mipmaps for a texture
    #   @param texture [Texture2D *]
    #   @return [void]
    [:GenTextureMipmaps, :GenTextureMipmaps, [:pointer], :void],

    # @!method SetTextureFilter(texture, filter)
    #   SetTextureFilter : Set texture scaling filter mode
    #   @param texture [Texture2D]
    #   @param filter [int]
    #   @return [void]
    [:SetTextureFilter, :SetTextureFilter, [Texture2D.by_value, :int], :void],

    # @!method SetTextureWrap(texture, wrap)
    #   SetTextureWrap : Set texture wrapping mode
    #   @param texture [Texture2D]
    #   @param wrap [int]
    #   @return [void]
    [:SetTextureWrap, :SetTextureWrap, [Texture2D.by_value, :int], :void],

    # @!method DrawTexture(texture, posX, posY, tint)
    #   DrawTexture : Draw a Texture2D
    #   @param texture [Texture2D]
    #   @param posX [int]
    #   @param posY [int]
    #   @param tint [Color]
    #   @return [void]
    [:DrawTexture, :DrawTexture, [Texture2D.by_value, :int, :int, Color.by_value], :void],

    # @!method DrawTextureV(texture, position, tint)
    #   DrawTextureV : Draw a Texture2D with position defined as Vector2
    #   @param texture [Texture2D]
    #   @param position [Vector2]
    #   @param tint [Color]
    #   @return [void]
    [:DrawTextureV, :DrawTextureV, [Texture2D.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method DrawTextureEx(texture, position, rotation, scale, tint)
    #   DrawTextureEx : Draw a Texture2D with extended parameters
    #   @param texture [Texture2D]
    #   @param position [Vector2]
    #   @param rotation [float]
    #   @param scale [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawTextureEx, :DrawTextureEx, [Texture2D.by_value, Vector2.by_value, :float, :float, Color.by_value], :void],

    # @!method DrawTextureRec(texture, source, position, tint)
    #   DrawTextureRec : Draw a part of a texture defined by a rectangle
    #   @param texture [Texture2D]
    #   @param source [Rectangle]
    #   @param position [Vector2]
    #   @param tint [Color]
    #   @return [void]
    [:DrawTextureRec, :DrawTextureRec, [Texture2D.by_value, Rectangle.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method DrawTexturePro(texture, source, dest, origin, rotation, tint)
    #   DrawTexturePro : Draw a part of a texture defined by a rectangle with 'pro' parameters
    #   @param texture [Texture2D]
    #   @param source [Rectangle]
    #   @param dest [Rectangle]
    #   @param origin [Vector2]
    #   @param rotation [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawTexturePro, :DrawTexturePro, [Texture2D.by_value, Rectangle.by_value, Rectangle.by_value, Vector2.by_value, :float, Color.by_value], :void],

    # @!method DrawTextureNPatch(texture, nPatchInfo, dest, origin, rotation, tint)
    #   DrawTextureNPatch : Draws a texture (or part of it) that stretches or shrinks nicely
    #   @param texture [Texture2D]
    #   @param nPatchInfo [NPatchInfo]
    #   @param dest [Rectangle]
    #   @param origin [Vector2]
    #   @param rotation [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawTextureNPatch, :DrawTextureNPatch, [Texture2D.by_value, NPatchInfo.by_value, Rectangle.by_value, Vector2.by_value, :float, Color.by_value], :void],

    # @!method ColorIsEqual(col1, col2)
    #   ColorIsEqual : Check if two colors are equal
    #   @param col1 [Color]
    #   @param col2 [Color]
    #   @return [bool]
    [:ColorIsEqual, :ColorIsEqual, [Color.by_value, Color.by_value], :bool],

    # @!method Fade(color, alpha)
    #   Fade : Get color with alpha applied, alpha goes from 0.0f to 1.0f
    #   @param color [Color]
    #   @param alpha [float]
    #   @return [Color]
    [:Fade, :Fade, [Color.by_value, :float], Color.by_value],

    # @!method ColorToInt(color)
    #   ColorToInt : Get hexadecimal value for a Color (0xRRGGBBAA)
    #   @param color [Color]
    #   @return [int]
    [:ColorToInt, :ColorToInt, [Color.by_value], :int],

    # @!method ColorNormalize(color)
    #   ColorNormalize : Get Color normalized as float [0..1]
    #   @param color [Color]
    #   @return [Vector4]
    [:ColorNormalize, :ColorNormalize, [Color.by_value], Vector4.by_value],

    # @!method ColorFromNormalized(normalized)
    #   ColorFromNormalized : Get Color from normalized values [0..1]
    #   @param normalized [Vector4]
    #   @return [Color]
    [:ColorFromNormalized, :ColorFromNormalized, [Vector4.by_value], Color.by_value],

    # @!method ColorToHSV(color)
    #   ColorToHSV : Get HSV values for a Color, hue [0..360], saturation/value [0..1]
    #   @param color [Color]
    #   @return [Vector3]
    [:ColorToHSV, :ColorToHSV, [Color.by_value], Vector3.by_value],

    # @!method ColorFromHSV(hue, saturation, value)
    #   ColorFromHSV : Get a Color from HSV values, hue [0..360], saturation/value [0..1]
    #   @param hue [float]
    #   @param saturation [float]
    #   @param value [float]
    #   @return [Color]
    [:ColorFromHSV, :ColorFromHSV, [:float, :float, :float], Color.by_value],

    # @!method ColorTint(color, tint)
    #   ColorTint : Get color multiplied with another color
    #   @param color [Color]
    #   @param tint [Color]
    #   @return [Color]
    [:ColorTint, :ColorTint, [Color.by_value, Color.by_value], Color.by_value],

    # @!method ColorBrightness(color, factor)
    #   ColorBrightness : Get color with brightness correction, brightness factor goes from -1.0f to 1.0f
    #   @param color [Color]
    #   @param factor [float]
    #   @return [Color]
    [:ColorBrightness, :ColorBrightness, [Color.by_value, :float], Color.by_value],

    # @!method ColorContrast(color, contrast)
    #   ColorContrast : Get color with contrast correction, contrast values between -1.0f and 1.0f
    #   @param color [Color]
    #   @param contrast [float]
    #   @return [Color]
    [:ColorContrast, :ColorContrast, [Color.by_value, :float], Color.by_value],

    # @!method ColorAlpha(color, alpha)
    #   ColorAlpha : Get color with alpha applied, alpha goes from 0.0f to 1.0f
    #   @param color [Color]
    #   @param alpha [float]
    #   @return [Color]
    [:ColorAlpha, :ColorAlpha, [Color.by_value, :float], Color.by_value],

    # @!method ColorAlphaBlend(dst, src, tint)
    #   ColorAlphaBlend : Get src alpha-blended into dst color with tint
    #   @param dst [Color]
    #   @param src [Color]
    #   @param tint [Color]
    #   @return [Color]
    [:ColorAlphaBlend, :ColorAlphaBlend, [Color.by_value, Color.by_value, Color.by_value], Color.by_value],

    # @!method ColorLerp(color1, color2, factor)
    #   ColorLerp : Get color lerp interpolation between two colors, factor [0.0f..1.0f]
    #   @param color1 [Color]
    #   @param color2 [Color]
    #   @param factor [float]
    #   @return [Color]
    [:ColorLerp, :ColorLerp, [Color.by_value, Color.by_value, :float], Color.by_value],

    # @!method GetColor(hexValue)
    #   GetColor : Get Color structure from hexadecimal value
    #   @param hexValue [unsigned int]
    #   @return [Color]
    [:GetColor, :GetColor, [:uint], Color.by_value],

    # @!method GetPixelColor(srcPtr, format)
    #   GetPixelColor : Get Color from a source pixel pointer of certain format
    #   @param srcPtr [void *]
    #   @param format [int]
    #   @return [Color]
    [:GetPixelColor, :GetPixelColor, [:pointer, :int], Color.by_value],

    # @!method SetPixelColor(dstPtr, color, format)
    #   SetPixelColor : Set color formatted into destination pixel pointer
    #   @param dstPtr [void *]
    #   @param color [Color]
    #   @param format [int]
    #   @return [void]
    [:SetPixelColor, :SetPixelColor, [:pointer, Color.by_value, :int], :void],

    # @!method GetPixelDataSize(width, height, format)
    #   GetPixelDataSize : Get pixel data size in bytes for certain format
    #   @param width [int]
    #   @param height [int]
    #   @param format [int]
    #   @return [int]
    [:GetPixelDataSize, :GetPixelDataSize, [:int, :int, :int], :int],

    # @!method GetFontDefault()
    #   GetFontDefault : Get the default Font
    #   @return [Font]
    [:GetFontDefault, :GetFontDefault, [], Font.by_value],

    # @!method LoadFont(fileName)
    #   LoadFont : Load font from file into GPU memory (VRAM)
    #   @param fileName [const char *]
    #   @return [Font]
    [:LoadFont, :LoadFont, [:pointer], Font.by_value],

    # @!method LoadFontEx(fileName, fontSize, codepoints, codepointCount)
    #   LoadFontEx : Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set, font size is provided in pixels height
    #   @param fileName [const char *]
    #   @param fontSize [int]
    #   @param codepoints [int *]
    #   @param codepointCount [int]
    #   @return [Font]
    [:LoadFontEx, :LoadFontEx, [:pointer, :int, :pointer, :int], Font.by_value],

    # @!method LoadFontFromImage(image, key, firstChar)
    #   LoadFontFromImage : Load font from Image (XNA style)
    #   @param image [Image]
    #   @param key [Color]
    #   @param firstChar [int]
    #   @return [Font]
    [:LoadFontFromImage, :LoadFontFromImage, [Image.by_value, Color.by_value, :int], Font.by_value],

    # @!method LoadFontFromMemory(fileType, fileData, dataSize, fontSize, codepoints, codepointCount)
    #   LoadFontFromMemory : Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
    #   @param fileType [const char *]
    #   @param fileData [const unsigned char *]
    #   @param dataSize [int]
    #   @param fontSize [int]
    #   @param codepoints [int *]
    #   @param codepointCount [int]
    #   @return [Font]
    [:LoadFontFromMemory, :LoadFontFromMemory, [:pointer, :pointer, :int, :int, :pointer, :int], Font.by_value],

    # @!method IsFontValid(font)
    #   IsFontValid : Check if a font is valid (font data loaded, WARNING: GPU texture not checked)
    #   @param font [Font]
    #   @return [bool]
    [:IsFontValid, :IsFontValid, [Font.by_value], :bool],

    # @!method LoadFontData(fileData, dataSize, fontSize, codepoints, codepointCount, type)
    #   LoadFontData : Load font data for further use
    #   @param fileData [const unsigned char *]
    #   @param dataSize [int]
    #   @param fontSize [int]
    #   @param codepoints [int *]
    #   @param codepointCount [int]
    #   @param type [int]
    #   @return [GlyphInfo *]
    [:LoadFontData, :LoadFontData, [:pointer, :int, :int, :pointer, :int, :int], :pointer],

    # @!method GenImageFontAtlas(glyphs, glyphRecs, glyphCount, fontSize, padding, packMethod)
    #   GenImageFontAtlas : Generate image font atlas using chars info
    #   @param glyphs [const GlyphInfo *]
    #   @param glyphRecs [Rectangle **]
    #   @param glyphCount [int]
    #   @param fontSize [int]
    #   @param padding [int]
    #   @param packMethod [int]
    #   @return [Image]
    [:GenImageFontAtlas, :GenImageFontAtlas, [:pointer, :pointer, :int, :int, :int, :int], Image.by_value],

    # @!method UnloadFontData(glyphs, glyphCount)
    #   UnloadFontData : Unload font chars info data (RAM)
    #   @param glyphs [GlyphInfo *]
    #   @param glyphCount [int]
    #   @return [void]
    [:UnloadFontData, :UnloadFontData, [:pointer, :int], :void],

    # @!method UnloadFont(font)
    #   UnloadFont : Unload font from GPU memory (VRAM)
    #   @param font [Font]
    #   @return [void]
    [:UnloadFont, :UnloadFont, [Font.by_value], :void],

    # @!method ExportFontAsCode(font, fileName)
    #   ExportFontAsCode : Export font as code file, returns true on success
    #   @param font [Font]
    #   @param fileName [const char *]
    #   @return [bool]
    [:ExportFontAsCode, :ExportFontAsCode, [Font.by_value, :pointer], :bool],

    # @!method DrawFPS(posX, posY)
    #   DrawFPS : Draw current FPS
    #   @param posX [int]
    #   @param posY [int]
    #   @return [void]
    [:DrawFPS, :DrawFPS, [:int, :int], :void],

    # @!method DrawText(text, posX, posY, fontSize, color)
    #   DrawText : Draw text (using default font)
    #   @param text [const char *]
    #   @param posX [int]
    #   @param posY [int]
    #   @param fontSize [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawText, :DrawText, [:pointer, :int, :int, :int, Color.by_value], :void],

    # @!method DrawTextEx(font, text, position, fontSize, spacing, tint)
    #   DrawTextEx : Draw text using font and additional parameters
    #   @param font [Font]
    #   @param text [const char *]
    #   @param position [Vector2]
    #   @param fontSize [float]
    #   @param spacing [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawTextEx, :DrawTextEx, [Font.by_value, :pointer, Vector2.by_value, :float, :float, Color.by_value], :void],

    # @!method DrawTextPro(font, text, position, origin, rotation, fontSize, spacing, tint)
    #   DrawTextPro : Draw text using Font and pro parameters (rotation)
    #   @param font [Font]
    #   @param text [const char *]
    #   @param position [Vector2]
    #   @param origin [Vector2]
    #   @param rotation [float]
    #   @param fontSize [float]
    #   @param spacing [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawTextPro, :DrawTextPro, [Font.by_value, :pointer, Vector2.by_value, Vector2.by_value, :float, :float, :float, Color.by_value], :void],

    # @!method DrawTextCodepoint(font, codepoint, position, fontSize, tint)
    #   DrawTextCodepoint : Draw one character (codepoint)
    #   @param font [Font]
    #   @param codepoint [int]
    #   @param position [Vector2]
    #   @param fontSize [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawTextCodepoint, :DrawTextCodepoint, [Font.by_value, :int, Vector2.by_value, :float, Color.by_value], :void],

    # @!method DrawTextCodepoints(font, codepoints, codepointCount, position, fontSize, spacing, tint)
    #   DrawTextCodepoints : Draw multiple character (codepoint)
    #   @param font [Font]
    #   @param codepoints [const int *]
    #   @param codepointCount [int]
    #   @param position [Vector2]
    #   @param fontSize [float]
    #   @param spacing [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawTextCodepoints, :DrawTextCodepoints, [Font.by_value, :pointer, :int, Vector2.by_value, :float, :float, Color.by_value], :void],

    # @!method SetTextLineSpacing(spacing)
    #   SetTextLineSpacing : Set vertical line spacing when drawing with line-breaks
    #   @param spacing [int]
    #   @return [void]
    [:SetTextLineSpacing, :SetTextLineSpacing, [:int], :void],

    # @!method MeasureText(text, fontSize)
    #   MeasureText : Measure string width for default font
    #   @param text [const char *]
    #   @param fontSize [int]
    #   @return [int]
    [:MeasureText, :MeasureText, [:pointer, :int], :int],

    # @!method MeasureTextEx(font, text, fontSize, spacing)
    #   MeasureTextEx : Measure string size for Font
    #   @param font [Font]
    #   @param text [const char *]
    #   @param fontSize [float]
    #   @param spacing [float]
    #   @return [Vector2]
    [:MeasureTextEx, :MeasureTextEx, [Font.by_value, :pointer, :float, :float], Vector2.by_value],

    # @!method GetGlyphIndex(font, codepoint)
    #   GetGlyphIndex : Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found
    #   @param font [Font]
    #   @param codepoint [int]
    #   @return [int]
    [:GetGlyphIndex, :GetGlyphIndex, [Font.by_value, :int], :int],

    # @!method GetGlyphInfo(font, codepoint)
    #   GetGlyphInfo : Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found
    #   @param font [Font]
    #   @param codepoint [int]
    #   @return [GlyphInfo]
    [:GetGlyphInfo, :GetGlyphInfo, [Font.by_value, :int], GlyphInfo.by_value],

    # @!method GetGlyphAtlasRec(font, codepoint)
    #   GetGlyphAtlasRec : Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found
    #   @param font [Font]
    #   @param codepoint [int]
    #   @return [Rectangle]
    [:GetGlyphAtlasRec, :GetGlyphAtlasRec, [Font.by_value, :int], Rectangle.by_value],

    # @!method LoadUTF8(codepoints, length)
    #   LoadUTF8 : Load UTF-8 text encoded from codepoints array
    #   @param codepoints [const int *]
    #   @param length [int]
    #   @return [char *]
    [:LoadUTF8, :LoadUTF8, [:pointer, :int], :pointer],

    # @!method UnloadUTF8(text)
    #   UnloadUTF8 : Unload UTF-8 text encoded from codepoints array
    #   @param text [char *]
    #   @return [void]
    [:UnloadUTF8, :UnloadUTF8, [:pointer], :void],

    # @!method LoadCodepoints(text, count)
    #   LoadCodepoints : Load all codepoints from a UTF-8 text string, codepoints count returned by parameter
    #   @param text [const char *]
    #   @param count [int *]
    #   @return [int *]
    [:LoadCodepoints, :LoadCodepoints, [:pointer, :pointer], :pointer],

    # @!method UnloadCodepoints(codepoints)
    #   UnloadCodepoints : Unload codepoints data from memory
    #   @param codepoints [int *]
    #   @return [void]
    [:UnloadCodepoints, :UnloadCodepoints, [:pointer], :void],

    # @!method GetCodepointCount(text)
    #   GetCodepointCount : Get total number of codepoints in a UTF-8 encoded string
    #   @param text [const char *]
    #   @return [int]
    [:GetCodepointCount, :GetCodepointCount, [:pointer], :int],

    # @!method GetCodepoint(text, codepointSize)
    #   GetCodepoint : Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
    #   @param text [const char *]
    #   @param codepointSize [int *]
    #   @return [int]
    [:GetCodepoint, :GetCodepoint, [:pointer, :pointer], :int],

    # @!method GetCodepointNext(text, codepointSize)
    #   GetCodepointNext : Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
    #   @param text [const char *]
    #   @param codepointSize [int *]
    #   @return [int]
    [:GetCodepointNext, :GetCodepointNext, [:pointer, :pointer], :int],

    # @!method GetCodepointPrevious(text, codepointSize)
    #   GetCodepointPrevious : Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
    #   @param text [const char *]
    #   @param codepointSize [int *]
    #   @return [int]
    [:GetCodepointPrevious, :GetCodepointPrevious, [:pointer, :pointer], :int],

    # @!method CodepointToUTF8(codepoint, utf8Size)
    #   CodepointToUTF8 : Encode one codepoint into UTF-8 byte array (array length returned as parameter)
    #   @param codepoint [int]
    #   @param utf8Size [int *]
    #   @return [const char *]
    [:CodepointToUTF8, :CodepointToUTF8, [:int, :pointer], :pointer],

    # @!method TextCopy(dst, src)
    #   TextCopy : Copy one string to another, returns bytes copied
    #   @param dst [char *]
    #   @param src [const char *]
    #   @return [int]
    [:TextCopy, :TextCopy, [:pointer, :pointer], :int],

    # @!method TextIsEqual(text1, text2)
    #   TextIsEqual : Check if two text string are equal
    #   @param text1 [const char *]
    #   @param text2 [const char *]
    #   @return [bool]
    [:TextIsEqual, :TextIsEqual, [:pointer, :pointer], :bool],

    # @!method TextLength(text)
    #   TextLength : Get text length, checks for '\0' ending
    #   @param text [const char *]
    #   @return [unsigned int]
    [:TextLength, :TextLength, [:pointer], :uint],

    # @!method TextFormat(text, ...)
    #   TextFormat : Text formatting with variables (sprintf() style)
    #   @param text [const char *]
    #   @param args [...]
    #   @return [const char *]
    [:TextFormat, :TextFormat, [:pointer, :varargs], :pointer],

    # @!method TextSubtext(text, position, length)
    #   TextSubtext : Get a piece of a text string
    #   @param text [const char *]
    #   @param position [int]
    #   @param length [int]
    #   @return [const char *]
    [:TextSubtext, :TextSubtext, [:pointer, :int, :int], :pointer],

    # @!method TextReplace(text, replace, by)
    #   TextReplace : Replace text string (WARNING: memory must be freed!)
    #   @param text [const char *]
    #   @param replace [const char *]
    #   @param by [const char *]
    #   @return [char *]
    [:TextReplace, :TextReplace, [:pointer, :pointer, :pointer], :pointer],

    # @!method TextInsert(text, insert, position)
    #   TextInsert : Insert text in a position (WARNING: memory must be freed!)
    #   @param text [const char *]
    #   @param insert [const char *]
    #   @param position [int]
    #   @return [char *]
    [:TextInsert, :TextInsert, [:pointer, :pointer, :int], :pointer],

    # @!method TextJoin(textList, count, delimiter)
    #   TextJoin : Join text strings with delimiter
    #   @param textList [const char **]
    #   @param count [int]
    #   @param delimiter [const char *]
    #   @return [const char *]
    [:TextJoin, :TextJoin, [:pointer, :int, :pointer], :pointer],

    # @!method TextSplit(text, delimiter, count)
    #   TextSplit : Split text into multiple strings
    #   @param text [const char *]
    #   @param delimiter [char]
    #   @param count [int *]
    #   @return [const char **]
    [:TextSplit, :TextSplit, [:pointer, :char, :pointer], :pointer],

    # @!method TextAppend(text, append, position)
    #   TextAppend : Append text at specific position and move cursor!
    #   @param text [char *]
    #   @param append [const char *]
    #   @param position [int *]
    #   @return [void]
    [:TextAppend, :TextAppend, [:pointer, :pointer, :pointer], :void],

    # @!method TextFindIndex(text, find)
    #   TextFindIndex : Find first text occurrence within a string
    #   @param text [const char *]
    #   @param find [const char *]
    #   @return [int]
    [:TextFindIndex, :TextFindIndex, [:pointer, :pointer], :int],

    # @!method TextToUpper(text)
    #   TextToUpper : Get upper case version of provided string
    #   @param text [const char *]
    #   @return [const char *]
    [:TextToUpper, :TextToUpper, [:pointer], :pointer],

    # @!method TextToLower(text)
    #   TextToLower : Get lower case version of provided string
    #   @param text [const char *]
    #   @return [const char *]
    [:TextToLower, :TextToLower, [:pointer], :pointer],

    # @!method TextToPascal(text)
    #   TextToPascal : Get Pascal case notation version of provided string
    #   @param text [const char *]
    #   @return [const char *]
    [:TextToPascal, :TextToPascal, [:pointer], :pointer],

    # @!method TextToSnake(text)
    #   TextToSnake : Get Snake case notation version of provided string
    #   @param text [const char *]
    #   @return [const char *]
    [:TextToSnake, :TextToSnake, [:pointer], :pointer],

    # @!method TextToCamel(text)
    #   TextToCamel : Get Camel case notation version of provided string
    #   @param text [const char *]
    #   @return [const char *]
    [:TextToCamel, :TextToCamel, [:pointer], :pointer],

    # @!method TextToInteger(text)
    #   TextToInteger : Get integer value from text
    #   @param text [const char *]
    #   @return [int]
    [:TextToInteger, :TextToInteger, [:pointer], :int],

    # @!method TextToFloat(text)
    #   TextToFloat : Get float value from text
    #   @param text [const char *]
    #   @return [float]
    [:TextToFloat, :TextToFloat, [:pointer], :float],

    # @!method DrawLine3D(startPos, endPos, color)
    #   DrawLine3D : Draw a line in 3D world space
    #   @param startPos [Vector3]
    #   @param endPos [Vector3]
    #   @param color [Color]
    #   @return [void]
    [:DrawLine3D, :DrawLine3D, [Vector3.by_value, Vector3.by_value, Color.by_value], :void],

    # @!method DrawPoint3D(position, color)
    #   DrawPoint3D : Draw a point in 3D space, actually a small line
    #   @param position [Vector3]
    #   @param color [Color]
    #   @return [void]
    [:DrawPoint3D, :DrawPoint3D, [Vector3.by_value, Color.by_value], :void],

    # @!method DrawCircle3D(center, radius, rotationAxis, rotationAngle, color)
    #   DrawCircle3D : Draw a circle in 3D world space
    #   @param center [Vector3]
    #   @param radius [float]
    #   @param rotationAxis [Vector3]
    #   @param rotationAngle [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawCircle3D, :DrawCircle3D, [Vector3.by_value, :float, Vector3.by_value, :float, Color.by_value], :void],

    # @!method DrawTriangle3D(v1, v2, v3, color)
    #   DrawTriangle3D : Draw a color-filled triangle (vertex in counter-clockwise order!)
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @param v3 [Vector3]
    #   @param color [Color]
    #   @return [void]
    [:DrawTriangle3D, :DrawTriangle3D, [Vector3.by_value, Vector3.by_value, Vector3.by_value, Color.by_value], :void],

    # @!method DrawTriangleStrip3D(points, pointCount, color)
    #   DrawTriangleStrip3D : Draw a triangle strip defined by points
    #   @param points [const Vector3 *]
    #   @param pointCount [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawTriangleStrip3D, :DrawTriangleStrip3D, [:pointer, :int, Color.by_value], :void],

    # @!method DrawCube(position, width, height, length, color)
    #   DrawCube : Draw cube
    #   @param position [Vector3]
    #   @param width [float]
    #   @param height [float]
    #   @param length [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawCube, :DrawCube, [Vector3.by_value, :float, :float, :float, Color.by_value], :void],

    # @!method DrawCubeV(position, size, color)
    #   DrawCubeV : Draw cube (Vector version)
    #   @param position [Vector3]
    #   @param size [Vector3]
    #   @param color [Color]
    #   @return [void]
    [:DrawCubeV, :DrawCubeV, [Vector3.by_value, Vector3.by_value, Color.by_value], :void],

    # @!method DrawCubeWires(position, width, height, length, color)
    #   DrawCubeWires : Draw cube wires
    #   @param position [Vector3]
    #   @param width [float]
    #   @param height [float]
    #   @param length [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawCubeWires, :DrawCubeWires, [Vector3.by_value, :float, :float, :float, Color.by_value], :void],

    # @!method DrawCubeWiresV(position, size, color)
    #   DrawCubeWiresV : Draw cube wires (Vector version)
    #   @param position [Vector3]
    #   @param size [Vector3]
    #   @param color [Color]
    #   @return [void]
    [:DrawCubeWiresV, :DrawCubeWiresV, [Vector3.by_value, Vector3.by_value, Color.by_value], :void],

    # @!method DrawSphere(centerPos, radius, color)
    #   DrawSphere : Draw sphere
    #   @param centerPos [Vector3]
    #   @param radius [float]
    #   @param color [Color]
    #   @return [void]
    [:DrawSphere, :DrawSphere, [Vector3.by_value, :float, Color.by_value], :void],

    # @!method DrawSphereEx(centerPos, radius, rings, slices, color)
    #   DrawSphereEx : Draw sphere with extended parameters
    #   @param centerPos [Vector3]
    #   @param radius [float]
    #   @param rings [int]
    #   @param slices [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawSphereEx, :DrawSphereEx, [Vector3.by_value, :float, :int, :int, Color.by_value], :void],

    # @!method DrawSphereWires(centerPos, radius, rings, slices, color)
    #   DrawSphereWires : Draw sphere wires
    #   @param centerPos [Vector3]
    #   @param radius [float]
    #   @param rings [int]
    #   @param slices [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawSphereWires, :DrawSphereWires, [Vector3.by_value, :float, :int, :int, Color.by_value], :void],

    # @!method DrawCylinder(position, radiusTop, radiusBottom, height, slices, color)
    #   DrawCylinder : Draw a cylinder/cone
    #   @param position [Vector3]
    #   @param radiusTop [float]
    #   @param radiusBottom [float]
    #   @param height [float]
    #   @param slices [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawCylinder, :DrawCylinder, [Vector3.by_value, :float, :float, :float, :int, Color.by_value], :void],

    # @!method DrawCylinderEx(startPos, endPos, startRadius, endRadius, sides, color)
    #   DrawCylinderEx : Draw a cylinder with base at startPos and top at endPos
    #   @param startPos [Vector3]
    #   @param endPos [Vector3]
    #   @param startRadius [float]
    #   @param endRadius [float]
    #   @param sides [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawCylinderEx, :DrawCylinderEx, [Vector3.by_value, Vector3.by_value, :float, :float, :int, Color.by_value], :void],

    # @!method DrawCylinderWires(position, radiusTop, radiusBottom, height, slices, color)
    #   DrawCylinderWires : Draw a cylinder/cone wires
    #   @param position [Vector3]
    #   @param radiusTop [float]
    #   @param radiusBottom [float]
    #   @param height [float]
    #   @param slices [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawCylinderWires, :DrawCylinderWires, [Vector3.by_value, :float, :float, :float, :int, Color.by_value], :void],

    # @!method DrawCylinderWiresEx(startPos, endPos, startRadius, endRadius, sides, color)
    #   DrawCylinderWiresEx : Draw a cylinder wires with base at startPos and top at endPos
    #   @param startPos [Vector3]
    #   @param endPos [Vector3]
    #   @param startRadius [float]
    #   @param endRadius [float]
    #   @param sides [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawCylinderWiresEx, :DrawCylinderWiresEx, [Vector3.by_value, Vector3.by_value, :float, :float, :int, Color.by_value], :void],

    # @!method DrawCapsule(startPos, endPos, radius, slices, rings, color)
    #   DrawCapsule : Draw a capsule with the center of its sphere caps at startPos and endPos
    #   @param startPos [Vector3]
    #   @param endPos [Vector3]
    #   @param radius [float]
    #   @param slices [int]
    #   @param rings [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawCapsule, :DrawCapsule, [Vector3.by_value, Vector3.by_value, :float, :int, :int, Color.by_value], :void],

    # @!method DrawCapsuleWires(startPos, endPos, radius, slices, rings, color)
    #   DrawCapsuleWires : Draw capsule wireframe with the center of its sphere caps at startPos and endPos
    #   @param startPos [Vector3]
    #   @param endPos [Vector3]
    #   @param radius [float]
    #   @param slices [int]
    #   @param rings [int]
    #   @param color [Color]
    #   @return [void]
    [:DrawCapsuleWires, :DrawCapsuleWires, [Vector3.by_value, Vector3.by_value, :float, :int, :int, Color.by_value], :void],

    # @!method DrawPlane(centerPos, size, color)
    #   DrawPlane : Draw a plane XZ
    #   @param centerPos [Vector3]
    #   @param size [Vector2]
    #   @param color [Color]
    #   @return [void]
    [:DrawPlane, :DrawPlane, [Vector3.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method DrawRay(ray, color)
    #   DrawRay : Draw a ray line
    #   @param ray [Ray]
    #   @param color [Color]
    #   @return [void]
    [:DrawRay, :DrawRay, [Ray.by_value, Color.by_value], :void],

    # @!method DrawGrid(slices, spacing)
    #   DrawGrid : Draw a grid (centered at (0, 0, 0))
    #   @param slices [int]
    #   @param spacing [float]
    #   @return [void]
    [:DrawGrid, :DrawGrid, [:int, :float], :void],

    # @!method LoadModel(fileName)
    #   LoadModel : Load model from files (meshes and materials)
    #   @param fileName [const char *]
    #   @return [Model]
    [:LoadModel, :LoadModel, [:pointer], Model.by_value],

    # @!method LoadModelFromMesh(mesh)
    #   LoadModelFromMesh : Load model from generated mesh (default material)
    #   @param mesh [Mesh]
    #   @return [Model]
    [:LoadModelFromMesh, :LoadModelFromMesh, [Mesh.by_value], Model.by_value],

    # @!method IsModelValid(model)
    #   IsModelValid : Check if a model is valid (loaded in GPU, VAO/VBOs)
    #   @param model [Model]
    #   @return [bool]
    [:IsModelValid, :IsModelValid, [Model.by_value], :bool],

    # @!method UnloadModel(model)
    #   UnloadModel : Unload model (including meshes) from memory (RAM and/or VRAM)
    #   @param model [Model]
    #   @return [void]
    [:UnloadModel, :UnloadModel, [Model.by_value], :void],

    # @!method GetModelBoundingBox(model)
    #   GetModelBoundingBox : Compute model bounding box limits (considers all meshes)
    #   @param model [Model]
    #   @return [BoundingBox]
    [:GetModelBoundingBox, :GetModelBoundingBox, [Model.by_value], BoundingBox.by_value],

    # @!method DrawModel(model, position, scale, tint)
    #   DrawModel : Draw a model (with texture if set)
    #   @param model [Model]
    #   @param position [Vector3]
    #   @param scale [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawModel, :DrawModel, [Model.by_value, Vector3.by_value, :float, Color.by_value], :void],

    # @!method internalDrawModelEx(model, position, rotationAxis, rotationAngle, scale, tint)
    #   internalDrawModelEx : Draw a model with extended parameters
    #   @param model [Model]
    #   @param position [Vector3]
    #   @param rotationAxis [Vector3]
    #   @param rotationAngle [float]
    #   @param scale [Vector3]
    #   @param tint [Color]
    #   @return [void]
    [:internalDrawModelEx, :DrawModelEx, [Model.by_value, Vector3.by_value, Vector3.by_value, :float, Vector3.by_value, Color.by_value], :void],

    # @!method DrawModelWires(model, position, scale, tint)
    #   DrawModelWires : Draw a model wires (with texture if set)
    #   @param model [Model]
    #   @param position [Vector3]
    #   @param scale [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawModelWires, :DrawModelWires, [Model.by_value, Vector3.by_value, :float, Color.by_value], :void],

    # @!method DrawModelWiresEx(model, position, rotationAxis, rotationAngle, scale, tint)
    #   DrawModelWiresEx : Draw a model wires (with texture if set) with extended parameters
    #   @param model [Model]
    #   @param position [Vector3]
    #   @param rotationAxis [Vector3]
    #   @param rotationAngle [float]
    #   @param scale [Vector3]
    #   @param tint [Color]
    #   @return [void]
    [:DrawModelWiresEx, :DrawModelWiresEx, [Model.by_value, Vector3.by_value, Vector3.by_value, :float, Vector3.by_value, Color.by_value], :void],

    # @!method DrawModelPoints(model, position, scale, tint)
    #   DrawModelPoints : Draw a model as points
    #   @param model [Model]
    #   @param position [Vector3]
    #   @param scale [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawModelPoints, :DrawModelPoints, [Model.by_value, Vector3.by_value, :float, Color.by_value], :void],

    # @!method DrawModelPointsEx(model, position, rotationAxis, rotationAngle, scale, tint)
    #   DrawModelPointsEx : Draw a model as points with extended parameters
    #   @param model [Model]
    #   @param position [Vector3]
    #   @param rotationAxis [Vector3]
    #   @param rotationAngle [float]
    #   @param scale [Vector3]
    #   @param tint [Color]
    #   @return [void]
    [:DrawModelPointsEx, :DrawModelPointsEx, [Model.by_value, Vector3.by_value, Vector3.by_value, :float, Vector3.by_value, Color.by_value], :void],

    # @!method DrawBoundingBox(box, color)
    #   DrawBoundingBox : Draw bounding box (wires)
    #   @param box [BoundingBox]
    #   @param color [Color]
    #   @return [void]
    [:DrawBoundingBox, :DrawBoundingBox, [BoundingBox.by_value, Color.by_value], :void],

    # @!method DrawBillboard(camera, texture, position, scale, tint)
    #   DrawBillboard : Draw a billboard texture
    #   @param camera [Camera]
    #   @param texture [Texture2D]
    #   @param position [Vector3]
    #   @param scale [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawBillboard, :DrawBillboard, [Camera.by_value, Texture2D.by_value, Vector3.by_value, :float, Color.by_value], :void],

    # @!method DrawBillboardRec(camera, texture, source, position, size, tint)
    #   DrawBillboardRec : Draw a billboard texture defined by source
    #   @param camera [Camera]
    #   @param texture [Texture2D]
    #   @param source [Rectangle]
    #   @param position [Vector3]
    #   @param size [Vector2]
    #   @param tint [Color]
    #   @return [void]
    [:DrawBillboardRec, :DrawBillboardRec, [Camera.by_value, Texture2D.by_value, Rectangle.by_value, Vector3.by_value, Vector2.by_value, Color.by_value], :void],

    # @!method DrawBillboardPro(camera, texture, source, position, up, size, origin, rotation, tint)
    #   DrawBillboardPro : Draw a billboard texture defined by source and rotation
    #   @param camera [Camera]
    #   @param texture [Texture2D]
    #   @param source [Rectangle]
    #   @param position [Vector3]
    #   @param up [Vector3]
    #   @param size [Vector2]
    #   @param origin [Vector2]
    #   @param rotation [float]
    #   @param tint [Color]
    #   @return [void]
    [:DrawBillboardPro, :DrawBillboardPro, [Camera.by_value, Texture2D.by_value, Rectangle.by_value, Vector3.by_value, Vector3.by_value, Vector2.by_value, Vector2.by_value, :float, Color.by_value], :void],

    # @!method UploadMesh(mesh, dynamic)
    #   UploadMesh : Upload mesh vertex data in GPU and provide VAO/VBO ids
    #   @param mesh [Mesh *]
    #   @param dynamic [bool]
    #   @return [void]
    [:UploadMesh, :UploadMesh, [:pointer, :bool], :void],

    # @!method UpdateMeshBuffer(mesh, index, data, dataSize, offset)
    #   UpdateMeshBuffer : Update mesh vertex data in GPU for a specific buffer index
    #   @param mesh [Mesh]
    #   @param index [int]
    #   @param data [const void *]
    #   @param dataSize [int]
    #   @param offset [int]
    #   @return [void]
    [:UpdateMeshBuffer, :UpdateMeshBuffer, [Mesh.by_value, :int, :pointer, :int, :int], :void],

    # @!method UnloadMesh(mesh)
    #   UnloadMesh : Unload mesh data from CPU and GPU
    #   @param mesh [Mesh]
    #   @return [void]
    [:UnloadMesh, :UnloadMesh, [Mesh.by_value], :void],

    # @!method DrawMesh(mesh, material, transform)
    #   DrawMesh : Draw a 3d mesh with material and transform
    #   @param mesh [Mesh]
    #   @param material [Material]
    #   @param transform [Matrix]
    #   @return [void]
    [:DrawMesh, :DrawMesh, [Mesh.by_value, Material.by_value, Matrix.by_value], :void],

    # @!method DrawMeshInstanced(mesh, material, transforms, instances)
    #   DrawMeshInstanced : Draw multiple mesh instances with material and different transforms
    #   @param mesh [Mesh]
    #   @param material [Material]
    #   @param transforms [const Matrix *]
    #   @param instances [int]
    #   @return [void]
    [:DrawMeshInstanced, :DrawMeshInstanced, [Mesh.by_value, Material.by_value, :pointer, :int], :void],

    # @!method GetMeshBoundingBox(mesh)
    #   GetMeshBoundingBox : Compute mesh bounding box limits
    #   @param mesh [Mesh]
    #   @return [BoundingBox]
    [:GetMeshBoundingBox, :GetMeshBoundingBox, [Mesh.by_value], BoundingBox.by_value],

    # @!method GenMeshTangents(mesh)
    #   GenMeshTangents : Compute mesh tangents
    #   @param mesh [Mesh *]
    #   @return [void]
    [:GenMeshTangents, :GenMeshTangents, [:pointer], :void],

    # @!method ExportMesh(mesh, fileName)
    #   ExportMesh : Export mesh data to file, returns true on success
    #   @param mesh [Mesh]
    #   @param fileName [const char *]
    #   @return [bool]
    [:ExportMesh, :ExportMesh, [Mesh.by_value, :pointer], :bool],

    # @!method ExportMeshAsCode(mesh, fileName)
    #   ExportMeshAsCode : Export mesh as code file (.h) defining multiple arrays of vertex attributes
    #   @param mesh [Mesh]
    #   @param fileName [const char *]
    #   @return [bool]
    [:ExportMeshAsCode, :ExportMeshAsCode, [Mesh.by_value, :pointer], :bool],

    # @!method GenMeshPoly(sides, radius)
    #   GenMeshPoly : Generate polygonal mesh
    #   @param sides [int]
    #   @param radius [float]
    #   @return [Mesh]
    [:GenMeshPoly, :GenMeshPoly, [:int, :float], Mesh.by_value],

    # @!method GenMeshPlane(width, length, resX, resZ)
    #   GenMeshPlane : Generate plane mesh (with subdivisions)
    #   @param width [float]
    #   @param length [float]
    #   @param resX [int]
    #   @param resZ [int]
    #   @return [Mesh]
    [:GenMeshPlane, :GenMeshPlane, [:float, :float, :int, :int], Mesh.by_value],

    # @!method GenMeshCube(width, height, length)
    #   GenMeshCube : Generate cuboid mesh
    #   @param width [float]
    #   @param height [float]
    #   @param length [float]
    #   @return [Mesh]
    [:GenMeshCube, :GenMeshCube, [:float, :float, :float], Mesh.by_value],

    # @!method GenMeshSphere(radius, rings, slices)
    #   GenMeshSphere : Generate sphere mesh (standard sphere)
    #   @param radius [float]
    #   @param rings [int]
    #   @param slices [int]
    #   @return [Mesh]
    [:GenMeshSphere, :GenMeshSphere, [:float, :int, :int], Mesh.by_value],

    # @!method GenMeshHemiSphere(radius, rings, slices)
    #   GenMeshHemiSphere : Generate half-sphere mesh (no bottom cap)
    #   @param radius [float]
    #   @param rings [int]
    #   @param slices [int]
    #   @return [Mesh]
    [:GenMeshHemiSphere, :GenMeshHemiSphere, [:float, :int, :int], Mesh.by_value],

    # @!method GenMeshCylinder(radius, height, slices)
    #   GenMeshCylinder : Generate cylinder mesh
    #   @param radius [float]
    #   @param height [float]
    #   @param slices [int]
    #   @return [Mesh]
    [:GenMeshCylinder, :GenMeshCylinder, [:float, :float, :int], Mesh.by_value],

    # @!method GenMeshCone(radius, height, slices)
    #   GenMeshCone : Generate cone/pyramid mesh
    #   @param radius [float]
    #   @param height [float]
    #   @param slices [int]
    #   @return [Mesh]
    [:GenMeshCone, :GenMeshCone, [:float, :float, :int], Mesh.by_value],

    # @!method GenMeshTorus(radius, size, radSeg, sides)
    #   GenMeshTorus : Generate torus mesh
    #   @param radius [float]
    #   @param size [float]
    #   @param radSeg [int]
    #   @param sides [int]
    #   @return [Mesh]
    [:GenMeshTorus, :GenMeshTorus, [:float, :float, :int, :int], Mesh.by_value],

    # @!method GenMeshKnot(radius, size, radSeg, sides)
    #   GenMeshKnot : Generate trefoil knot mesh
    #   @param radius [float]
    #   @param size [float]
    #   @param radSeg [int]
    #   @param sides [int]
    #   @return [Mesh]
    [:GenMeshKnot, :GenMeshKnot, [:float, :float, :int, :int], Mesh.by_value],

    # @!method GenMeshHeightmap(heightmap, size)
    #   GenMeshHeightmap : Generate heightmap mesh from image data
    #   @param heightmap [Image]
    #   @param size [Vector3]
    #   @return [Mesh]
    [:GenMeshHeightmap, :GenMeshHeightmap, [Image.by_value, Vector3.by_value], Mesh.by_value],

    # @!method GenMeshCubicmap(cubicmap, cubeSize)
    #   GenMeshCubicmap : Generate cubes-based map mesh from image data
    #   @param cubicmap [Image]
    #   @param cubeSize [Vector3]
    #   @return [Mesh]
    [:GenMeshCubicmap, :GenMeshCubicmap, [Image.by_value, Vector3.by_value], Mesh.by_value],

    # @!method LoadMaterials(fileName, materialCount)
    #   LoadMaterials : Load materials from model file
    #   @param fileName [const char *]
    #   @param materialCount [int *]
    #   @return [Material *]
    [:LoadMaterials, :LoadMaterials, [:pointer, :pointer], :pointer],

    # @!method LoadMaterialDefault()
    #   LoadMaterialDefault : Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
    #   @return [Material]
    [:LoadMaterialDefault, :LoadMaterialDefault, [], Material.by_value],

    # @!method IsMaterialValid(material)
    #   IsMaterialValid : Check if a material is valid (shader assigned, map textures loaded in GPU)
    #   @param material [Material]
    #   @return [bool]
    [:IsMaterialValid, :IsMaterialValid, [Material.by_value], :bool],

    # @!method UnloadMaterial(material)
    #   UnloadMaterial : Unload material from GPU memory (VRAM)
    #   @param material [Material]
    #   @return [void]
    [:UnloadMaterial, :UnloadMaterial, [Material.by_value], :void],

    # @!method SetMaterialTexture(material, mapType, texture)
    #   SetMaterialTexture : Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
    #   @param material [Material *]
    #   @param mapType [int]
    #   @param texture [Texture2D]
    #   @return [void]
    [:SetMaterialTexture, :SetMaterialTexture, [:pointer, :int, Texture2D.by_value], :void],

    # @!method SetModelMeshMaterial(model, meshId, materialId)
    #   SetModelMeshMaterial : Set material for a mesh
    #   @param model [Model *]
    #   @param meshId [int]
    #   @param materialId [int]
    #   @return [void]
    [:SetModelMeshMaterial, :SetModelMeshMaterial, [:pointer, :int, :int], :void],

    # @!method LoadModelAnimations(fileName, animCount)
    #   LoadModelAnimations : Load model animations from file
    #   @param fileName [const char *]
    #   @param animCount [int *]
    #   @return [ModelAnimation *]
    [:LoadModelAnimations, :LoadModelAnimations, [:pointer, :pointer], :pointer],

    # @!method UpdateModelAnimation(model, anim, frame)
    #   UpdateModelAnimation : Update model animation pose (CPU)
    #   @param model [Model]
    #   @param anim [ModelAnimation]
    #   @param frame [int]
    #   @return [void]
    [:UpdateModelAnimation, :UpdateModelAnimation, [Model.by_value, ModelAnimation.by_value, :int], :void],

    # @!method UpdateModelAnimationBones(model, anim, frame)
    #   UpdateModelAnimationBones : Update model animation mesh bone matrices (GPU skinning)
    #   @param model [Model]
    #   @param anim [ModelAnimation]
    #   @param frame [int]
    #   @return [void]
    [:UpdateModelAnimationBones, :UpdateModelAnimationBones, [Model.by_value, ModelAnimation.by_value, :int], :void],

    # @!method UnloadModelAnimation(anim)
    #   UnloadModelAnimation : Unload animation data
    #   @param anim [ModelAnimation]
    #   @return [void]
    [:UnloadModelAnimation, :UnloadModelAnimation, [ModelAnimation.by_value], :void],

    # @!method UnloadModelAnimations(animations, animCount)
    #   UnloadModelAnimations : Unload animation array data
    #   @param animations [ModelAnimation *]
    #   @param animCount [int]
    #   @return [void]
    [:UnloadModelAnimations, :UnloadModelAnimations, [:pointer, :int], :void],

    # @!method IsModelAnimationValid(model, anim)
    #   IsModelAnimationValid : Check model animation skeleton match
    #   @param model [Model]
    #   @param anim [ModelAnimation]
    #   @return [bool]
    [:IsModelAnimationValid, :IsModelAnimationValid, [Model.by_value, ModelAnimation.by_value], :bool],

    # @!method CheckCollisionSpheres(center1, radius1, center2, radius2)
    #   CheckCollisionSpheres : Check collision between two spheres
    #   @param center1 [Vector3]
    #   @param radius1 [float]
    #   @param center2 [Vector3]
    #   @param radius2 [float]
    #   @return [bool]
    [:CheckCollisionSpheres, :CheckCollisionSpheres, [Vector3.by_value, :float, Vector3.by_value, :float], :bool],

    # @!method CheckCollisionBoxes(box1, box2)
    #   CheckCollisionBoxes : Check collision between two bounding boxes
    #   @param box1 [BoundingBox]
    #   @param box2 [BoundingBox]
    #   @return [bool]
    [:CheckCollisionBoxes, :CheckCollisionBoxes, [BoundingBox.by_value, BoundingBox.by_value], :bool],

    # @!method CheckCollisionBoxSphere(box, center, radius)
    #   CheckCollisionBoxSphere : Check collision between box and sphere
    #   @param box [BoundingBox]
    #   @param center [Vector3]
    #   @param radius [float]
    #   @return [bool]
    [:CheckCollisionBoxSphere, :CheckCollisionBoxSphere, [BoundingBox.by_value, Vector3.by_value, :float], :bool],

    # @!method GetRayCollisionSphere(ray, center, radius)
    #   GetRayCollisionSphere : Get collision info between ray and sphere
    #   @param ray [Ray]
    #   @param center [Vector3]
    #   @param radius [float]
    #   @return [RayCollision]
    [:GetRayCollisionSphere, :GetRayCollisionSphere, [Ray.by_value, Vector3.by_value, :float], RayCollision.by_value],

    # @!method GetRayCollisionBox(ray, box)
    #   GetRayCollisionBox : Get collision info between ray and box
    #   @param ray [Ray]
    #   @param box [BoundingBox]
    #   @return [RayCollision]
    [:GetRayCollisionBox, :GetRayCollisionBox, [Ray.by_value, BoundingBox.by_value], RayCollision.by_value],

    # @!method GetRayCollisionMesh(ray, mesh, transform)
    #   GetRayCollisionMesh : Get collision info between ray and mesh
    #   @param ray [Ray]
    #   @param mesh [Mesh]
    #   @param transform [Matrix]
    #   @return [RayCollision]
    [:GetRayCollisionMesh, :GetRayCollisionMesh, [Ray.by_value, Mesh.by_value, Matrix.by_value], RayCollision.by_value],

    # @!method GetRayCollisionTriangle(ray, p1, p2, p3)
    #   GetRayCollisionTriangle : Get collision info between ray and triangle
    #   @param ray [Ray]
    #   @param p1 [Vector3]
    #   @param p2 [Vector3]
    #   @param p3 [Vector3]
    #   @return [RayCollision]
    [:GetRayCollisionTriangle, :GetRayCollisionTriangle, [Ray.by_value, Vector3.by_value, Vector3.by_value, Vector3.by_value], RayCollision.by_value],

    # @!method GetRayCollisionQuad(ray, p1, p2, p3, p4)
    #   GetRayCollisionQuad : Get collision info between ray and quad
    #   @param ray [Ray]
    #   @param p1 [Vector3]
    #   @param p2 [Vector3]
    #   @param p3 [Vector3]
    #   @param p4 [Vector3]
    #   @return [RayCollision]
    [:GetRayCollisionQuad, :GetRayCollisionQuad, [Ray.by_value, Vector3.by_value, Vector3.by_value, Vector3.by_value, Vector3.by_value], RayCollision.by_value],

    # @!method InitAudioDevice()
    #   InitAudioDevice : Initialize audio device and context
    #   @return [void]
    [:InitAudioDevice, :InitAudioDevice, [], :void],

    # @!method CloseAudioDevice()
    #   CloseAudioDevice : Close the audio device and context
    #   @return [void]
    [:CloseAudioDevice, :CloseAudioDevice, [], :void],

    # @!method IsAudioDeviceReady()
    #   IsAudioDeviceReady : Check if audio device has been initialized successfully
    #   @return [bool]
    [:IsAudioDeviceReady, :IsAudioDeviceReady, [], :bool],

    # @!method SetMasterVolume(volume)
    #   SetMasterVolume : Set master volume (listener)
    #   @param volume [float]
    #   @return [void]
    [:SetMasterVolume, :SetMasterVolume, [:float], :void],

    # @!method GetMasterVolume()
    #   GetMasterVolume : Get master volume (listener)
    #   @return [float]
    [:GetMasterVolume, :GetMasterVolume, [], :float],

    # @!method LoadWave(fileName)
    #   LoadWave : Load wave data from file
    #   @param fileName [const char *]
    #   @return [Wave]
    [:LoadWave, :LoadWave, [:pointer], Wave.by_value],

    # @!method LoadWaveFromMemory(fileType, fileData, dataSize)
    #   LoadWaveFromMemory : Load wave from memory buffer, fileType refers to extension: i.e. '.wav'
    #   @param fileType [const char *]
    #   @param fileData [const unsigned char *]
    #   @param dataSize [int]
    #   @return [Wave]
    [:LoadWaveFromMemory, :LoadWaveFromMemory, [:pointer, :pointer, :int], Wave.by_value],

    # @!method IsWaveValid(wave)
    #   IsWaveValid : Checks if wave data is valid (data loaded and parameters)
    #   @param wave [Wave]
    #   @return [bool]
    [:IsWaveValid, :IsWaveValid, [Wave.by_value], :bool],

    # @!method LoadSound(fileName)
    #   LoadSound : Load sound from file
    #   @param fileName [const char *]
    #   @return [Sound]
    [:LoadSound, :LoadSound, [:pointer], Sound.by_value],

    # @!method LoadSoundFromWave(wave)
    #   LoadSoundFromWave : Load sound from wave data
    #   @param wave [Wave]
    #   @return [Sound]
    [:LoadSoundFromWave, :LoadSoundFromWave, [Wave.by_value], Sound.by_value],

    # @!method LoadSoundAlias(source)
    #   LoadSoundAlias : Create a new sound that shares the same sample data as the source sound, does not own the sound data
    #   @param source [Sound]
    #   @return [Sound]
    [:LoadSoundAlias, :LoadSoundAlias, [Sound.by_value], Sound.by_value],

    # @!method IsSoundValid(sound)
    #   IsSoundValid : Checks if a sound is valid (data loaded and buffers initialized)
    #   @param sound [Sound]
    #   @return [bool]
    [:IsSoundValid, :IsSoundValid, [Sound.by_value], :bool],

    # @!method UpdateSound(sound, data, sampleCount)
    #   UpdateSound : Update sound buffer with new data
    #   @param sound [Sound]
    #   @param data [const void *]
    #   @param sampleCount [int]
    #   @return [void]
    [:UpdateSound, :UpdateSound, [Sound.by_value, :pointer, :int], :void],

    # @!method UnloadWave(wave)
    #   UnloadWave : Unload wave data
    #   @param wave [Wave]
    #   @return [void]
    [:UnloadWave, :UnloadWave, [Wave.by_value], :void],

    # @!method UnloadSound(sound)
    #   UnloadSound : Unload sound
    #   @param sound [Sound]
    #   @return [void]
    [:UnloadSound, :UnloadSound, [Sound.by_value], :void],

    # @!method UnloadSoundAlias(alias)
    #   UnloadSoundAlias : Unload a sound alias (does not deallocate sample data)
    #   @param alias [Sound]
    #   @return [void]
    [:UnloadSoundAlias, :UnloadSoundAlias, [Sound.by_value], :void],

    # @!method ExportWave(wave, fileName)
    #   ExportWave : Export wave data to file, returns true on success
    #   @param wave [Wave]
    #   @param fileName [const char *]
    #   @return [bool]
    [:ExportWave, :ExportWave, [Wave.by_value, :pointer], :bool],

    # @!method ExportWaveAsCode(wave, fileName)
    #   ExportWaveAsCode : Export wave sample data to code (.h), returns true on success
    #   @param wave [Wave]
    #   @param fileName [const char *]
    #   @return [bool]
    [:ExportWaveAsCode, :ExportWaveAsCode, [Wave.by_value, :pointer], :bool],

    # @!method PlaySound(sound)
    #   PlaySound : Play a sound
    #   @param sound [Sound]
    #   @return [void]
    [:PlaySound, :PlaySound, [Sound.by_value], :void],

    # @!method StopSound(sound)
    #   StopSound : Stop playing a sound
    #   @param sound [Sound]
    #   @return [void]
    [:StopSound, :StopSound, [Sound.by_value], :void],

    # @!method PauseSound(sound)
    #   PauseSound : Pause a sound
    #   @param sound [Sound]
    #   @return [void]
    [:PauseSound, :PauseSound, [Sound.by_value], :void],

    # @!method ResumeSound(sound)
    #   ResumeSound : Resume a paused sound
    #   @param sound [Sound]
    #   @return [void]
    [:ResumeSound, :ResumeSound, [Sound.by_value], :void],

    # @!method IsSoundPlaying(sound)
    #   IsSoundPlaying : Check if a sound is currently playing
    #   @param sound [Sound]
    #   @return [bool]
    [:IsSoundPlaying, :IsSoundPlaying, [Sound.by_value], :bool],

    # @!method SetSoundVolume(sound, volume)
    #   SetSoundVolume : Set volume for a sound (1.0 is max level)
    #   @param sound [Sound]
    #   @param volume [float]
    #   @return [void]
    [:SetSoundVolume, :SetSoundVolume, [Sound.by_value, :float], :void],

    # @!method SetSoundPitch(sound, pitch)
    #   SetSoundPitch : Set pitch for a sound (1.0 is base level)
    #   @param sound [Sound]
    #   @param pitch [float]
    #   @return [void]
    [:SetSoundPitch, :SetSoundPitch, [Sound.by_value, :float], :void],

    # @!method SetSoundPan(sound, pan)
    #   SetSoundPan : Set pan for a sound (0.5 is center)
    #   @param sound [Sound]
    #   @param pan [float]
    #   @return [void]
    [:SetSoundPan, :SetSoundPan, [Sound.by_value, :float], :void],

    # @!method WaveCopy(wave)
    #   WaveCopy : Copy a wave to a new wave
    #   @param wave [Wave]
    #   @return [Wave]
    [:WaveCopy, :WaveCopy, [Wave.by_value], Wave.by_value],

    # @!method WaveCrop(wave, initFrame, finalFrame)
    #   WaveCrop : Crop a wave to defined frames range
    #   @param wave [Wave *]
    #   @param initFrame [int]
    #   @param finalFrame [int]
    #   @return [void]
    [:WaveCrop, :WaveCrop, [:pointer, :int, :int], :void],

    # @!method WaveFormat(wave, sampleRate, sampleSize, channels)
    #   WaveFormat : Convert wave data to desired format
    #   @param wave [Wave *]
    #   @param sampleRate [int]
    #   @param sampleSize [int]
    #   @param channels [int]
    #   @return [void]
    [:WaveFormat, :WaveFormat, [:pointer, :int, :int, :int], :void],

    # @!method LoadWaveSamples(wave)
    #   LoadWaveSamples : Load samples data from wave as a 32bit float data array
    #   @param wave [Wave]
    #   @return [float *]
    [:LoadWaveSamples, :LoadWaveSamples, [Wave.by_value], :pointer],

    # @!method UnloadWaveSamples(samples)
    #   UnloadWaveSamples : Unload samples data loaded with LoadWaveSamples()
    #   @param samples [float *]
    #   @return [void]
    [:UnloadWaveSamples, :UnloadWaveSamples, [:pointer], :void],

    # @!method LoadMusicStream(fileName)
    #   LoadMusicStream : Load music stream from file
    #   @param fileName [const char *]
    #   @return [Music]
    [:LoadMusicStream, :LoadMusicStream, [:pointer], Music.by_value],

    # @!method LoadMusicStreamFromMemory(fileType, data, dataSize)
    #   LoadMusicStreamFromMemory : Load music stream from data
    #   @param fileType [const char *]
    #   @param data [const unsigned char *]
    #   @param dataSize [int]
    #   @return [Music]
    [:LoadMusicStreamFromMemory, :LoadMusicStreamFromMemory, [:pointer, :pointer, :int], Music.by_value],

    # @!method IsMusicValid(music)
    #   IsMusicValid : Checks if a music stream is valid (context and buffers initialized)
    #   @param music [Music]
    #   @return [bool]
    [:IsMusicValid, :IsMusicValid, [Music.by_value], :bool],

    # @!method UnloadMusicStream(music)
    #   UnloadMusicStream : Unload music stream
    #   @param music [Music]
    #   @return [void]
    [:UnloadMusicStream, :UnloadMusicStream, [Music.by_value], :void],

    # @!method PlayMusicStream(music)
    #   PlayMusicStream : Start music playing
    #   @param music [Music]
    #   @return [void]
    [:PlayMusicStream, :PlayMusicStream, [Music.by_value], :void],

    # @!method IsMusicStreamPlaying(music)
    #   IsMusicStreamPlaying : Check if music is playing
    #   @param music [Music]
    #   @return [bool]
    [:IsMusicStreamPlaying, :IsMusicStreamPlaying, [Music.by_value], :bool],

    # @!method UpdateMusicStream(music)
    #   UpdateMusicStream : Updates buffers for music streaming
    #   @param music [Music]
    #   @return [void]
    [:UpdateMusicStream, :UpdateMusicStream, [Music.by_value], :void],

    # @!method StopMusicStream(music)
    #   StopMusicStream : Stop music playing
    #   @param music [Music]
    #   @return [void]
    [:StopMusicStream, :StopMusicStream, [Music.by_value], :void],

    # @!method PauseMusicStream(music)
    #   PauseMusicStream : Pause music playing
    #   @param music [Music]
    #   @return [void]
    [:PauseMusicStream, :PauseMusicStream, [Music.by_value], :void],

    # @!method ResumeMusicStream(music)
    #   ResumeMusicStream : Resume playing paused music
    #   @param music [Music]
    #   @return [void]
    [:ResumeMusicStream, :ResumeMusicStream, [Music.by_value], :void],

    # @!method SeekMusicStream(music, position)
    #   SeekMusicStream : Seek music to a position (in seconds)
    #   @param music [Music]
    #   @param position [float]
    #   @return [void]
    [:SeekMusicStream, :SeekMusicStream, [Music.by_value, :float], :void],

    # @!method SetMusicVolume(music, volume)
    #   SetMusicVolume : Set volume for music (1.0 is max level)
    #   @param music [Music]
    #   @param volume [float]
    #   @return [void]
    [:SetMusicVolume, :SetMusicVolume, [Music.by_value, :float], :void],

    # @!method SetMusicPitch(music, pitch)
    #   SetMusicPitch : Set pitch for a music (1.0 is base level)
    #   @param music [Music]
    #   @param pitch [float]
    #   @return [void]
    [:SetMusicPitch, :SetMusicPitch, [Music.by_value, :float], :void],

    # @!method SetMusicPan(music, pan)
    #   SetMusicPan : Set pan for a music (0.5 is center)
    #   @param music [Music]
    #   @param pan [float]
    #   @return [void]
    [:SetMusicPan, :SetMusicPan, [Music.by_value, :float], :void],

    # @!method GetMusicTimeLength(music)
    #   GetMusicTimeLength : Get music time length (in seconds)
    #   @param music [Music]
    #   @return [float]
    [:GetMusicTimeLength, :GetMusicTimeLength, [Music.by_value], :float],

    # @!method GetMusicTimePlayed(music)
    #   GetMusicTimePlayed : Get current music time played (in seconds)
    #   @param music [Music]
    #   @return [float]
    [:GetMusicTimePlayed, :GetMusicTimePlayed, [Music.by_value], :float],

    # @!method LoadAudioStream(sampleRate, sampleSize, channels)
    #   LoadAudioStream : Load audio stream (to stream raw audio pcm data)
    #   @param sampleRate [unsigned int]
    #   @param sampleSize [unsigned int]
    #   @param channels [unsigned int]
    #   @return [AudioStream]
    [:LoadAudioStream, :LoadAudioStream, [:uint, :uint, :uint], AudioStream.by_value],

    # @!method IsAudioStreamValid(stream)
    #   IsAudioStreamValid : Checks if an audio stream is valid (buffers initialized)
    #   @param stream [AudioStream]
    #   @return [bool]
    [:IsAudioStreamValid, :IsAudioStreamValid, [AudioStream.by_value], :bool],

    # @!method UnloadAudioStream(stream)
    #   UnloadAudioStream : Unload audio stream and free memory
    #   @param stream [AudioStream]
    #   @return [void]
    [:UnloadAudioStream, :UnloadAudioStream, [AudioStream.by_value], :void],

    # @!method UpdateAudioStream(stream, data, frameCount)
    #   UpdateAudioStream : Update audio stream buffers with data
    #   @param stream [AudioStream]
    #   @param data [const void *]
    #   @param frameCount [int]
    #   @return [void]
    [:UpdateAudioStream, :UpdateAudioStream, [AudioStream.by_value, :pointer, :int], :void],

    # @!method IsAudioStreamProcessed(stream)
    #   IsAudioStreamProcessed : Check if any audio stream buffers requires refill
    #   @param stream [AudioStream]
    #   @return [bool]
    [:IsAudioStreamProcessed, :IsAudioStreamProcessed, [AudioStream.by_value], :bool],

    # @!method PlayAudioStream(stream)
    #   PlayAudioStream : Play audio stream
    #   @param stream [AudioStream]
    #   @return [void]
    [:PlayAudioStream, :PlayAudioStream, [AudioStream.by_value], :void],

    # @!method PauseAudioStream(stream)
    #   PauseAudioStream : Pause audio stream
    #   @param stream [AudioStream]
    #   @return [void]
    [:PauseAudioStream, :PauseAudioStream, [AudioStream.by_value], :void],

    # @!method ResumeAudioStream(stream)
    #   ResumeAudioStream : Resume audio stream
    #   @param stream [AudioStream]
    #   @return [void]
    [:ResumeAudioStream, :ResumeAudioStream, [AudioStream.by_value], :void],

    # @!method IsAudioStreamPlaying(stream)
    #   IsAudioStreamPlaying : Check if audio stream is playing
    #   @param stream [AudioStream]
    #   @return [bool]
    [:IsAudioStreamPlaying, :IsAudioStreamPlaying, [AudioStream.by_value], :bool],

    # @!method StopAudioStream(stream)
    #   StopAudioStream : Stop audio stream
    #   @param stream [AudioStream]
    #   @return [void]
    [:StopAudioStream, :StopAudioStream, [AudioStream.by_value], :void],

    # @!method SetAudioStreamVolume(stream, volume)
    #   SetAudioStreamVolume : Set volume for audio stream (1.0 is max level)
    #   @param stream [AudioStream]
    #   @param volume [float]
    #   @return [void]
    [:SetAudioStreamVolume, :SetAudioStreamVolume, [AudioStream.by_value, :float], :void],

    # @!method SetAudioStreamPitch(stream, pitch)
    #   SetAudioStreamPitch : Set pitch for audio stream (1.0 is base level)
    #   @param stream [AudioStream]
    #   @param pitch [float]
    #   @return [void]
    [:SetAudioStreamPitch, :SetAudioStreamPitch, [AudioStream.by_value, :float], :void],

    # @!method SetAudioStreamPan(stream, pan)
    #   SetAudioStreamPan : Set pan for audio stream (0.5 is centered)
    #   @param stream [AudioStream]
    #   @param pan [float]
    #   @return [void]
    [:SetAudioStreamPan, :SetAudioStreamPan, [AudioStream.by_value, :float], :void],

    # @!method SetAudioStreamBufferSizeDefault(size)
    #   SetAudioStreamBufferSizeDefault : Default size for new audio streams
    #   @param size [int]
    #   @return [void]
    [:SetAudioStreamBufferSizeDefault, :SetAudioStreamBufferSizeDefault, [:int], :void],

    # @!method SetAudioStreamCallback(stream, callback)
    #   SetAudioStreamCallback : Audio thread callback to request new data
    #   @param stream [AudioStream]
    #   @param callback [AudioCallback]
    #   @return [void]
    [:SetAudioStreamCallback, :SetAudioStreamCallback, [AudioStream.by_value, :AudioCallback], :void],

    # @!method AttachAudioStreamProcessor(stream, processor)
    #   AttachAudioStreamProcessor : Attach audio stream processor to stream, receives the samples as 'float'
    #   @param stream [AudioStream]
    #   @param processor [AudioCallback]
    #   @return [void]
    [:AttachAudioStreamProcessor, :AttachAudioStreamProcessor, [AudioStream.by_value, :AudioCallback], :void],

    # @!method DetachAudioStreamProcessor(stream, processor)
    #   DetachAudioStreamProcessor : Detach audio stream processor from stream
    #   @param stream [AudioStream]
    #   @param processor [AudioCallback]
    #   @return [void]
    [:DetachAudioStreamProcessor, :DetachAudioStreamProcessor, [AudioStream.by_value, :AudioCallback], :void],

    # @!method AttachAudioMixedProcessor(processor)
    #   AttachAudioMixedProcessor : Attach audio stream processor to the entire audio pipeline, receives the samples as 'float'
    #   @param processor [AudioCallback]
    #   @return [void]
    [:AttachAudioMixedProcessor, :AttachAudioMixedProcessor, [:AudioCallback], :void],

    # @!method DetachAudioMixedProcessor(processor)
    #   DetachAudioMixedProcessor : Detach audio stream processor from the entire audio pipeline
    #   @param processor [AudioCallback]
    #   @return [void]
    [:DetachAudioMixedProcessor, :DetachAudioMixedProcessor, [:AudioCallback], :void],
  ]
  entries.each do |entry|
    api_name = if method_naming == :snake_case
                 snake_case_name = entry[0].to_s.gsub(/([A-Z]+)([A-Z0-9][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z0-9])/, '\1_\2').downcase
                 snake_case_name.gsub!('vector_3', 'vector3_') if snake_case_name.include?('vector_3')
                 snake_case_name.gsub!('vector_2', 'vector2_') if snake_case_name.include?('vector_2')
                 snake_case_name.chop! if snake_case_name.end_with?('_')
                 snake_case_name.to_sym
               else
                 entry[0]
               end
    attach_function api_name, entry[1], entry[2], entry[3]
  rescue FFI::NotFoundError => e
    warn "[Warning] Failed to import #{entry[0]} (#{e})."
  end
end

.setup_raymath_symbols(method_naming: :original) ⇒ Object

Function

# File 'lib/raymath.rb', line 41

def self.setup_raymath_symbols(method_naming: :original)
  entries = [

    # @!method Clamp(value, min, max)
    #   Clamp
    #   @param value [float]
    #   @param min [float]
    #   @param max [float]
    #   @return [float]
    [:Clamp, :Clamp, [:float, :float, :float], :float],

    # @!method Lerp(start, end, amount)
    #   Lerp
    #   @param start [float]
    #   @param end [float]
    #   @param amount [float]
    #   @return [float]
    [:Lerp, :Lerp, [:float, :float, :float], :float],

    # @!method Normalize(value, start, end)
    #   Normalize
    #   @param value [float]
    #   @param start [float]
    #   @param end [float]
    #   @return [float]
    [:Normalize, :Normalize, [:float, :float, :float], :float],

    # @!method Remap(value, inputStart, inputEnd, outputStart, outputEnd)
    #   Remap
    #   @param value [float]
    #   @param inputStart [float]
    #   @param inputEnd [float]
    #   @param outputStart [float]
    #   @param outputEnd [float]
    #   @return [float]
    [:Remap, :Remap, [:float, :float, :float, :float, :float], :float],

    # @!method Wrap(value, min, max)
    #   Wrap
    #   @param value [float]
    #   @param min [float]
    #   @param max [float]
    #   @return [float]
    [:Wrap, :Wrap, [:float, :float, :float], :float],

    # @!method FloatEquals(x, y)
    #   FloatEquals
    #   @param x [float]
    #   @param y [float]
    #   @return [int]
    [:FloatEquals, :FloatEquals, [:float, :float], :int],

    # @!method Vector2Zero()
    #   Vector2Zero
    #   @return [Vector2]
    [:Vector2Zero, :Vector2Zero, [], Vector2.by_value],

    # @!method Vector2One()
    #   Vector2One
    #   @return [Vector2]
    [:Vector2One, :Vector2One, [], Vector2.by_value],

    # @!method Vector2Add(v1, v2)
    #   Vector2Add
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @return [Vector2]
    [:Vector2Add, :Vector2Add, [Vector2.by_value, Vector2.by_value], Vector2.by_value],

    # @!method Vector2AddValue(v, add)
    #   Vector2AddValue
    #   @param v [Vector2]
    #   @param add [float]
    #   @return [Vector2]
    [:Vector2AddValue, :Vector2AddValue, [Vector2.by_value, :float], Vector2.by_value],

    # @!method Vector2Subtract(v1, v2)
    #   Vector2Subtract
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @return [Vector2]
    [:Vector2Subtract, :Vector2Subtract, [Vector2.by_value, Vector2.by_value], Vector2.by_value],

    # @!method Vector2SubtractValue(v, sub)
    #   Vector2SubtractValue
    #   @param v [Vector2]
    #   @param sub [float]
    #   @return [Vector2]
    [:Vector2SubtractValue, :Vector2SubtractValue, [Vector2.by_value, :float], Vector2.by_value],

    # @!method Vector2Length(v)
    #   Vector2Length
    #   @param v [Vector2]
    #   @return [float]
    [:Vector2Length, :Vector2Length, [Vector2.by_value], :float],

    # @!method Vector2LengthSqr(v)
    #   Vector2LengthSqr
    #   @param v [Vector2]
    #   @return [float]
    [:Vector2LengthSqr, :Vector2LengthSqr, [Vector2.by_value], :float],

    # @!method Vector2DotProduct(v1, v2)
    #   Vector2DotProduct
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @return [float]
    [:Vector2DotProduct, :Vector2DotProduct, [Vector2.by_value, Vector2.by_value], :float],

    # @!method Vector2CrossProduct(v1, v2)
    #   Vector2CrossProduct
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @return [float]
    [:Vector2CrossProduct, :Vector2CrossProduct, [Vector2.by_value, Vector2.by_value], :float],

    # @!method Vector2Distance(v1, v2)
    #   Vector2Distance
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @return [float]
    [:Vector2Distance, :Vector2Distance, [Vector2.by_value, Vector2.by_value], :float],

    # @!method Vector2DistanceSqr(v1, v2)
    #   Vector2DistanceSqr
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @return [float]
    [:Vector2DistanceSqr, :Vector2DistanceSqr, [Vector2.by_value, Vector2.by_value], :float],

    # @!method Vector2Angle(v1, v2)
    #   Vector2Angle
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @return [float]
    [:Vector2Angle, :Vector2Angle, [Vector2.by_value, Vector2.by_value], :float],

    # @!method Vector2LineAngle(start, end)
    #   Vector2LineAngle
    #   @param start [Vector2]
    #   @param end [Vector2]
    #   @return [float]
    [:Vector2LineAngle, :Vector2LineAngle, [Vector2.by_value, Vector2.by_value], :float],

    # @!method Vector2Scale(v, scale)
    #   Vector2Scale
    #   @param v [Vector2]
    #   @param scale [float]
    #   @return [Vector2]
    [:Vector2Scale, :Vector2Scale, [Vector2.by_value, :float], Vector2.by_value],

    # @!method Vector2Multiply(v1, v2)
    #   Vector2Multiply
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @return [Vector2]
    [:Vector2Multiply, :Vector2Multiply, [Vector2.by_value, Vector2.by_value], Vector2.by_value],

    # @!method Vector2Negate(v)
    #   Vector2Negate
    #   @param v [Vector2]
    #   @return [Vector2]
    [:Vector2Negate, :Vector2Negate, [Vector2.by_value], Vector2.by_value],

    # @!method Vector2Divide(v1, v2)
    #   Vector2Divide
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @return [Vector2]
    [:Vector2Divide, :Vector2Divide, [Vector2.by_value, Vector2.by_value], Vector2.by_value],

    # @!method Vector2Normalize(v)
    #   Vector2Normalize
    #   @param v [Vector2]
    #   @return [Vector2]
    [:Vector2Normalize, :Vector2Normalize, [Vector2.by_value], Vector2.by_value],

    # @!method Vector2Transform(v, mat)
    #   Vector2Transform
    #   @param v [Vector2]
    #   @param mat [Matrix]
    #   @return [Vector2]
    [:Vector2Transform, :Vector2Transform, [Vector2.by_value, Matrix.by_value], Vector2.by_value],

    # @!method Vector2Lerp(v1, v2, amount)
    #   Vector2Lerp
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @param amount [float]
    #   @return [Vector2]
    [:Vector2Lerp, :Vector2Lerp, [Vector2.by_value, Vector2.by_value, :float], Vector2.by_value],

    # @!method Vector2Reflect(v, normal)
    #   Vector2Reflect
    #   @param v [Vector2]
    #   @param normal [Vector2]
    #   @return [Vector2]
    [:Vector2Reflect, :Vector2Reflect, [Vector2.by_value, Vector2.by_value], Vector2.by_value],

    # @!method Vector2Min(v1, v2)
    #   Vector2Min
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @return [Vector2]
    [:Vector2Min, :Vector2Min, [Vector2.by_value, Vector2.by_value], Vector2.by_value],

    # @!method Vector2Max(v1, v2)
    #   Vector2Max
    #   @param v1 [Vector2]
    #   @param v2 [Vector2]
    #   @return [Vector2]
    [:Vector2Max, :Vector2Max, [Vector2.by_value, Vector2.by_value], Vector2.by_value],

    # @!method Vector2Rotate(v, angle)
    #   Vector2Rotate
    #   @param v [Vector2]
    #   @param angle [float]
    #   @return [Vector2]
    [:Vector2Rotate, :Vector2Rotate, [Vector2.by_value, :float], Vector2.by_value],

    # @!method Vector2MoveTowards(v, target, maxDistance)
    #   Vector2MoveTowards
    #   @param v [Vector2]
    #   @param target [Vector2]
    #   @param maxDistance [float]
    #   @return [Vector2]
    [:Vector2MoveTowards, :Vector2MoveTowards, [Vector2.by_value, Vector2.by_value, :float], Vector2.by_value],

    # @!method Vector2Invert(v)
    #   Vector2Invert
    #   @param v [Vector2]
    #   @return [Vector2]
    [:Vector2Invert, :Vector2Invert, [Vector2.by_value], Vector2.by_value],

    # @!method Vector2Clamp(v, min, max)
    #   Vector2Clamp
    #   @param v [Vector2]
    #   @param min [Vector2]
    #   @param max [Vector2]
    #   @return [Vector2]
    [:Vector2Clamp, :Vector2Clamp, [Vector2.by_value, Vector2.by_value, Vector2.by_value], Vector2.by_value],

    # @!method Vector2ClampValue(v, min, max)
    #   Vector2ClampValue
    #   @param v [Vector2]
    #   @param min [float]
    #   @param max [float]
    #   @return [Vector2]
    [:Vector2ClampValue, :Vector2ClampValue, [Vector2.by_value, :float, :float], Vector2.by_value],

    # @!method Vector2Equals(p, q)
    #   Vector2Equals
    #   @param p [Vector2]
    #   @param q [Vector2]
    #   @return [int]
    [:Vector2Equals, :Vector2Equals, [Vector2.by_value, Vector2.by_value], :int],

    # @!method Vector2Refract(v, n, r)
    #   Vector2Refract
    #   @param v [Vector2]
    #   @param n [Vector2]
    #   @param r [float]
    #   @return [Vector2]
    [:Vector2Refract, :Vector2Refract, [Vector2.by_value, Vector2.by_value, :float], Vector2.by_value],

    # @!method Vector3Zero()
    #   Vector3Zero
    #   @return [Vector3]
    [:Vector3Zero, :Vector3Zero, [], Vector3.by_value],

    # @!method Vector3One()
    #   Vector3One
    #   @return [Vector3]
    [:Vector3One, :Vector3One, [], Vector3.by_value],

    # @!method Vector3Add(v1, v2)
    #   Vector3Add
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [Vector3]
    [:Vector3Add, :Vector3Add, [Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3AddValue(v, add)
    #   Vector3AddValue
    #   @param v [Vector3]
    #   @param add [float]
    #   @return [Vector3]
    [:Vector3AddValue, :Vector3AddValue, [Vector3.by_value, :float], Vector3.by_value],

    # @!method Vector3Subtract(v1, v2)
    #   Vector3Subtract
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [Vector3]
    [:Vector3Subtract, :Vector3Subtract, [Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3SubtractValue(v, sub)
    #   Vector3SubtractValue
    #   @param v [Vector3]
    #   @param sub [float]
    #   @return [Vector3]
    [:Vector3SubtractValue, :Vector3SubtractValue, [Vector3.by_value, :float], Vector3.by_value],

    # @!method Vector3Scale(v, scalar)
    #   Vector3Scale
    #   @param v [Vector3]
    #   @param scalar [float]
    #   @return [Vector3]
    [:Vector3Scale, :Vector3Scale, [Vector3.by_value, :float], Vector3.by_value],

    # @!method Vector3Multiply(v1, v2)
    #   Vector3Multiply
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [Vector3]
    [:Vector3Multiply, :Vector3Multiply, [Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3CrossProduct(v1, v2)
    #   Vector3CrossProduct
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [Vector3]
    [:Vector3CrossProduct, :Vector3CrossProduct, [Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3Perpendicular(v)
    #   Vector3Perpendicular
    #   @param v [Vector3]
    #   @return [Vector3]
    [:Vector3Perpendicular, :Vector3Perpendicular, [Vector3.by_value], Vector3.by_value],

    # @!method Vector3Length(v)
    #   Vector3Length
    #   @param v [const Vector3]
    #   @return [float]
    [:Vector3Length, :Vector3Length, [Vector3.by_value], :float],

    # @!method Vector3LengthSqr(v)
    #   Vector3LengthSqr
    #   @param v [const Vector3]
    #   @return [float]
    [:Vector3LengthSqr, :Vector3LengthSqr, [Vector3.by_value], :float],

    # @!method Vector3DotProduct(v1, v2)
    #   Vector3DotProduct
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [float]
    [:Vector3DotProduct, :Vector3DotProduct, [Vector3.by_value, Vector3.by_value], :float],

    # @!method Vector3Distance(v1, v2)
    #   Vector3Distance
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [float]
    [:Vector3Distance, :Vector3Distance, [Vector3.by_value, Vector3.by_value], :float],

    # @!method Vector3DistanceSqr(v1, v2)
    #   Vector3DistanceSqr
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [float]
    [:Vector3DistanceSqr, :Vector3DistanceSqr, [Vector3.by_value, Vector3.by_value], :float],

    # @!method Vector3Angle(v1, v2)
    #   Vector3Angle
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [float]
    [:Vector3Angle, :Vector3Angle, [Vector3.by_value, Vector3.by_value], :float],

    # @!method Vector3Negate(v)
    #   Vector3Negate
    #   @param v [Vector3]
    #   @return [Vector3]
    [:Vector3Negate, :Vector3Negate, [Vector3.by_value], Vector3.by_value],

    # @!method Vector3Divide(v1, v2)
    #   Vector3Divide
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [Vector3]
    [:Vector3Divide, :Vector3Divide, [Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3Normalize(v)
    #   Vector3Normalize
    #   @param v [Vector3]
    #   @return [Vector3]
    [:Vector3Normalize, :Vector3Normalize, [Vector3.by_value], Vector3.by_value],

    # @!method Vector3Project(v1, v2)
    #   Vector3Project
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [Vector3]
    [:Vector3Project, :Vector3Project, [Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3Reject(v1, v2)
    #   Vector3Reject
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [Vector3]
    [:Vector3Reject, :Vector3Reject, [Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3OrthoNormalize(v1, v2)
    #   Vector3OrthoNormalize
    #   @param v1 [Vector3 *]
    #   @param v2 [Vector3 *]
    #   @return [void]
    [:Vector3OrthoNormalize, :Vector3OrthoNormalize, [:pointer, :pointer], :void],

    # @!method Vector3Transform(v, mat)
    #   Vector3Transform
    #   @param v [Vector3]
    #   @param mat [Matrix]
    #   @return [Vector3]
    [:Vector3Transform, :Vector3Transform, [Vector3.by_value, Matrix.by_value], Vector3.by_value],

    # @!method Vector3RotateByQuaternion(v, q)
    #   Vector3RotateByQuaternion
    #   @param v [Vector3]
    #   @param q [Quaternion]
    #   @return [Vector3]
    [:Vector3RotateByQuaternion, :Vector3RotateByQuaternion, [Vector3.by_value, Quaternion.by_value], Vector3.by_value],

    # @!method Vector3RotateByAxisAngle(v, axis, angle)
    #   Vector3RotateByAxisAngle
    #   @param v [Vector3]
    #   @param axis [Vector3]
    #   @param angle [float]
    #   @return [Vector3]
    [:Vector3RotateByAxisAngle, :Vector3RotateByAxisAngle, [Vector3.by_value, Vector3.by_value, :float], Vector3.by_value],

    # @!method Vector3MoveTowards(v, target, maxDistance)
    #   Vector3MoveTowards
    #   @param v [Vector3]
    #   @param target [Vector3]
    #   @param maxDistance [float]
    #   @return [Vector3]
    [:Vector3MoveTowards, :Vector3MoveTowards, [Vector3.by_value, Vector3.by_value, :float], Vector3.by_value],

    # @!method Vector3Lerp(v1, v2, amount)
    #   Vector3Lerp
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @param amount [float]
    #   @return [Vector3]
    [:Vector3Lerp, :Vector3Lerp, [Vector3.by_value, Vector3.by_value, :float], Vector3.by_value],

    # @!method Vector3CubicHermite(v1, tangent1, v2, tangent2, amount)
    #   Vector3CubicHermite
    #   @param v1 [Vector3]
    #   @param tangent1 [Vector3]
    #   @param v2 [Vector3]
    #   @param tangent2 [Vector3]
    #   @param amount [float]
    #   @return [Vector3]
    [:Vector3CubicHermite, :Vector3CubicHermite, [Vector3.by_value, Vector3.by_value, Vector3.by_value, Vector3.by_value, :float], Vector3.by_value],

    # @!method Vector3Reflect(v, normal)
    #   Vector3Reflect
    #   @param v [Vector3]
    #   @param normal [Vector3]
    #   @return [Vector3]
    [:Vector3Reflect, :Vector3Reflect, [Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3Min(v1, v2)
    #   Vector3Min
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [Vector3]
    [:Vector3Min, :Vector3Min, [Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3Max(v1, v2)
    #   Vector3Max
    #   @param v1 [Vector3]
    #   @param v2 [Vector3]
    #   @return [Vector3]
    [:Vector3Max, :Vector3Max, [Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3Barycenter(p, a, b, c)
    #   Vector3Barycenter
    #   @param p [Vector3]
    #   @param a [Vector3]
    #   @param b [Vector3]
    #   @param c [Vector3]
    #   @return [Vector3]
    [:Vector3Barycenter, :Vector3Barycenter, [Vector3.by_value, Vector3.by_value, Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3Unproject(source, projection, view)
    #   Vector3Unproject
    #   @param source [Vector3]
    #   @param projection [Matrix]
    #   @param view [Matrix]
    #   @return [Vector3]
    [:Vector3Unproject, :Vector3Unproject, [Vector3.by_value, Matrix.by_value, Matrix.by_value], Vector3.by_value],

    # @!method Vector3ToFloatV(v)
    #   Vector3ToFloatV
    #   @param v [Vector3]
    #   @return [float3]
    [:Vector3ToFloatV, :Vector3ToFloatV, [Vector3.by_value], Float3.by_value],

    # @!method Vector3Invert(v)
    #   Vector3Invert
    #   @param v [Vector3]
    #   @return [Vector3]
    [:Vector3Invert, :Vector3Invert, [Vector3.by_value], Vector3.by_value],

    # @!method Vector3Clamp(v, min, max)
    #   Vector3Clamp
    #   @param v [Vector3]
    #   @param min [Vector3]
    #   @param max [Vector3]
    #   @return [Vector3]
    [:Vector3Clamp, :Vector3Clamp, [Vector3.by_value, Vector3.by_value, Vector3.by_value], Vector3.by_value],

    # @!method Vector3ClampValue(v, min, max)
    #   Vector3ClampValue
    #   @param v [Vector3]
    #   @param min [float]
    #   @param max [float]
    #   @return [Vector3]
    [:Vector3ClampValue, :Vector3ClampValue, [Vector3.by_value, :float, :float], Vector3.by_value],

    # @!method Vector3Equals(p, q)
    #   Vector3Equals
    #   @param p [Vector3]
    #   @param q [Vector3]
    #   @return [int]
    [:Vector3Equals, :Vector3Equals, [Vector3.by_value, Vector3.by_value], :int],

    # @!method Vector3Refract(v, n, r)
    #   Vector3Refract
    #   @param v [Vector3]
    #   @param n [Vector3]
    #   @param r [float]
    #   @return [Vector3]
    [:Vector3Refract, :Vector3Refract, [Vector3.by_value, Vector3.by_value, :float], Vector3.by_value],

    # @!method Vector4Zero()
    #   Vector4Zero
    #   @return [Vector4]
    [:Vector4Zero, :Vector4Zero, [], Vector4.by_value],

    # @!method Vector4One()
    #   Vector4One
    #   @return [Vector4]
    [:Vector4One, :Vector4One, [], Vector4.by_value],

    # @!method Vector4Add(v1, v2)
    #   Vector4Add
    #   @param v1 [Vector4]
    #   @param v2 [Vector4]
    #   @return [Vector4]
    [:Vector4Add, :Vector4Add, [Vector4.by_value, Vector4.by_value], Vector4.by_value],

    # @!method Vector4AddValue(v, add)
    #   Vector4AddValue
    #   @param v [Vector4]
    #   @param add [float]
    #   @return [Vector4]
    [:Vector4AddValue, :Vector4AddValue, [Vector4.by_value, :float], Vector4.by_value],

    # @!method Vector4Subtract(v1, v2)
    #   Vector4Subtract
    #   @param v1 [Vector4]
    #   @param v2 [Vector4]
    #   @return [Vector4]
    [:Vector4Subtract, :Vector4Subtract, [Vector4.by_value, Vector4.by_value], Vector4.by_value],

    # @!method Vector4SubtractValue(v, add)
    #   Vector4SubtractValue
    #   @param v [Vector4]
    #   @param add [float]
    #   @return [Vector4]
    [:Vector4SubtractValue, :Vector4SubtractValue, [Vector4.by_value, :float], Vector4.by_value],

    # @!method Vector4Length(v)
    #   Vector4Length
    #   @param v [Vector4]
    #   @return [float]
    [:Vector4Length, :Vector4Length, [Vector4.by_value], :float],

    # @!method Vector4LengthSqr(v)
    #   Vector4LengthSqr
    #   @param v [Vector4]
    #   @return [float]
    [:Vector4LengthSqr, :Vector4LengthSqr, [Vector4.by_value], :float],

    # @!method Vector4DotProduct(v1, v2)
    #   Vector4DotProduct
    #   @param v1 [Vector4]
    #   @param v2 [Vector4]
    #   @return [float]
    [:Vector4DotProduct, :Vector4DotProduct, [Vector4.by_value, Vector4.by_value], :float],

    # @!method Vector4Distance(v1, v2)
    #   Vector4Distance
    #   @param v1 [Vector4]
    #   @param v2 [Vector4]
    #   @return [float]
    [:Vector4Distance, :Vector4Distance, [Vector4.by_value, Vector4.by_value], :float],

    # @!method Vector4DistanceSqr(v1, v2)
    #   Vector4DistanceSqr
    #   @param v1 [Vector4]
    #   @param v2 [Vector4]
    #   @return [float]
    [:Vector4DistanceSqr, :Vector4DistanceSqr, [Vector4.by_value, Vector4.by_value], :float],

    # @!method Vector4Scale(v, scale)
    #   Vector4Scale
    #   @param v [Vector4]
    #   @param scale [float]
    #   @return [Vector4]
    [:Vector4Scale, :Vector4Scale, [Vector4.by_value, :float], Vector4.by_value],

    # @!method Vector4Multiply(v1, v2)
    #   Vector4Multiply
    #   @param v1 [Vector4]
    #   @param v2 [Vector4]
    #   @return [Vector4]
    [:Vector4Multiply, :Vector4Multiply, [Vector4.by_value, Vector4.by_value], Vector4.by_value],

    # @!method Vector4Negate(v)
    #   Vector4Negate
    #   @param v [Vector4]
    #   @return [Vector4]
    [:Vector4Negate, :Vector4Negate, [Vector4.by_value], Vector4.by_value],

    # @!method Vector4Divide(v1, v2)
    #   Vector4Divide
    #   @param v1 [Vector4]
    #   @param v2 [Vector4]
    #   @return [Vector4]
    [:Vector4Divide, :Vector4Divide, [Vector4.by_value, Vector4.by_value], Vector4.by_value],

    # @!method Vector4Normalize(v)
    #   Vector4Normalize
    #   @param v [Vector4]
    #   @return [Vector4]
    [:Vector4Normalize, :Vector4Normalize, [Vector4.by_value], Vector4.by_value],

    # @!method Vector4Min(v1, v2)
    #   Vector4Min
    #   @param v1 [Vector4]
    #   @param v2 [Vector4]
    #   @return [Vector4]
    [:Vector4Min, :Vector4Min, [Vector4.by_value, Vector4.by_value], Vector4.by_value],

    # @!method Vector4Max(v1, v2)
    #   Vector4Max
    #   @param v1 [Vector4]
    #   @param v2 [Vector4]
    #   @return [Vector4]
    [:Vector4Max, :Vector4Max, [Vector4.by_value, Vector4.by_value], Vector4.by_value],

    # @!method Vector4Lerp(v1, v2, amount)
    #   Vector4Lerp
    #   @param v1 [Vector4]
    #   @param v2 [Vector4]
    #   @param amount [float]
    #   @return [Vector4]
    [:Vector4Lerp, :Vector4Lerp, [Vector4.by_value, Vector4.by_value, :float], Vector4.by_value],

    # @!method Vector4MoveTowards(v, target, maxDistance)
    #   Vector4MoveTowards
    #   @param v [Vector4]
    #   @param target [Vector4]
    #   @param maxDistance [float]
    #   @return [Vector4]
    [:Vector4MoveTowards, :Vector4MoveTowards, [Vector4.by_value, Vector4.by_value, :float], Vector4.by_value],

    # @!method Vector4Invert(v)
    #   Vector4Invert
    #   @param v [Vector4]
    #   @return [Vector4]
    [:Vector4Invert, :Vector4Invert, [Vector4.by_value], Vector4.by_value],

    # @!method Vector4Equals(p, q)
    #   Vector4Equals
    #   @param p [Vector4]
    #   @param q [Vector4]
    #   @return [int]
    [:Vector4Equals, :Vector4Equals, [Vector4.by_value, Vector4.by_value], :int],

    # @!method MatrixDeterminant(mat)
    #   MatrixDeterminant
    #   @param mat [Matrix]
    #   @return [float]
    [:MatrixDeterminant, :MatrixDeterminant, [Matrix.by_value], :float],

    # @!method MatrixTrace(mat)
    #   MatrixTrace
    #   @param mat [Matrix]
    #   @return [float]
    [:MatrixTrace, :MatrixTrace, [Matrix.by_value], :float],

    # @!method MatrixTranspose(mat)
    #   MatrixTranspose
    #   @param mat [Matrix]
    #   @return [Matrix]
    [:MatrixTranspose, :MatrixTranspose, [Matrix.by_value], Matrix.by_value],

    # @!method MatrixInvert(mat)
    #   MatrixInvert
    #   @param mat [Matrix]
    #   @return [Matrix]
    [:MatrixInvert, :MatrixInvert, [Matrix.by_value], Matrix.by_value],

    # @!method MatrixIdentity()
    #   MatrixIdentity
    #   @return [Matrix]
    [:MatrixIdentity, :MatrixIdentity, [], Matrix.by_value],

    # @!method MatrixAdd(left, right)
    #   MatrixAdd
    #   @param left [Matrix]
    #   @param right [Matrix]
    #   @return [Matrix]
    [:MatrixAdd, :MatrixAdd, [Matrix.by_value, Matrix.by_value], Matrix.by_value],

    # @!method MatrixSubtract(left, right)
    #   MatrixSubtract
    #   @param left [Matrix]
    #   @param right [Matrix]
    #   @return [Matrix]
    [:MatrixSubtract, :MatrixSubtract, [Matrix.by_value, Matrix.by_value], Matrix.by_value],

    # @!method MatrixMultiply(left, right)
    #   MatrixMultiply
    #   @param left [Matrix]
    #   @param right [Matrix]
    #   @return [Matrix]
    [:MatrixMultiply, :MatrixMultiply, [Matrix.by_value, Matrix.by_value], Matrix.by_value],

    # @!method MatrixTranslate(x, y, z)
    #   MatrixTranslate
    #   @param x [float]
    #   @param y [float]
    #   @param z [float]
    #   @return [Matrix]
    [:MatrixTranslate, :MatrixTranslate, [:float, :float, :float], Matrix.by_value],

    # @!method MatrixRotate(axis, angle)
    #   MatrixRotate
    #   @param axis [Vector3]
    #   @param angle [float]
    #   @return [Matrix]
    [:MatrixRotate, :MatrixRotate, [Vector3.by_value, :float], Matrix.by_value],

    # @!method MatrixRotateX(angle)
    #   MatrixRotateX
    #   @param angle [float]
    #   @return [Matrix]
    [:MatrixRotateX, :MatrixRotateX, [:float], Matrix.by_value],

    # @!method MatrixRotateY(angle)
    #   MatrixRotateY
    #   @param angle [float]
    #   @return [Matrix]
    [:MatrixRotateY, :MatrixRotateY, [:float], Matrix.by_value],

    # @!method MatrixRotateZ(angle)
    #   MatrixRotateZ
    #   @param angle [float]
    #   @return [Matrix]
    [:MatrixRotateZ, :MatrixRotateZ, [:float], Matrix.by_value],

    # @!method MatrixRotateXYZ(angle)
    #   MatrixRotateXYZ
    #   @param angle [Vector3]
    #   @return [Matrix]
    [:MatrixRotateXYZ, :MatrixRotateXYZ, [Vector3.by_value], Matrix.by_value],

    # @!method MatrixRotateZYX(angle)
    #   MatrixRotateZYX
    #   @param angle [Vector3]
    #   @return [Matrix]
    [:MatrixRotateZYX, :MatrixRotateZYX, [Vector3.by_value], Matrix.by_value],

    # @!method MatrixScale(x, y, z)
    #   MatrixScale
    #   @param x [float]
    #   @param y [float]
    #   @param z [float]
    #   @return [Matrix]
    [:MatrixScale, :MatrixScale, [:float, :float, :float], Matrix.by_value],

    # @!method MatrixFrustum(left, right, bottom, top, nearPlane, farPlane)
    #   MatrixFrustum
    #   @param left [double]
    #   @param right [double]
    #   @param bottom [double]
    #   @param top [double]
    #   @param nearPlane [double]
    #   @param farPlane [double]
    #   @return [Matrix]
    [:MatrixFrustum, :MatrixFrustum, [:double, :double, :double, :double, :double, :double], Matrix.by_value],

    # @!method MatrixPerspective(fovY, aspect, nearPlane, farPlane)
    #   MatrixPerspective
    #   @param fovY [double]
    #   @param aspect [double]
    #   @param nearPlane [double]
    #   @param farPlane [double]
    #   @return [Matrix]
    [:MatrixPerspective, :MatrixPerspective, [:double, :double, :double, :double], Matrix.by_value],

    # @!method MatrixOrtho(left, right, bottom, top, nearPlane, farPlane)
    #   MatrixOrtho
    #   @param left [double]
    #   @param right [double]
    #   @param bottom [double]
    #   @param top [double]
    #   @param nearPlane [double]
    #   @param farPlane [double]
    #   @return [Matrix]
    [:MatrixOrtho, :MatrixOrtho, [:double, :double, :double, :double, :double, :double], Matrix.by_value],

    # @!method MatrixLookAt(eye, target, up)
    #   MatrixLookAt
    #   @param eye [Vector3]
    #   @param target [Vector3]
    #   @param up [Vector3]
    #   @return [Matrix]
    [:MatrixLookAt, :MatrixLookAt, [Vector3.by_value, Vector3.by_value, Vector3.by_value], Matrix.by_value],

    # @!method MatrixToFloatV(mat)
    #   MatrixToFloatV
    #   @param mat [Matrix]
    #   @return [float16]
    [:MatrixToFloatV, :MatrixToFloatV, [Matrix.by_value], Float16.by_value],

    # @!method QuaternionAdd(q1, q2)
    #   QuaternionAdd
    #   @param q1 [Quaternion]
    #   @param q2 [Quaternion]
    #   @return [Quaternion]
    [:QuaternionAdd, :QuaternionAdd, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value],

    # @!method QuaternionAddValue(q, add)
    #   QuaternionAddValue
    #   @param q [Quaternion]
    #   @param add [float]
    #   @return [Quaternion]
    [:QuaternionAddValue, :QuaternionAddValue, [Quaternion.by_value, :float], Quaternion.by_value],

    # @!method QuaternionSubtract(q1, q2)
    #   QuaternionSubtract
    #   @param q1 [Quaternion]
    #   @param q2 [Quaternion]
    #   @return [Quaternion]
    [:QuaternionSubtract, :QuaternionSubtract, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value],

    # @!method QuaternionSubtractValue(q, sub)
    #   QuaternionSubtractValue
    #   @param q [Quaternion]
    #   @param sub [float]
    #   @return [Quaternion]
    [:QuaternionSubtractValue, :QuaternionSubtractValue, [Quaternion.by_value, :float], Quaternion.by_value],

    # @!method QuaternionIdentity()
    #   QuaternionIdentity
    #   @return [Quaternion]
    [:QuaternionIdentity, :QuaternionIdentity, [], Quaternion.by_value],

    # @!method QuaternionLength(q)
    #   QuaternionLength
    #   @param q [Quaternion]
    #   @return [float]
    [:QuaternionLength, :QuaternionLength, [Quaternion.by_value], :float],

    # @!method QuaternionNormalize(q)
    #   QuaternionNormalize
    #   @param q [Quaternion]
    #   @return [Quaternion]
    [:QuaternionNormalize, :QuaternionNormalize, [Quaternion.by_value], Quaternion.by_value],

    # @!method QuaternionInvert(q)
    #   QuaternionInvert
    #   @param q [Quaternion]
    #   @return [Quaternion]
    [:QuaternionInvert, :QuaternionInvert, [Quaternion.by_value], Quaternion.by_value],

    # @!method QuaternionMultiply(q1, q2)
    #   QuaternionMultiply
    #   @param q1 [Quaternion]
    #   @param q2 [Quaternion]
    #   @return [Quaternion]
    [:QuaternionMultiply, :QuaternionMultiply, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value],

    # @!method QuaternionScale(q, mul)
    #   QuaternionScale
    #   @param q [Quaternion]
    #   @param mul [float]
    #   @return [Quaternion]
    [:QuaternionScale, :QuaternionScale, [Quaternion.by_value, :float], Quaternion.by_value],

    # @!method QuaternionDivide(q1, q2)
    #   QuaternionDivide
    #   @param q1 [Quaternion]
    #   @param q2 [Quaternion]
    #   @return [Quaternion]
    [:QuaternionDivide, :QuaternionDivide, [Quaternion.by_value, Quaternion.by_value], Quaternion.by_value],

    # @!method QuaternionLerp(q1, q2, amount)
    #   QuaternionLerp
    #   @param q1 [Quaternion]
    #   @param q2 [Quaternion]
    #   @param amount [float]
    #   @return [Quaternion]
    [:QuaternionLerp, :QuaternionLerp, [Quaternion.by_value, Quaternion.by_value, :float], Quaternion.by_value],

    # @!method QuaternionNlerp(q1, q2, amount)
    #   QuaternionNlerp
    #   @param q1 [Quaternion]
    #   @param q2 [Quaternion]
    #   @param amount [float]
    #   @return [Quaternion]
    [:QuaternionNlerp, :QuaternionNlerp, [Quaternion.by_value, Quaternion.by_value, :float], Quaternion.by_value],

    # @!method QuaternionSlerp(q1, q2, amount)
    #   QuaternionSlerp
    #   @param q1 [Quaternion]
    #   @param q2 [Quaternion]
    #   @param amount [float]
    #   @return [Quaternion]
    [:QuaternionSlerp, :QuaternionSlerp, [Quaternion.by_value, Quaternion.by_value, :float], Quaternion.by_value],

    # @!method QuaternionCubicHermiteSpline(q1, outTangent1, q2, inTangent2, t)
    #   QuaternionCubicHermiteSpline
    #   @param q1 [Quaternion]
    #   @param outTangent1 [Quaternion]
    #   @param q2 [Quaternion]
    #   @param inTangent2 [Quaternion]
    #   @param t [float]
    #   @return [Quaternion]
    [:QuaternionCubicHermiteSpline, :QuaternionCubicHermiteSpline, [Quaternion.by_value, Quaternion.by_value, Quaternion.by_value, Quaternion.by_value, :float], Quaternion.by_value],

    # @!method QuaternionFromVector3ToVector3(from, to)
    #   QuaternionFromVector3ToVector3
    #   @param from [Vector3]
    #   @param to [Vector3]
    #   @return [Quaternion]
    [:QuaternionFromVector3ToVector3, :QuaternionFromVector3ToVector3, [Vector3.by_value, Vector3.by_value], Quaternion.by_value],

    # @!method QuaternionFromMatrix(mat)
    #   QuaternionFromMatrix
    #   @param mat [Matrix]
    #   @return [Quaternion]
    [:QuaternionFromMatrix, :QuaternionFromMatrix, [Matrix.by_value], Quaternion.by_value],

    # @!method QuaternionToMatrix(q)
    #   QuaternionToMatrix
    #   @param q [Quaternion]
    #   @return [Matrix]
    [:QuaternionToMatrix, :QuaternionToMatrix, [Quaternion.by_value], Matrix.by_value],

    # @!method QuaternionFromAxisAngle(axis, angle)
    #   QuaternionFromAxisAngle
    #   @param axis [Vector3]
    #   @param angle [float]
    #   @return [Quaternion]
    [:QuaternionFromAxisAngle, :QuaternionFromAxisAngle, [Vector3.by_value, :float], Quaternion.by_value],

    # @!method QuaternionToAxisAngle(q, outAxis, outAngle)
    #   QuaternionToAxisAngle
    #   @param q [Quaternion]
    #   @param outAxis [Vector3 *]
    #   @param outAngle [float *]
    #   @return [void]
    [:QuaternionToAxisAngle, :QuaternionToAxisAngle, [Quaternion.by_value, :pointer, :pointer], :void],

    # @!method QuaternionFromEuler(pitch, yaw, roll)
    #   QuaternionFromEuler
    #   @param pitch [float]
    #   @param yaw [float]
    #   @param roll [float]
    #   @return [Quaternion]
    [:QuaternionFromEuler, :QuaternionFromEuler, [:float, :float, :float], Quaternion.by_value],

    # @!method QuaternionToEuler(q)
    #   QuaternionToEuler
    #   @param q [Quaternion]
    #   @return [Vector3]
    [:QuaternionToEuler, :QuaternionToEuler, [Quaternion.by_value], Vector3.by_value],

    # @!method QuaternionTransform(q, mat)
    #   QuaternionTransform
    #   @param q [Quaternion]
    #   @param mat [Matrix]
    #   @return [Quaternion]
    [:QuaternionTransform, :QuaternionTransform, [Quaternion.by_value, Matrix.by_value], Quaternion.by_value],

    # @!method QuaternionEquals(p, q)
    #   QuaternionEquals
    #   @param p [Quaternion]
    #   @param q [Quaternion]
    #   @return [int]
    [:QuaternionEquals, :QuaternionEquals, [Quaternion.by_value, Quaternion.by_value], :int],

    # @!method MatrixDecompose(mat, translation, rotation, scale)
    #   MatrixDecompose
    #   @param mat [Matrix]
    #   @param translation [Vector3 *]
    #   @param rotation [Quaternion *]
    #   @param scale [Vector3 *]
    #   @return [void]
    [:MatrixDecompose, :MatrixDecompose, [Matrix.by_value, :pointer, :pointer, :pointer], :void],
  ]
  entries.each do |entry|
    api_name = if method_naming == :snake_case
                 snake_case_name = entry[0].to_s.gsub(/([A-Z]+)([A-Z0-9][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z0-9])/, '\1_\2').downcase
                 snake_case_name.gsub!('vector_3', 'vector3_') if snake_case_name.include?('vector_3')
                 snake_case_name.gsub!('vector_2', 'vector2_') if snake_case_name.include?('vector_2')
                 snake_case_name.chop! if snake_case_name.end_with?('_')
                 snake_case_name.to_sym
               else
                 entry[0]
               end
    attach_function api_name, entry[1], entry[2], entry[3]
  rescue FFI::NotFoundError => e
    warn "[Warning] Failed to import #{entry[0]} (#{e})."
  end
end

.setup_rcamera_symbols(method_naming: :original) ⇒ Object

Function

# File 'lib/rcamera.rb', line 22

def self.setup_rcamera_symbols(method_naming: :original)
  entries = [

    # @!method GetCameraForward(camera)
    #   GetCameraForward
    #   @param camera [Camera *]
    #   @return [Vector3]
    [:GetCameraForward, :GetCameraForward, [:pointer], Vector3.by_value],

    # @!method GetCameraUp(camera)
    #   GetCameraUp
    #   @param camera [Camera *]
    #   @return [Vector3]
    [:GetCameraUp, :GetCameraUp, [:pointer], Vector3.by_value],

    # @!method GetCameraRight(camera)
    #   GetCameraRight
    #   @param camera [Camera *]
    #   @return [Vector3]
    [:GetCameraRight, :GetCameraRight, [:pointer], Vector3.by_value],

    # @!method CameraMoveForward(camera, distance, moveInWorldPlane)
    #   CameraMoveForward
    #   @param camera [Camera *]
    #   @param distance [float]
    #   @param moveInWorldPlane [bool]
    #   @return [void]
    [:CameraMoveForward, :CameraMoveForward, [:pointer, :float, :bool], :void],

    # @!method CameraMoveUp(camera, distance)
    #   CameraMoveUp
    #   @param camera [Camera *]
    #   @param distance [float]
    #   @return [void]
    [:CameraMoveUp, :CameraMoveUp, [:pointer, :float], :void],

    # @!method CameraMoveRight(camera, distance, moveInWorldPlane)
    #   CameraMoveRight
    #   @param camera [Camera *]
    #   @param distance [float]
    #   @param moveInWorldPlane [bool]
    #   @return [void]
    [:CameraMoveRight, :CameraMoveRight, [:pointer, :float, :bool], :void],

    # @!method CameraMoveToTarget(camera, delta)
    #   CameraMoveToTarget
    #   @param camera [Camera *]
    #   @param delta [float]
    #   @return [void]
    [:CameraMoveToTarget, :CameraMoveToTarget, [:pointer, :float], :void],

    # @!method CameraYaw(camera, angle, rotateAroundTarget)
    #   CameraYaw
    #   @param camera [Camera *]
    #   @param angle [float]
    #   @param rotateAroundTarget [bool]
    #   @return [void]
    [:CameraYaw, :CameraYaw, [:pointer, :float, :bool], :void],

    # @!method CameraPitch(camera, angle, lockView, rotateAroundTarget, rotateUp)
    #   CameraPitch
    #   @param camera [Camera *]
    #   @param angle [float]
    #   @param lockView [bool]
    #   @param rotateAroundTarget [bool]
    #   @param rotateUp [bool]
    #   @return [void]
    [:CameraPitch, :CameraPitch, [:pointer, :float, :bool, :bool, :bool], :void],

    # @!method CameraRoll(camera, angle)
    #   CameraRoll
    #   @param camera [Camera *]
    #   @param angle [float]
    #   @return [void]
    [:CameraRoll, :CameraRoll, [:pointer, :float], :void],

    # @!method GetCameraViewMatrix(camera)
    #   GetCameraViewMatrix
    #   @param camera [Camera *]
    #   @return [Matrix]
    [:GetCameraViewMatrix, :GetCameraViewMatrix, [:pointer], Matrix.by_value],

    # @!method GetCameraProjectionMatrix(camera, aspect)
    #   GetCameraProjectionMatrix
    #   @param camera [Camera *]
    #   @param aspect [float]
    #   @return [Matrix]
    [:GetCameraProjectionMatrix, :GetCameraProjectionMatrix, [:pointer, :float], Matrix.by_value],
  ]
  entries.each do |entry|
    api_name = if method_naming == :snake_case
                 snake_case_name = entry[0].to_s.gsub(/([A-Z]+)([A-Z0-9][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z0-9])/, '\1_\2').downcase
                 snake_case_name.gsub!('vector_3', 'vector3_') if snake_case_name.include?('vector_3')
                 snake_case_name.gsub!('vector_2', 'vector2_') if snake_case_name.include?('vector_2')
                 snake_case_name.chop! if snake_case_name.end_with?('_')
                 snake_case_name.to_sym
               else
                 entry[0]
               end
    attach_function api_name, entry[1], entry[2], entry[3]
  rescue FFI::NotFoundError => e
    warn "[Warning] Failed to import #{entry[0]} (#{e})."
  end
end

.setup_rlgl_symbols(method_naming: :original) ⇒ Object

Function

# File 'lib/rlgl.rb', line 326

def self.setup_rlgl_symbols(method_naming: :original)
  entries = [

    # @!method rlMatrixMode(mode)
    #   rlMatrixMode : Choose the current matrix to be transformed
    #   @param mode [int]
    #   @return [void]
    [:rlMatrixMode, :rlMatrixMode, [:int], :void],

    # @!method rlPushMatrix()
    #   rlPushMatrix : Push the current matrix to stack
    #   @return [void]
    [:rlPushMatrix, :rlPushMatrix, [], :void],

    # @!method rlPopMatrix()
    #   rlPopMatrix : Pop latest inserted matrix from stack
    #   @return [void]
    [:rlPopMatrix, :rlPopMatrix, [], :void],

    # @!method rlLoadIdentity()
    #   rlLoadIdentity : Reset current matrix to identity matrix
    #   @return [void]
    [:rlLoadIdentity, :rlLoadIdentity, [], :void],

    # @!method rlTranslatef(x, y, z)
    #   rlTranslatef : Multiply the current matrix by a translation matrix
    #   @param x [float]
    #   @param y [float]
    #   @param z [float]
    #   @return [void]
    [:rlTranslatef, :rlTranslatef, [:float, :float, :float], :void],

    # @!method rlRotatef(angle, x, y, z)
    #   rlRotatef : Multiply the current matrix by a rotation matrix
    #   @param angle [float]
    #   @param x [float]
    #   @param y [float]
    #   @param z [float]
    #   @return [void]
    [:rlRotatef, :rlRotatef, [:float, :float, :float, :float], :void],

    # @!method rlScalef(x, y, z)
    #   rlScalef : Multiply the current matrix by a scaling matrix
    #   @param x [float]
    #   @param y [float]
    #   @param z [float]
    #   @return [void]
    [:rlScalef, :rlScalef, [:float, :float, :float], :void],

    # @!method rlMultMatrixf(matf)
    #   rlMultMatrixf : Multiply the current matrix by another matrix
    #   @param matf [const float *]
    #   @return [void]
    [:rlMultMatrixf, :rlMultMatrixf, [:pointer], :void],

    # @!method rlFrustum(left, right, bottom, top, znear, zfar)
    #   rlFrustum
    #   @param left [double]
    #   @param right [double]
    #   @param bottom [double]
    #   @param top [double]
    #   @param znear [double]
    #   @param zfar [double]
    #   @return [void]
    [:rlFrustum, :rlFrustum, [:double, :double, :double, :double, :double, :double], :void],

    # @!method rlOrtho(left, right, bottom, top, znear, zfar)
    #   rlOrtho
    #   @param left [double]
    #   @param right [double]
    #   @param bottom [double]
    #   @param top [double]
    #   @param znear [double]
    #   @param zfar [double]
    #   @return [void]
    [:rlOrtho, :rlOrtho, [:double, :double, :double, :double, :double, :double], :void],

    # @!method rlViewport(x, y, width, height)
    #   rlViewport : Set the viewport area
    #   @param x [int]
    #   @param y [int]
    #   @param width [int]
    #   @param height [int]
    #   @return [void]
    [:rlViewport, :rlViewport, [:int, :int, :int, :int], :void],

    # @!method rlSetClipPlanes(nearPlane, farPlane)
    #   rlSetClipPlanes : Set clip planes distances
    #   @param nearPlane [double]
    #   @param farPlane [double]
    #   @return [void]
    [:rlSetClipPlanes, :rlSetClipPlanes, [:double, :double], :void],

    # @!method rlGetCullDistanceNear()
    #   rlGetCullDistanceNear : Get cull plane distance near
    #   @return [double]
    [:rlGetCullDistanceNear, :rlGetCullDistanceNear, [], :double],

    # @!method rlGetCullDistanceFar()
    #   rlGetCullDistanceFar : Get cull plane distance far
    #   @return [double]
    [:rlGetCullDistanceFar, :rlGetCullDistanceFar, [], :double],

    # @!method rlBegin(mode)
    #   rlBegin : Initialize drawing mode (how to organize vertex)
    #   @param mode [int]
    #   @return [void]
    [:rlBegin, :rlBegin, [:int], :void],

    # @!method rlEnd()
    #   rlEnd : Finish vertex providing
    #   @return [void]
    [:rlEnd, :rlEnd, [], :void],

    # @!method rlVertex2i(x, y)
    #   rlVertex2i : Define one vertex (position) - 2 int
    #   @param x [int]
    #   @param y [int]
    #   @return [void]
    [:rlVertex2i, :rlVertex2i, [:int, :int], :void],

    # @!method rlVertex2f(x, y)
    #   rlVertex2f : Define one vertex (position) - 2 float
    #   @param x [float]
    #   @param y [float]
    #   @return [void]
    [:rlVertex2f, :rlVertex2f, [:float, :float], :void],

    # @!method rlVertex3f(x, y, z)
    #   rlVertex3f : Define one vertex (position) - 3 float
    #   @param x [float]
    #   @param y [float]
    #   @param z [float]
    #   @return [void]
    [:rlVertex3f, :rlVertex3f, [:float, :float, :float], :void],

    # @!method rlTexCoord2f(x, y)
    #   rlTexCoord2f : Define one vertex (texture coordinate) - 2 float
    #   @param x [float]
    #   @param y [float]
    #   @return [void]
    [:rlTexCoord2f, :rlTexCoord2f, [:float, :float], :void],

    # @!method rlNormal3f(x, y, z)
    #   rlNormal3f : Define one vertex (normal) - 3 float
    #   @param x [float]
    #   @param y [float]
    #   @param z [float]
    #   @return [void]
    [:rlNormal3f, :rlNormal3f, [:float, :float, :float], :void],

    # @!method rlColor4ub(r, g, b, a)
    #   rlColor4ub : Define one vertex (color) - 4 byte
    #   @param r [unsigned char]
    #   @param g [unsigned char]
    #   @param b [unsigned char]
    #   @param a [unsigned char]
    #   @return [void]
    [:rlColor4ub, :rlColor4ub, [:uchar, :uchar, :uchar, :uchar], :void],

    # @!method rlColor3f(x, y, z)
    #   rlColor3f : Define one vertex (color) - 3 float
    #   @param x [float]
    #   @param y [float]
    #   @param z [float]
    #   @return [void]
    [:rlColor3f, :rlColor3f, [:float, :float, :float], :void],

    # @!method rlColor4f(x, y, z, w)
    #   rlColor4f : Define one vertex (color) - 4 float
    #   @param x [float]
    #   @param y [float]
    #   @param z [float]
    #   @param w [float]
    #   @return [void]
    [:rlColor4f, :rlColor4f, [:float, :float, :float, :float], :void],

    # @!method rlEnableVertexArray(vaoId)
    #   rlEnableVertexArray : Enable vertex array (VAO, if supported)
    #   @param vaoId [unsigned int]
    #   @return [bool]
    [:rlEnableVertexArray, :rlEnableVertexArray, [:uint], :bool],

    # @!method rlDisableVertexArray()
    #   rlDisableVertexArray : Disable vertex array (VAO, if supported)
    #   @return [void]
    [:rlDisableVertexArray, :rlDisableVertexArray, [], :void],

    # @!method rlEnableVertexBuffer(id)
    #   rlEnableVertexBuffer : Enable vertex buffer (VBO)
    #   @param id [unsigned int]
    #   @return [void]
    [:rlEnableVertexBuffer, :rlEnableVertexBuffer, [:uint], :void],

    # @!method rlDisableVertexBuffer()
    #   rlDisableVertexBuffer : Disable vertex buffer (VBO)
    #   @return [void]
    [:rlDisableVertexBuffer, :rlDisableVertexBuffer, [], :void],

    # @!method rlEnableVertexBufferElement(id)
    #   rlEnableVertexBufferElement : Enable vertex buffer element (VBO element)
    #   @param id [unsigned int]
    #   @return [void]
    [:rlEnableVertexBufferElement, :rlEnableVertexBufferElement, [:uint], :void],

    # @!method rlDisableVertexBufferElement()
    #   rlDisableVertexBufferElement : Disable vertex buffer element (VBO element)
    #   @return [void]
    [:rlDisableVertexBufferElement, :rlDisableVertexBufferElement, [], :void],

    # @!method rlEnableVertexAttribute(index)
    #   rlEnableVertexAttribute : Enable vertex attribute index
    #   @param index [unsigned int]
    #   @return [void]
    [:rlEnableVertexAttribute, :rlEnableVertexAttribute, [:uint], :void],

    # @!method rlDisableVertexAttribute(index)
    #   rlDisableVertexAttribute : Disable vertex attribute index
    #   @param index [unsigned int]
    #   @return [void]
    [:rlDisableVertexAttribute, :rlDisableVertexAttribute, [:uint], :void],

    # @!method rlActiveTextureSlot(slot)
    #   rlActiveTextureSlot : Select and active a texture slot
    #   @param slot [int]
    #   @return [void]
    [:rlActiveTextureSlot, :rlActiveTextureSlot, [:int], :void],

    # @!method rlEnableTexture(id)
    #   rlEnableTexture : Enable texture
    #   @param id [unsigned int]
    #   @return [void]
    [:rlEnableTexture, :rlEnableTexture, [:uint], :void],

    # @!method rlDisableTexture()
    #   rlDisableTexture : Disable texture
    #   @return [void]
    [:rlDisableTexture, :rlDisableTexture, [], :void],

    # @!method rlEnableTextureCubemap(id)
    #   rlEnableTextureCubemap : Enable texture cubemap
    #   @param id [unsigned int]
    #   @return [void]
    [:rlEnableTextureCubemap, :rlEnableTextureCubemap, [:uint], :void],

    # @!method rlDisableTextureCubemap()
    #   rlDisableTextureCubemap : Disable texture cubemap
    #   @return [void]
    [:rlDisableTextureCubemap, :rlDisableTextureCubemap, [], :void],

    # @!method rlTextureParameters(id, param, value)
    #   rlTextureParameters : Set texture parameters (filter, wrap)
    #   @param id [unsigned int]
    #   @param param [int]
    #   @param value [int]
    #   @return [void]
    [:rlTextureParameters, :rlTextureParameters, [:uint, :int, :int], :void],

    # @!method rlCubemapParameters(id, param, value)
    #   rlCubemapParameters : Set cubemap parameters (filter, wrap)
    #   @param id [unsigned int]
    #   @param param [int]
    #   @param value [int]
    #   @return [void]
    [:rlCubemapParameters, :rlCubemapParameters, [:uint, :int, :int], :void],

    # @!method rlEnableShader(id)
    #   rlEnableShader : Enable shader program
    #   @param id [unsigned int]
    #   @return [void]
    [:rlEnableShader, :rlEnableShader, [:uint], :void],

    # @!method rlDisableShader()
    #   rlDisableShader : Disable shader program
    #   @return [void]
    [:rlDisableShader, :rlDisableShader, [], :void],

    # @!method rlEnableFramebuffer(id)
    #   rlEnableFramebuffer : Enable render texture (fbo)
    #   @param id [unsigned int]
    #   @return [void]
    [:rlEnableFramebuffer, :rlEnableFramebuffer, [:uint], :void],

    # @!method rlDisableFramebuffer()
    #   rlDisableFramebuffer : Disable render texture (fbo), return to default framebuffer
    #   @return [void]
    [:rlDisableFramebuffer, :rlDisableFramebuffer, [], :void],

    # @!method rlGetActiveFramebuffer()
    #   rlGetActiveFramebuffer : Get the currently active render texture (fbo), 0 for default framebuffer
    #   @return [unsigned int]
    [:rlGetActiveFramebuffer, :rlGetActiveFramebuffer, [], :uint],

    # @!method rlActiveDrawBuffers(count)
    #   rlActiveDrawBuffers : Activate multiple draw color buffers
    #   @param count [int]
    #   @return [void]
    [:rlActiveDrawBuffers, :rlActiveDrawBuffers, [:int], :void],

    # @!method rlBlitFramebuffer(srcX, srcY, srcWidth, srcHeight, dstX, dstY, dstWidth, dstHeight, bufferMask)
    #   rlBlitFramebuffer : Blit active framebuffer to main framebuffer
    #   @param srcX [int]
    #   @param srcY [int]
    #   @param srcWidth [int]
    #   @param srcHeight [int]
    #   @param dstX [int]
    #   @param dstY [int]
    #   @param dstWidth [int]
    #   @param dstHeight [int]
    #   @param bufferMask [int]
    #   @return [void]
    [:rlBlitFramebuffer, :rlBlitFramebuffer, [:int, :int, :int, :int, :int, :int, :int, :int, :int], :void],

    # @!method rlBindFramebuffer(target, framebuffer)
    #   rlBindFramebuffer : Bind framebuffer (FBO)
    #   @param target [unsigned int]
    #   @param framebuffer [unsigned int]
    #   @return [void]
    [:rlBindFramebuffer, :rlBindFramebuffer, [:uint, :uint], :void],

    # @!method rlEnableColorBlend()
    #   rlEnableColorBlend : Enable color blending
    #   @return [void]
    [:rlEnableColorBlend, :rlEnableColorBlend, [], :void],

    # @!method rlDisableColorBlend()
    #   rlDisableColorBlend : Disable color blending
    #   @return [void]
    [:rlDisableColorBlend, :rlDisableColorBlend, [], :void],

    # @!method rlEnableDepthTest()
    #   rlEnableDepthTest : Enable depth test
    #   @return [void]
    [:rlEnableDepthTest, :rlEnableDepthTest, [], :void],

    # @!method rlDisableDepthTest()
    #   rlDisableDepthTest : Disable depth test
    #   @return [void]
    [:rlDisableDepthTest, :rlDisableDepthTest, [], :void],

    # @!method rlEnableDepthMask()
    #   rlEnableDepthMask : Enable depth write
    #   @return [void]
    [:rlEnableDepthMask, :rlEnableDepthMask, [], :void],

    # @!method rlDisableDepthMask()
    #   rlDisableDepthMask : Disable depth write
    #   @return [void]
    [:rlDisableDepthMask, :rlDisableDepthMask, [], :void],

    # @!method rlEnableBackfaceCulling()
    #   rlEnableBackfaceCulling : Enable backface culling
    #   @return [void]
    [:rlEnableBackfaceCulling, :rlEnableBackfaceCulling, [], :void],

    # @!method rlDisableBackfaceCulling()
    #   rlDisableBackfaceCulling : Disable backface culling
    #   @return [void]
    [:rlDisableBackfaceCulling, :rlDisableBackfaceCulling, [], :void],

    # @!method rlColorMask(r, g, b, a)
    #   rlColorMask : Color mask control
    #   @param r [bool]
    #   @param g [bool]
    #   @param b [bool]
    #   @param a [bool]
    #   @return [void]
    [:rlColorMask, :rlColorMask, [:bool, :bool, :bool, :bool], :void],

    # @!method rlSetCullFace(mode)
    #   rlSetCullFace : Set face culling mode
    #   @param mode [int]
    #   @return [void]
    [:rlSetCullFace, :rlSetCullFace, [:int], :void],

    # @!method rlEnableScissorTest()
    #   rlEnableScissorTest : Enable scissor test
    #   @return [void]
    [:rlEnableScissorTest, :rlEnableScissorTest, [], :void],

    # @!method rlDisableScissorTest()
    #   rlDisableScissorTest : Disable scissor test
    #   @return [void]
    [:rlDisableScissorTest, :rlDisableScissorTest, [], :void],

    # @!method rlScissor(x, y, width, height)
    #   rlScissor : Scissor test
    #   @param x [int]
    #   @param y [int]
    #   @param width [int]
    #   @param height [int]
    #   @return [void]
    [:rlScissor, :rlScissor, [:int, :int, :int, :int], :void],

    # @!method rlEnableWireMode()
    #   rlEnableWireMode : Enable wire mode
    #   @return [void]
    [:rlEnableWireMode, :rlEnableWireMode, [], :void],

    # @!method rlEnablePointMode()
    #   rlEnablePointMode : Enable point mode
    #   @return [void]
    [:rlEnablePointMode, :rlEnablePointMode, [], :void],

    # @!method rlDisableWireMode()
    #   rlDisableWireMode : Disable wire (and point) mode
    #   @return [void]
    [:rlDisableWireMode, :rlDisableWireMode, [], :void],

    # @!method rlSetLineWidth(width)
    #   rlSetLineWidth : Set the line drawing width
    #   @param width [float]
    #   @return [void]
    [:rlSetLineWidth, :rlSetLineWidth, [:float], :void],

    # @!method rlGetLineWidth()
    #   rlGetLineWidth : Get the line drawing width
    #   @return [float]
    [:rlGetLineWidth, :rlGetLineWidth, [], :float],

    # @!method rlEnableSmoothLines()
    #   rlEnableSmoothLines : Enable line aliasing
    #   @return [void]
    [:rlEnableSmoothLines, :rlEnableSmoothLines, [], :void],

    # @!method rlDisableSmoothLines()
    #   rlDisableSmoothLines : Disable line aliasing
    #   @return [void]
    [:rlDisableSmoothLines, :rlDisableSmoothLines, [], :void],

    # @!method rlEnableStereoRender()
    #   rlEnableStereoRender : Enable stereo rendering
    #   @return [void]
    [:rlEnableStereoRender, :rlEnableStereoRender, [], :void],

    # @!method rlDisableStereoRender()
    #   rlDisableStereoRender : Disable stereo rendering
    #   @return [void]
    [:rlDisableStereoRender, :rlDisableStereoRender, [], :void],

    # @!method rlIsStereoRenderEnabled()
    #   rlIsStereoRenderEnabled : Check if stereo render is enabled
    #   @return [bool]
    [:rlIsStereoRenderEnabled, :rlIsStereoRenderEnabled, [], :bool],

    # @!method rlClearColor(r, g, b, a)
    #   rlClearColor : Clear color buffer with color
    #   @param r [unsigned char]
    #   @param g [unsigned char]
    #   @param b [unsigned char]
    #   @param a [unsigned char]
    #   @return [void]
    [:rlClearColor, :rlClearColor, [:uchar, :uchar, :uchar, :uchar], :void],

    # @!method rlClearScreenBuffers()
    #   rlClearScreenBuffers : Clear used screen buffers (color and depth)
    #   @return [void]
    [:rlClearScreenBuffers, :rlClearScreenBuffers, [], :void],

    # @!method rlCheckErrors()
    #   rlCheckErrors : Check and log OpenGL error codes
    #   @return [void]
    [:rlCheckErrors, :rlCheckErrors, [], :void],

    # @!method rlSetBlendMode(mode)
    #   rlSetBlendMode : Set blending mode
    #   @param mode [int]
    #   @return [void]
    [:rlSetBlendMode, :rlSetBlendMode, [:int], :void],

    # @!method rlSetBlendFactors(glSrcFactor, glDstFactor, glEquation)
    #   rlSetBlendFactors : Set blending mode factor and equation (using OpenGL factors)
    #   @param glSrcFactor [int]
    #   @param glDstFactor [int]
    #   @param glEquation [int]
    #   @return [void]
    [:rlSetBlendFactors, :rlSetBlendFactors, [:int, :int, :int], :void],

    # @!method rlSetBlendFactorsSeparate(glSrcRGB, glDstRGB, glSrcAlpha, glDstAlpha, glEqRGB, glEqAlpha)
    #   rlSetBlendFactorsSeparate : Set blending mode factors and equations separately (using OpenGL factors)
    #   @param glSrcRGB [int]
    #   @param glDstRGB [int]
    #   @param glSrcAlpha [int]
    #   @param glDstAlpha [int]
    #   @param glEqRGB [int]
    #   @param glEqAlpha [int]
    #   @return [void]
    [:rlSetBlendFactorsSeparate, :rlSetBlendFactorsSeparate, [:int, :int, :int, :int, :int, :int], :void],

    # @!method rlglInit(width, height)
    #   rlglInit : Initialize rlgl (buffers, shaders, textures, states)
    #   @param width [int]
    #   @param height [int]
    #   @return [void]
    [:rlglInit, :rlglInit, [:int, :int], :void],

    # @!method rlglClose()
    #   rlglClose : De-initialize rlgl (buffers, shaders, textures)
    #   @return [void]
    [:rlglClose, :rlglClose, [], :void],

    # @!method rlLoadExtensions(loader)
    #   rlLoadExtensions : Load OpenGL extensions (loader function required)
    #   @param loader [void *]
    #   @return [void]
    [:rlLoadExtensions, :rlLoadExtensions, [:pointer], :void],

    # @!method rlGetVersion()
    #   rlGetVersion : Get current OpenGL version
    #   @return [int]
    [:rlGetVersion, :rlGetVersion, [], :int],

    # @!method rlSetFramebufferWidth(width)
    #   rlSetFramebufferWidth : Set current framebuffer width
    #   @param width [int]
    #   @return [void]
    [:rlSetFramebufferWidth, :rlSetFramebufferWidth, [:int], :void],

    # @!method rlGetFramebufferWidth()
    #   rlGetFramebufferWidth : Get default framebuffer width
    #   @return [int]
    [:rlGetFramebufferWidth, :rlGetFramebufferWidth, [], :int],

    # @!method rlSetFramebufferHeight(height)
    #   rlSetFramebufferHeight : Set current framebuffer height
    #   @param height [int]
    #   @return [void]
    [:rlSetFramebufferHeight, :rlSetFramebufferHeight, [:int], :void],

    # @!method rlGetFramebufferHeight()
    #   rlGetFramebufferHeight : Get default framebuffer height
    #   @return [int]
    [:rlGetFramebufferHeight, :rlGetFramebufferHeight, [], :int],

    # @!method rlGetTextureIdDefault()
    #   rlGetTextureIdDefault : Get default texture id
    #   @return [unsigned int]
    [:rlGetTextureIdDefault, :rlGetTextureIdDefault, [], :uint],

    # @!method rlGetShaderIdDefault()
    #   rlGetShaderIdDefault : Get default shader id
    #   @return [unsigned int]
    [:rlGetShaderIdDefault, :rlGetShaderIdDefault, [], :uint],

    # @!method rlGetShaderLocsDefault()
    #   rlGetShaderLocsDefault : Get default shader locations
    #   @return [int *]
    [:rlGetShaderLocsDefault, :rlGetShaderLocsDefault, [], :pointer],

    # @!method rlLoadRenderBatch(numBuffers, bufferElements)
    #   rlLoadRenderBatch : Load a render batch system
    #   @param numBuffers [int]
    #   @param bufferElements [int]
    #   @return [rlRenderBatch]
    [:rlLoadRenderBatch, :rlLoadRenderBatch, [:int, :int], RlRenderBatch.by_value],

    # @!method rlUnloadRenderBatch(batch)
    #   rlUnloadRenderBatch : Unload render batch system
    #   @param batch [rlRenderBatch]
    #   @return [void]
    [:rlUnloadRenderBatch, :rlUnloadRenderBatch, [RlRenderBatch.by_value], :void],

    # @!method rlDrawRenderBatch(batch)
    #   rlDrawRenderBatch : Draw render batch data (Update->Draw->Reset)
    #   @param batch [rlRenderBatch *]
    #   @return [void]
    [:rlDrawRenderBatch, :rlDrawRenderBatch, [:pointer], :void],

    # @!method rlSetRenderBatchActive(batch)
    #   rlSetRenderBatchActive : Set the active render batch for rlgl (NULL for default internal)
    #   @param batch [rlRenderBatch *]
    #   @return [void]
    [:rlSetRenderBatchActive, :rlSetRenderBatchActive, [:pointer], :void],

    # @!method rlDrawRenderBatchActive()
    #   rlDrawRenderBatchActive : Update and draw internal render batch
    #   @return [void]
    [:rlDrawRenderBatchActive, :rlDrawRenderBatchActive, [], :void],

    # @!method rlCheckRenderBatchLimit(vCount)
    #   rlCheckRenderBatchLimit : Check internal buffer overflow for a given number of vertex
    #   @param vCount [int]
    #   @return [bool]
    [:rlCheckRenderBatchLimit, :rlCheckRenderBatchLimit, [:int], :bool],

    # @!method rlSetTexture(id)
    #   rlSetTexture : Set current texture for render batch and check buffers limits
    #   @param id [unsigned int]
    #   @return [void]
    [:rlSetTexture, :rlSetTexture, [:uint], :void],

    # @!method rlLoadVertexArray()
    #   rlLoadVertexArray : Load vertex array (vao) if supported
    #   @return [unsigned int]
    [:rlLoadVertexArray, :rlLoadVertexArray, [], :uint],

    # @!method rlLoadVertexBuffer(buffer, size, dynamic)
    #   rlLoadVertexBuffer : Load a vertex buffer object
    #   @param buffer [const void *]
    #   @param size [int]
    #   @param dynamic [bool]
    #   @return [unsigned int]
    [:rlLoadVertexBuffer, :rlLoadVertexBuffer, [:pointer, :int, :bool], :uint],

    # @!method rlLoadVertexBufferElement(buffer, size, dynamic)
    #   rlLoadVertexBufferElement : Load vertex buffer elements object
    #   @param buffer [const void *]
    #   @param size [int]
    #   @param dynamic [bool]
    #   @return [unsigned int]
    [:rlLoadVertexBufferElement, :rlLoadVertexBufferElement, [:pointer, :int, :bool], :uint],

    # @!method rlUpdateVertexBuffer(bufferId, data, dataSize, offset)
    #   rlUpdateVertexBuffer : Update vertex buffer object data on GPU buffer
    #   @param bufferId [unsigned int]
    #   @param data [const void *]
    #   @param dataSize [int]
    #   @param offset [int]
    #   @return [void]
    [:rlUpdateVertexBuffer, :rlUpdateVertexBuffer, [:uint, :pointer, :int, :int], :void],

    # @!method rlUpdateVertexBufferElements(id, data, dataSize, offset)
    #   rlUpdateVertexBufferElements : Update vertex buffer elements data on GPU buffer
    #   @param id [unsigned int]
    #   @param data [const void *]
    #   @param dataSize [int]
    #   @param offset [int]
    #   @return [void]
    [:rlUpdateVertexBufferElements, :rlUpdateVertexBufferElements, [:uint, :pointer, :int, :int], :void],

    # @!method rlUnloadVertexArray(vaoId)
    #   rlUnloadVertexArray : Unload vertex array (vao)
    #   @param vaoId [unsigned int]
    #   @return [void]
    [:rlUnloadVertexArray, :rlUnloadVertexArray, [:uint], :void],

    # @!method rlUnloadVertexBuffer(vboId)
    #   rlUnloadVertexBuffer : Unload vertex buffer object
    #   @param vboId [unsigned int]
    #   @return [void]
    [:rlUnloadVertexBuffer, :rlUnloadVertexBuffer, [:uint], :void],

    # @!method rlSetVertexAttribute(index, compSize, type, normalized, stride, offset)
    #   rlSetVertexAttribute : Set vertex attribute data configuration
    #   @param index [unsigned int]
    #   @param compSize [int]
    #   @param type [int]
    #   @param normalized [bool]
    #   @param stride [int]
    #   @param offset [int]
    #   @return [void]
    [:rlSetVertexAttribute, :rlSetVertexAttribute, [:uint, :int, :int, :bool, :int, :int], :void],

    # @!method rlSetVertexAttributeDivisor(index, divisor)
    #   rlSetVertexAttributeDivisor : Set vertex attribute data divisor
    #   @param index [unsigned int]
    #   @param divisor [int]
    #   @return [void]
    [:rlSetVertexAttributeDivisor, :rlSetVertexAttributeDivisor, [:uint, :int], :void],

    # @!method rlSetVertexAttributeDefault(locIndex, value, attribType, count)
    #   rlSetVertexAttributeDefault : Set vertex attribute default value, when attribute to provided
    #   @param locIndex [int]
    #   @param value [const void *]
    #   @param attribType [int]
    #   @param count [int]
    #   @return [void]
    [:rlSetVertexAttributeDefault, :rlSetVertexAttributeDefault, [:int, :pointer, :int, :int], :void],

    # @!method rlDrawVertexArray(offset, count)
    #   rlDrawVertexArray : Draw vertex array (currently active vao)
    #   @param offset [int]
    #   @param count [int]
    #   @return [void]
    [:rlDrawVertexArray, :rlDrawVertexArray, [:int, :int], :void],

    # @!method rlDrawVertexArrayElements(offset, count, buffer)
    #   rlDrawVertexArrayElements : Draw vertex array elements
    #   @param offset [int]
    #   @param count [int]
    #   @param buffer [const void *]
    #   @return [void]
    [:rlDrawVertexArrayElements, :rlDrawVertexArrayElements, [:int, :int, :pointer], :void],

    # @!method rlDrawVertexArrayInstanced(offset, count, instances)
    #   rlDrawVertexArrayInstanced : Draw vertex array (currently active vao) with instancing
    #   @param offset [int]
    #   @param count [int]
    #   @param instances [int]
    #   @return [void]
    [:rlDrawVertexArrayInstanced, :rlDrawVertexArrayInstanced, [:int, :int, :int], :void],

    # @!method rlDrawVertexArrayElementsInstanced(offset, count, buffer, instances)
    #   rlDrawVertexArrayElementsInstanced : Draw vertex array elements with instancing
    #   @param offset [int]
    #   @param count [int]
    #   @param buffer [const void *]
    #   @param instances [int]
    #   @return [void]
    [:rlDrawVertexArrayElementsInstanced, :rlDrawVertexArrayElementsInstanced, [:int, :int, :pointer, :int], :void],

    # @!method rlLoadTexture(data, width, height, format, mipmapCount)
    #   rlLoadTexture : Load texture data
    #   @param data [const void *]
    #   @param width [int]
    #   @param height [int]
    #   @param format [int]
    #   @param mipmapCount [int]
    #   @return [unsigned int]
    [:rlLoadTexture, :rlLoadTexture, [:pointer, :int, :int, :int, :int], :uint],

    # @!method rlLoadTextureDepth(width, height, useRenderBuffer)
    #   rlLoadTextureDepth : Load depth texture/renderbuffer (to be attached to fbo)
    #   @param width [int]
    #   @param height [int]
    #   @param useRenderBuffer [bool]
    #   @return [unsigned int]
    [:rlLoadTextureDepth, :rlLoadTextureDepth, [:int, :int, :bool], :uint],

    # @!method rlLoadTextureCubemap(data, size, format, mipmapCount)
    #   rlLoadTextureCubemap : Load texture cubemap data
    #   @param data [const void *]
    #   @param size [int]
    #   @param format [int]
    #   @param mipmapCount [int]
    #   @return [unsigned int]
    [:rlLoadTextureCubemap, :rlLoadTextureCubemap, [:pointer, :int, :int, :int], :uint],

    # @!method rlUpdateTexture(id, offsetX, offsetY, width, height, format, data)
    #   rlUpdateTexture : Update texture with new data on GPU
    #   @param id [unsigned int]
    #   @param offsetX [int]
    #   @param offsetY [int]
    #   @param width [int]
    #   @param height [int]
    #   @param format [int]
    #   @param data [const void *]
    #   @return [void]
    [:rlUpdateTexture, :rlUpdateTexture, [:uint, :int, :int, :int, :int, :int, :pointer], :void],

    # @!method rlGetGlTextureFormats(format, glInternalFormat, glFormat, glType)
    #   rlGetGlTextureFormats : Get OpenGL internal formats
    #   @param format [int]
    #   @param glInternalFormat [unsigned int *]
    #   @param glFormat [unsigned int *]
    #   @param glType [unsigned int *]
    #   @return [void]
    [:rlGetGlTextureFormats, :rlGetGlTextureFormats, [:int, :pointer, :pointer, :pointer], :void],

    # @!method rlGetPixelFormatName(format)
    #   rlGetPixelFormatName : Get name string for pixel format
    #   @param format [unsigned int]
    #   @return [const char *]
    [:rlGetPixelFormatName, :rlGetPixelFormatName, [:uint], :pointer],

    # @!method rlUnloadTexture(id)
    #   rlUnloadTexture : Unload texture from GPU memory
    #   @param id [unsigned int]
    #   @return [void]
    [:rlUnloadTexture, :rlUnloadTexture, [:uint], :void],

    # @!method rlGenTextureMipmaps(id, width, height, format, mipmaps)
    #   rlGenTextureMipmaps : Generate mipmap data for selected texture
    #   @param id [unsigned int]
    #   @param width [int]
    #   @param height [int]
    #   @param format [int]
    #   @param mipmaps [int *]
    #   @return [void]
    [:rlGenTextureMipmaps, :rlGenTextureMipmaps, [:uint, :int, :int, :int, :pointer], :void],

    # @!method rlReadTexturePixels(id, width, height, format)
    #   rlReadTexturePixels : Read texture pixel data
    #   @param id [unsigned int]
    #   @param width [int]
    #   @param height [int]
    #   @param format [int]
    #   @return [void *]
    [:rlReadTexturePixels, :rlReadTexturePixels, [:uint, :int, :int, :int], :pointer],

    # @!method rlReadScreenPixels(width, height)
    #   rlReadScreenPixels : Read screen pixel data (color buffer)
    #   @param width [int]
    #   @param height [int]
    #   @return [unsigned char *]
    [:rlReadScreenPixels, :rlReadScreenPixels, [:int, :int], :pointer],

    # @!method rlLoadFramebuffer()
    #   rlLoadFramebuffer : Load an empty framebuffer
    #   @return [unsigned int]
    [:rlLoadFramebuffer, :rlLoadFramebuffer, [], :uint],

    # @!method rlFramebufferAttach(fboId, texId, attachType, texType, mipLevel)
    #   rlFramebufferAttach : Attach texture/renderbuffer to a framebuffer
    #   @param fboId [unsigned int]
    #   @param texId [unsigned int]
    #   @param attachType [int]
    #   @param texType [int]
    #   @param mipLevel [int]
    #   @return [void]
    [:rlFramebufferAttach, :rlFramebufferAttach, [:uint, :uint, :int, :int, :int], :void],

    # @!method rlFramebufferComplete(id)
    #   rlFramebufferComplete : Verify framebuffer is complete
    #   @param id [unsigned int]
    #   @return [bool]
    [:rlFramebufferComplete, :rlFramebufferComplete, [:uint], :bool],

    # @!method rlUnloadFramebuffer(id)
    #   rlUnloadFramebuffer : Delete framebuffer from GPU
    #   @param id [unsigned int]
    #   @return [void]
    [:rlUnloadFramebuffer, :rlUnloadFramebuffer, [:uint], :void],

    # @!method rlLoadShaderCode(vsCode, fsCode)
    #   rlLoadShaderCode : Load shader from code strings
    #   @param vsCode [const char *]
    #   @param fsCode [const char *]
    #   @return [unsigned int]
    [:rlLoadShaderCode, :rlLoadShaderCode, [:pointer, :pointer], :uint],

    # @!method rlCompileShader(shaderCode, type)
    #   rlCompileShader : Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER)
    #   @param shaderCode [const char *]
    #   @param type [int]
    #   @return [unsigned int]
    [:rlCompileShader, :rlCompileShader, [:pointer, :int], :uint],

    # @!method rlLoadShaderProgram(vShaderId, fShaderId)
    #   rlLoadShaderProgram : Load custom shader program
    #   @param vShaderId [unsigned int]
    #   @param fShaderId [unsigned int]
    #   @return [unsigned int]
    [:rlLoadShaderProgram, :rlLoadShaderProgram, [:uint, :uint], :uint],

    # @!method rlUnloadShaderProgram(id)
    #   rlUnloadShaderProgram : Unload shader program
    #   @param id [unsigned int]
    #   @return [void]
    [:rlUnloadShaderProgram, :rlUnloadShaderProgram, [:uint], :void],

    # @!method rlGetLocationUniform(shaderId, uniformName)
    #   rlGetLocationUniform : Get shader location uniform
    #   @param shaderId [unsigned int]
    #   @param uniformName [const char *]
    #   @return [int]
    [:rlGetLocationUniform, :rlGetLocationUniform, [:uint, :pointer], :int],

    # @!method rlGetLocationAttrib(shaderId, attribName)
    #   rlGetLocationAttrib : Get shader location attribute
    #   @param shaderId [unsigned int]
    #   @param attribName [const char *]
    #   @return [int]
    [:rlGetLocationAttrib, :rlGetLocationAttrib, [:uint, :pointer], :int],

    # @!method rlSetUniform(locIndex, value, uniformType, count)
    #   rlSetUniform : Set shader value uniform
    #   @param locIndex [int]
    #   @param value [const void *]
    #   @param uniformType [int]
    #   @param count [int]
    #   @return [void]
    [:rlSetUniform, :rlSetUniform, [:int, :pointer, :int, :int], :void],

    # @!method rlSetUniformMatrix(locIndex, mat)
    #   rlSetUniformMatrix : Set shader value matrix
    #   @param locIndex [int]
    #   @param mat [Matrix]
    #   @return [void]
    [:rlSetUniformMatrix, :rlSetUniformMatrix, [:int, Matrix.by_value], :void],

    # @!method rlSetUniformMatrices(locIndex, mat, count)
    #   rlSetUniformMatrices : Set shader value matrices
    #   @param locIndex [int]
    #   @param mat [const Matrix *]
    #   @param count [int]
    #   @return [void]
    [:rlSetUniformMatrices, :rlSetUniformMatrices, [:int, :pointer, :int], :void],

    # @!method rlSetUniformSampler(locIndex, textureId)
    #   rlSetUniformSampler : Set shader value sampler
    #   @param locIndex [int]
    #   @param textureId [unsigned int]
    #   @return [void]
    [:rlSetUniformSampler, :rlSetUniformSampler, [:int, :uint], :void],

    # @!method rlSetShader(id, locs)
    #   rlSetShader : Set shader currently active (id and locations)
    #   @param id [unsigned int]
    #   @param locs [int *]
    #   @return [void]
    [:rlSetShader, :rlSetShader, [:uint, :pointer], :void],

    # @!method rlLoadComputeShaderProgram(shaderId)
    #   rlLoadComputeShaderProgram : Load compute shader program
    #   @param shaderId [unsigned int]
    #   @return [unsigned int]
    [:rlLoadComputeShaderProgram, :rlLoadComputeShaderProgram, [:uint], :uint],

    # @!method rlComputeShaderDispatch(groupX, groupY, groupZ)
    #   rlComputeShaderDispatch : Dispatch compute shader (equivalent to *draw* for graphics pipeline)
    #   @param groupX [unsigned int]
    #   @param groupY [unsigned int]
    #   @param groupZ [unsigned int]
    #   @return [void]
    [:rlComputeShaderDispatch, :rlComputeShaderDispatch, [:uint, :uint, :uint], :void],

    # @!method rlLoadShaderBuffer(size, data, usageHint)
    #   rlLoadShaderBuffer : Load shader storage buffer object (SSBO)
    #   @param size [unsigned int]
    #   @param data [const void *]
    #   @param usageHint [int]
    #   @return [unsigned int]
    [:rlLoadShaderBuffer, :rlLoadShaderBuffer, [:uint, :pointer, :int], :uint],

    # @!method rlUnloadShaderBuffer(ssboId)
    #   rlUnloadShaderBuffer : Unload shader storage buffer object (SSBO)
    #   @param ssboId [unsigned int]
    #   @return [void]
    [:rlUnloadShaderBuffer, :rlUnloadShaderBuffer, [:uint], :void],

    # @!method rlUpdateShaderBuffer(id, data, dataSize, offset)
    #   rlUpdateShaderBuffer : Update SSBO buffer data
    #   @param id [unsigned int]
    #   @param data [const void *]
    #   @param dataSize [unsigned int]
    #   @param offset [unsigned int]
    #   @return [void]
    [:rlUpdateShaderBuffer, :rlUpdateShaderBuffer, [:uint, :pointer, :uint, :uint], :void],

    # @!method rlBindShaderBuffer(id, index)
    #   rlBindShaderBuffer : Bind SSBO buffer
    #   @param id [unsigned int]
    #   @param index [unsigned int]
    #   @return [void]
    [:rlBindShaderBuffer, :rlBindShaderBuffer, [:uint, :uint], :void],

    # @!method rlReadShaderBuffer(id, dest, count, offset)
    #   rlReadShaderBuffer : Read SSBO buffer data (GPU->CPU)
    #   @param id [unsigned int]
    #   @param dest [void *]
    #   @param count [unsigned int]
    #   @param offset [unsigned int]
    #   @return [void]
    [:rlReadShaderBuffer, :rlReadShaderBuffer, [:uint, :pointer, :uint, :uint], :void],

    # @!method rlCopyShaderBuffer(destId, srcId, destOffset, srcOffset, count)
    #   rlCopyShaderBuffer : Copy SSBO data between buffers
    #   @param destId [unsigned int]
    #   @param srcId [unsigned int]
    #   @param destOffset [unsigned int]
    #   @param srcOffset [unsigned int]
    #   @param count [unsigned int]
    #   @return [void]
    [:rlCopyShaderBuffer, :rlCopyShaderBuffer, [:uint, :uint, :uint, :uint, :uint], :void],

    # @!method rlGetShaderBufferSize(id)
    #   rlGetShaderBufferSize : Get SSBO buffer size
    #   @param id [unsigned int]
    #   @return [unsigned int]
    [:rlGetShaderBufferSize, :rlGetShaderBufferSize, [:uint], :uint],

    # @!method rlBindImageTexture(id, index, format, readonly)
    #   rlBindImageTexture : Bind image texture
    #   @param id [unsigned int]
    #   @param index [unsigned int]
    #   @param format [int]
    #   @param readonly [bool]
    #   @return [void]
    [:rlBindImageTexture, :rlBindImageTexture, [:uint, :uint, :int, :bool], :void],

    # @!method rlGetMatrixModelview()
    #   rlGetMatrixModelview : Get internal modelview matrix
    #   @return [Matrix]
    [:rlGetMatrixModelview, :rlGetMatrixModelview, [], Matrix.by_value],

    # @!method rlGetMatrixProjection()
    #   rlGetMatrixProjection : Get internal projection matrix
    #   @return [Matrix]
    [:rlGetMatrixProjection, :rlGetMatrixProjection, [], Matrix.by_value],

    # @!method rlGetMatrixTransform()
    #   rlGetMatrixTransform : Get internal accumulated transform matrix
    #   @return [Matrix]
    [:rlGetMatrixTransform, :rlGetMatrixTransform, [], Matrix.by_value],

    # @!method rlGetMatrixProjectionStereo(eye)
    #   rlGetMatrixProjectionStereo : Get internal projection matrix for stereo render (selected eye)
    #   @param eye [int]
    #   @return [Matrix]
    [:rlGetMatrixProjectionStereo, :rlGetMatrixProjectionStereo, [:int], Matrix.by_value],

    # @!method rlGetMatrixViewOffsetStereo(eye)
    #   rlGetMatrixViewOffsetStereo : Get internal view offset matrix for stereo render (selected eye)
    #   @param eye [int]
    #   @return [Matrix]
    [:rlGetMatrixViewOffsetStereo, :rlGetMatrixViewOffsetStereo, [:int], Matrix.by_value],

    # @!method rlSetMatrixProjection(proj)
    #   rlSetMatrixProjection : Set a custom projection matrix (replaces internal projection matrix)
    #   @param proj [Matrix]
    #   @return [void]
    [:rlSetMatrixProjection, :rlSetMatrixProjection, [Matrix.by_value], :void],

    # @!method rlSetMatrixModelview(view)
    #   rlSetMatrixModelview : Set a custom modelview matrix (replaces internal modelview matrix)
    #   @param view [Matrix]
    #   @return [void]
    [:rlSetMatrixModelview, :rlSetMatrixModelview, [Matrix.by_value], :void],

    # @!method rlSetMatrixProjectionStereo(right, left)
    #   rlSetMatrixProjectionStereo : Set eyes projection matrices for stereo rendering
    #   @param right [Matrix]
    #   @param left [Matrix]
    #   @return [void]
    [:rlSetMatrixProjectionStereo, :rlSetMatrixProjectionStereo, [Matrix.by_value, Matrix.by_value], :void],

    # @!method rlSetMatrixViewOffsetStereo(right, left)
    #   rlSetMatrixViewOffsetStereo : Set eyes view offsets matrices for stereo rendering
    #   @param right [Matrix]
    #   @param left [Matrix]
    #   @return [void]
    [:rlSetMatrixViewOffsetStereo, :rlSetMatrixViewOffsetStereo, [Matrix.by_value, Matrix.by_value], :void],

    # @!method rlLoadDrawCube()
    #   rlLoadDrawCube : Load and draw a cube
    #   @return [void]
    [:rlLoadDrawCube, :rlLoadDrawCube, [], :void],

    # @!method rlLoadDrawQuad()
    #   rlLoadDrawQuad : Load and draw a quad
    #   @return [void]
    [:rlLoadDrawQuad, :rlLoadDrawQuad, [], :void],
  ]
  entries.each do |entry|
    api_name = if method_naming == :snake_case
                 snake_case_name = entry[0].to_s.gsub(/([A-Z]+)([A-Z0-9][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z0-9])/, '\1_\2').downcase
                 snake_case_name.gsub!('vector_3', 'vector3_') if snake_case_name.include?('vector_3')
                 snake_case_name.gsub!('vector_2', 'vector2_') if snake_case_name.include?('vector_2')
                 snake_case_name.chop! if snake_case_name.end_with?('_')
                 snake_case_name.to_sym
               else
                 entry[0]
               end
    attach_function api_name, entry[1], entry[2], entry[3]
  rescue FFI::NotFoundError => e
    warn "[Warning] Failed to import #{entry[0]} (#{e})."
  end
end

.setup_symbols(method_naming: :original) ⇒ Object

# File 'lib/raylib.rb', line 33

def self.setup_symbols(method_naming: :original)
  setup_raylib_symbols(method_naming: method_naming)
  setup_raymath_symbols(method_naming: method_naming)
  setup_rcamera_symbols(method_naming: method_naming)
  setup_rlgl_symbols(method_naming: method_naming)
end

.template ⇒ Object

Generate sample code

# File 'lib/raylib.rb', line 43

def self.template
  # Copy template code to user's current directory
  example_path = "#{Gem::Specification.find_by_name('raylib-bindings').full_gem_path}/examples"
  template_code_src = "#{example_path}/template.rb"
  unless File.exist? template_code_src
    warn "[Error] Raylib.template : Template source #{template_code_src} not found"
    return false
  end

  template_code_dst = "#{Dir.getwd}/template.rb"
  if File.exist? template_code_dst
    warn "[Error] Raylib.template : Template destination #{template_code_dst} already exists"
    return false
  end

  warn "[Info] Raylib.template : #{template_code_src} => #{template_code_dst}"
  FileUtils.copy template_code_src, template_code_dst
  warn '[Info] Raylib.template : Done'
end

Instance Method Details

#DrawModelEx(model, position, rotationAxis, rotationAngle, scale, tint) ⇒ void

This method returns an undefined value.

DrawModelEx : Draw a model with extended parameters

Parameters:

• model (Model)
• position (Vector3)
• rotationAxis (Vector3)
• rotationAngle (float)
• scale (Vector3)
• tint (Color)

# File 'lib/raylib_helper.rb', line 306

def DrawModelEx(model, position, rotationAxis, rotationAngle, scale, tint)
  # [NOTE] Fixing unintended matrix modification
  # - In C, DrawModelEx uses the whole copy of `model` on stack, which will never affect the content of original `model`.
  #   But Ruby FFI seems to pass the reference of `model` to DrawModelEx, which results in transform accumulation (e.g.:`model` get rotated by `rotationAngle` around `rotationAxis` every frame).
  #   So here I copy the transform into `mtx_clone` and copy back this to the original after finished calling DrawModelEx.
  # - Other DrawXXX members (DrawModel, DrawModelWires, DrawModelWiresEx) are free from this problem.
  #   - They call DrawModelEx in C layer, which will use the copy of `model` on stack.
  mtx_clone = model[:transform].clone
  internalDrawModelEx(model, position, rotationAxis, rotationAngle, scale, tint)
  model[:transform] = mtx_clone
end

#LoadAndAllocateModelAnimations(fileName) ⇒ Object

LoadAndAllocateModelAnimations : (ruby raylib original)

Parameters:

• fileName (const char *)

Returns:

• array of ModelAnimation and pointer to loaded memory

# File 'lib/raylib_helper.rb', line 411

def LoadAndAllocateModelAnimations(fileName)
  animsCount_buf = FFI::MemoryPointer.new(:uint, 1)
  anim_ptrs = LoadModelAnimations(fileName, animsCount_buf)
  animsCount = animsCount_buf.read_uint
  anims = animsCount.times.map do |i|
    ModelAnimation.new(anim_ptrs + i * ModelAnimation.size)
  end
  return anims, anim_ptrs
end

#MatrixToFloat(mat) ⇒ Object

# File 'lib/raylib_helper.rb', line 227

def MatrixToFloat(mat)
  MatrixToFloatV(mat)[:v].to_a
end

#RGuiCheckBox(bounds, text, checked) ⇒ Object

# File 'lib/raygui_helper.rb', line 37

def RGuiCheckBox(bounds, text, checked)
  checked_buf = FFI::MemoryPointer.new(:bool, 1)
  checked_buf.put(:bool, 0, checked)
  result = GuiCheckBox(bounds, text, checked_buf)
  return checked_buf.get(:bool, 0), result
end

#RGuiColorBarAlpha(bounds, text, alpha) ⇒ Object

# File 'lib/raygui_helper.rb', line 113

def RGuiColorBarAlpha(bounds, text, alpha)
  alpha_buf = FFI::MemoryPointer.new(:float, 1)
  alpha_buf.put_float(0, alpha)
  result = GuiColorBarAlpha(bounds, text, alpha_buf)
  return alpha_buf.read_float, result
end

#RGuiColorBarHue(bounds, text, value) ⇒ Object

# File 'lib/raygui_helper.rb', line 120

def RGuiColorBarHue(bounds, text, value)
  value_buf = FFI::MemoryPointer.new(:float, 1)
  value_buf.put_float(0, value)
  result = GuiColorBarHue(bounds, text, value_buf)
  return value_buf.read_float, result
end

#RGuiComboBox(bounds, text, active) ⇒ Object

# File 'lib/raygui_helper.rb', line 44

def RGuiComboBox(bounds, text, active)
  active_buf = FFI::MemoryPointer.new(:int, 1)
  active_buf.put(:int, 0, active)
  result = GuiComboBox(bounds, text, active_buf)
  return active_buf.get(:int, 0), result
end

#RGuiDropdownBox(bounds, text, active, editMode) ⇒ Object

# File 'lib/raygui_helper.rb', line 51

def RGuiDropdownBox(bounds, text, active, editMode)
  active_buf = FFI::MemoryPointer.new(:int, 1)
  active_buf.put(:int, 0, active)
  result = GuiDropdownBox(bounds, text, active_buf, editMode)
  return active_buf.get(:int, 0), result
end

#RGuiListView(bounds, text, scrollIndex, active) ⇒ Object

# File 'lib/raygui_helper.rb', line 93

def RGuiListView(bounds, text, scrollIndex, active)
  scrollIndex_buf = FFI::MemoryPointer.new(:int, 1)
  scrollIndex_buf.put(:int, 0, scrollIndex)
  active_buf = FFI::MemoryPointer.new(:int, 1)
  active_buf.put(:int, 0, active)
  result = GuiListView(bounds, text, scrollIndex_buf, active_buf)
  return scrollIndex_buf.get(:int, 0), active_buf.get(:int, 0), result
end

#RGuiListViewEx(bounds, text, count, scrollIndex, active, focus) ⇒ Object

# File 'lib/raygui_helper.rb', line 102

def RGuiListViewEx(bounds, text, count, scrollIndex, active, focus)
  scrollIndex_buf = FFI::MemoryPointer.new(:int, 1)
  scrollIndex_buf.put(:int, 0, scrollIndex)
  active_buf = FFI::MemoryPointer.new(:int, 1)
  active_buf.put(:int, 0, active)
  focus_buf = FFI::MemoryPointer.new(:int, 1)
  focus_buf.put(:int, 0, focus)
  result = GuiListViewEx(bounds, text, count, scrollIndex_buf, active_buf, focus_buf)
  return scrollIndex_buf.get(:int, 0), active_buf.get(:int, 0), focus_buf.get(:int, 0), result
end

#RGuiProgressBar(bounds, textLeft, textRight, value, minValue, maxValue) ⇒ Object

# File 'lib/raygui_helper.rb', line 86

def RGuiProgressBar(bounds, textLeft, textRight, value, minValue, maxValue)
  value_buf = FFI::MemoryPointer.new(:float, 1)
  value_buf.put_float(0, value)
  result = GuiProgressBar(bounds, textLeft, textRight, value_buf, minValue, maxValue)
  return value_buf.read_float, result
end

#RGuiSlider(bounds, textLeft, textRight, value, minValue, maxValue) ⇒ Object

# File 'lib/raygui_helper.rb', line 72

def RGuiSlider(bounds, textLeft, textRight, value, minValue, maxValue)
  value_buf = FFI::MemoryPointer.new(:float, 1)
  value_buf.put_float(0, value)
  result = GuiSlider(bounds, textLeft, textRight, value_buf, minValue, maxValue)
  return value_buf.read_float, result
end

#RGuiSliderBar(bounds, textLeft, textRight, value, minValue, maxValue) ⇒ Object

# File 'lib/raygui_helper.rb', line 79

def RGuiSliderBar(bounds, textLeft, textRight, value, minValue, maxValue)
  value_buf = FFI::MemoryPointer.new(:float, 1)
  value_buf.put_float(0, value)
  result = GuiSliderBar(bounds, textLeft, textRight, value_buf, minValue, maxValue)
  return value_buf.read_float, result
end

#RGuiSpinner(bounds, text, value, minValue, maxValue, editMode) ⇒ Object

# File 'lib/raygui_helper.rb', line 58

def RGuiSpinner(bounds, text, value, minValue, maxValue, editMode)
  value_buf = FFI::MemoryPointer.new(:int, 1)
  value_buf.put(:int, 0, value)
  result = GuiSpinner(bounds, text, value_buf, minValue, maxValue, editMode)
  return value_buf.get(:int, 0), result
end

#RGuiTabBar(bounds, text, count, active) ⇒ Object

# File 'lib/raygui_helper.rb', line 9

def RGuiTabBar(bounds, text, count, active)
  active_buf = FFI::MemoryPointer.new(:int, 1)
  active_buf.put(:int, 0, active)
  result = GuiTabBar(bounds, text, count, active_buf)
  return active_buf.get(:int, 0), result
end

#RGuiToggle(bounds, text, active) ⇒ Object

# File 'lib/raygui_helper.rb', line 16

def RGuiToggle(bounds, text, active)
  active_buf = FFI::MemoryPointer.new(:int, 1)
  active_buf.put(:int, 0, active)
  result = GuiToggle(bounds, text, active_buf)
  return active_buf.get(:int, 0), result
end

#RGuiToggleGroup(bounds, text, active) ⇒ Object

# File 'lib/raygui_helper.rb', line 23

def RGuiToggleGroup(bounds, text, active)
  active_buf = FFI::MemoryPointer.new(:int, 1)
  active_buf.put(:int, 0, active)
  result = GuiToggleGroup(bounds, text, active_buf)
  return active_buf.get(:int, 0), result
end

#RGuiToggleSlider(bounds, text, active) ⇒ Object

# File 'lib/raygui_helper.rb', line 30

def RGuiToggleSlider(bounds, text, active)
  active_buf = FFI::MemoryPointer.new(:int, 1)
  active_buf.put(:int, 0, active)
  result = GuiToggleSlider(bounds, text, active_buf)
  return active_buf.get(:int, 0), result
end

#RGuiValueBox(bounds, text, value, minValue, maxValue, editMode) ⇒ Object

# File 'lib/raygui_helper.rb', line 65

def RGuiValueBox(bounds, text, value, minValue, maxValue, editMode)
  value_buf = FFI::MemoryPointer.new(:int, 1)
  value_buf.put(:int, 0, value)
  result = GuiValueBox(bounds, text, value_buf, minValue, maxValue, editMode)
  return value_buf.get(:int, 0), result
end

#UnloadAndFreeModelAnimations(anims, anim_ptrs) ⇒ Object

UnloadAndFreeModelAnimations : (ruby raylib original)

Parameters:

• anims (array of ModelAnimation)
• anim_ptrs (pointer to loaded memory)

# File 'lib/raylib_helper.rb', line 424

def UnloadAndFreeModelAnimations(anims, anim_ptrs)
  anims.each do |anim|
    UnloadModelAnimation(anim)
  end
  MemFree(anim_ptrs)
end

#Vector3ToFloat(vec) ⇒ Object

# File 'lib/raylib_helper.rb', line 223

def Vector3ToFloat(vec)
  Vector3ToFloatV(vec)[:v].to_a
end