Binding

raylib defined Beige

raylib defined Black

raylib defined Transparent

raylib defined Blue

raylib defined Brown

raylib defined Dark Blue

raylib defined Dark Brown

raylib defined Dark Gray

raylib defined Dark Green

raylib defined Dark Purple

raylib defined Gold

raylib defined Gray

raylib defined Green

raylib defined Light Gray

raylib defined Lime

raylib defined Magenta

raylib defined Maroon

raylib defined Orange

raylib defined Pink

raylib defined Purple

raylib defined Ray White

raylib defined Red

raylib defined Sky Blue

raylib defined Violet

raylib defined White

raylib defined Yellow

RayFileData(filename::AbstractString)

Read the file data. It will be auto-unloaded when being garbage collected.

GetDroppedFiles()

Return a list of dropped file paths.

UpdateCamera(camera::RayCamera3D)

Return new camera with updated parameter.

UpdateCamera!(camera::RayCamera3D)

Update camera position for selected mode

function BeginBlendMode(mode::Integer)
    return @ccall(libraylib.BeginBlendMode(mode::Cint)::Cvoid)
end

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

function BeginDrawing()
    return @ccall(libraylib.BeginDrawing()::Cvoid)
end

Setup canvas (framebuffer) to start drawing

function BeginMode2D(camera::RayCamera2D)
    return @ccall(libraylib.BeginMode2D(camera::RayCamera2D)::Cvoid)
end

Begin 2D mode with custom camera (2D)

function BeginMode3D(camera::RayCamera3D)
    return @ccall(libraylib.BeginMode3D(camera::RayCamera3D)::Cvoid)
end

Begin 3D mode with custom camera (3D)

function BeginScissorMode(x::Integer, y::Integer, width::Integer, height::Integer)
    return @ccall(libraylib.BeginScissorMode(x::Cint, y::Cint, width::Cint, height::Cint)::Cvoid)
end

Begin scissor mode (define screen area for following drawing)

function BeginShaderMode(shader::RayShader)
    return @ccall(libraylib.BeginShaderMode(shader::RayShader)::Cvoid)
end

Begin custom shader drawing

function BeginTextureMode(target::RayRenderTexture)
    return @ccall(libraylib.BeginTextureMode(target::RayRenderTexture)::Cvoid)
end

Begin drawing to render texture

function BeginVrStereoMode(config::RayVrStereoConfig)
    return @ccall(libraylib.BeginVrStereoMode(config::RayVrStereoConfig)::Cvoid)
end

Begin stereo rendering (requires VR simulator)

function ChangeDirectory(dir::String)::Bool
    return @ccall(libraylib.ChangeDirectory(dir::Cstring)::Cuchar)
end

Change working directory, return true on success

function CheckCollisionBoxSphere(box::RayBoundingBox, center::StaticVector{3}, radius::Real)::Bool
    return @ccall(libraylib.CheckCollisionBoxSphere(box::RayBoundingBox, center::RayVector3, radius::Cfloat)::Cuchar)
end

Check collision between box and sphere

function CheckCollisionBoxes(box1::RayBoundingBox, box2::RayBoundingBox)::Bool
    return @ccall(libraylib.CheckCollisionBoxes(box1::RayBoundingBox, box2::RayBoundingBox)::Cuchar)
end

Check collision between two bounding boxes

function CheckCollisionCircleRec(center::StaticVector{2}, radius::Real, rec::RayRectangle)::Bool
    return @ccall(libraylib.CheckCollisionCircleRec(center::RayVector2, radius::Cfloat, rec::RayRectangle)::Cuchar)
end

Check collision between circle and rectangle

function CheckCollisionCircles(center1::StaticVector{2}, radius1::Real, center2::StaticVector{2}, radius2::Real)::Bool
    return @ccall(libraylib.CheckCollisionCircles(center1::RayVector2, radius1::Cfloat, center2::RayVector2, radius2::Cfloat)::Cuchar)
end

Check collision between two circles

function CheckCollisionLines(startPos1::StaticVector{2}, endPos1::StaticVector{2}, startPos2::StaticVector{2}, endPos2::StaticVector{2}, collisionPoint::Ref{<:StaticVector{2}})::Bool
    return @ccall(libraylib.CheckCollisionLines(startPos1::RayVector2, endPos1::RayVector2, startPos2::RayVector2, endPos2::RayVector2, collisionPoint::Ptr{RayVector2})::Cuchar)
end

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

function CheckCollisionPointCircle(point::StaticVector{2}, center::StaticVector{2}, radius::Real)::Bool
    return @ccall(libraylib.CheckCollisionPointCircle(point::RayVector2, center::RayVector2, radius::Cfloat)::Cuchar)
end

Check if point is inside circle

function CheckCollisionPointLine(point::StaticVector{2}, p1::StaticVector{2}, p2::StaticVector{2}, threshold::Integer)::Bool
    return @ccall(libraylib.CheckCollisionPointLine(point::RayVector2, p1::RayVector2, p2::RayVector2, threshold::Cint)::Cuchar)
end

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

function CheckCollisionPointRec(point::StaticVector{2}, rec::RayRectangle)::Bool
    return @ccall(libraylib.CheckCollisionPointRec(point::RayVector2, rec::RayRectangle)::Cuchar)
end

Check if point is inside rectangle

function CheckCollisionPointTriangle(point::StaticVector{2}, p1::StaticVector{2}, p2::StaticVector{2}, p3::StaticVector{2})::Bool
    return @ccall(libraylib.CheckCollisionPointTriangle(point::RayVector2, p1::RayVector2, p2::RayVector2, p3::RayVector2)::Cuchar)
end

Check if point is inside a triangle

function CheckCollisionRecs(rec1::RayRectangle, rec2::RayRectangle)::Bool
    return @ccall(libraylib.CheckCollisionRecs(rec1::RayRectangle, rec2::RayRectangle)::Cuchar)
end

Check collision between two rectangles

function CheckCollisionSpheres(center1::StaticVector{3}, radius1::Real, center2::StaticVector{3}, radius2::Real)::Bool
    return @ccall(libraylib.CheckCollisionSpheres(center1::RayVector3, radius1::Cfloat, center2::RayVector3, radius2::Cfloat)::Cuchar)
end

Check collision between two spheres

function Clamp(value::Real, min::Real, max::Real)
    return @ccall(libraylib.Clamp(value::Cfloat, min::Cfloat, max::Cfloat)::Cfloat)
end

function ClearBackground(color::RayColor)
    return @ccall(libraylib.ClearBackground(color::RayColor)::Cvoid)
end

Set background color (framebuffer clear color)

function ClearDirectoryFiles()
    return @ccall(libraylib.ClearDirectoryFiles()::Cvoid)
end

Clear directory files paths buffers (free memory)

function ClearDroppedFiles()
    return @ccall(libraylib.ClearDroppedFiles()::Cvoid)
end

Clear dropped files paths buffer (free memory)

function ClearWindowState(flags::Integer)
    return @ccall(libraylib.ClearWindowState(flags::Cuint)::Cvoid)
end

Clear window configuration state flags

function CloseAudioDevice()
    return @ccall(libraylib.CloseAudioDevice()::Cvoid)
end

Close the audio device and context

function ClosePhysics()
    return @ccall(libraylib.ClosePhysics()::Cvoid)
end

Close physics system and unload used memory

function CloseWindow()
    return @ccall(libraylib.CloseWindow()::Cvoid)
end

Close window and unload OpenGL context

function CodepointToUTF8(codepoint::Integer, byteSize::Ref{<:Integer})
    return @ccall(libraylib.CodepointToUTF8(codepoint::Cint, byteSize::Ptr{Cint})::Cstring)
end

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

function ColorAlpha(color::RayColor, alpha::Real)::RayColor
    return @ccall(libraylib.ColorAlpha(color::RayColor, alpha::Cfloat)::RayColor)
end

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

function ColorAlphaBlend(dst::RayColor, src::RayColor, tint::RayColor)::RayColor
    return @ccall(libraylib.ColorAlphaBlend(dst::RayColor, src::RayColor, tint::RayColor)::RayColor)
end

Get src alpha-blended into dst color with tint

function ColorFromHSV(hue::Real, saturation::Real, value::Real)::RayColor
    return @ccall(libraylib.ColorFromHSV(hue::Cfloat, saturation::Cfloat, value::Cfloat)::RayColor)
end

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

function ColorFromNormalized(normalized::StaticVector{4})::RayColor
    return @ccall(libraylib.ColorFromNormalized(normalized::RayVector4)::RayColor)
end

Get Color from normalized values [0..1]

function ColorNormalize(color::RayColor)
    return @ccall(libraylib.ColorNormalize(color::RayColor)::RayVector4)
end

Get Color normalized as float [0..1]

function ColorToHSV(color::RayColor)
    return @ccall(libraylib.ColorToHSV(color::RayColor)::RayVector3)
end

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

function ColorToInt(color::RayColor)
    return @ccall(libraylib.ColorToInt(color::RayColor)::Cint)
end

Get hexadecimal value for a Color

function CompressData(data::Ref{UInt8}, dataLength::Integer, compDataLength::Ref{<:Integer})
    return @ccall(libraylib.CompressData(data::Ptr{Cuchar}, dataLength::Cint, compDataLength::Ptr{Cint})::Ptr{Cuchar})
end

Compress data (DEFLATE algorithm)

function CreatePhysicsBodyCircle(pos::StaticVector{2}, radius::Real, density::Real)::Ptr{RayPhysicsBodyData}
    return @ccall(libraylib.CreatePhysicsBodyCircle(pos::RayVector2, radius::Cfloat, density::Cfloat)::Ptr{RayPhysicsBodyData})
end

Creates a new circle physics body with generic parameters

function CreatePhysicsBodyPolygon(pos::StaticVector{2}, radius::Real, sides::Integer, density::Real)::Ptr{RayPhysicsBodyData}
    return @ccall(libraylib.CreatePhysicsBodyPolygon(pos::RayVector2, radius::Cfloat, sides::Cint, density::Cfloat)::Ptr{RayPhysicsBodyData})
end

Creates a new polygon physics body with generic parameters

function CreatePhysicsBodyRectangle(pos::StaticVector{2}, width::Real, height::Real, density::Real)::Ptr{RayPhysicsBodyData}
    return @ccall(libraylib.CreatePhysicsBodyRectangle(pos::RayVector2, width::Cfloat, height::Cfloat, density::Cfloat)::Ptr{RayPhysicsBodyData})
end

Creates a new rectangle physics body with generic parameters

function DecodeDataBase64(data::Ref{UInt8}, outputLength::Ref{<:Integer})
    return @ccall(libraylib.DecodeDataBase64(data::Ptr{Cuchar}, outputLength::Ptr{Cint})::Ptr{Cuchar})
end

Decode Base64 string data

function DecompressData(compData::Ref{UInt8}, compDataLength::Integer, dataLength::Ref{<:Integer})
    return @ccall(libraylib.DecompressData(compData::Ptr{Cuchar}, compDataLength::Cint, dataLength::Ptr{Cint})::Ptr{Cuchar})
end

Decompress data (DEFLATE algorithm)

function DestroyPhysicsBody(body::Ptr{RayPhysicsBodyData})
    return @ccall(libraylib.DestroyPhysicsBody(body::Ptr{RayPhysicsBodyData})::Cvoid)
end

Destroy a physics body

function DirectoryExists(dirPath::String)::Bool
    return @ccall(libraylib.DirectoryExists(dirPath::Cstring)::Cuchar)
end

Check if a directory path exists

function DisableCursor()
    return @ccall(libraylib.DisableCursor()::Cvoid)
end

Disables cursor (lock cursor)

function DrawBillboard(camera::RayCamera3D, texture::RayTexture, position::StaticVector{3}, size::Real, tint::RayColor)
    return @ccall(libraylib.DrawBillboard(camera::RayCamera3D, texture::RayTexture, position::RayVector3, size::Cfloat, tint::RayColor)::Cvoid)
end

Draw a billboard texture

function DrawBillboardPro(camera::RayCamera3D, texture::RayTexture, source::RayRectangle, position::StaticVector{3}, up::StaticVector{3}, size::StaticVector{2}, origin::StaticVector{2}, rotation::Real, tint::RayColor)
    return @ccall(libraylib.DrawBillboardPro(camera::RayCamera3D, texture::RayTexture, source::RayRectangle, position::RayVector3, up::RayVector3, size::RayVector2, origin::RayVector2, rotation::Cfloat, tint::RayColor)::Cvoid)
end

Draw a billboard texture defined by source and rotation

function DrawBillboardRec(camera::RayCamera3D, texture::RayTexture, source::RayRectangle, position::StaticVector{3}, size::StaticVector{2}, tint::RayColor)
    return @ccall(libraylib.DrawBillboardRec(camera::RayCamera3D, texture::RayTexture, source::RayRectangle, position::RayVector3, size::RayVector2, tint::RayColor)::Cvoid)
end

Draw a billboard texture defined by source

function DrawBoundingBox(box::RayBoundingBox, color::RayColor)
    return @ccall(libraylib.DrawBoundingBox(box::RayBoundingBox, color::RayColor)::Cvoid)
end

Draw bounding box (wires)

function DrawCircle(centerX::Integer, centerY::Integer, radius::Real, color::RayColor)
    return @ccall(libraylib.DrawCircle(centerX::Cint, centerY::Cint, radius::Cfloat, color::RayColor)::Cvoid)
end

Draw a color-filled circle

function DrawCircle3D(center::StaticVector{3}, radius::Real, rotationAxis::StaticVector{3}, rotationAngle::Real, color::RayColor)
    return @ccall(libraylib.DrawCircle3D(center::RayVector3, radius::Cfloat, rotationAxis::RayVector3, rotationAngle::Cfloat, color::RayColor)::Cvoid)
end

Draw a circle in 3D world space

function DrawCircleGradient(centerX::Integer, centerY::Integer, radius::Real, color1::RayColor, color2::RayColor)
    return @ccall(libraylib.DrawCircleGradient(centerX::Cint, centerY::Cint, radius::Cfloat, color1::RayColor, color2::RayColor)::Cvoid)
end

Draw a gradient-filled circle

function DrawCircleLines(centerX::Integer, centerY::Integer, radius::Real, color::RayColor)
    return @ccall(libraylib.DrawCircleLines(centerX::Cint, centerY::Cint, radius::Cfloat, color::RayColor)::Cvoid)
end

Draw circle outline

function DrawCircleSector(center::StaticVector{2}, radius::Real, startAngle::Real, endAngle::Real, segments::Integer, color::RayColor)
    return @ccall(libraylib.DrawCircleSector(center::RayVector2, radius::Cfloat, startAngle::Cfloat, endAngle::Cfloat, segments::Cint, color::RayColor)::Cvoid)
end

Draw a piece of a circle

function DrawCircleSectorLines(center::StaticVector{2}, radius::Real, startAngle::Real, endAngle::Real, segments::Integer, color::RayColor)
    return @ccall(libraylib.DrawCircleSectorLines(center::RayVector2, radius::Cfloat, startAngle::Cfloat, endAngle::Cfloat, segments::Cint, color::RayColor)::Cvoid)
end

Draw circle sector outline

function DrawCircleV(center::StaticVector{2}, radius::Real, color::RayColor)
    return @ccall(libraylib.DrawCircleV(center::RayVector2, radius::Cfloat, color::RayColor)::Cvoid)
end

Draw a color-filled circle (Vector version)

function DrawCube(position::StaticVector{3}, width::Real, height::Real, length::Real, color::RayColor)
    return @ccall(libraylib.DrawCube(position::RayVector3, width::Cfloat, height::Cfloat, length::Cfloat, color::RayColor)::Cvoid)
end

Draw cube

function DrawCubeTexture(texture::RayTexture, position::StaticVector{3}, width::Real, height::Real, length::Real, color::RayColor)
    return @ccall(libraylib.DrawCubeTexture(texture::RayTexture, position::RayVector3, width::Cfloat, height::Cfloat, length::Cfloat, color::RayColor)::Cvoid)
end

Draw cube textured

function DrawCubeTextureRec(texture::RayTexture, source::RayRectangle, position::StaticVector{3}, width::Real, height::Real, length::Real, color::RayColor)
    return @ccall(libraylib.DrawCubeTextureRec(texture::RayTexture, source::RayRectangle, position::RayVector3, width::Cfloat, height::Cfloat, length::Cfloat, color::RayColor)::Cvoid)
end

Draw cube with a region of a texture

function DrawCubeV(position::StaticVector{3}, size::StaticVector{3}, color::RayColor)
    return @ccall(libraylib.DrawCubeV(position::RayVector3, size::RayVector3, color::RayColor)::Cvoid)
end

Draw cube (Vector version)

function DrawCubeWires(position::StaticVector{3}, width::Real, height::Real, length::Real, color::RayColor)
    return @ccall(libraylib.DrawCubeWires(position::RayVector3, width::Cfloat, height::Cfloat, length::Cfloat, color::RayColor)::Cvoid)
end

Draw cube wires

function DrawCubeWiresV(position::StaticVector{3}, size::StaticVector{3}, color::RayColor)
    return @ccall(libraylib.DrawCubeWiresV(position::RayVector3, size::RayVector3, color::RayColor)::Cvoid)
end

Draw cube wires (Vector version)

function DrawCylinder(position::StaticVector{3}, radiusTop::Real, radiusBottom::Real, height::Real, slices::Integer, color::RayColor)
    return @ccall(libraylib.DrawCylinder(position::RayVector3, radiusTop::Cfloat, radiusBottom::Cfloat, height::Cfloat, slices::Cint, color::RayColor)::Cvoid)
end

Draw a cylinder/cone

function DrawCylinderEx(startPos::StaticVector{3}, endPos::StaticVector{3}, startRadius::Real, endRadius::Real, sides::Integer, color::RayColor)
    return @ccall(libraylib.DrawCylinderEx(startPos::RayVector3, endPos::RayVector3, startRadius::Cfloat, endRadius::Cfloat, sides::Cint, color::RayColor)::Cvoid)
end

Draw a cylinder with base at startPos and top at endPos

function DrawCylinderWires(position::StaticVector{3}, radiusTop::Real, radiusBottom::Real, height::Real, slices::Integer, color::RayColor)
    return @ccall(libraylib.DrawCylinderWires(position::RayVector3, radiusTop::Cfloat, radiusBottom::Cfloat, height::Cfloat, slices::Cint, color::RayColor)::Cvoid)
end

Draw a cylinder/cone wires

function DrawCylinderWiresEx(startPos::StaticVector{3}, endPos::StaticVector{3}, startRadius::Real, endRadius::Real, sides::Integer, color::RayColor)
    return @ccall(libraylib.DrawCylinderWiresEx(startPos::RayVector3, endPos::RayVector3, startRadius::Cfloat, endRadius::Cfloat, sides::Cint, color::RayColor)::Cvoid)
end

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

function DrawEllipse(centerX::Integer, centerY::Integer, radiusH::Real, radiusV::Real, color::RayColor)
    return @ccall(libraylib.DrawEllipse(centerX::Cint, centerY::Cint, radiusH::Cfloat, radiusV::Cfloat, color::RayColor)::Cvoid)
end

Draw ellipse

function DrawEllipseLines(centerX::Integer, centerY::Integer, radiusH::Real, radiusV::Real, color::RayColor)
    return @ccall(libraylib.DrawEllipseLines(centerX::Cint, centerY::Cint, radiusH::Cfloat, radiusV::Cfloat, color::RayColor)::Cvoid)
end

Draw ellipse outline

function DrawFPS(posX::Integer, posY::Integer)
    return @ccall(libraylib.DrawFPS(posX::Cint, posY::Cint)::Cvoid)
end

Draw current FPS

function DrawGrid(slices::Integer, spacing::Real)
    return @ccall(libraylib.DrawGrid(slices::Cint, spacing::Cfloat)::Cvoid)
end

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

function DrawLine(startPosX::Integer, startPosY::Integer, endPosX::Integer, endPosY::Integer, color::RayColor)
    return @ccall(libraylib.DrawLine(startPosX::Cint, startPosY::Cint, endPosX::Cint, endPosY::Cint, color::RayColor)::Cvoid)
end

Draw a line

function DrawLine3D(startPos::StaticVector{3}, endPos::StaticVector{3}, color::RayColor)
    return @ccall(libraylib.DrawLine3D(startPos::RayVector3, endPos::RayVector3, color::RayColor)::Cvoid)
end

Draw a line in 3D world space

function DrawLineBezier(startPos::StaticVector{2}, endPos::StaticVector{2}, thick::Real, color::RayColor)
    return @ccall(libraylib.DrawLineBezier(startPos::RayVector2, endPos::RayVector2, thick::Cfloat, color::RayColor)::Cvoid)
end

Draw a line using cubic-bezier curves in-out

function DrawLineBezierCubic(startPos::StaticVector{2}, endPos::StaticVector{2}, startControlPos::StaticVector{2}, endControlPos::StaticVector{2}, thick::Real, color::RayColor)
    return @ccall(libraylib.DrawLineBezierCubic(startPos::RayVector2, endPos::RayVector2, startControlPos::RayVector2, endControlPos::RayVector2, thick::Cfloat, color::RayColor)::Cvoid)
end

Draw line using cubic bezier curves with 2 control points

function DrawLineBezierQuad(startPos::StaticVector{2}, endPos::StaticVector{2}, controlPos::StaticVector{2}, thick::Real, color::RayColor)
    return @ccall(libraylib.DrawLineBezierQuad(startPos::RayVector2, endPos::RayVector2, controlPos::RayVector2, thick::Cfloat, color::RayColor)::Cvoid)
end

Draw line using quadratic bezier curves with a control point

function DrawLineEx(startPos::StaticVector{2}, endPos::StaticVector{2}, thick::Real, color::RayColor)
    return @ccall(libraylib.DrawLineEx(startPos::RayVector2, endPos::RayVector2, thick::Cfloat, color::RayColor)::Cvoid)
end

Draw a line defining thickness

function DrawLineStrip(points::Ref{<:StaticVector{2}}, pointCount::Integer, color::RayColor)
    return @ccall(libraylib.DrawLineStrip(points::Ptr{RayVector2}, pointCount::Cint, color::RayColor)::Cvoid)
end

Draw lines sequence

function DrawLineV(startPos::StaticVector{2}, endPos::StaticVector{2}, color::RayColor)
    return @ccall(libraylib.DrawLineV(startPos::RayVector2, endPos::RayVector2, color::RayColor)::Cvoid)
end

Draw a line (Vector version)

function DrawMesh(mesh::RayMesh, material::RayMaterial, transform::RayMatrix)
    return @ccall(libraylib.DrawMesh(mesh::RayMesh, material::RayMaterial, transform::RayMatrix)::Cvoid)
end

Draw a 3d mesh with material and transform

function DrawMeshInstanced(mesh::RayMesh, material::RayMaterial, transforms::Ref{RayMatrix}, instances::Integer)
    return @ccall(libraylib.DrawMeshInstanced(mesh::RayMesh, material::RayMaterial, transforms::Ptr{RayMatrix}, instances::Cint)::Cvoid)
end

Draw multiple mesh instances with material and different transforms

function DrawModel(model::RayModel, position::StaticVector{3}, scale::Real, tint::RayColor)
    return @ccall(libraylib.DrawModel(model::RayModel, position::RayVector3, scale::Cfloat, tint::RayColor)::Cvoid)
end

Draw a model (with texture if set)

function DrawModelEx(model::RayModel, position::StaticVector{3}, rotationAxis::StaticVector{3}, rotationAngle::Real, scale::StaticVector{3}, tint::RayColor)
    return @ccall(libraylib.DrawModelEx(model::RayModel, position::RayVector3, rotationAxis::RayVector3, rotationAngle::Cfloat, scale::RayVector3, tint::RayColor)::Cvoid)
end

Draw a model with extended parameters

function DrawModelWires(model::RayModel, position::StaticVector{3}, scale::Real, tint::RayColor)
    return @ccall(libraylib.DrawModelWires(model::RayModel, position::RayVector3, scale::Cfloat, tint::RayColor)::Cvoid)
end

Draw a model wires (with texture if set)

function DrawModelWiresEx(model::RayModel, position::StaticVector{3}, rotationAxis::StaticVector{3}, rotationAngle::Real, scale::StaticVector{3}, tint::RayColor)
    return @ccall(libraylib.DrawModelWiresEx(model::RayModel, position::RayVector3, rotationAxis::RayVector3, rotationAngle::Cfloat, scale::RayVector3, tint::RayColor)::Cvoid)
end

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

function DrawPixel(posX::Integer, posY::Integer, color::RayColor)
    return @ccall(libraylib.DrawPixel(posX::Cint, posY::Cint, color::RayColor)::Cvoid)
end

Draw a pixel

function DrawPixelV(position::StaticVector{2}, color::RayColor)
    return @ccall(libraylib.DrawPixelV(position::RayVector2, color::RayColor)::Cvoid)
end

Draw a pixel (Vector version)

function DrawPlane(centerPos::StaticVector{3}, size::StaticVector{2}, color::RayColor)
    return @ccall(libraylib.DrawPlane(centerPos::RayVector3, size::RayVector2, color::RayColor)::Cvoid)
end

Draw a plane XZ

function DrawPoint3D(position::StaticVector{3}, color::RayColor)
    return @ccall(libraylib.DrawPoint3D(position::RayVector3, color::RayColor)::Cvoid)
end

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

function DrawPoly(center::StaticVector{2}, sides::Integer, radius::Real, rotation::Real, color::RayColor)
    return @ccall(libraylib.DrawPoly(center::RayVector2, sides::Cint, radius::Cfloat, rotation::Cfloat, color::RayColor)::Cvoid)
end

Draw a regular polygon (Vector version)

function DrawPolyLines(center::StaticVector{2}, sides::Integer, radius::Real, rotation::Real, color::RayColor)
    return @ccall(libraylib.DrawPolyLines(center::RayVector2, sides::Cint, radius::Cfloat, rotation::Cfloat, color::RayColor)::Cvoid)
end

Draw a polygon outline of n sides

function DrawPolyLinesEx(center::StaticVector{2}, sides::Integer, radius::Real, rotation::Real, lineThick::Real, color::RayColor)
    return @ccall(libraylib.DrawPolyLinesEx(center::RayVector2, sides::Cint, radius::Cfloat, rotation::Cfloat, lineThick::Cfloat, color::RayColor)::Cvoid)
end

Draw a polygon outline of n sides with extended parameters

function DrawRay(ray::Ray, color::RayColor)
    return @ccall(libraylib.DrawRay(ray::Ray, color::RayColor)::Cvoid)
end

Draw a ray line

function DrawRectangle(posX::Integer, posY::Integer, width::Integer, height::Integer, color::RayColor)
    return @ccall(libraylib.DrawRectangle(posX::Cint, posY::Cint, width::Cint, height::Cint, color::RayColor)::Cvoid)
end

Draw a color-filled rectangle

function DrawRectangleGradientEx(rec::RayRectangle, col1::RayColor, col2::RayColor, col3::RayColor, col4::RayColor)
    return @ccall(libraylib.DrawRectangleGradientEx(rec::RayRectangle, col1::RayColor, col2::RayColor, col3::RayColor, col4::RayColor)::Cvoid)
end

Draw a gradient-filled rectangle with custom vertex colors

function DrawRectangleGradientH(posX::Integer, posY::Integer, width::Integer, height::Integer, color1::RayColor, color2::RayColor)
    return @ccall(libraylib.DrawRectangleGradientH(posX::Cint, posY::Cint, width::Cint, height::Cint, color1::RayColor, color2::RayColor)::Cvoid)
end

Draw a horizontal-gradient-filled rectangle

function DrawRectangleGradientV(posX::Integer, posY::Integer, width::Integer, height::Integer, color1::RayColor, color2::RayColor)
    return @ccall(libraylib.DrawRectangleGradientV(posX::Cint, posY::Cint, width::Cint, height::Cint, color1::RayColor, color2::RayColor)::Cvoid)
end

Draw a vertical-gradient-filled rectangle

function DrawRectangleLines(posX::Integer, posY::Integer, width::Integer, height::Integer, color::RayColor)
    return @ccall(libraylib.DrawRectangleLines(posX::Cint, posY::Cint, width::Cint, height::Cint, color::RayColor)::Cvoid)
end

Draw rectangle outline

function DrawRectangleLinesEx(rec::RayRectangle, lineThick::Real, color::RayColor)
    return @ccall(libraylib.DrawRectangleLinesEx(rec::RayRectangle, lineThick::Cfloat, color::RayColor)::Cvoid)
end

Draw rectangle outline with extended parameters

function DrawRectanglePro(rec::RayRectangle, origin::StaticVector{2}, rotation::Real, color::RayColor)
    return @ccall(libraylib.DrawRectanglePro(rec::RayRectangle, origin::RayVector2, rotation::Cfloat, color::RayColor)::Cvoid)
end

Draw a color-filled rectangle with pro parameters

function DrawRectangleRec(rec::RayRectangle, color::RayColor)
    return @ccall(libraylib.DrawRectangleRec(rec::RayRectangle, color::RayColor)::Cvoid)
end

Draw a color-filled rectangle

function DrawRectangleRounded(rec::RayRectangle, roundness::Real, segments::Integer, color::RayColor)
    return @ccall(libraylib.DrawRectangleRounded(rec::RayRectangle, roundness::Cfloat, segments::Cint, color::RayColor)::Cvoid)
end

Draw rectangle with rounded edges

function DrawRectangleRoundedLines(rec::RayRectangle, roundness::Real, segments::Integer, lineThick::Real, color::RayColor)
    return @ccall(libraylib.DrawRectangleRoundedLines(rec::RayRectangle, roundness::Cfloat, segments::Cint, lineThick::Cfloat, color::RayColor)::Cvoid)
end

Draw rectangle with rounded edges outline

function DrawRectangleV(position::StaticVector{2}, size::StaticVector{2}, color::RayColor)
    return @ccall(libraylib.DrawRectangleV(position::RayVector2, size::RayVector2, color::RayColor)::Cvoid)
end

Draw a color-filled rectangle (Vector version)

function DrawRing(center::StaticVector{2}, innerRadius::Real, outerRadius::Real, startAngle::Real, endAngle::Real, segments::Integer, color::RayColor)
    return @ccall(libraylib.DrawRing(center::RayVector2, innerRadius::Cfloat, outerRadius::Cfloat, startAngle::Cfloat, endAngle::Cfloat, segments::Cint, color::RayColor)::Cvoid)
end

Draw ring

function DrawRingLines(center::StaticVector{2}, innerRadius::Real, outerRadius::Real, startAngle::Real, endAngle::Real, segments::Integer, color::RayColor)
    return @ccall(libraylib.DrawRingLines(center::RayVector2, innerRadius::Cfloat, outerRadius::Cfloat, startAngle::Cfloat, endAngle::Cfloat, segments::Cint, color::RayColor)::Cvoid)
end

Draw ring outline

function DrawSphere(centerPos::StaticVector{3}, radius::Real, color::RayColor)
    return @ccall(libraylib.DrawSphere(centerPos::RayVector3, radius::Cfloat, color::RayColor)::Cvoid)
end

Draw sphere

function DrawSphereEx(centerPos::StaticVector{3}, radius::Real, rings::Integer, slices::Integer, color::RayColor)
    return @ccall(libraylib.DrawSphereEx(centerPos::RayVector3, radius::Cfloat, rings::Cint, slices::Cint, color::RayColor)::Cvoid)
end

Draw sphere with extended parameters

function DrawSphereWires(centerPos::StaticVector{3}, radius::Real, rings::Integer, slices::Integer, color::RayColor)
    return @ccall(libraylib.DrawSphereWires(centerPos::RayVector3, radius::Cfloat, rings::Cint, slices::Cint, color::RayColor)::Cvoid)
end

Draw sphere wires

function DrawText(text::String, posX::Integer, posY::Integer, fontSize::Integer, color::RayColor)
    return @ccall(libraylib.DrawText(text::Cstring, posX::Cint, posY::Cint, fontSize::Cint, color::RayColor)::Cvoid)
end

Draw text (using default font)

function DrawTextCodepoint(font::RayFont, codepoint::Integer, position::StaticVector{2}, fontSize::Real, tint::RayColor)
    return @ccall(libraylib.DrawTextCodepoint(font::RayFont, codepoint::Cint, position::RayVector2, fontSize::Cfloat, tint::RayColor)::Cvoid)
end

Draw one character (codepoint)

function DrawTextEx(font::RayFont, text::String, position::StaticVector{2}, fontSize::Real, spacing::Real, tint::RayColor)
    return @ccall(libraylib.DrawTextEx(font::RayFont, text::Cstring, position::RayVector2, fontSize::Cfloat, spacing::Cfloat, tint::RayColor)::Cvoid)
end

Draw text using font and additional parameters

function DrawTextPro(font::RayFont, text::String, position::StaticVector{2}, origin::StaticVector{2}, rotation::Real, fontSize::Real, spacing::Real, tint::RayColor)
    return @ccall(libraylib.DrawTextPro(font::RayFont, text::Cstring, position::RayVector2, origin::RayVector2, rotation::Cfloat, fontSize::Cfloat, spacing::Cfloat, tint::RayColor)::Cvoid)
end

Draw text using Font and pro parameters (rotation)

function DrawTexture(texture::RayTexture, posX::Integer, posY::Integer, tint::RayColor)
    return @ccall(libraylib.DrawTexture(texture::RayTexture, posX::Cint, posY::Cint, tint::RayColor)::Cvoid)
end

Draw a Texture2D

function DrawTextureEx(texture::RayTexture, position::StaticVector{2}, rotation::Real, scale::Real, tint::RayColor)
    return @ccall(libraylib.DrawTextureEx(texture::RayTexture, position::RayVector2, rotation::Cfloat, scale::Cfloat, tint::RayColor)::Cvoid)
end

Draw a Texture2D with extended parameters

function DrawTextureNPatch(texture::RayTexture, nPatchInfo::RayNPatchInfo, dest::RayRectangle, origin::StaticVector{2}, rotation::Real, tint::RayColor)
    return @ccall(libraylib.DrawTextureNPatch(texture::RayTexture, nPatchInfo::RayNPatchInfo, dest::RayRectangle, origin::RayVector2, rotation::Cfloat, tint::RayColor)::Cvoid)
end

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

function DrawTexturePoly(texture::RayTexture, center::StaticVector{2}, points::Ref{<:StaticVector{2}}, texcoords::Ref{<:StaticVector{2}}, pointCount::Integer, tint::RayColor)
    return @ccall(libraylib.DrawTexturePoly(texture::RayTexture, center::RayVector2, points::Ptr{RayVector2}, texcoords::Ptr{RayVector2}, pointCount::Cint, tint::RayColor)::Cvoid)
end

Draw a textured polygon

function DrawTexturePro(texture::RayTexture, source::RayRectangle, dest::RayRectangle, origin::StaticVector{2}, rotation::Real, tint::RayColor)
    return @ccall(libraylib.DrawTexturePro(texture::RayTexture, source::RayRectangle, dest::RayRectangle, origin::RayVector2, rotation::Cfloat, tint::RayColor)::Cvoid)
end

Draw a part of a texture defined by a rectangle with 'pro' parameters

function DrawTextureQuad(texture::RayTexture, tiling::StaticVector{2}, offset::StaticVector{2}, quad::RayRectangle, tint::RayColor)
    return @ccall(libraylib.DrawTextureQuad(texture::RayTexture, tiling::RayVector2, offset::RayVector2, quad::RayRectangle, tint::RayColor)::Cvoid)
end

Draw texture quad with tiling and offset parameters

function DrawTextureRec(texture::RayTexture, source::RayRectangle, position::StaticVector{2}, tint::RayColor)
    return @ccall(libraylib.DrawTextureRec(texture::RayTexture, source::RayRectangle, position::RayVector2, tint::RayColor)::Cvoid)
end

Draw a part of a texture defined by a rectangle

function DrawTextureTiled(texture::RayTexture, source::RayRectangle, dest::RayRectangle, origin::StaticVector{2}, rotation::Real, scale::Real, tint::RayColor)
    return @ccall(libraylib.DrawTextureTiled(texture::RayTexture, source::RayRectangle, dest::RayRectangle, origin::RayVector2, rotation::Cfloat, scale::Cfloat, tint::RayColor)::Cvoid)
end

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

function DrawTextureV(texture::RayTexture, position::StaticVector{2}, tint::RayColor)
    return @ccall(libraylib.DrawTextureV(texture::RayTexture, position::RayVector2, tint::RayColor)::Cvoid)
end

Draw a Texture2D with position defined as Vector2

function DrawTriangle(v1::StaticVector{2}, v2::StaticVector{2}, v3::StaticVector{2}, color::RayColor)
    return @ccall(libraylib.DrawTriangle(v1::RayVector2, v2::RayVector2, v3::RayVector2, color::RayColor)::Cvoid)
end

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

function DrawTriangle3D(v1::StaticVector{3}, v2::StaticVector{3}, v3::StaticVector{3}, color::RayColor)
    return @ccall(libraylib.DrawTriangle3D(v1::RayVector3, v2::RayVector3, v3::RayVector3, color::RayColor)::Cvoid)
end

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

function DrawTriangleFan(points::Ref{<:StaticVector{2}}, pointCount::Integer, color::RayColor)
    return @ccall(libraylib.DrawTriangleFan(points::Ptr{RayVector2}, pointCount::Cint, color::RayColor)::Cvoid)
end

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

function DrawTriangleLines(v1::StaticVector{2}, v2::StaticVector{2}, v3::StaticVector{2}, color::RayColor)
    return @ccall(libraylib.DrawTriangleLines(v1::RayVector2, v2::RayVector2, v3::RayVector2, color::RayColor)::Cvoid)
end

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

function DrawTriangleStrip(points::Ref{<:StaticVector{2}}, pointCount::Integer, color::RayColor)
    return @ccall(libraylib.DrawTriangleStrip(points::Ptr{RayVector2}, pointCount::Cint, color::RayColor)::Cvoid)
end

Draw a triangle strip defined by points

function DrawTriangleStrip3D(points::Ref{<:StaticVector{3}}, pointCount::Integer, color::RayColor)
    return @ccall(libraylib.DrawTriangleStrip3D(points::Ptr{RayVector3}, pointCount::Cint, color::RayColor)::Cvoid)
end

Draw a triangle strip defined by points

function EnableCursor()
    return @ccall(libraylib.EnableCursor()::Cvoid)
end

Enables cursor (unlock cursor)

function EncodeDataBase64(data::Ref{UInt8}, dataLength::Integer, outputLength::Ref{<:Integer})
    return @ccall(libraylib.EncodeDataBase64(data::Ptr{Cuchar}, dataLength::Cint, outputLength::Ptr{Cint})::Cstring)
end

Encode data to Base64 string

function EndBlendMode()
    return @ccall(libraylib.EndBlendMode()::Cvoid)
end

End blending mode (reset to default: alpha blending)

function EndDrawing()
    return @ccall(libraylib.EndDrawing()::Cvoid)
end

End canvas drawing and swap buffers (double buffering)

function EndMode2D()
    return @ccall(libraylib.EndMode2D()::Cvoid)
end

Ends 2D mode with custom camera

function EndMode3D()
    return @ccall(libraylib.EndMode3D()::Cvoid)
end

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

function EndScissorMode()
    return @ccall(libraylib.EndScissorMode()::Cvoid)
end

End scissor mode

function EndShaderMode()
    return @ccall(libraylib.EndShaderMode()::Cvoid)
end

End custom shader drawing (use default shader)

function EndTextureMode()
    return @ccall(libraylib.EndTextureMode()::Cvoid)
end

Ends drawing to render texture

function EndVrStereoMode()
    return @ccall(libraylib.EndVrStereoMode()::Cvoid)
end

End stereo rendering (requires VR simulator)

function ExportImage(image::RayImage, fileName::String)::Bool
    return @ccall(libraylib.ExportImage(image::RayImage, fileName::Cstring)::Cuchar)
end

Export image data to file, returns true on success

function ExportImageAsCode(image::RayImage, fileName::String)::Bool
    return @ccall(libraylib.ExportImageAsCode(image::RayImage, fileName::Cstring)::Cuchar)
end

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

function ExportMesh(mesh::RayMesh, fileName::String)::Bool
    return @ccall(libraylib.ExportMesh(mesh::RayMesh, fileName::Cstring)::Cuchar)
end

Export mesh data to file, returns true on success

function ExportWave(wave::RayWave, fileName::String)::Bool
    return @ccall(libraylib.ExportWave(wave::RayWave, fileName::Cstring)::Cuchar)
end

Export wave data to file, returns true on success

function ExportWaveAsCode(wave::RayWave, fileName::String)::Bool
    return @ccall(libraylib.ExportWaveAsCode(wave::RayWave, fileName::Cstring)::Cuchar)
end

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

function Fade(color::RayColor, alpha::Real)::RayColor
    return @ccall(libraylib.Fade(color::RayColor, alpha::Cfloat)::RayColor)
end

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

function FileExists(fileName::String)::Bool
    return @ccall(libraylib.FileExists(fileName::Cstring)::Cuchar)
end

Check if file exists

function GenImageCellular(width::Integer, height::Integer, tileSize::Integer)::RayImage
    return @ccall(libraylib.GenImageCellular(width::Cint, height::Cint, tileSize::Cint)::RayImage)
end

Generate image: cellular algorithm, bigger tileSize means bigger cells

function GenImageChecked(width::Integer, height::Integer, checksX::Integer, checksY::Integer, col1::RayColor, col2::RayColor)::RayImage
    return @ccall(libraylib.GenImageChecked(width::Cint, height::Cint, checksX::Cint, checksY::Cint, col1::RayColor, col2::RayColor)::RayImage)
end

Generate image: checked

function GenImageColor(width::Integer, height::Integer, color::RayColor)::RayImage
    return @ccall(libraylib.GenImageColor(width::Cint, height::Cint, color::RayColor)::RayImage)
end

Generate image: plain color

function GenImageFontAtlas(chars::Ref{RayGlyphInfo}, recs::Ref{Ptr{RayRectangle}}, glyphCount::Integer, fontSize::Integer, padding::Integer, packMethod::Integer)::RayImage
    return @ccall(libraylib.GenImageFontAtlas(chars::Ptr{RayGlyphInfo}, recs::Ptr{Ptr{RayRectangle}}, glyphCount::Cint, fontSize::Cint, padding::Cint, packMethod::Cint)::RayImage)
end

Generate image font atlas using chars info

function GenImageGradientH(width::Integer, height::Integer, left::RayColor, right::RayColor)::RayImage
    return @ccall(libraylib.GenImageGradientH(width::Cint, height::Cint, left::RayColor, right::RayColor)::RayImage)
end

Generate image: horizontal gradient

function GenImageGradientRadial(width::Integer, height::Integer, density::Real, inner::RayColor, outer::RayColor)::RayImage
    return @ccall(libraylib.GenImageGradientRadial(width::Cint, height::Cint, density::Cfloat, inner::RayColor, outer::RayColor)::RayImage)
end

Generate image: radial gradient

function GenImageGradientV(width::Integer, height::Integer, top::RayColor, bottom::RayColor)::RayImage
    return @ccall(libraylib.GenImageGradientV(width::Cint, height::Cint, top::RayColor, bottom::RayColor)::RayImage)
end

Generate image: vertical gradient

function GenImageWhiteNoise(width::Integer, height::Integer, factor::Real)::RayImage
    return @ccall(libraylib.GenImageWhiteNoise(width::Cint, height::Cint, factor::Cfloat)::RayImage)
end

Generate image: white noise

function GenMeshBinormals(mesh::Ref{RayMesh})
    return @ccall(libraylib.GenMeshBinormals(mesh::Ptr{RayMesh})::Cvoid)
end

Compute mesh binormals

function GenMeshCone(radius::Real, height::Real, slices::Integer)::RayMesh
    return @ccall(libraylib.GenMeshCone(radius::Cfloat, height::Cfloat, slices::Cint)::RayMesh)
end

Generate cone/pyramid mesh

function GenMeshCube(width::Real, height::Real, length::Real)::RayMesh
    return @ccall(libraylib.GenMeshCube(width::Cfloat, height::Cfloat, length::Cfloat)::RayMesh)
end

Generate cuboid mesh

function GenMeshCubicmap(cubicmap::RayImage, cubeSize::StaticVector{3})::RayMesh
    return @ccall(libraylib.GenMeshCubicmap(cubicmap::RayImage, cubeSize::RayVector3)::RayMesh)
end

Generate cubes-based map mesh from image data

function GenMeshCylinder(radius::Real, height::Real, slices::Integer)::RayMesh
    return @ccall(libraylib.GenMeshCylinder(radius::Cfloat, height::Cfloat, slices::Cint)::RayMesh)
end

Generate cylinder mesh

function GenMeshHeightmap(heightmap::RayImage, size::StaticVector{3})::RayMesh
    return @ccall(libraylib.GenMeshHeightmap(heightmap::RayImage, size::RayVector3)::RayMesh)
end

Generate heightmap mesh from image data

function GenMeshHemiSphere(radius::Real, rings::Integer, slices::Integer)::RayMesh
    return @ccall(libraylib.GenMeshHemiSphere(radius::Cfloat, rings::Cint, slices::Cint)::RayMesh)
end

Generate half-sphere mesh (no bottom cap)

function GenMeshKnot(radius::Real, size::Real, radSeg::Integer, sides::Integer)::RayMesh
    return @ccall(libraylib.GenMeshKnot(radius::Cfloat, size::Cfloat, radSeg::Cint, sides::Cint)::RayMesh)
end

Generate trefoil knot mesh

function GenMeshPlane(width::Real, length::Real, resX::Integer, resZ::Integer)::RayMesh
    return @ccall(libraylib.GenMeshPlane(width::Cfloat, length::Cfloat, resX::Cint, resZ::Cint)::RayMesh)
end

Generate plane mesh (with subdivisions)

function GenMeshPoly(sides::Integer, radius::Real)::RayMesh
    return @ccall(libraylib.GenMeshPoly(sides::Cint, radius::Cfloat)::RayMesh)
end

Generate polygonal mesh

function GenMeshSphere(radius::Real, rings::Integer, slices::Integer)::RayMesh
    return @ccall(libraylib.GenMeshSphere(radius::Cfloat, rings::Cint, slices::Cint)::RayMesh)
end

Generate sphere mesh (standard sphere)

function GenMeshTangents(mesh::Ref{RayMesh})
    return @ccall(libraylib.GenMeshTangents(mesh::Ptr{RayMesh})::Cvoid)
end

Compute mesh tangents

function GenMeshTorus(radius::Real, size::Real, radSeg::Integer, sides::Integer)::RayMesh
    return @ccall(libraylib.GenMeshTorus(radius::Cfloat, size::Cfloat, radSeg::Cint, sides::Cint)::RayMesh)
end

Generate torus mesh

function GenTextureMipmaps(texture::Ref{RayTexture})
    return @ccall(libraylib.GenTextureMipmaps(texture::Ptr{RayTexture})::Cvoid)
end

Generate GPU mipmaps for a texture

function GetCameraMatrix(camera::RayCamera3D)::RayMatrix
    return @ccall(libraylib.GetCameraMatrix(camera::RayCamera3D)::RayMatrix)
end

Get camera transform matrix (view matrix)

function GetCameraMatrix2D(camera::RayCamera2D)::RayMatrix
    return @ccall(libraylib.GetCameraMatrix2D(camera::RayCamera2D)::RayMatrix)
end

Get camera 2d transform matrix

function GetCharPressed()
    return @ccall(libraylib.GetCharPressed()::Cint)
end

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

function GetClipboardText()
    return @ccall(libraylib.GetClipboardText()::Cstring)
end

Get clipboard text content

function GetCodepoint(text::String, bytesProcessed::Ref{<:Integer})
    return @ccall(libraylib.GetCodepoint(text::Cstring, bytesProcessed::Ptr{Cint})::Cint)
end

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

function GetCodepointCount(text::String)
    return @ccall(libraylib.GetCodepointCount(text::Cstring)::Cint)
end

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

function GetCollisionRec(rec1::RayRectangle, rec2::RayRectangle)::RayRectangle
    return @ccall(libraylib.GetCollisionRec(rec1::RayRectangle, rec2::RayRectangle)::RayRectangle)
end

Get collision rectangle for two rectangles collision

function GetColor(hexValue::Integer)::RayColor
    return @ccall(libraylib.GetColor(hexValue::Cuint)::RayColor)
end

Get Color structure from hexadecimal value

function GetCurrentMonitor()
    return @ccall(libraylib.GetCurrentMonitor()::Cint)
end

Get current connected monitor

function GetDirectoryFiles(dirPath::String, count::Ref{<:Integer})
    return @ccall(libraylib.GetDirectoryFiles(dirPath::Cstring, count::Ptr{Cint})::Ptr{Cstring})
end

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

function GetDirectoryPath(filePath::String)
    return @ccall(libraylib.GetDirectoryPath(filePath::Cstring)::Cstring)
end

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

function GetDroppedFiles(count::Ref{<:Integer})
    return @ccall(libraylib.GetDroppedFiles(count::Ptr{Cint})::Ptr{Cstring})
end

Get dropped files names (memory should be freed)

function GetFPS()
    return @ccall(libraylib.GetFPS()::Cint)
end

Get current FPS

function GetFileExtension(fileName::String)
    return @ccall(libraylib.GetFileExtension(fileName::Cstring)::Cstring)
end

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

function GetFileModTime(fileName::String)
    return @ccall(libraylib.GetFileModTime(fileName::Cstring)::Clong)
end

Get file modification time (last write time)

function GetFileName(filePath::String)
    return @ccall(libraylib.GetFileName(filePath::Cstring)::Cstring)
end

Get pointer to filename for a path string

function GetFileNameWithoutExt(filePath::String)
    return @ccall(libraylib.GetFileNameWithoutExt(filePath::Cstring)::Cstring)
end

Get filename string without extension (uses static string)

function GetFontDefault()::RayFont
    return @ccall(libraylib.GetFontDefault()::RayFont)
end

Get the default Font

function GetFrameTime()
    return @ccall(libraylib.GetFrameTime()::Cfloat)
end

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

function GetGamepadAxisCount(gamepad::Integer)
    return @ccall(libraylib.GetGamepadAxisCount(gamepad::Cint)::Cint)
end

Get gamepad axis count for a gamepad

function GetGamepadAxisMovement(gamepad::Integer, axis::Integer)
    return @ccall(libraylib.GetGamepadAxisMovement(gamepad::Cint, axis::Cint)::Cfloat)
end

Get axis movement value for a gamepad axis

function GetGamepadButtonPressed()
    return @ccall(libraylib.GetGamepadButtonPressed()::Cint)
end

Get the last gamepad button pressed

function GetGamepadName(gamepad::Integer)
    return @ccall(libraylib.GetGamepadName(gamepad::Cint)::Cstring)
end

Get gamepad internal name id

function GetGestureDetected()
    return @ccall(libraylib.GetGestureDetected()::Cint)
end

Get latest detected gesture

function GetGestureDragAngle()
    return @ccall(libraylib.GetGestureDragAngle()::Cfloat)
end

Get gesture drag angle

function GetGestureDragVector()
    return @ccall(libraylib.GetGestureDragVector()::RayVector2)
end

Get gesture drag vector

function GetGestureHoldDuration()
    return @ccall(libraylib.GetGestureHoldDuration()::Cfloat)
end

Get gesture hold time in milliseconds

function GetGesturePinchAngle()
    return @ccall(libraylib.GetGesturePinchAngle()::Cfloat)
end

Get gesture pinch angle

function GetGesturePinchVector()
    return @ccall(libraylib.GetGesturePinchVector()::RayVector2)
end

Get gesture pinch delta

function GetGlyphAtlasRec(font::RayFont, codepoint::Integer)::RayRectangle
    return @ccall(libraylib.GetGlyphAtlasRec(font::RayFont, codepoint::Cint)::RayRectangle)
end

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

function GetGlyphIndex(font::RayFont, codepoint::Integer)
    return @ccall(libraylib.GetGlyphIndex(font::RayFont, codepoint::Cint)::Cint)
end

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

function GetGlyphInfo(font::RayFont, codepoint::Integer)::RayGlyphInfo
    return @ccall(libraylib.GetGlyphInfo(font::RayFont, codepoint::Cint)::RayGlyphInfo)
end

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

function GetImageAlphaBorder(image::RayImage, threshold::Real)::RayRectangle
    return @ccall(libraylib.GetImageAlphaBorder(image::RayImage, threshold::Cfloat)::RayRectangle)
end

Get image alpha border rectangle

function GetImageColor(image::RayImage, x::Integer, y::Integer)::RayColor
    return @ccall(libraylib.GetImageColor(image::RayImage, x::Cint, y::Cint)::RayColor)
end

Get image pixel color at (x, y) position

function GetKeyPressed()
    return @ccall(libraylib.GetKeyPressed()::Cint)
end

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

function GetMeshBoundingBox(mesh::RayMesh)::RayBoundingBox
    return @ccall(libraylib.GetMeshBoundingBox(mesh::RayMesh)::RayBoundingBox)
end

Compute mesh bounding box limits

function GetModelBoundingBox(model::RayModel)::RayBoundingBox
    return @ccall(libraylib.GetModelBoundingBox(model::RayModel)::RayBoundingBox)
end

Compute model bounding box limits (considers all meshes)

function GetMonitorCount()
    return @ccall(libraylib.GetMonitorCount()::Cint)
end

Get number of connected monitors

function GetMonitorHeight(monitor::Integer)
    return @ccall(libraylib.GetMonitorHeight(monitor::Cint)::Cint)
end

Get specified monitor height (max available by monitor)

function GetMonitorName(monitor::Integer)
    return @ccall(libraylib.GetMonitorName(monitor::Cint)::Cstring)
end

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

function GetMonitorPhysicalHeight(monitor::Integer)
    return @ccall(libraylib.GetMonitorPhysicalHeight(monitor::Cint)::Cint)
end

Get specified monitor physical height in millimetres

function GetMonitorPhysicalWidth(monitor::Integer)
    return @ccall(libraylib.GetMonitorPhysicalWidth(monitor::Cint)::Cint)
end

Get specified monitor physical width in millimetres

function GetMonitorPosition(monitor::Integer)
    return @ccall(libraylib.GetMonitorPosition(monitor::Cint)::RayVector2)
end

Get specified monitor position

function GetMonitorRefreshRate(monitor::Integer)
    return @ccall(libraylib.GetMonitorRefreshRate(monitor::Cint)::Cint)
end

Get specified monitor refresh rate

function GetMonitorWidth(monitor::Integer)
    return @ccall(libraylib.GetMonitorWidth(monitor::Cint)::Cint)
end

Get specified monitor width (max available by monitor)

function GetMouseDelta()
    return @ccall(libraylib.GetMouseDelta()::RayVector2)
end

Get mouse delta between frames

function GetMousePosition()
    return @ccall(libraylib.GetMousePosition()::RayVector2)
end

Get mouse position XY

function GetMouseRay(mousePosition::StaticVector{2}, camera::RayCamera3D)::Ray
    return @ccall(libraylib.GetMouseRay(mousePosition::RayVector2, camera::RayCamera3D)::Ray)
end

Get a ray trace from mouse position

function GetMouseWheelMove()
    return @ccall(libraylib.GetMouseWheelMove()::Cfloat)
end

Get mouse wheel movement Y

function GetMouseX()
    return @ccall(libraylib.GetMouseX()::Cint)
end

Get mouse position X

function GetMouseY()
    return @ccall(libraylib.GetMouseY()::Cint)
end

Get mouse position Y

function GetMusicTimeLength(music::RayMusic)
    return @ccall(libraylib.GetMusicTimeLength(music::RayMusic)::Cfloat)
end

Get music time length (in seconds)

function GetMusicTimePlayed(music::RayMusic)
    return @ccall(libraylib.GetMusicTimePlayed(music::RayMusic)::Cfloat)
end

Get current music time played (in seconds)

function GetPhysicsBodiesCount()
    return @ccall(libraylib.GetPhysicsBodiesCount()::Cint)
end

Returns the current amount of created physics bodies

function GetPhysicsBody(index::Integer)::Ptr{RayPhysicsBodyData}
    return @ccall(libraylib.GetPhysicsBody(index::Cint)::Ptr{RayPhysicsBodyData})
end

Returns a physics body of the bodies pool at a specific index

function GetPhysicsShapeType(index::Integer)
    return @ccall(libraylib.GetPhysicsShapeType(index::Cint)::Cint)
end

Returns the physics body shape type (PHYSICSCIRCLE or PHYSICSPOLYGON)

function GetPhysicsShapeVertex(body::Ptr{RayPhysicsBodyData}, vertex::Integer)
    return @ccall(libraylib.GetPhysicsShapeVertex(body::Ptr{RayPhysicsBodyData}, vertex::Cint)::RayVector2)
end

Returns transformed position of a body shape (body position + vertex transformed position)

function GetPhysicsShapeVerticesCount(index::Integer)
    return @ccall(libraylib.GetPhysicsShapeVerticesCount(index::Cint)::Cint)
end

Returns the amount of vertices of a physics body shape

function GetPixelColor(srcPtr::Ref{Nothing}, format::Integer)::RayColor
    return @ccall(libraylib.GetPixelColor(srcPtr::Ptr{Cvoid}, format::Cint)::RayColor)
end

Get Color from a source pixel pointer of certain format

function GetPixelDataSize(width::Integer, height::Integer, format::Integer)
    return @ccall(libraylib.GetPixelDataSize(width::Cint, height::Cint, format::Cint)::Cint)
end

Get pixel data size in bytes for certain format

function GetPrevDirectoryPath(dirPath::String)
    return @ccall(libraylib.GetPrevDirectoryPath(dirPath::Cstring)::Cstring)
end

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

function GetRandomValue(min::Integer, max::Integer)
    return @ccall(libraylib.GetRandomValue(min::Cint, max::Cint)::Cint)
end

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

function GetRayCollisionBox(ray::Ray, box::RayBoundingBox)::RayCollision
    return @ccall(libraylib.GetRayCollisionBox(ray::Ray, box::RayBoundingBox)::RayCollision)
end

Get collision info between ray and box

function GetRayCollisionMesh(ray::Ray, mesh::RayMesh, transform::RayMatrix)::RayCollision
    return @ccall(libraylib.GetRayCollisionMesh(ray::Ray, mesh::RayMesh, transform::RayMatrix)::RayCollision)
end

Get collision info between ray and mesh

function GetRayCollisionModel(ray::Ray, model::RayModel)::RayCollision
    return @ccall(libraylib.GetRayCollisionModel(ray::Ray, model::RayModel)::RayCollision)
end

Get collision info between ray and model

function GetRayCollisionQuad(ray::Ray, p1::StaticVector{3}, p2::StaticVector{3}, p3::StaticVector{3}, p4::StaticVector{3})::RayCollision
    return @ccall(libraylib.GetRayCollisionQuad(ray::Ray, p1::RayVector3, p2::RayVector3, p3::RayVector3, p4::RayVector3)::RayCollision)
end

Get collision info between ray and quad

function GetRayCollisionSphere(ray::Ray, center::StaticVector{3}, radius::Real)::RayCollision
    return @ccall(libraylib.GetRayCollisionSphere(ray::Ray, center::RayVector3, radius::Cfloat)::RayCollision)
end

Get collision info between ray and sphere

function GetRayCollisionTriangle(ray::Ray, p1::StaticVector{3}, p2::StaticVector{3}, p3::StaticVector{3})::RayCollision
    return @ccall(libraylib.GetRayCollisionTriangle(ray::Ray, p1::RayVector3, p2::RayVector3, p3::RayVector3)::RayCollision)
end

Get collision info between ray and triangle

function GetScreenHeight()
    return @ccall(libraylib.GetScreenHeight()::Cint)
end

Get current screen height

function GetScreenToWorld2D(position::StaticVector{2}, camera::RayCamera2D)
    return @ccall(libraylib.GetScreenToWorld2D(position::RayVector2, camera::RayCamera2D)::RayVector2)
end

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

function GetScreenWidth()
    return @ccall(libraylib.GetScreenWidth()::Cint)
end

Get current screen width

function GetShaderLocation(shader::RayShader, uniformName::String)
    return @ccall(libraylib.GetShaderLocation(shader::RayShader, uniformName::Cstring)::Cint)
end

Get shader uniform location

function GetShaderLocationAttrib(shader::RayShader, attribName::String)
    return @ccall(libraylib.GetShaderLocationAttrib(shader::RayShader, attribName::Cstring)::Cint)
end

Get shader attribute location

function GetSoundsPlaying()
    return @ccall(libraylib.GetSoundsPlaying()::Cint)
end

Get number of sounds playing in the multichannel

function GetTime()
    return @ccall(libraylib.GetTime()::Cdouble)
end

Get elapsed time in seconds since InitWindow()

function GetTouchPointCount()
    return @ccall(libraylib.GetTouchPointCount()::Cint)
end

Get number of touch points

function GetTouchPointId(index::Integer)
    return @ccall(libraylib.GetTouchPointId(index::Cint)::Cint)
end

Get touch point identifier for given index

function GetTouchPosition(index::Integer)
    return @ccall(libraylib.GetTouchPosition(index::Cint)::RayVector2)
end

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

function GetTouchX()
    return @ccall(libraylib.GetTouchX()::Cint)
end

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

function GetTouchY()
    return @ccall(libraylib.GetTouchY()::Cint)
end

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

function GetWindowHandle()
    return @ccall(libraylib.GetWindowHandle()::Ptr{Cvoid})
end

Get native window handle

function GetWindowPosition()
    return @ccall(libraylib.GetWindowPosition()::RayVector2)
end

Get window position XY on monitor

function GetWindowScaleDPI()
    return @ccall(libraylib.GetWindowScaleDPI()::RayVector2)
end

Get window scale DPI factor

function GetWorkingDirectory()
    return @ccall(libraylib.GetWorkingDirectory()::Cstring)
end

Get current working directory (uses static string)

function GetWorldToScreen(position::StaticVector{3}, camera::RayCamera3D)
    return @ccall(libraylib.GetWorldToScreen(position::RayVector3, camera::RayCamera3D)::RayVector2)
end

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

function GetWorldToScreen2D(position::StaticVector{2}, camera::RayCamera2D)
    return @ccall(libraylib.GetWorldToScreen2D(position::RayVector2, camera::RayCamera2D)::RayVector2)
end

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

function GetWorldToScreenEx(position::StaticVector{3}, camera::RayCamera3D, width::Integer, height::Integer)
    return @ccall(libraylib.GetWorldToScreenEx(position::RayVector3, camera::RayCamera3D, width::Cint, height::Cint)::RayVector2)
end

Get size position for a 3d world space position

function HideCursor()
    return @ccall(libraylib.HideCursor()::Cvoid)
end

Hides cursor

function ImageAlphaClear(image::Ref{RayImage}, color::RayColor, threshold::Real)
    return @ccall(libraylib.ImageAlphaClear(image::Ptr{RayImage}, color::RayColor, threshold::Cfloat)::Cvoid)
end

Clear alpha channel to desired color

function ImageAlphaCrop(image::Ref{RayImage}, threshold::Real)
    return @ccall(libraylib.ImageAlphaCrop(image::Ptr{RayImage}, threshold::Cfloat)::Cvoid)
end

Crop image depending on alpha value

function ImageAlphaMask(image::Ref{RayImage}, alphaMask::RayImage)
    return @ccall(libraylib.ImageAlphaMask(image::Ptr{RayImage}, alphaMask::RayImage)::Cvoid)
end

Apply alpha mask to image

function ImageAlphaPremultiply(image::Ref{RayImage})
    return @ccall(libraylib.ImageAlphaPremultiply(image::Ptr{RayImage})::Cvoid)
end

Premultiply alpha channel

function ImageClearBackground(dst::Ref{RayImage}, color::RayColor)
    return @ccall(libraylib.ImageClearBackground(dst::Ptr{RayImage}, color::RayColor)::Cvoid)
end

Clear image background with given color

function ImageColorBrightness(image::Ref{RayImage}, brightness::Integer)
    return @ccall(libraylib.ImageColorBrightness(image::Ptr{RayImage}, brightness::Cint)::Cvoid)
end

Modify image color: brightness (-255 to 255)

function ImageColorContrast(image::Ref{RayImage}, contrast::Real)
    return @ccall(libraylib.ImageColorContrast(image::Ptr{RayImage}, contrast::Cfloat)::Cvoid)
end

Modify image color: contrast (-100 to 100)

function ImageColorGrayscale(image::Ref{RayImage})
    return @ccall(libraylib.ImageColorGrayscale(image::Ptr{RayImage})::Cvoid)
end

Modify image color: grayscale

function ImageColorInvert(image::Ref{RayImage})
    return @ccall(libraylib.ImageColorInvert(image::Ptr{RayImage})::Cvoid)
end

Modify image color: invert

function ImageColorReplace(image::Ref{RayImage}, color::RayColor, replace::RayColor)
    return @ccall(libraylib.ImageColorReplace(image::Ptr{RayImage}, color::RayColor, replace::RayColor)::Cvoid)
end

Modify image color: replace color

function ImageColorTint(image::Ref{RayImage}, color::RayColor)
    return @ccall(libraylib.ImageColorTint(image::Ptr{RayImage}, color::RayColor)::Cvoid)
end

Modify image color: tint

function ImageCopy(image::RayImage)::RayImage
    return @ccall(libraylib.ImageCopy(image::RayImage)::RayImage)
end

Create an image duplicate (useful for transformations)

function ImageCrop(image::Ref{RayImage}, crop::RayRectangle)
    return @ccall(libraylib.ImageCrop(image::Ptr{RayImage}, crop::RayRectangle)::Cvoid)
end

Crop an image to a defined rectangle

function ImageDither(image::Ref{RayImage}, rBpp::Integer, gBpp::Integer, bBpp::Integer, aBpp::Integer)
    return @ccall(libraylib.ImageDither(image::Ptr{RayImage}, rBpp::Cint, gBpp::Cint, bBpp::Cint, aBpp::Cint)::Cvoid)
end

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

function ImageDraw(dst::Ref{RayImage}, src::RayImage, srcRec::RayRectangle, dstRec::RayRectangle, tint::RayColor)
    return @ccall(libraylib.ImageDraw(dst::Ptr{RayImage}, src::RayImage, srcRec::RayRectangle, dstRec::RayRectangle, tint::RayColor)::Cvoid)
end

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

function ImageDrawCircle(dst::Ref{RayImage}, centerX::Integer, centerY::Integer, radius::Integer, color::RayColor)
    return @ccall(libraylib.ImageDrawCircle(dst::Ptr{RayImage}, centerX::Cint, centerY::Cint, radius::Cint, color::RayColor)::Cvoid)
end

Draw circle within an image

function ImageDrawCircleV(dst::Ref{RayImage}, center::StaticVector{2}, radius::Integer, color::RayColor)
    return @ccall(libraylib.ImageDrawCircleV(dst::Ptr{RayImage}, center::RayVector2, radius::Cint, color::RayColor)::Cvoid)
end

Draw circle within an image (Vector version)

function ImageDrawLine(dst::Ref{RayImage}, startPosX::Integer, startPosY::Integer, endPosX::Integer, endPosY::Integer, color::RayColor)
    return @ccall(libraylib.ImageDrawLine(dst::Ptr{RayImage}, startPosX::Cint, startPosY::Cint, endPosX::Cint, endPosY::Cint, color::RayColor)::Cvoid)
end

Draw line within an image

function ImageDrawLineV(dst::Ref{RayImage}, start::StaticVector{2}, end::StaticVector{2}, color::RayColor)
    return @ccall(libraylib.ImageDrawLineV(dst::Ptr{RayImage}, start::RayVector2, end::RayVector2, color::RayColor)::Cvoid)
end

Draw line within an image (Vector version)

function ImageDrawPixel(dst::Ref{RayImage}, posX::Integer, posY::Integer, color::RayColor)
    return @ccall(libraylib.ImageDrawPixel(dst::Ptr{RayImage}, posX::Cint, posY::Cint, color::RayColor)::Cvoid)
end

Draw pixel within an image

function ImageDrawPixelV(dst::Ref{RayImage}, position::StaticVector{2}, color::RayColor)
    return @ccall(libraylib.ImageDrawPixelV(dst::Ptr{RayImage}, position::RayVector2, color::RayColor)::Cvoid)
end

Draw pixel within an image (Vector version)

function ImageDrawRectangle(dst::Ref{RayImage}, posX::Integer, posY::Integer, width::Integer, height::Integer, color::RayColor)
    return @ccall(libraylib.ImageDrawRectangle(dst::Ptr{RayImage}, posX::Cint, posY::Cint, width::Cint, height::Cint, color::RayColor)::Cvoid)
end

Draw rectangle within an image

function ImageDrawRectangleLines(dst::Ref{RayImage}, rec::RayRectangle, thick::Integer, color::RayColor)
    return @ccall(libraylib.ImageDrawRectangleLines(dst::Ptr{RayImage}, rec::RayRectangle, thick::Cint, color::RayColor)::Cvoid)
end

Draw rectangle lines within an image

function ImageDrawRectangleRec(dst::Ref{RayImage}, rec::RayRectangle, color::RayColor)
    return @ccall(libraylib.ImageDrawRectangleRec(dst::Ptr{RayImage}, rec::RayRectangle, color::RayColor)::Cvoid)
end

Draw rectangle within an image

function ImageDrawRectangleV(dst::Ref{RayImage}, position::StaticVector{2}, size::StaticVector{2}, color::RayColor)
    return @ccall(libraylib.ImageDrawRectangleV(dst::Ptr{RayImage}, position::RayVector2, size::RayVector2, color::RayColor)::Cvoid)
end

Draw rectangle within an image (Vector version)

function ImageDrawText(dst::Ref{RayImage}, text::String, posX::Integer, posY::Integer, fontSize::Integer, color::RayColor)
    return @ccall(libraylib.ImageDrawText(dst::Ptr{RayImage}, text::Cstring, posX::Cint, posY::Cint, fontSize::Cint, color::RayColor)::Cvoid)
end

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

function ImageDrawTextEx(dst::Ref{RayImage}, font::RayFont, text::String, position::StaticVector{2}, fontSize::Real, spacing::Real, tint::RayColor)
    return @ccall(libraylib.ImageDrawTextEx(dst::Ptr{RayImage}, font::RayFont, text::Cstring, position::RayVector2, fontSize::Cfloat, spacing::Cfloat, tint::RayColor)::Cvoid)
end

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

function ImageFlipHorizontal(image::Ref{RayImage})
    return @ccall(libraylib.ImageFlipHorizontal(image::Ptr{RayImage})::Cvoid)
end

Flip image horizontally

function ImageFlipVertical(image::Ref{RayImage})
    return @ccall(libraylib.ImageFlipVertical(image::Ptr{RayImage})::Cvoid)
end

Flip image vertically

function ImageFormat(image::Ref{RayImage}, newFormat::Integer)
    return @ccall(libraylib.ImageFormat(image::Ptr{RayImage}, newFormat::Cint)::Cvoid)
end

Convert image data to desired format

function ImageFromImage(image::RayImage, rec::RayRectangle)::RayImage
    return @ccall(libraylib.ImageFromImage(image::RayImage, rec::RayRectangle)::RayImage)
end

Create an image from another image piece

function ImageMipmaps(image::Ref{RayImage})
    return @ccall(libraylib.ImageMipmaps(image::Ptr{RayImage})::Cvoid)
end

Compute all mipmap levels for a provided image

function ImageResize(image::Ref{RayImage}, newWidth::Integer, newHeight::Integer)
    return @ccall(libraylib.ImageResize(image::Ptr{RayImage}, newWidth::Cint, newHeight::Cint)::Cvoid)
end

Resize image (Bicubic scaling algorithm)

function ImageResizeCanvas(image::Ref{RayImage}, newWidth::Integer, newHeight::Integer, offsetX::Integer, offsetY::Integer, fill::RayColor)
    return @ccall(libraylib.ImageResizeCanvas(image::Ptr{RayImage}, newWidth::Cint, newHeight::Cint, offsetX::Cint, offsetY::Cint, fill::RayColor)::Cvoid)
end

Resize canvas and fill with color

function ImageResizeNN(image::Ref{RayImage}, newWidth::Integer, newHeight::Integer)
    return @ccall(libraylib.ImageResizeNN(image::Ptr{RayImage}, newWidth::Cint, newHeight::Cint)::Cvoid)
end

Resize image (Nearest-Neighbor scaling algorithm)

function ImageRotateCCW(image::Ref{RayImage})
    return @ccall(libraylib.ImageRotateCCW(image::Ptr{RayImage})::Cvoid)
end

Rotate image counter-clockwise 90deg

function ImageRotateCW(image::Ref{RayImage})
    return @ccall(libraylib.ImageRotateCW(image::Ptr{RayImage})::Cvoid)
end

Rotate image clockwise 90deg

function ImageText(text::String, fontSize::Integer, color::RayColor)::RayImage
    return @ccall(libraylib.ImageText(text::Cstring, fontSize::Cint, color::RayColor)::RayImage)
end

Create an image from text (default font)

function ImageTextEx(font::RayFont, text::String, fontSize::Real, spacing::Real, tint::RayColor)::RayImage
    return @ccall(libraylib.ImageTextEx(font::RayFont, text::Cstring, fontSize::Cfloat, spacing::Cfloat, tint::RayColor)::RayImage)
end

Create an image from text (custom sprite font)

function ImageToPOT(image::Ref{RayImage}, fill::RayColor)
    return @ccall(libraylib.ImageToPOT(image::Ptr{RayImage}, fill::RayColor)::Cvoid)
end

Convert image to POT (power-of-two)

function InitAudioDevice()
    return @ccall(libraylib.InitAudioDevice()::Cvoid)
end

Initialize audio device and context

function InitPhysics()
    return @ccall(libraylib.InitPhysics()::Cvoid)
end

Initializes physics system

function InitWindow(width::Integer, height::Integer, title::String)
    return @ccall(libraylib.InitWindow(width::Cint, height::Cint, title::Cstring)::Cvoid)
end

Initialize window and OpenGL context

function IsAudioDeviceReady()::Bool
    return @ccall(libraylib.IsAudioDeviceReady()::Cuchar)
end

Check if audio device has been initialized successfully

function IsAudioStreamPlaying(stream::RayAudioStream)::Bool
    return @ccall(libraylib.IsAudioStreamPlaying(stream::RayAudioStream)::Cuchar)
end

Check if audio stream is playing

function IsAudioStreamProcessed(stream::RayAudioStream)::Bool
    return @ccall(libraylib.IsAudioStreamProcessed(stream::RayAudioStream)::Cuchar)
end

Check if any audio stream buffers requires refill

function IsCursorHidden()::Bool
    return @ccall(libraylib.IsCursorHidden()::Cuchar)
end

Check if cursor is not visible

function IsCursorOnScreen()::Bool
    return @ccall(libraylib.IsCursorOnScreen()::Cuchar)
end

Check if cursor is on the screen

function IsFileDropped()::Bool
    return @ccall(libraylib.IsFileDropped()::Cuchar)
end

Check if a file has been dropped into window

function IsFileExtension(fileName::String, ext::String)::Bool
    return @ccall(libraylib.IsFileExtension(fileName::Cstring, ext::Cstring)::Cuchar)
end

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

function IsGamepadAvailable(gamepad::Integer)::Bool
    return @ccall(libraylib.IsGamepadAvailable(gamepad::Cint)::Cuchar)
end

Check if a gamepad is available

function IsGamepadButtonDown(gamepad::Integer, button::Integer)::Bool
    return @ccall(libraylib.IsGamepadButtonDown(gamepad::Cint, button::Cint)::Cuchar)
end

Check if a gamepad button is being pressed

function IsGamepadButtonPressed(gamepad::Integer, button::Integer)::Bool
    return @ccall(libraylib.IsGamepadButtonPressed(gamepad::Cint, button::Cint)::Cuchar)
end

Check if a gamepad button has been pressed once

function IsGamepadButtonReleased(gamepad::Integer, button::Integer)::Bool
    return @ccall(libraylib.IsGamepadButtonReleased(gamepad::Cint, button::Cint)::Cuchar)
end

Check if a gamepad button has been released once

function IsGamepadButtonUp(gamepad::Integer, button::Integer)::Bool
    return @ccall(libraylib.IsGamepadButtonUp(gamepad::Cint, button::Cint)::Cuchar)
end

Check if a gamepad button is NOT being pressed

function IsGestureDetected(gesture::Integer)::Bool
    return @ccall(libraylib.IsGestureDetected(gesture::Cint)::Cuchar)
end

Check if a gesture have been detected

function IsKeyDown(key::Integer)::Bool
    return @ccall(libraylib.IsKeyDown(key::Cint)::Cuchar)
end

Check if a key is being pressed

function IsKeyPressed(key::Integer)::Bool
    return @ccall(libraylib.IsKeyPressed(key::Cint)::Cuchar)
end

Check if a key has been pressed once

function IsKeyReleased(key::Integer)::Bool
    return @ccall(libraylib.IsKeyReleased(key::Cint)::Cuchar)
end

Check if a key has been released once

function IsKeyUp(key::Integer)::Bool
    return @ccall(libraylib.IsKeyUp(key::Cint)::Cuchar)
end

Check if a key is NOT being pressed

function IsModelAnimationValid(model::RayModel, anim::RayModelAnimation)::Bool
    return @ccall(libraylib.IsModelAnimationValid(model::RayModel, anim::RayModelAnimation)::Cuchar)
end

Check model animation skeleton match

function IsMouseButtonDown(button::Integer)::Bool
    return @ccall(libraylib.IsMouseButtonDown(button::Cint)::Cuchar)
end

Check if a mouse button is being pressed

function IsMouseButtonPressed(button::Integer)::Bool
    return @ccall(libraylib.IsMouseButtonPressed(button::Cint)::Cuchar)
end

Check if a mouse button has been pressed once

function IsMouseButtonReleased(button::Integer)::Bool
    return @ccall(libraylib.IsMouseButtonReleased(button::Cint)::Cuchar)
end

Check if a mouse button has been released once

function IsMouseButtonUp(button::Integer)::Bool
    return @ccall(libraylib.IsMouseButtonUp(button::Cint)::Cuchar)
end

Check if a mouse button is NOT being pressed

function IsMusicStreamPlaying(music::RayMusic)::Bool
    return @ccall(libraylib.IsMusicStreamPlaying(music::RayMusic)::Cuchar)
end

Check if music is playing

function IsSoundPlaying(sound::RaySound)::Bool
    return @ccall(libraylib.IsSoundPlaying(sound::RaySound)::Cuchar)
end

Check if a sound is currently playing

function IsWindowFocused()::Bool
    return @ccall(libraylib.IsWindowFocused()::Cuchar)
end

Check if window is currently focused (only PLATFORM_DESKTOP)

function IsWindowFullscreen()::Bool
    return @ccall(libraylib.IsWindowFullscreen()::Cuchar)
end

Check if window is currently fullscreen

function IsWindowHidden()::Bool
    return @ccall(libraylib.IsWindowHidden()::Cuchar)
end

Check if window is currently hidden (only PLATFORM_DESKTOP)

function IsWindowMaximized()::Bool
    return @ccall(libraylib.IsWindowMaximized()::Cuchar)
end

Check if window is currently maximized (only PLATFORM_DESKTOP)

function IsWindowMinimized()::Bool
    return @ccall(libraylib.IsWindowMinimized()::Cuchar)
end

Check if window is currently minimized (only PLATFORM_DESKTOP)

function IsWindowReady()::Bool
    return @ccall(libraylib.IsWindowReady()::Cuchar)
end

Check if window has been initialized successfully

function IsWindowResized()::Bool
    return @ccall(libraylib.IsWindowResized()::Cuchar)
end

Check if window has been resized last frame

function IsWindowState(flag::Integer)::Bool
    return @ccall(libraylib.IsWindowState(flag::Cuint)::Cuchar)
end

Check if one specific window flag is enabled

function Lerp(start::Real, end::Real, amount::Real)
    return @ccall(libraylib.Lerp(start::Cfloat, end::Cfloat, amount::Cfloat)::Cfloat)
end

function LoadAudioStream(sampleRate::Integer, sampleSize::Integer, channels::Integer)::RayAudioStream
    return @ccall(libraylib.LoadAudioStream(sampleRate::Cuint, sampleSize::Cuint, channels::Cuint)::RayAudioStream)
end

Load audio stream (to stream raw audio pcm data)

function LoadCodepoints(text::String, count::Ref{<:Integer})
    return @ccall(libraylib.LoadCodepoints(text::Cstring, count::Ptr{Cint})::Ptr{Cint})
end

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

function LoadFileData(fileName::String, bytesRead::Ref{<:Integer})
    return @ccall(libraylib.LoadFileData(fileName::Cstring, bytesRead::Ptr{Cuint})::Ptr{Cuchar})
end

Load file data as byte array (read)

function LoadFileText(fileName::String)
    return @ccall(libraylib.LoadFileText(fileName::Cstring)::Cstring)
end

Load text data from file (read), returns a '\0' terminated string

function LoadFont(fileName::String)::RayFont
    return @ccall(libraylib.LoadFont(fileName::Cstring)::RayFont)
end

Load font from file into GPU memory (VRAM)

function LoadFontData(fileData::Ref{UInt8}, dataSize::Integer, fontSize::Integer, fontChars::Ref{<:Integer}, glyphCount::Integer, type::Integer)::Ref{RayGlyphInfo}
    return @ccall(libraylib.LoadFontData(fileData::Ptr{Cuchar}, dataSize::Cint, fontSize::Cint, fontChars::Ptr{Cint}, glyphCount::Cint, type::Cint)::Ptr{RayGlyphInfo})
end

Load font data for further use

function LoadFontEx(fileName::String, fontSize::Integer, fontChars::Ref{<:Integer}, glyphCount::Integer)::RayFont
    return @ccall(libraylib.LoadFontEx(fileName::Cstring, fontSize::Cint, fontChars::Ptr{Cint}, glyphCount::Cint)::RayFont)
end

Load font from file with extended parameters

function LoadFontFromImage(image::RayImage, key::RayColor, firstChar::Integer)::RayFont
    return @ccall(libraylib.LoadFontFromImage(image::RayImage, key::RayColor, firstChar::Cint)::RayFont)
end

Load font from Image (XNA style)

function LoadFontFromMemory(fileType::String, fileData::Ref{UInt8}, dataSize::Integer, fontSize::Integer, fontChars::Ref{<:Integer}, glyphCount::Integer)::RayFont
    return @ccall(libraylib.LoadFontFromMemory(fileType::Cstring, fileData::Ptr{Cuchar}, dataSize::Cint, fontSize::Cint, fontChars::Ptr{Cint}, glyphCount::Cint)::RayFont)
end

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

function LoadImage(fileName::String)::RayImage
    return @ccall(libraylib.LoadImage(fileName::Cstring)::RayImage)
end

Load image from file into CPU memory (RAM)

function LoadImageAnim(fileName::String, frames::Ref{<:Integer})::RayImage
    return @ccall(libraylib.LoadImageAnim(fileName::Cstring, frames::Ptr{Cint})::RayImage)
end

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

function LoadImageColors(image::RayImage)::Ref{RayColor}
    return @ccall(libraylib.LoadImageColors(image::RayImage)::Ptr{RayColor})
end

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

function LoadImageFromMemory(fileType::String, fileData::Ref{UInt8}, dataSize::Integer)::RayImage
    return @ccall(libraylib.LoadImageFromMemory(fileType::Cstring, fileData::Ptr{Cuchar}, dataSize::Cint)::RayImage)
end

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

function LoadImageFromScreen()::RayImage
    return @ccall(libraylib.LoadImageFromScreen()::RayImage)
end

Load image from screen buffer and (screenshot)

function LoadImageFromTexture(texture::RayTexture)::RayImage
    return @ccall(libraylib.LoadImageFromTexture(texture::RayTexture)::RayImage)
end

Load image from GPU texture data

function LoadImagePalette(image::RayImage, maxPaletteSize::Integer, colorCount::Ref{<:Integer})::Ref{RayColor}
    return @ccall(libraylib.LoadImagePalette(image::RayImage, maxPaletteSize::Cint, colorCount::Ptr{Cint})::Ptr{RayColor})
end

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

function LoadImageRaw(fileName::String, width::Integer, height::Integer, format::Integer, headerSize::Integer)::RayImage
    return @ccall(libraylib.LoadImageRaw(fileName::Cstring, width::Cint, height::Cint, format::Cint, headerSize::Cint)::RayImage)
end

Load image from RAW file data

function LoadMaterialDefault()::RayMaterial
    return @ccall(libraylib.LoadMaterialDefault()::RayMaterial)
end

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

function LoadMaterials(fileName::String, materialCount::Ref{<:Integer})::Ref{RayMaterial}
    return @ccall(libraylib.LoadMaterials(fileName::Cstring, materialCount::Ptr{Cint})::Ptr{RayMaterial})
end

Load materials from model file

function LoadModel(fileName::String)::RayModel
    return @ccall(libraylib.LoadModel(fileName::Cstring)::RayModel)
end

Load model from files (meshes and materials)

function LoadModelAnimations(fileName::String, animCount::Ref{<:Integer})::Ref{RayModelAnimation}
    return @ccall(libraylib.LoadModelAnimations(fileName::Cstring, animCount::Ptr{Cuint})::Ptr{RayModelAnimation})
end

Load model animations from file

function LoadModelFromMesh(mesh::RayMesh)::RayModel
    return @ccall(libraylib.LoadModelFromMesh(mesh::RayMesh)::RayModel)
end

Load model from generated mesh (default material)

function LoadMusicStream(fileName::String)::RayMusic
    return @ccall(libraylib.LoadMusicStream(fileName::Cstring)::RayMusic)
end

Load music stream from file

function LoadMusicStreamFromMemory(fileType::String, data::Ref{UInt8}, dataSize::Integer)::RayMusic
    return @ccall(libraylib.LoadMusicStreamFromMemory(fileType::Cstring, data::Ptr{Cuchar}, dataSize::Cint)::RayMusic)
end

Load music stream from data

function LoadRenderTexture(width::Integer, height::Integer)::RayRenderTexture
    return @ccall(libraylib.LoadRenderTexture(width::Cint, height::Cint)::RayRenderTexture)
end

Load texture for rendering (framebuffer)

function LoadShader(vsFileName::String, fsFileName::String)::RayShader
    return @ccall(libraylib.LoadShader(vsFileName::Cstring, fsFileName::Cstring)::RayShader)
end

Load shader from files and bind default locations

function LoadShaderFromMemory(vsCode::String, fsCode::String)::RayShader
    return @ccall(libraylib.LoadShaderFromMemory(vsCode::Cstring, fsCode::Cstring)::RayShader)
end

Load shader from code strings and bind default locations

function LoadSound(fileName::String)::RaySound
    return @ccall(libraylib.LoadSound(fileName::Cstring)::RaySound)
end

Load sound from file

function LoadSoundFromWave(wave::RayWave)::RaySound
    return @ccall(libraylib.LoadSoundFromWave(wave::RayWave)::RaySound)
end

Load sound from wave data

function LoadStorageValue(position::Integer)
    return @ccall(libraylib.LoadStorageValue(position::Cuint)::Cint)
end

Load integer value from storage file (from defined position)

function LoadTexture(fileName::String)::RayTexture
    return @ccall(libraylib.LoadTexture(fileName::Cstring)::RayTexture)
end

Load texture from file into GPU memory (VRAM)

function LoadTextureCubemap(image::RayImage, layout::Integer)::RayTexture
    return @ccall(libraylib.LoadTextureCubemap(image::RayImage, layout::Cint)::RayTexture)
end

Load cubemap from image, multiple image cubemap layouts supported

function LoadTextureFromImage(image::RayImage)::RayTexture
    return @ccall(libraylib.LoadTextureFromImage(image::RayImage)::RayTexture)
end

Load texture from image data

function LoadVrStereoConfig(device::RayVrDeviceInfo)::RayVrStereoConfig
    return @ccall(libraylib.LoadVrStereoConfig(device::RayVrDeviceInfo)::RayVrStereoConfig)
end

Load VR stereo config for VR simulator device parameters

function LoadWave(fileName::String)::RayWave
    return @ccall(libraylib.LoadWave(fileName::Cstring)::RayWave)
end

Load wave data from file

function LoadWaveFromMemory(fileType::String, fileData::Ref{UInt8}, dataSize::Integer)::RayWave
    return @ccall(libraylib.LoadWaveFromMemory(fileType::Cstring, fileData::Ptr{Cuchar}, dataSize::Cint)::RayWave)
end

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

function LoadWaveSamples(wave::RayWave)
    return @ccall(libraylib.LoadWaveSamples(wave::RayWave)::Ptr{Cfloat})
end

Load samples data from wave as a floats array

function MatrixAdd(left::RayMatrix, right::RayMatrix)::RayMatrix
    return @ccall(libraylib.MatrixAdd(left::RayMatrix, right::RayMatrix)::RayMatrix)
end

function MatrixDeterminant(mat::RayMatrix)
    return @ccall(libraylib.MatrixDeterminant(mat::RayMatrix)::Cfloat)
end

function MatrixFrustum(left::Real, right::Real, bottom::Real, top::Real, near::Real, far::Real)::RayMatrix
    return @ccall(libraylib.MatrixFrustum(left::Cdouble, right::Cdouble, bottom::Cdouble, top::Cdouble, near::Cdouble, far::Cdouble)::RayMatrix)
end

function MatrixIdentity()::RayMatrix
    return @ccall(libraylib.MatrixIdentity()::RayMatrix)
end

function MatrixInvert(mat::RayMatrix)::RayMatrix
    return @ccall(libraylib.MatrixInvert(mat::RayMatrix)::RayMatrix)
end

function MatrixLookAt(eye::StaticVector{3}, target::StaticVector{3}, up::StaticVector{3})::RayMatrix
    return @ccall(libraylib.MatrixLookAt(eye::RayVector3, target::RayVector3, up::RayVector3)::RayMatrix)
end

function MatrixMultiply(left::RayMatrix, right::RayMatrix)::RayMatrix
    return @ccall(libraylib.MatrixMultiply(left::RayMatrix, right::RayMatrix)::RayMatrix)
end

function MatrixNormalize(mat::RayMatrix)::RayMatrix
    return @ccall(libraylib.MatrixNormalize(mat::RayMatrix)::RayMatrix)
end

function MatrixOrtho(left::Real, right::Real, bottom::Real, top::Real, near::Real, far::Real)::RayMatrix
    return @ccall(libraylib.MatrixOrtho(left::Cdouble, right::Cdouble, bottom::Cdouble, top::Cdouble, near::Cdouble, far::Cdouble)::RayMatrix)
end

function MatrixPerspective(fovy::Real, aspect::Real, near::Real, far::Real)::RayMatrix
    return @ccall(libraylib.MatrixPerspective(fovy::Cdouble, aspect::Cdouble, near::Cdouble, far::Cdouble)::RayMatrix)
end

function MatrixRotate(axis::StaticVector{3}, angle::Real)::RayMatrix
    return @ccall(libraylib.MatrixRotate(axis::RayVector3, angle::Cfloat)::RayMatrix)
end

function MatrixRotateX(angle::Real)::RayMatrix
    return @ccall(libraylib.MatrixRotateX(angle::Cfloat)::RayMatrix)
end

function MatrixRotateXYZ(ang::StaticVector{3})::RayMatrix
    return @ccall(libraylib.MatrixRotateXYZ(ang::RayVector3)::RayMatrix)
end

function MatrixRotateY(angle::Real)::RayMatrix
    return @ccall(libraylib.MatrixRotateY(angle::Cfloat)::RayMatrix)
end

function MatrixRotateZ(angle::Real)::RayMatrix
    return @ccall(libraylib.MatrixRotateZ(angle::Cfloat)::RayMatrix)
end

function MatrixRotateZYX(ang::StaticVector{3})::RayMatrix
    return @ccall(libraylib.MatrixRotateZYX(ang::RayVector3)::RayMatrix)
end

function MatrixScale(x::Real, y::Real, z::Real)::RayMatrix
    return @ccall(libraylib.MatrixScale(x::Cfloat, y::Cfloat, z::Cfloat)::RayMatrix)
end

function MatrixSubtract(left::RayMatrix, right::RayMatrix)::RayMatrix
    return @ccall(libraylib.MatrixSubtract(left::RayMatrix, right::RayMatrix)::RayMatrix)
end

function MatrixToFloatV(mat::RayMatrix)::NTuple{16, Cfloat}
    return @ccall(libraylib.MatrixToFloatV(mat::RayMatrix)::NTuple{16, Cfloat})
end

function MatrixTrace(mat::RayMatrix)
    return @ccall(libraylib.MatrixTrace(mat::RayMatrix)::Cfloat)
end

function MatrixTranslate(x::Real, y::Real, z::Real)::RayMatrix
    return @ccall(libraylib.MatrixTranslate(x::Cfloat, y::Cfloat, z::Cfloat)::RayMatrix)
end

function MatrixTranspose(mat::RayMatrix)::RayMatrix
    return @ccall(libraylib.MatrixTranspose(mat::RayMatrix)::RayMatrix)
end

function MaximizeWindow()
    return @ccall(libraylib.MaximizeWindow()::Cvoid)
end

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

function MeasureText(text::String, fontSize::Integer)
    return @ccall(libraylib.MeasureText(text::Cstring, fontSize::Cint)::Cint)
end

Measure string width for default font

function MeasureTextEx(font::RayFont, text::String, fontSize::Real, spacing::Real)
    return @ccall(libraylib.MeasureTextEx(font::RayFont, text::Cstring, fontSize::Cfloat, spacing::Cfloat)::RayVector2)
end

Measure string size for Font

function MemAlloc(size::Integer)
    return @ccall(libraylib.MemAlloc(size::Cint)::Ptr{Cvoid})
end

Internal memory allocator

function MemFree(ptr::Ref{Nothing})
    return @ccall(libraylib.MemFree(ptr::Ptr{Cvoid})::Cvoid)
end

Internal memory free

function MemRealloc(ptr::Ref{Nothing}, size::Integer)
    return @ccall(libraylib.MemRealloc(ptr::Ptr{Cvoid}, size::Cint)::Ptr{Cvoid})
end

Internal memory reallocator

function MinimizeWindow()
    return @ccall(libraylib.MinimizeWindow()::Cvoid)
end

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

function Normalize(value::Real, start::Real, end::Real)
    return @ccall(libraylib.Normalize(value::Cfloat, start::Cfloat, end::Cfloat)::Cfloat)
end

function OpenURL(url::String)
    return @ccall(libraylib.OpenURL(url::Cstring)::Cvoid)
end

Open URL with default system browser (if available)

function PauseAudioStream(stream::RayAudioStream)
    return @ccall(libraylib.PauseAudioStream(stream::RayAudioStream)::Cvoid)
end

Pause audio stream

function PauseMusicStream(music::RayMusic)
    return @ccall(libraylib.PauseMusicStream(music::RayMusic)::Cvoid)
end

Pause music playing

function PauseSound(sound::RaySound)
    return @ccall(libraylib.PauseSound(sound::RaySound)::Cvoid)
end

Pause a sound

function PhysicsAddForce(body::Ptr{RayPhysicsBodyData}, force::StaticVector{2})
    return @ccall(libraylib.PhysicsAddForce(body::Ptr{RayPhysicsBodyData}, force::RayVector2)::Cvoid)
end

Adds a force to a physics body

function PhysicsAddTorque(body::Ptr{RayPhysicsBodyData}, amount::Real)
    return @ccall(libraylib.PhysicsAddTorque(body::Ptr{RayPhysicsBodyData}, amount::Cfloat)::Cvoid)
end

Adds an angular force to a physics body

function PhysicsShatter(body::Ptr{RayPhysicsBodyData}, position::StaticVector{2}, force::Real)
    return @ccall(libraylib.PhysicsShatter(body::Ptr{RayPhysicsBodyData}, position::RayVector2, force::Cfloat)::Cvoid)
end

Shatters a polygon shape physics body to little physics bodies with explosion force

function PlayAudioStream(stream::RayAudioStream)
    return @ccall(libraylib.PlayAudioStream(stream::RayAudioStream)::Cvoid)
end

Play audio stream

function PlayMusicStream(music::RayMusic)
    return @ccall(libraylib.PlayMusicStream(music::RayMusic)::Cvoid)
end

Start music playing

function PlaySound(sound::RaySound)
    return @ccall(libraylib.PlaySound(sound::RaySound)::Cvoid)
end

Play a sound

function PlaySoundMulti(sound::RaySound)
    return @ccall(libraylib.PlaySoundMulti(sound::RaySound)::Cvoid)
end

Play a sound (using multichannel buffer pool)

function PollInputEvents()
    return @ccall(libraylib.PollInputEvents()::Cvoid)
end

Register all input events

function QuaternionAdd(q1::StaticVector{4}, q2::StaticVector{4})
    return @ccall(libraylib.QuaternionAdd(q1::RayVector4, q2::RayVector4)::RayVector4)
end

function QuaternionAddValue(q::StaticVector{4}, add::Real)
    return @ccall(libraylib.QuaternionAddValue(q::RayVector4, add::Cfloat)::RayVector4)
end

function QuaternionDivide(q1::StaticVector{4}, q2::StaticVector{4})
    return @ccall(libraylib.QuaternionDivide(q1::RayVector4, q2::RayVector4)::RayVector4)
end

function QuaternionFromAxisAngle(axis::StaticVector{3}, angle::Real)
    return @ccall(libraylib.QuaternionFromAxisAngle(axis::RayVector3, angle::Cfloat)::RayVector4)
end

function QuaternionFromEuler(pitch::Real, yaw::Real, roll::Real)
    return @ccall(libraylib.QuaternionFromEuler(pitch::Cfloat, yaw::Cfloat, roll::Cfloat)::RayVector4)
end

function QuaternionFromMatrix(mat::RayMatrix)
    return @ccall(libraylib.QuaternionFromMatrix(mat::RayMatrix)::RayVector4)
end

function QuaternionFromVector3ToVector3(from::StaticVector{3}, to::StaticVector{3})
    return @ccall(libraylib.QuaternionFromVector3ToVector3(from::RayVector3, to::RayVector3)::RayVector4)
end

function QuaternionIdentity()
    return @ccall(libraylib.QuaternionIdentity()::RayVector4)
end

function QuaternionInvert(q::StaticVector{4})
    return @ccall(libraylib.QuaternionInvert(q::RayVector4)::RayVector4)
end

function QuaternionLength(q::StaticVector{4})
    return @ccall(libraylib.QuaternionLength(q::RayVector4)::Cfloat)
end

function QuaternionLerp(q1::StaticVector{4}, q2::StaticVector{4}, amount::Real)
    return @ccall(libraylib.QuaternionLerp(q1::RayVector4, q2::RayVector4, amount::Cfloat)::RayVector4)
end

function QuaternionMultiply(q1::StaticVector{4}, q2::StaticVector{4})
    return @ccall(libraylib.QuaternionMultiply(q1::RayVector4, q2::RayVector4)::RayVector4)
end

function QuaternionNlerp(q1::StaticVector{4}, q2::StaticVector{4}, amount::Real)
    return @ccall(libraylib.QuaternionNlerp(q1::RayVector4, q2::RayVector4, amount::Cfloat)::RayVector4)
end

function QuaternionNormalize(q::StaticVector{4})
    return @ccall(libraylib.QuaternionNormalize(q::RayVector4)::RayVector4)
end

function QuaternionScale(q::StaticVector{4}, mul::Real)
    return @ccall(libraylib.QuaternionScale(q::RayVector4, mul::Cfloat)::RayVector4)
end

function QuaternionSlerp(q1::StaticVector{4}, q2::StaticVector{4}, amount::Real)
    return @ccall(libraylib.QuaternionSlerp(q1::RayVector4, q2::RayVector4, amount::Cfloat)::RayVector4)
end

function QuaternionSubtract(q1::StaticVector{4}, q2::StaticVector{4})
    return @ccall(libraylib.QuaternionSubtract(q1::RayVector4, q2::RayVector4)::RayVector4)
end

function QuaternionSubtractValue(q::StaticVector{4}, sub::Real)
    return @ccall(libraylib.QuaternionSubtractValue(q::RayVector4, sub::Cfloat)::RayVector4)
end

function QuaternionToAxisAngle(q::StaticVector{4}, outAxis::Ref{<:StaticVector{3}}, outAngle::Ref{<:Real})
    return @ccall(libraylib.QuaternionToAxisAngle(q::RayVector4, outAxis::Ptr{RayVector3}, outAngle::Ptr{Cfloat})::Cvoid)
end

function QuaternionToEuler(q::StaticVector{4})
    return @ccall(libraylib.QuaternionToEuler(q::RayVector4)::RayVector3)
end

function QuaternionToMatrix(q::StaticVector{4})::RayMatrix
    return @ccall(libraylib.QuaternionToMatrix(q::RayVector4)::RayMatrix)
end

function QuaternionTransform(q::StaticVector{4}, mat::RayMatrix)
    return @ccall(libraylib.QuaternionTransform(q::RayVector4, mat::RayMatrix)::RayVector4)
end

function Remap(value::Real, inputStart::Real, inputEnd::Real, outputStart::Real, outputEnd::Real)
    return @ccall(libraylib.Remap(value::Cfloat, inputStart::Cfloat, inputEnd::Cfloat, outputStart::Cfloat, outputEnd::Cfloat)::Cfloat)
end

function ResetPhysics()
    return @ccall(libraylib.ResetPhysics()::Cvoid)
end

Reset physics system (global variables)

function RestoreWindow()
    return @ccall(libraylib.RestoreWindow()::Cvoid)
end

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

function ResumeAudioStream(stream::RayAudioStream)
    return @ccall(libraylib.ResumeAudioStream(stream::RayAudioStream)::Cvoid)
end

Resume audio stream

function ResumeMusicStream(music::RayMusic)
    return @ccall(libraylib.ResumeMusicStream(music::RayMusic)::Cvoid)
end

Resume playing paused music

function ResumeSound(sound::RaySound)
    return @ccall(libraylib.ResumeSound(sound::RaySound)::Cvoid)
end

Resume a paused sound

function SaveFileData(fileName::String, data::Ref{Nothing}, bytesToWrite::Integer)::Bool
    return @ccall(libraylib.SaveFileData(fileName::Cstring, data::Ptr{Cvoid}, bytesToWrite::Cuint)::Cuchar)
end

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

function SaveFileText(fileName::String, text::String)::Bool
    return @ccall(libraylib.SaveFileText(fileName::Cstring, text::Cstring)::Cuchar)
end

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

function SaveStorageValue(position::Integer, value::Integer)::Bool
    return @ccall(libraylib.SaveStorageValue(position::Cuint, value::Cint)::Cuchar)
end

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

function SeekMusicStream(music::RayMusic, position::Real)
    return @ccall(libraylib.SeekMusicStream(music::RayMusic, position::Cfloat)::Cvoid)
end

Seek music to a position (in seconds)

function SetAudioStreamBufferSizeDefault(size::Integer)
    return @ccall(libraylib.SetAudioStreamBufferSizeDefault(size::Cint)::Cvoid)
end

Default size for new audio streams

function SetAudioStreamPitch(stream::RayAudioStream, pitch::Real)
    return @ccall(libraylib.SetAudioStreamPitch(stream::RayAudioStream, pitch::Cfloat)::Cvoid)
end

Set pitch for audio stream (1.0 is base level)

function SetAudioStreamVolume(stream::RayAudioStream, volume::Real)
    return @ccall(libraylib.SetAudioStreamVolume(stream::RayAudioStream, volume::Cfloat)::Cvoid)
end

Set volume for audio stream (1.0 is max level)

function SetCameraAltControl(keyAlt::Integer)
    return @ccall(libraylib.SetCameraAltControl(keyAlt::Cint)::Cvoid)
end

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

function SetCameraMode(camera::RayCamera3D, mode::Integer)
    return @ccall(libraylib.SetCameraMode(camera::RayCamera3D, mode::Cint)::Cvoid)
end

Set camera mode (multiple camera modes available)

function SetCameraMoveControls(keyFront::Integer, keyBack::Integer, keyRight::Integer, keyLeft::Integer, keyUp::Integer, keyDown::Integer)
    return @ccall(libraylib.SetCameraMoveControls(keyFront::Cint, keyBack::Cint, keyRight::Cint, keyLeft::Cint, keyUp::Cint, keyDown::Cint)::Cvoid)
end

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

function SetCameraPanControl(keyPan::Integer)
    return @ccall(libraylib.SetCameraPanControl(keyPan::Cint)::Cvoid)
end

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

function SetCameraSmoothZoomControl(keySmoothZoom::Integer)
    return @ccall(libraylib.SetCameraSmoothZoomControl(keySmoothZoom::Cint)::Cvoid)
end

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

function SetClipboardText(text::String)
    return @ccall(libraylib.SetClipboardText(text::Cstring)::Cvoid)
end

Set clipboard text content

function SetConfigFlags(flags::Integer)
    return @ccall(libraylib.SetConfigFlags(flags::Cuint)::Cvoid)
end

Setup init configuration flags (view FLAGS)

function SetExitKey(key::Integer)
    return @ccall(libraylib.SetExitKey(key::Cint)::Cvoid)
end

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

function SetGamepadMappings(mappings::String)
    return @ccall(libraylib.SetGamepadMappings(mappings::Cstring)::Cint)
end

Set internal gamepad mappings (SDL_GameControllerDB)

function SetGesturesEnabled(flags::Integer)
    return @ccall(libraylib.SetGesturesEnabled(flags::Cuint)::Cvoid)
end

Enable a set of gestures using flags

function SetMasterVolume(volume::Real)
    return @ccall(libraylib.SetMasterVolume(volume::Cfloat)::Cvoid)
end

Set master volume (listener)

function SetMaterialTexture(material::Ref{RayMaterial}, mapType::Integer, texture::RayTexture)
    return @ccall(libraylib.SetMaterialTexture(material::Ptr{RayMaterial}, mapType::Cint, texture::RayTexture)::Cvoid)
end

Set texture for a material map type (MATERIALMAPDIFFUSE, MATERIALMAPSPECULAR...)

function SetModelMeshMaterial(model::Ref{RayModel}, meshId::Integer, materialId::Integer)
    return @ccall(libraylib.SetModelMeshMaterial(model::Ptr{RayModel}, meshId::Cint, materialId::Cint)::Cvoid)
end

Set material for a mesh

function SetMouseCursor(cursor::Integer)
    return @ccall(libraylib.SetMouseCursor(cursor::Cint)::Cvoid)
end

Set mouse cursor

function SetMouseOffset(offsetX::Integer, offsetY::Integer)
    return @ccall(libraylib.SetMouseOffset(offsetX::Cint, offsetY::Cint)::Cvoid)
end

Set mouse offset

function SetMousePosition(x::Integer, y::Integer)
    return @ccall(libraylib.SetMousePosition(x::Cint, y::Cint)::Cvoid)
end

Set mouse position XY

function SetMouseScale(scaleX::Real, scaleY::Real)
    return @ccall(libraylib.SetMouseScale(scaleX::Cfloat, scaleY::Cfloat)::Cvoid)
end

Set mouse scaling

function SetMusicPitch(music::RayMusic, pitch::Real)
    return @ccall(libraylib.SetMusicPitch(music::RayMusic, pitch::Cfloat)::Cvoid)
end

Set pitch for a music (1.0 is base level)

function SetMusicVolume(music::RayMusic, volume::Real)
    return @ccall(libraylib.SetMusicVolume(music::RayMusic, volume::Cfloat)::Cvoid)
end

Set volume for music (1.0 is max level)

function SetPhysicsBodyRotation(body::Ptr{RayPhysicsBodyData}, radians::Real)
    return @ccall(libraylib.SetPhysicsBodyRotation(body::Ptr{RayPhysicsBodyData}, radians::Cfloat)::Cvoid)
end

Sets physics body shape transform based on radians parameter

function SetPhysicsGravity(x::Real, y::Real)
    return @ccall(libraylib.SetPhysicsGravity(x::Cfloat, y::Cfloat)::Cvoid)
end

Sets physics global gravity force

function SetPhysicsTimeStep(delta::Real)
    return @ccall(libraylib.SetPhysicsTimeStep(delta::Cdouble)::Cvoid)
end

Sets physics fixed time step in milliseconds. 1.666666 by default

function SetPixelColor(dstPtr::Ref{Nothing}, color::RayColor, format::Integer)
    return @ccall(libraylib.SetPixelColor(dstPtr::Ptr{Cvoid}, color::RayColor, format::Cint)::Cvoid)
end

Set color formatted into destination pixel pointer

function SetRandomSeed(seed::Integer)
    return @ccall(libraylib.SetRandomSeed(seed::Cuint)::Cvoid)
end

Set the seed for the random number generator

function SetShaderValue(shader::RayShader, locIndex::Integer, value::Ref{Nothing}, uniformType::Integer)
    return @ccall(libraylib.SetShaderValue(shader::RayShader, locIndex::Cint, value::Ptr{Cvoid}, uniformType::Cint)::Cvoid)
end

Set shader uniform value

function SetShaderValueMatrix(shader::RayShader, locIndex::Integer, mat::RayMatrix)
    return @ccall(libraylib.SetShaderValueMatrix(shader::RayShader, locIndex::Cint, mat::RayMatrix)::Cvoid)
end

Set shader uniform value (matrix 4x4)

function SetShaderValueTexture(shader::RayShader, locIndex::Integer, texture::RayTexture)
    return @ccall(libraylib.SetShaderValueTexture(shader::RayShader, locIndex::Cint, texture::RayTexture)::Cvoid)
end

Set shader uniform value for texture (sampler2d)

function SetShaderValueV(shader::RayShader, locIndex::Integer, value::Ref{Nothing}, uniformType::Integer, count::Integer)
    return @ccall(libraylib.SetShaderValueV(shader::RayShader, locIndex::Cint, value::Ptr{Cvoid}, uniformType::Cint, count::Cint)::Cvoid)
end

Set shader uniform value vector

function SetShapesTexture(texture::RayTexture, source::RayRectangle)
    return @ccall(libraylib.SetShapesTexture(texture::RayTexture, source::RayRectangle)::Cvoid)
end

Set texture and rectangle to be used on shapes drawing

function SetSoundPitch(sound::RaySound, pitch::Real)
    return @ccall(libraylib.SetSoundPitch(sound::RaySound, pitch::Cfloat)::Cvoid)
end

Set pitch for a sound (1.0 is base level)

function SetSoundVolume(sound::RaySound, volume::Real)
    return @ccall(libraylib.SetSoundVolume(sound::RaySound, volume::Cfloat)::Cvoid)
end

Set volume for a sound (1.0 is max level)

function SetTargetFPS(fps::Integer)
    return @ccall(libraylib.SetTargetFPS(fps::Cint)::Cvoid)
end

Set target FPS (maximum)

function SetTextureFilter(texture::RayTexture, filter::Integer)
    return @ccall(libraylib.SetTextureFilter(texture::RayTexture, filter::Cint)::Cvoid)
end

Set texture scaling filter mode

function SetTextureWrap(texture::RayTexture, wrap::Integer)
    return @ccall(libraylib.SetTextureWrap(texture::RayTexture, wrap::Cint)::Cvoid)
end

Set texture wrapping mode

function SetTraceLogLevel(logLevel::Integer)
    return @ccall(libraylib.SetTraceLogLevel(logLevel::Cint)::Cvoid)
end

Set the current threshold (minimum) log level

function SetWindowIcon(image::RayImage)
    return @ccall(libraylib.SetWindowIcon(image::RayImage)::Cvoid)
end

Set icon for window (only PLATFORM_DESKTOP)

function SetWindowMinSize(width::Integer, height::Integer)
    return @ccall(libraylib.SetWindowMinSize(width::Cint, height::Cint)::Cvoid)
end

Set window minimum dimensions (for FLAGWINDOWRESIZABLE)

function SetWindowMonitor(monitor::Integer)
    return @ccall(libraylib.SetWindowMonitor(monitor::Cint)::Cvoid)
end

Set monitor for the current window (fullscreen mode)

function SetWindowPosition(x::Integer, y::Integer)
    return @ccall(libraylib.SetWindowPosition(x::Cint, y::Cint)::Cvoid)
end

Set window position on screen (only PLATFORM_DESKTOP)

function SetWindowSize(width::Integer, height::Integer)
    return @ccall(libraylib.SetWindowSize(width::Cint, height::Cint)::Cvoid)
end

Set window dimensions

function SetWindowState(flags::Integer)
    return @ccall(libraylib.SetWindowState(flags::Cuint)::Cvoid)
end

Set window configuration state using flags

function SetWindowTitle(title::String)
    return @ccall(libraylib.SetWindowTitle(title::Cstring)::Cvoid)
end

Set title for window (only PLATFORM_DESKTOP)

function ShowCursor()
    return @ccall(libraylib.ShowCursor()::Cvoid)
end

Shows cursor

function StopAudioStream(stream::RayAudioStream)
    return @ccall(libraylib.StopAudioStream(stream::RayAudioStream)::Cvoid)
end

Stop audio stream

function StopMusicStream(music::RayMusic)
    return @ccall(libraylib.StopMusicStream(music::RayMusic)::Cvoid)
end

Stop music playing

function StopSound(sound::RaySound)
    return @ccall(libraylib.StopSound(sound::RaySound)::Cvoid)
end

Stop playing a sound

function StopSoundMulti()
    return @ccall(libraylib.StopSoundMulti()::Cvoid)
end

Stop any sound playing (using multichannel buffer pool)

function SwapScreenBuffer()
    return @ccall(libraylib.SwapScreenBuffer()::Cvoid)
end

Swap back buffer with front buffer (screen drawing)

function TakeScreenshot(fileName::String)
    return @ccall(libraylib.TakeScreenshot(fileName::Cstring)::Cvoid)
end

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

function TextAppend(text::String, append::String, position::Ref{<:Integer})
    return @ccall(libraylib.TextAppend(text::Cstring, append::Cstring, position::Ptr{Cint})::Cvoid)
end

Append text at specific position and move cursor!

function TextCodepointsToUTF8(codepoints::Ref{<:Integer}, length::Integer)
    return @ccall(libraylib.TextCodepointsToUTF8(codepoints::Ptr{Cint}, length::Cint)::Cstring)
end

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

function TextCopy(dst::String, src::String)
    return @ccall(libraylib.TextCopy(dst::Cstring, src::Cstring)::Cint)
end

Copy one string to another, returns bytes copied

function TextFindIndex(text::String, find::String)
    return @ccall(libraylib.TextFindIndex(text::Cstring, find::Cstring)::Cint)
end

Find first text occurrence within a string

function TextInsert(text::String, insert::String, position::Integer)
    return @ccall(libraylib.TextInsert(text::Cstring, insert::Cstring, position::Cint)::Cstring)
end

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

function TextIsEqual(text1::String, text2::String)::Bool
    return @ccall(libraylib.TextIsEqual(text1::Cstring, text2::Cstring)::Cuchar)
end

Check if two text string are equal

function TextJoin(textList::Ref{String}, count::Integer, delimiter::String)
    return @ccall(libraylib.TextJoin(textList::Ptr{Cstring}, count::Cint, delimiter::Cstring)::Cstring)
end

Join text strings with delimiter

function TextLength(text::String)
    return @ccall(libraylib.TextLength(text::Cstring)::Cuint)
end

Get text length, checks for '\0' ending

function TextReplace(text::String, replace::String, by::String)
    return @ccall(libraylib.TextReplace(text::Cstring, replace::Cstring, by::Cstring)::Cstring)
end

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

function TextSplit(text::String, delimiter::Char, count::Ref{<:Integer})
    return @ccall(libraylib.TextSplit(text::Cstring, delimiter::Cchar, count::Ptr{Cint})::Ptr{Cstring})
end

Split text into multiple strings

function TextSubtext(text::String, position::Integer, length::Integer)
    return @ccall(libraylib.TextSubtext(text::Cstring, position::Cint, length::Cint)::Cstring)
end

Get a piece of a text string

function TextToInteger(text::String)
    return @ccall(libraylib.TextToInteger(text::Cstring)::Cint)
end

Get integer value from text (negative values not supported)

function TextToLower(text::String)
    return @ccall(libraylib.TextToLower(text::Cstring)::Cstring)
end

Get lower case version of provided string

function TextToPascal(text::String)
    return @ccall(libraylib.TextToPascal(text::Cstring)::Cstring)
end

Get Pascal case notation version of provided string

function TextToUpper(text::String)
    return @ccall(libraylib.TextToUpper(text::Cstring)::Cstring)
end

Get upper case version of provided string

function ToggleFullscreen()
    return @ccall(libraylib.ToggleFullscreen()::Cvoid)
end

Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)

function UnloadAudioStream(stream::RayAudioStream)
    return @ccall(libraylib.UnloadAudioStream(stream::RayAudioStream)::Cvoid)
end

Unload audio stream and free memory

function UnloadCodepoints(codepoints::Ref{<:Integer})
    return @ccall(libraylib.UnloadCodepoints(codepoints::Ptr{Cint})::Cvoid)
end

Unload codepoints data from memory

function UnloadFileData(data::Ref{UInt8})
    return @ccall(libraylib.UnloadFileData(data::Ptr{Cuchar})::Cvoid)
end

Unload file data allocated by LoadFileData()

function UnloadFileText(text::String)
    return @ccall(libraylib.UnloadFileText(text::Cstring)::Cvoid)
end

Unload file text data allocated by LoadFileText()

function UnloadFont(font::RayFont)
    return @ccall(libraylib.UnloadFont(font::RayFont)::Cvoid)
end

Unload Font from GPU memory (VRAM)

function UnloadFontData(chars::Ref{RayGlyphInfo}, glyphCount::Integer)
    return @ccall(libraylib.UnloadFontData(chars::Ptr{RayGlyphInfo}, glyphCount::Cint)::Cvoid)
end

Unload font chars info data (RAM)

function UnloadImage(image::RayImage)
    return @ccall(libraylib.UnloadImage(image::RayImage)::Cvoid)
end

Unload image from CPU memory (RAM)

function UnloadImageColors(colors::Ref{RayColor})
    return @ccall(libraylib.UnloadImageColors(colors::Ptr{RayColor})::Cvoid)
end

Unload color data loaded with LoadImageColors()

function UnloadImagePalette(colors::Ref{RayColor})
    return @ccall(libraylib.UnloadImagePalette(colors::Ptr{RayColor})::Cvoid)
end

Unload colors palette loaded with LoadImagePalette()

function UnloadMaterial(material::RayMaterial)
    return @ccall(libraylib.UnloadMaterial(material::RayMaterial)::Cvoid)
end

Unload material from GPU memory (VRAM)

function UnloadMesh(mesh::RayMesh)
    return @ccall(libraylib.UnloadMesh(mesh::RayMesh)::Cvoid)
end

Unload mesh data from CPU and GPU

function UnloadModel(model::RayModel)
    return @ccall(libraylib.UnloadModel(model::RayModel)::Cvoid)
end

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

function UnloadModelAnimation(anim::RayModelAnimation)
    return @ccall(libraylib.UnloadModelAnimation(anim::RayModelAnimation)::Cvoid)
end

Unload animation data

function UnloadModelAnimations(animations::Ref{RayModelAnimation}, count::Integer)
    return @ccall(libraylib.UnloadModelAnimations(animations::Ptr{RayModelAnimation}, count::Cuint)::Cvoid)
end

Unload animation array data

function UnloadModelKeepMeshes(model::RayModel)
    return @ccall(libraylib.UnloadModelKeepMeshes(model::RayModel)::Cvoid)
end

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

function UnloadMusicStream(music::RayMusic)
    return @ccall(libraylib.UnloadMusicStream(music::RayMusic)::Cvoid)
end

Unload music stream

function UnloadRenderTexture(target::RayRenderTexture)
    return @ccall(libraylib.UnloadRenderTexture(target::RayRenderTexture)::Cvoid)
end

Unload render texture from GPU memory (VRAM)

function UnloadShader(shader::RayShader)
    return @ccall(libraylib.UnloadShader(shader::RayShader)::Cvoid)
end

Unload shader from GPU memory (VRAM)

function UnloadSound(sound::RaySound)
    return @ccall(libraylib.UnloadSound(sound::RaySound)::Cvoid)
end

Unload sound

function UnloadTexture(texture::RayTexture)
    return @ccall(libraylib.UnloadTexture(texture::RayTexture)::Cvoid)
end

Unload texture from GPU memory (VRAM)

function UnloadVrStereoConfig(config::RayVrStereoConfig)
    return @ccall(libraylib.UnloadVrStereoConfig(config::RayVrStereoConfig)::Cvoid)
end

Unload VR stereo config

function UnloadWave(wave::RayWave)
    return @ccall(libraylib.UnloadWave(wave::RayWave)::Cvoid)
end

Unload wave data

function UnloadWaveSamples(samples::Ref{<:Real})
    return @ccall(libraylib.UnloadWaveSamples(samples::Ptr{Cfloat})::Cvoid)
end

Unload samples data loaded with LoadWaveSamples()

function UpdateAudioStream(stream::RayAudioStream, data::Ref{Nothing}, frameCount::Integer)
    return @ccall(libraylib.UpdateAudioStream(stream::RayAudioStream, data::Ptr{Cvoid}, frameCount::Cint)::Cvoid)
end

Update audio stream buffers with data

function UpdateCamera(camera::Ref{RayCamera3D})
    return @ccall(libraylib.UpdateCamera(camera::Ptr{RayCamera3D})::Cvoid)
end

Update camera position for selected mode