🥮 mooncakes.io

raylib

MoonBit bindings for raylib

moon add tonyfettes/raylib@0.4.0
Download zip
Version
0.4.0
License
MIT
Repository
Last updated
3 months ago
Downloads
4K
README

#tonyfettes/raylib

MoonBit bindings for raylib 5.5 — a simple and easy-to-use library to enjoy videogames programming.

#Features

  • Native target support (macOS, Linux, Windows, Android)
  • Covers core, shapes, textures, text, models, shaders, and audio APIs
  • Automatic resource management via GC finalizers for opaque types (Image, Texture, Font, Sound, Music, Model, etc.)
  • 329 included examples — ports of official raylib examples plus original games and demos
  • Platform-specific linking handled automatically via prebuild script

#Prerequisites

A C compiler is required because raylib's C sources are compiled from source as part of the build.

PlatformC Compiler
macOSXcode Command Line Tools (xcode-select --install)
LinuxGCC or Clang (e.g., apt install build-essential)
WindowsMSVC or MinGW-w64 (GCC) — see below
AndroidAndroid NDK

#Windows

Either of the following C compilers will work:

  • MSVC — Install Visual Studio or the Build Tools for Visual Studio. Make sure to select the "Desktop development with C++" workload. The cl.exe compiler should be available in your PATH (use the "Developer Command Prompt" or "Developer PowerShell" that Visual Studio provides).

  • MinGW-w64 (GCC) — Install via MSYS2:
    1. Install MSYS2 and open the MSYS2 UCRT64 terminal
    2. Run pacman -S mingw-w64-ucrt-x86_64-gcc
    3. Add the MinGW bin directory to your system PATH (default: C:\msys64\ucrt64\bin)
    4. Verify in a new terminal: gcc --version

#Quick Start

#Install

Add the dependency to your project:

moon add tonyfettes/raylib

#Hello Window

fn main {
  @raylib.init_window(800, 450, "Hello Raylib")
  @raylib.set_target_fps(60)
  while not(@raylib.window_should_close()) {
    @raylib.begin_drawing()
    @raylib.clear_background(@raylib.raywhite)
    @raylib.draw_text("Hello, MoonBit!", 190, 200, 20, @raylib.lightgray)
    @raylib.end_drawing()
  }
  @raylib.close_window()
}

Build and run:

moon run --target native main/

#Building Examples

Examples live in the examples/ directory as a separate module:

# Build a specific example
moon -C examples build --target native raylib_core_basic_window/

# Run a specific example
moon -C examples run --target native raylib_demo/

# Run the bunnymark benchmark
moon -C examples run --target native raylib_textures_bunnymark/

#API Overview

Import tonyfettes/raylib and use the @raylib namespace:

// Window management
@raylib.init_window(width, height, title)
@raylib.close_window()
@raylib.set_target_fps(60)

// Drawing
@raylib.begin_drawing()
@raylib.end_drawing()
@raylib.clear_background(@raylib.skyblue)

// Shapes
@raylib.draw_rectangle(x, y, width, height, @raylib.red)
@raylib.draw_circle(x, y, radius, @raylib.blue)

// Textures
let texture = @raylib.load_texture("sprite.png")
@raylib.draw_texture(texture, x, y, @raylib.white)

// Input
@raylib.is_key_pressed(@raylib.KeySpace)
@raylib.is_mouse_button_down(@raylib.MouseButtonLeft)
@raylib.get_mouse_position()  // -> Vector2

// Audio
@raylib.init_audio_device()
let sound = @raylib.load_sound("hit.wav")
@raylib.play_sound(sound)

// 3D
@raylib.begin_mode_3d(camera)
@raylib.draw_cube(position, width, height, length, @raylib.red)
@raylib.end_mode_3d()

#License

MIT

#
AudioBuffer

source

#
AudioStream

source
type AudioStream

#
AudioStream::attach_processor

source
#as_free_fn(attach_audio_stream_processor)
fn AudioStream::attach_processor(self : AudioStream, processor : FuncRef[(
AudioBuffer, UInt) -> Unit]) -> Unit

#
AudioStream::detach_processor

source
#as_free_fn(detach_audio_stream_processor)
fn AudioStream::detach_processor(self : AudioStream, processor : FuncRef[(
AudioBuffer, UInt) -> Unit]) -> Unit

#
AudioStream::is_playing

source
#as_free_fn(is_audio_stream_playing)
fn AudioStream::is_playing(self : AudioStream) -> Bool

#
AudioStream::is_processed

source
#as_free_fn(is_audio_stream_processed)
fn AudioStream::is_processed(self : AudioStream) -> Bool

#
AudioStream::is_valid

source
#as_free_fn(is_audio_stream_valid)
fn AudioStream::is_valid(self : AudioStream) -> Bool

#
AudioStream::load

source
#as_free_fn(load_audio_stream)
fn AudioStream::load(sample_rate : Int, sample_size : Int, channels : Int) -> AudioStream

#
AudioStream::pause

source
#as_free_fn(pause_audio_stream)
fn AudioStream::pause(self : AudioStream) -> Unit

#
AudioStream::play

source
#as_free_fn(play_audio_stream)
fn AudioStream::play(self : AudioStream) -> Unit

#
AudioStream::resume_

source
#as_free_fn(resume_audio_stream)
fn AudioStream::resume_(self : AudioStream) -> Unit

#
AudioStream::set_pan

source
#as_free_fn(set_audio_stream_pan)
fn AudioStream::set_pan(self : AudioStream, pan : Float) -> Unit

#
AudioStream::set_pitch

source
#as_free_fn(set_audio_stream_pitch)
fn AudioStream::set_pitch(self : AudioStream, pitch : Float) -> Unit

#
AudioStream::set_volume

source
#as_free_fn(set_audio_stream_volume)
fn AudioStream::set_volume(self : AudioStream, volume : Float) -> Unit

#
AudioStream::stop

source
#as_free_fn(stop_audio_stream)
fn AudioStream::stop(self : AudioStream) -> Unit

#
AudioStream::unload

source
#as_free_fn(unload_audio_stream)
fn AudioStream::unload(self : AudioStream) -> Unit

#
AudioStream::update

source
#as_free_fn(update_audio_stream)
fn AudioStream::update(self : AudioStream, data : Bytes, frame_count : Int) -> Unit

#
AutomationEvent

source
pub struct AutomationEvent {
  frame : Int
  type_ : Int
  params : FixedArray[Int]
}

#
AutomationEvent::from_bytes

source
fn AutomationEvent::from_bytes(b : Bytes) -> AutomationEvent

#
AutomationEvent::to_bytes

source
fn AutomationEvent::to_bytes(e : AutomationEvent) -> Bytes

#
AutomationEventList

source
type AutomationEventList

#
AutomationEventList::count

source
#as_free_fn(automation_event_list_count)
fn AutomationEventList::count(self : AutomationEventList) -> Int

#
AutomationEventList::export_

source
#as_free_fn(export_automation_event_list)
fn AutomationEventList::export_(self : AutomationEventList, file_name : String) -> Bool

#
AutomationEventList::get

source
#as_free_fn(automation_event_list_get)
fn AutomationEventList::get(self : AutomationEventList, index : Int) -> AutomationEvent

#
AutomationEventList::load

source
#as_free_fn(load_automation_event_list)
fn AutomationEventList::load(file_name : String) -> AutomationEventList

#
AutomationEventList::set

source
#as_free_fn(set_automation_event_list)
fn AutomationEventList::set(self : AutomationEventList) -> Unit

#
AutomationEventList::unload

source
#as_free_fn(unload_automation_event_list)
fn AutomationEventList::unload(self : AutomationEventList) -> Unit

#
BoundingBox

source
pub struct BoundingBox {
  min : Vector3
  max : Vector3
}

impl Eq for BoundingBox
impl Show for BoundingBox

#
BoundingBox::from_bytes

source
fn BoundingBox::from_bytes(b : Bytes) -> BoundingBox

#
BoundingBox::new

source
fn BoundingBox::new(min : Vector3, max : Vector3) -> BoundingBox

#
BoundingBox::to_bytes

source
fn BoundingBox::to_bytes(bb : BoundingBox) -> Bytes

#
Camera2D

source
pub struct Camera2D {
  offset : Vector2
  target : Vector2
  rotation : Float
  zoom : Float
}

impl Eq for Camera2D
impl Show for Camera2D

#
Camera2D::from_bytes

source
fn Camera2D::from_bytes(b : Bytes) -> Camera2D

#
Camera2D::new

source
fn Camera2D::new(offset : Vector2, target : Vector2, rotation : Float, zoom : Float) -> Camera2D

#
Camera2D::to_bytes

source
fn Camera2D::to_bytes(c : Camera2D) -> Bytes

#
Camera3D

source
pub struct Camera3D {
  position : Vector3
  target : Vector3
  up : Vector3
  fovy : Float
  projection : Int
}

impl Eq for Camera3D
impl Show for Camera3D

#
Camera3D::from_bytes

source
fn Camera3D::from_bytes(b : Bytes) -> Camera3D

#
Camera3D::new

source
fn Camera3D::new(position : Vector3, target : Vector3, up : Vector3, fovy : Float, projection : Int) -> Camera3D

#
Camera3D::to_bytes

source
fn Camera3D::to_bytes(c : Camera3D) -> Bytes

#
Color

source
pub struct Color {
  r : Byte
  g : Byte
  b : Byte
  a : Byte
}

impl Eq for Color
impl Show for Color

#
Color::from_bytes

source
fn Color::from_bytes(b : Bytes) -> Color

#
Color::new

source
fn Color::new(r : Int, g : Int, b : Int, a : Int) -> Color

#
Color::to_bytes

source
fn Color::to_bytes(color : Color) -> Bytes

#
FilePathList

source
type FilePathList

#
FilePathList::count

source
#as_free_fn(file_path_list_count)
fn FilePathList::count(self : FilePathList) -> Int

#
FilePathList::load_dropped

source
#as_free_fn(load_dropped_files)
fn FilePathList::load_dropped() -> FilePathList

#
FloatArray

source
type FloatArray

#
FloatArray::length

source
fn FloatArray::length(self : FloatArray) -> Int

#
FloatArray::op_get

source
fn FloatArray::op_get(self : FloatArray, index : Int) -> Float

#
FloatArray::op_set

source
fn FloatArray::op_set(self : FloatArray, index : Int, value : Float) -> Unit

#
Font

source
type Font

impl Default for Font

#
Font::base_size

source
#as_free_fn(get_font_base_size)
fn Font::base_size(self : Font) -> Int

#
Font::build_from_data

source
#as_free_fn(build_font_from_data)
fn Font::build_from_data(file_data : Bytes, data_size : Int, font_size : Int, font_type : Int, padding : Int, pack_method : Int) -> Font

#
Font::draw_codepoint

source
#as_free_fn(draw_text_codepoint)
fn Font::draw_codepoint(self : Font, codepoint : Int, position : Vector2, font_size : Float, tint : Color) -> Unit

#
Font::draw_codepoints

source
#as_free_fn(draw_text_codepoints)
fn Font::draw_codepoints(self : Font, codepoints : Array[Int], position : Vector2, font_size : Float, spacing : Float, tint : Color) -> Unit

#
Font::draw_text

source
#as_free_fn(draw_text_ex)
fn Font::draw_text(self : Font, text : String, position : Vector2, font_size : Float, spacing : Float, tint : Color) -> Unit

#
Font::draw_text_pro

source
#as_free_fn(draw_text_pro)
fn Font::draw_text_pro(self : Font, text : String, position : Vector2, origin : Vector2, rotation : Float, font_size : Float, spacing : Float, tint : Color) -> Unit

#
Font::export_as_code

source
#as_free_fn(export_font_as_code)
fn Font::export_as_code(self : Font, file_name : String) -> Bool

#
Font::get_default

source
#deprecated("Use Font::default() instead")
#as_free_fn(get_font_default, deprecated="Use Font::default() instead")
fn Font::get_default() -> Font

#
Font::glyph_atlas_rec

source
#as_free_fn(get_glyph_atlas_rec)
fn Font::glyph_atlas_rec(self : Font, codepoint : Int) -> Rectangle

#
Font::glyph_count

source
#as_free_fn(get_font_glyph_count)
fn Font::glyph_count(self : Font) -> Int

#
Font::glyph_index

source
#as_free_fn(get_glyph_index)
fn Font::glyph_index(self : Font, codepoint : Int) -> Int

#
Font::glyph_info

source
#as_free_fn(get_glyph_info)
fn Font::glyph_info(self : Font, codepoint : Int) -> GlyphInfo

#
Font::glyph_padding

source
#as_free_fn(get_font_glyph_padding)
fn Font::glyph_padding(self : Font) -> Int

#
Font::is_valid

source
#as_free_fn(is_font_valid)
fn Font::is_valid(self : Font) -> Bool

#
Font::load

source
#as_free_fn(load_font)
fn Font::load(file_name : String) -> Font

#
Font::load_ex

source
#as_free_fn(load_font_ex)
fn Font::load_ex(file_name : String, font_size : Int) -> Font

#
Font::load_ex_codepoints

source
#as_free_fn(load_font_ex_codepoints)
fn Font::load_ex_codepoints(file_name : String, font_size : Int, codepoints : Array[Int]) -> Font

#
Font::load_from_atlas

source
#as_free_fn(load_font_from_atlas)
fn Font::load_from_atlas(pixel_data : Bytes, pixel_data_size : Int, img_width : Int, img_height : Int, img_format : Int, base_size : Int, glyph_count : Int, font_type : Int, recs_data : Bytes, glyphs_data : Bytes) -> Font

#
Font::load_from_image

source
#as_free_fn(load_font_from_image)
fn Font::load_from_image(image : Image, key : Color, first_char : Int) -> Font

#
Font::load_from_memory

source
#as_free_fn(load_font_from_memory)
fn Font::load_from_memory(file_type : String, file_data : Bytes, data_size : Int, font_size : Int) -> Font

#
Font::measure_text

source
#as_free_fn(measure_text_ex)
fn Font::measure_text(self : Font, text : String, font_size : Float, spacing : Float) -> Vector2

#
Font::texture

source
#as_free_fn(get_font_texture)
fn Font::texture(self : Font) -> Texture

#
Font::unload

source
#as_free_fn(unload_font)
fn Font::unload(self : Font) -> Unit

#
GlyphInfo

source
pub struct GlyphInfo {
  value : Int
  offset_x : Int
  offset_y : Int
  advance_x : Int
}

impl Eq for GlyphInfo
impl Show for GlyphInfo

#
GlyphInfo::from_bytes

source
fn GlyphInfo::from_bytes(b : Bytes) -> GlyphInfo

#
GlyphInfoArray

source
type GlyphInfoArray

#
GlyphInfoArray::count

source
#as_free_fn(glyph_info_array_count)
fn GlyphInfoArray::count(self : GlyphInfoArray) -> Int

#
GlyphInfoArray::gen_image_atlas

source
#as_free_fn(gen_image_font_atlas)
fn GlyphInfoArray::gen_image_atlas(self : GlyphInfoArray, font_size : Int, padding : Int, pack_method : Int) -> Image

#
GlyphInfoArray::get

source
#as_free_fn(glyph_info_array_get)
fn GlyphInfoArray::get(self : GlyphInfoArray, index : Int) -> GlyphInfo

#
GlyphInfoArray::load

source
#as_free_fn(load_font_data)
fn GlyphInfoArray::load(file_data : Bytes, data_size : Int, font_size : Int, font_type : Int) -> GlyphInfoArray

#
GlyphInfoArray::unload

source
#as_free_fn(unload_font_data)
fn GlyphInfoArray::unload(self : GlyphInfoArray) -> Unit

#
Image

source
type Image

#
Image::adjust_brightness

source
#as_free_fn(image_color_brightness)
fn Image::adjust_brightness(self : Image, brightness : Int) -> Unit

#
Image::adjust_contrast

source
#as_free_fn(image_color_contrast)
fn Image::adjust_contrast(self : Image, contrast : Float) -> Unit

#
Image::alpha_border

source
#as_free_fn(get_image_alpha_border)
fn Image::alpha_border(self : Image, threshold : Float) -> Rectangle

#
Image::alpha_clear

source
#as_free_fn(image_alpha_clear)
fn Image::alpha_clear(self : Image, color : Color, threshold : Float) -> Unit

#
Image::alpha_crop

source
#as_free_fn(image_alpha_crop)
fn Image::alpha_crop(self : Image, threshold : Float) -> Unit

#
Image::alpha_mask

source
#as_free_fn(image_alpha_mask)
fn Image::alpha_mask(self : Image, alpha_mask : Image) -> Unit

#
Image::alpha_premultiply

source
#as_free_fn(image_alpha_premultiply)
fn Image::alpha_premultiply(self : Image) -> Unit

#
Image::blur_gaussian

source
#as_free_fn(image_blur_gaussian)
fn Image::blur_gaussian(self : Image, blur_size : Int) -> Unit

#
Image::clear_background

source
#as_free_fn(image_clear_background)
fn Image::clear_background(self : Image, color : Color) -> Unit

#
Image::color_grayscale

source
#as_free_fn(image_color_grayscale)
fn Image::color_grayscale(self : Image) -> Unit

#
Image::color_invert

source
#as_free_fn(image_color_invert)
fn Image::color_invert(self : Image) -> Unit

#
Image::color_replace

source
#as_free_fn(image_color_replace)
fn Image::color_replace(self : Image, color : Color, replace : Color) -> Unit

#
Image::color_tint

source
#as_free_fn(image_color_tint)
fn Image::color_tint(self : Image, color : Color) -> Unit

#
Image::copy

source
#as_free_fn(image_copy)
fn Image::copy(self : Image) -> Image

#
Image::crop

source
#as_free_fn(image_crop)
fn Image::crop(self : Image, crop : Rectangle) -> Unit

#
Image::dither

source
#as_free_fn(image_dither)
fn Image::dither(self : Image, r_bpp : Int, g_bpp : Int, b_bpp : Int, a_bpp : Int) -> Unit

#
Image::draw

source
#as_free_fn(image_draw)
fn Image::draw(self : Image, src : Image, src_rec : Rectangle, dst_rec : Rectangle, tint : Color) -> Unit

#
Image::draw_circle

source
#as_free_fn(image_draw_circle)
fn Image::draw_circle(self : Image, center_x : Int, center_y : Int, radius : Int, color : Color) -> Unit

#
Image::draw_circle_lines

source
#as_free_fn(image_draw_circle_lines)
fn Image::draw_circle_lines(self : Image, center_x : Int, center_y : Int, radius : Int, color : Color) -> Unit

#
Image::draw_circle_lines_v

source
#as_free_fn(image_draw_circle_lines_v)
fn Image::draw_circle_lines_v(self : Image, center : Vector2, radius : Int, color : Color) -> Unit

#
Image::draw_circle_v

source
#as_free_fn(image_draw_circle_v)
fn Image::draw_circle_v(self : Image, center : Vector2, radius : Int, color : Color) -> Unit

#
Image::draw_line

source
#as_free_fn(image_draw_line)
fn Image::draw_line(self : Image, start_pos_x : Int, start_pos_y : Int, end_pos_x : Int, end_pos_y : Int, color : Color) -> Unit

#
Image::draw_line_ex

source
#as_free_fn(image_draw_line_ex)
fn Image::draw_line_ex(self : Image, start : Vector2, end_ : Vector2, thick : Int, color : Color) -> Unit

#
Image::draw_line_v

source
#as_free_fn(image_draw_line_v)
fn Image::draw_line_v(self : Image, start : Vector2, end_ : Vector2, color : Color) -> Unit

#
Image::draw_pixel

source
#as_free_fn(image_draw_pixel)
fn Image::draw_pixel(self : Image, pos_x : Int, pos_y : Int, color : Color) -> Unit

#
Image::draw_pixel_v

source
#as_free_fn(image_draw_pixel_v)
fn Image::draw_pixel_v(self : Image, position : Vector2, color : Color) -> Unit

#
Image::draw_rectangle

source
#as_free_fn(image_draw_rectangle)
fn Image::draw_rectangle(self : Image, pos_x : Int, pos_y : Int, width : Int, height : Int, color : Color) -> Unit

#
Image::draw_rectangle_lines

source
#as_free_fn(image_draw_rectangle_lines)
fn Image::draw_rectangle_lines(self : Image, rec : Rectangle, thick : Int, color : Color) -> Unit

#
Image::draw_rectangle_rec

source
#as_free_fn(image_draw_rectangle_rec)
fn Image::draw_rectangle_rec(self : Image, rec : Rectangle, color : Color) -> Unit

#
Image::draw_rectangle_v

source
#as_free_fn(image_draw_rectangle_v)
fn Image::draw_rectangle_v(self : Image, position : Vector2, size : Vector2, color : Color) -> Unit

#
Image::draw_text

source
#as_free_fn(image_draw_text)
fn Image::draw_text(self : Image, text : String, pos_x : Int, pos_y : Int, font_size : Int, color : Color) -> Unit

#
Image::draw_text_ex

source
#as_free_fn(image_draw_text_ex)
fn Image::draw_text_ex(self : Image, font : Font, text : String, position : Vector2, font_size : Float, spacing : Float, tint : Color) -> Unit

#
Image::draw_triangle

source
#as_free_fn(image_draw_triangle)
fn Image::draw_triangle(self : Image, v1 : Vector2, v2 : Vector2, v3 : Vector2, color : Color) -> Unit

#
Image::draw_triangle_ex

source
#as_free_fn(image_draw_triangle_ex)
fn Image::draw_triangle_ex(self : Image, v1 : Vector2, v2 : Vector2, v3 : Vector2, c1 : Color, c2 : Color, c3 : Color) -> Unit

#
Image::draw_triangle_fan

source
#as_free_fn(image_draw_triangle_fan)
fn Image::draw_triangle_fan(self : Image, points : Array[Vector2], color : Color) -> Unit

#
Image::draw_triangle_lines

source
#as_free_fn(image_draw_triangle_lines)
fn Image::draw_triangle_lines(self : Image, v1 : Vector2, v2 : Vector2, v3 : Vector2, color : Color) -> Unit

#
Image::draw_triangle_strip

source
#as_free_fn(image_draw_triangle_strip)
fn Image::draw_triangle_strip(self : Image, points : Array[Vector2], color : Color) -> Unit

#
Image::export_

source
#as_free_fn(export_image)
fn Image::export_(self : Image, file_name : String) -> Bool

#
Image::export_as_code

source
#as_free_fn(export_image_as_code)
fn Image::export_as_code(self : Image, file_name : String) -> Bool

#
Image::export_to_memory

source
#as_free_fn(export_image_to_memory)
fn Image::export_to_memory(self : Image, file_type : String) -> Bytes

#
Image::flip_horizontal

source
#as_free_fn(image_flip_horizontal)
fn Image::flip_horizontal(self : Image) -> Unit

#
Image::flip_vertical

source
#as_free_fn(image_flip_vertical)
fn Image::flip_vertical(self : Image) -> Unit

#
Image::format

source
#as_free_fn(get_image_format)
fn Image::format(self : Image) -> Int

#
Image::from_channel

source
#as_free_fn(image_from_channel)
fn Image::from_channel(self : Image, selected_channel : Int) -> Image

#
Image::from_image

source
#as_free_fn(image_from_image)
fn Image::from_image(self : Image, rec : Rectangle) -> Image

#
Image::gen_cellular

source
#as_free_fn(gen_image_cellular)
fn Image::gen_cellular(width : Int, height : Int, tile_size : Int) -> Image

#
Image::gen_checked

source
#as_free_fn(gen_image_checked)
fn Image::gen_checked(width : Int, height : Int, checks_x : Int, checks_y : Int, col1 : Color, col2 : Color) -> Image

#
Image::gen_color

source
#as_free_fn(gen_image_color)
fn Image::gen_color(width : Int, height : Int, color : Color) -> Image

#
Image::gen_gradient_linear

source
#as_free_fn(gen_image_gradient_linear)
fn Image::gen_gradient_linear(width : Int, height : Int, direction : Int, start : Color, end_ : Color) -> Image

#
Image::gen_gradient_radial

source
#as_free_fn(gen_image_gradient_radial)
fn Image::gen_gradient_radial(width : Int, height : Int, density : Float, inner : Color, outer : Color) -> Image

#
Image::gen_gradient_square

source
#as_free_fn(gen_image_gradient_square)
fn Image::gen_gradient_square(width : Int, height : Int, density : Float, inner : Color, outer : Color) -> Image

#
Image::gen_mipmaps

source
#as_free_fn(image_mipmaps)
fn Image::gen_mipmaps(self : Image) -> Unit

#
Image::gen_perlin_noise

source
#as_free_fn(gen_image_perlin_noise)
fn Image::gen_perlin_noise(width : Int, height : Int, offset_x : Int, offset_y : Int, scale : Float) -> Image

#
Image::gen_text

source
#as_free_fn(gen_image_text)
fn Image::gen_text(width : Int, height : Int, text : String) -> Image

#
Image::gen_white_noise

source
#as_free_fn(gen_image_white_noise)
fn Image::gen_white_noise(width : Int, height : Int, factor : Float) -> Image

#
Image::get_color

source
#as_free_fn(get_image_color)
fn Image::get_color(self : Image, x : Int, y : Int) -> Color

#
Image::height

source
#as_free_fn(image_height, deprecated="Use @raylib.Image::height() instead")
#as_free_fn(get_image_height)
fn Image::height(self : Image) -> Int

#
Image::is_valid

source
#as_free_fn(is_image_valid)
fn Image::is_valid(self : Image) -> Bool

#
Image::kernel_convolution

source
#as_free_fn(image_kernel_convolution)
fn Image::kernel_convolution(self : Image, kernel : Bytes, kernel_size : Int) -> Unit

#
Image::load

source
#as_free_fn(load_image)
fn Image::load(file_name : String) -> Image

#
Image::load_anim

source
fn Image::load_anim(file_name : String) -> (Image, Int)

#
Image::load_anim_from_memory

source
fn Image::load_anim_from_memory(file_type : String, file_data : Bytes, data_size : Int) -> (Image, Int)

#
Image::load_colors

source
#as_free_fn(load_image_colors)
fn Image::load_colors(self : Image) -> Bytes

#
Image::load_from_memory

source
#as_free_fn(load_image_from_memory)
fn Image::load_from_memory(file_type : String, file_data : Bytes, data_size : Int) -> Image

#
Image::load_from_screen

source
#as_free_fn(load_image_from_screen)
fn Image::load_from_screen() -> Image

#
Image::load_from_texture

source
#as_free_fn(load_image_from_texture)
fn Image::load_from_texture(texture : Texture) -> Image

#
Image::load_palette

source
#as_free_fn(load_image_palette)
fn Image::load_palette(self : Image, max_palette_size : Int) -> Bytes

#
Image::load_raw

source
#as_free_fn(load_image_raw)
fn Image::load_raw(file_name : String, width : Int, height : Int, format : Int, header_size : Int) -> Image

#
Image::mipmaps

source
#as_free_fn(get_image_mipmaps)
fn Image::mipmaps(self : Image) -> Int

#
Image::resize

source
#as_free_fn(image_resize)
fn Image::resize(self : Image, new_width : Int, new_height : Int) -> Unit

#
Image::resize_canvas

source
#as_free_fn(image_resize_canvas)
fn Image::resize_canvas(self : Image, new_width : Int, new_height : Int, offset_x : Int, offset_y : Int, fill : Color) -> Unit

#
Image::resize_nn

source
#as_free_fn(image_resize_nn)
fn Image::resize_nn(self : Image, new_width : Int, new_height : Int) -> Unit

#
Image::rotate

source
#as_free_fn(image_rotate)
fn Image::rotate(self : Image, degrees : Int) -> Unit

#
Image::rotate_ccw

source
#as_free_fn(image_rotate_ccw)
fn Image::rotate_ccw(self : Image) -> Unit

#
Image::rotate_cw

source
#as_free_fn(image_rotate_cw)
fn Image::rotate_cw(self : Image) -> Unit

#
Image::set_format

source
#as_free_fn(image_format)
fn Image::set_format(self : Image, new_format : Int) -> Unit

#
Image::text

source
#as_free_fn(image_text)
fn Image::text(text : String, font_size : Int, color : Color) -> Image

#
Image::text_ex

source
#as_free_fn(image_text_ex)
fn Image::text_ex(font : Font, text : String, font_size : Float, spacing : Float, tint : Color) -> Image

#
Image::to_pot

source
#as_free_fn(image_to_pot)
fn Image::to_pot(self : Image, fill : Color) -> Unit

#
Image::to_texture

source
#as_free_fn(load_texture_from_image)
fn Image::to_texture(self : Image) -> Texture

#
Image::to_texture_cubemap

source
#as_free_fn(load_texture_cubemap)
fn Image::to_texture_cubemap(self : Image, layout : Int) -> Texture

#
Image::unload

source
#as_free_fn(unload_image)
fn Image::unload(self : Image) -> Unit

#
Image::width

source
#as_free_fn(image_width, deprecated="Use @raylib.Image::width() instead")
#as_free_fn(get_image_width)
fn Image::width(self : Image) -> Int

#
Material

source
type Material

impl Default for Material

#
Material::is_valid

source
#as_free_fn(is_material_valid)
fn Material::is_valid(self : Material) -> Bool

#
Material::load_default

source
#deprecated("Use Material::default() instead")
#as_free_fn(load_material_default, deprecated="Use Material::default() instead")
fn Material::load_default() -> Material

#
Material::maps

source
#as_free_fn(get_material_maps)
fn Material::maps(self : Material) -> MaterialMapArray

#
Material::set_map_color

source
#as_free_fn(set_material_map_color)
fn Material::set_map_color(self : Material, map_type : Int, color : Color) -> Unit

#
Material::set_map_value

source
#as_free_fn(set_material_map_value)
fn Material::set_map_value(self : Material, map_type : Int, value : Float) -> Unit

#
Material::set_shader

source
#as_free_fn(set_material_shader)
fn Material::set_shader(self : Material, shader : Shader) -> Unit

#
Material::set_texture

source
#as_free_fn(set_material_texture)
fn Material::set_texture(self : Material, map_type : Int, texture : Texture) -> Unit

#
Material::shader

source
#as_free_fn(get_material_shader)
fn Material::shader(self : Material) -> Shader

#
Material::unload

source
#as_free_fn(unload_material)
fn Material::unload(self : Material) -> Unit

#
MaterialMap

source
type MaterialMap

#
MaterialMap::color

source
fn MaterialMap::color(self : MaterialMap) -> Color

#
MaterialMap::set_color

source
fn MaterialMap::set_color(self : MaterialMap, color : Color) -> Unit

#
MaterialMap::set_texture

source
fn MaterialMap::set_texture(self : MaterialMap, texture : Texture) -> Unit

#
MaterialMap::set_value

source
fn MaterialMap::set_value(self : MaterialMap, value : Float) -> Unit

#
MaterialMap::texture

source
fn MaterialMap::texture(self : MaterialMap) -> Texture

#
MaterialMap::value

source
fn MaterialMap::value(self : MaterialMap) -> Float

#
MaterialMapArray

source
type MaterialMapArray

#
MaterialMapArray::count

source
fn MaterialMapArray::count(self : MaterialMapArray) -> Int

#
MaterialMapArray::op_get

source
fn MaterialMapArray::op_get(self : MaterialMapArray, index : Int) -> MaterialMap

#
MaterialMapArray::op_set

source
fn MaterialMapArray::op_set(self : MaterialMapArray, index : Int, value : MaterialMap) -> Unit

#
MaterialsArray

source
type MaterialsArray

#
MaterialsArray::count

source
#as_free_fn(materials_array_count)
fn MaterialsArray::count(self : MaterialsArray) -> Int

#
MaterialsArray::get

source
#as_free_fn(materials_array_get)
fn MaterialsArray::get(self : MaterialsArray, index : Int) -> Material

#
MaterialsArray::load

source
#as_free_fn(load_materials)
fn MaterialsArray::load(file_name : String) -> MaterialsArray

#
MaterialsArray::unload

source
#as_free_fn(unload_materials_array)
fn MaterialsArray::unload(self : MaterialsArray) -> Unit

#
Matrix

source
pub struct Matrix {
  m0 : Float
  m1 : Float
  m2 : Float
  m3 : Float
  m4 : Float
  m5 : Float
  m6 : Float
  m7 : Float
  m8 : Float
  m9 : Float
  m10 : Float
  m11 : Float
  m12 : Float
  m13 : Float
  m14 : Float
  m15 : Float
}

impl Eq for Matrix
impl Show for Matrix

#
Matrix::add

source
fn Matrix::add(left : Matrix, right : Matrix) -> Matrix

#
Matrix::decompose

source
fn Matrix::decompose(mat : Matrix) -> (Vector3, Vector4, Vector3)

#
Matrix::determinant

source
fn Matrix::determinant(mat : Matrix) -> Float

#
Matrix::from_bytes

source
fn Matrix::from_bytes(b : Bytes) -> Matrix

#
Matrix::frustum

source
fn Matrix::frustum(left : Double, right : Double, bottom : Double, top : Double, near_plane : Double, far_plane : Double) -> Matrix

#
Matrix::identity

source
fn Matrix::identity() -> Matrix

#
Matrix::invert

source
fn Matrix::invert(mat : Matrix) -> Matrix

#
Matrix::look_at

source
fn Matrix::look_at(eye : Vector3, target : Vector3, up : Vector3) -> Matrix

#
Matrix::multiply

source
fn Matrix::multiply(left : Matrix, right : Matrix) -> Matrix

#
Matrix::ortho

source
fn Matrix::ortho(left : Double, right : Double, bottom : Double, top : Double, near_plane : Double, far_plane : Double) -> Matrix

#
Matrix::perspective

source
fn Matrix::perspective(fov_y : Double, aspect : Double, near_plane : Double, far_plane : Double) -> Matrix

#
Matrix::rotate

source
fn Matrix::rotate(axis : Vector3, angle : Float) -> Matrix

#
Matrix::rotate_x

source
fn Matrix::rotate_x(angle : Float) -> Matrix

#
Matrix::rotate_xyz

source
fn Matrix::rotate_xyz(angle : Vector3) -> Matrix

#
Matrix::rotate_y

source
fn Matrix::rotate_y(angle : Float) -> Matrix

#
Matrix::rotate_z

source
fn Matrix::rotate_z(angle : Float) -> Matrix

#
Matrix::rotate_zyx

source
fn Matrix::rotate_zyx(angle : Vector3) -> Matrix

#
Matrix::scale

source
fn Matrix::scale(x : Float, y : Float, z : Float) -> Matrix

#
Matrix::subtract

source
fn Matrix::subtract(left : Matrix, right : Matrix) -> Matrix

#
Matrix::to_bytes

source
fn Matrix::to_bytes(m : Matrix) -> Bytes

#
Matrix::trace

source
fn Matrix::trace(mat : Matrix) -> Float

#
Matrix::translate

source
fn Matrix::translate(x : Float, y : Float, z : Float) -> Matrix

#
Matrix::transpose

source
fn Matrix::transpose(mat : Matrix) -> Matrix

#
MatrixArray

source
type MatrixArray

#
MatrixArray::length

source
fn MatrixArray::length(self : MatrixArray) -> Int

#
MatrixArray::op_get

source
fn MatrixArray::op_get(self : MatrixArray, index : Int) -> Matrix

#
MatrixArray::op_set

source
fn MatrixArray::op_set(self : MatrixArray, index : Int, value : Matrix) -> Unit

#
Mesh

source
type Mesh

#
Mesh::bone_matrices

source
#as_free_fn(get_mesh_bone_matrices)
fn Mesh::bone_matrices(self : Mesh) -> MatrixArray?

#
Mesh::bounding_box

source
#as_free_fn(get_mesh_bounding_box)
fn Mesh::bounding_box(self : Mesh) -> BoundingBox

#
Mesh::colors

source
#as_free_fn(get_mesh_colors)
fn Mesh::colors(self : Mesh) -> UByteArray?

#
Mesh::draw

source
#as_free_fn(draw_mesh)
fn Mesh::draw(self : Mesh, material : Material, transform : Matrix) -> Unit

#
Mesh::draw_instanced

source
#as_free_fn(draw_mesh_instanced)
fn Mesh::draw_instanced(self : Mesh, material : Material, transforms : Array[Matrix], instances : Int) -> Unit

#
Mesh::export_

source
#as_free_fn(export_mesh)
fn Mesh::export_(self : Mesh, file_name : String) -> Bool

#
Mesh::export_as_code

source
#as_free_fn(export_mesh_as_code)
fn Mesh::export_as_code(self : Mesh, file_name : String) -> Bool

#
Mesh::gen_cone

source
#as_free_fn(gen_mesh_cone)
fn Mesh::gen_cone(radius : Float, height : Float, slices : Int) -> Mesh

#
Mesh::gen_cube

source
#as_free_fn(gen_mesh_cube)
fn Mesh::gen_cube(width : Float, height : Float, length : Float) -> Mesh

#
Mesh::gen_cubicmap

source
#as_free_fn(gen_mesh_cubicmap)
fn Mesh::gen_cubicmap(cubicmap : Image, cube_size : Vector3) -> Mesh

#
Mesh::gen_cylinder

source
#as_free_fn(gen_mesh_cylinder)
fn Mesh::gen_cylinder(radius : Float, height : Float, slices : Int) -> Mesh

#
Mesh::gen_from_points

source
#as_free_fn(gen_mesh_from_points)
fn Mesh::gen_from_points(vertices : Bytes, colors : Bytes, num_points : Int) -> Mesh

#
Mesh::gen_heightmap

source
#as_free_fn(gen_mesh_heightmap)
fn Mesh::gen_heightmap(heightmap : Image, size : Vector3) -> Mesh

#
Mesh::gen_hemisphere

source
#as_free_fn(gen_mesh_hemisphere)
fn Mesh::gen_hemisphere(radius : Float, rings : Int, slices : Int) -> Mesh

#
Mesh::gen_knot

source
#as_free_fn(gen_mesh_knot)
fn Mesh::gen_knot(radius : Float, size : Float, rad_seg : Int, sides : Int) -> Mesh

#
Mesh::gen_plane

source
#as_free_fn(gen_mesh_plane)
fn Mesh::gen_plane(width : Float, length : Float, res_x : Int, res_z : Int) -> Mesh

#
Mesh::gen_poly

source
#as_free_fn(gen_mesh_poly)
fn Mesh::gen_poly(sides : Int, radius : Float) -> Mesh

#
Mesh::gen_sphere

source
#as_free_fn(gen_mesh_sphere)
fn Mesh::gen_sphere(radius : Float, rings : Int, slices : Int) -> Mesh

#
Mesh::gen_tangents

source
#as_free_fn(gen_mesh_tangents)
fn Mesh::gen_tangents(self : Mesh) -> Unit

#
Mesh::gen_torus

source
#as_free_fn(gen_mesh_torus)
fn Mesh::gen_torus(radius : Float, size : Float, rad_seg : Int, sides : Int) -> Mesh

#
Mesh::indices

source
#as_free_fn(get_mesh_indices)
fn Mesh::indices(self : Mesh) -> UShortArray?

#
Mesh::new

source
fn Mesh::new(vertices : FixedArray[Float], texcoords? : FixedArray[Float], texcoords2? : FixedArray[Float], normals? : FixedArray[Float], tangents? : FixedArray[Float], colors? : FixedArray[Byte], indices? : FixedArray[UInt16]) -> Mesh

#
Mesh::normals

source
#as_free_fn(get_mesh_normals)
fn Mesh::normals(self : Mesh) -> FloatArray?

#
Mesh::tangents

source
#as_free_fn(get_mesh_tangents)
fn Mesh::tangents(self : Mesh) -> FloatArray?

#
Mesh::texcoords

source
#as_free_fn(get_mesh_texcoords)
fn Mesh::texcoords(self : Mesh) -> FloatArray?

#
Mesh::texcoords2

source
#as_free_fn(get_mesh_texcoords2)
fn Mesh::texcoords2(self : Mesh) -> FloatArray?

#
Mesh::triangle_count

source
#as_free_fn(get_mesh_triangle_count)
fn Mesh::triangle_count(self : Mesh) -> Int

#
Mesh::unload

source
#as_free_fn(unload_mesh)
fn Mesh::unload(self : Mesh) -> Unit

#
Mesh::update_buffer

source
#as_free_fn(update_mesh_buffer)
fn Mesh::update_buffer(self : Mesh, index : Int, data : Bytes, data_size : Int, offset : Int) -> Unit

#
Mesh::upload

source
fn Mesh::upload(self : Mesh, dynamic : Bool) -> Unit

#
Mesh::vertex_count

source
#as_free_fn(get_mesh_vertex_count)
fn Mesh::vertex_count(self : Mesh) -> Int

#
Mesh::vertices

source
#as_free_fn(get_mesh_vertices)
fn Mesh::vertices(self : Mesh) -> FloatArray?

#
Model

source
type Model

#
Model::bind_pose_rotation

source
#as_free_fn(get_model_bind_pose_rotation)
fn Model::bind_pose_rotation(self : Model, bone_index : Int) -> Vector4

#
Model::bind_pose_translation

source
#as_free_fn(get_model_bind_pose_translation)
fn Model::bind_pose_translation(self : Model, bone_index : Int) -> Vector3

#
Model::bone_count

source
#as_free_fn(get_model_bone_count)
fn Model::bone_count(self : Model) -> Int

#
Model::bone_name

source
#as_free_fn(get_model_bone_name)
fn Model::bone_name(self : Model, bone_index : Int) -> String

#
Model::bone_parent

source
#as_free_fn(get_model_bone_parent)
fn Model::bone_parent(self : Model, bone_index : Int) -> Int

#
Model::bounding_box

source
#as_free_fn(get_model_bounding_box)
fn Model::bounding_box(self : Model) -> BoundingBox

#
Model::draw

source
#as_free_fn(draw_model)
fn Model::draw(self : Model, position : Vector3, scale : Float, tint : Color) -> Unit

#
Model::draw_ex

source
#as_free_fn(draw_model_ex)
fn Model::draw_ex(self : Model, position : Vector3, rotation_axis : Vector3, rotation_angle : Float, scale : Vector3, tint : Color) -> Unit

#
Model::draw_points

source
#as_free_fn(draw_model_points)
fn Model::draw_points(self : Model, position : Vector3, scale : Float, tint : Color) -> Unit

#
Model::draw_points_ex

source
#as_free_fn(draw_model_points_ex)
fn Model::draw_points_ex(self : Model, position : Vector3, rotation_axis : Vector3, rotation_angle : Float, scale : Vector3, tint : Color) -> Unit

#
Model::draw_wires

source
#as_free_fn(draw_model_wires)
fn Model::draw_wires(self : Model, position : Vector3, scale : Float, tint : Color) -> Unit

#
Model::draw_wires_ex

source
#as_free_fn(draw_model_wires_ex)
fn Model::draw_wires_ex(self : Model, position : Vector3, rotation_axis : Vector3, rotation_angle : Float, scale : Vector3, tint : Color) -> Unit

#
Model::is_animation_valid

source
#as_free_fn(is_model_animation_valid)
fn Model::is_animation_valid(self : Model, anims : ModelAnimations, index : Int) -> Bool

#
Model::is_valid

source
#as_free_fn(is_model_valid)
fn Model::is_valid(self : Model) -> Bool

#
Model::load

source
#as_free_fn(load_model)
fn Model::load(file_name : String) -> Model

#
Model::load_from_mesh

source
#as_free_fn(load_model_from_mesh)
fn Model::load_from_mesh(mesh : Mesh) -> Model

#
Model::material

source
#as_free_fn(get_model_material)
fn Model::material(self : Model, index : Int) -> Material

#
Model::material_count

source
#as_free_fn(get_model_material_count)
fn Model::material_count(self : Model) -> Int

#
Model::mesh

source
#as_free_fn(get_model_mesh)
fn Model::mesh(self : Model, index : Int) -> Mesh

#
Model::mesh_count

source
#as_free_fn(get_model_mesh_count)
fn Model::mesh_count(self : Model) -> Int

#
Model::set_material_shader

source
#as_free_fn(set_model_material_shader)
fn Model::set_material_shader(self : Model, material_index : Int, shader : Shader) -> Unit

#
Model::set_material_texture

source
#as_free_fn(set_model_material_texture)
fn Model::set_material_texture(self : Model, material_index : Int, map_type : Int, texture : Texture) -> Unit

#
Model::set_mesh_material

source
#as_free_fn(set_model_mesh_material)
fn Model::set_mesh_material(self : Model, mesh_id : Int, material_id : Int) -> Unit

#
Model::set_transform

source
#as_free_fn(set_model_transform)
fn Model::set_transform(self : Model, transform : Matrix) -> Unit

#
Model::transform

source
#as_free_fn(get_model_transform)
fn Model::transform(self : Model) -> Matrix

#
Model::unload

source
#as_free_fn(unload_model)
fn Model::unload(self : Model) -> Unit

#
Model::update_animation

source
#as_free_fn(update_model_animation)
fn Model::update_animation(self : Model, anims : ModelAnimations, index : Int, frame : Int) -> Unit

#
Model::update_animation_bones

source
#as_free_fn(update_model_animation_bones)
fn Model::update_animation_bones(self : Model, anims : ModelAnimations, index : Int, frame : Int) -> Unit

#
ModelAnimations

source
type ModelAnimations

#
ModelAnimations::bone_count

source
#as_free_fn(get_model_animation_bone_count)
fn ModelAnimations::bone_count(self : ModelAnimations, anim_index : Int) -> Int

#
ModelAnimations::bone_parent

source
#as_free_fn(get_model_animation_bone_parent)
fn ModelAnimations::bone_parent(self : ModelAnimations, anim_index : Int, bone_index : Int) -> Int

#
ModelAnimations::count

source
#as_free_fn(model_animations_count)
fn ModelAnimations::count(self : ModelAnimations) -> Int

#
ModelAnimations::frame_count

source
#as_free_fn(get_model_animation_frame_count)
fn ModelAnimations::frame_count(self : ModelAnimations, anim_index : Int) -> Int

#
ModelAnimations::frame_pose_rotation

source
#as_free_fn(get_model_animation_frame_pose_rotation)
fn ModelAnimations::frame_pose_rotation(self : ModelAnimations, anim_index : Int, frame : Int, bone_index : Int) -> Vector4

#
ModelAnimations::frame_pose_translation

source
#as_free_fn(get_model_animation_frame_pose_translation)
fn ModelAnimations::frame_pose_translation(self : ModelAnimations, anim_index : Int, frame : Int, bone_index : Int) -> Vector3

#
ModelAnimations::load

source
#as_free_fn(load_model_animations)
fn ModelAnimations::load(file_name : String) -> ModelAnimations

#
ModelAnimations::unload

source
#as_free_fn(unload_model_animations)
fn ModelAnimations::unload(self : ModelAnimations) -> Unit

#
Music

source
type Music

#
Music::is_playing

source
#as_free_fn(is_music_stream_playing)
fn Music::is_playing(self : Music) -> Bool

#
Music::is_valid

source
#as_free_fn(is_music_valid)
fn Music::is_valid(self : Music) -> Bool

#
Music::load

source
#as_free_fn(load_music_stream)
fn Music::load(file_name : String) -> Music

#
Music::load_from_memory

source
#as_free_fn(load_music_stream_from_memory)
fn Music::load_from_memory(file_type : String, data : Bytes, data_size : Int) -> Music

#
Music::pause

source
#as_free_fn(pause_music_stream)
fn Music::pause(self : Music) -> Unit

#
Music::play

source
#as_free_fn(play_music_stream)
fn Music::play(self : Music) -> Unit

#
Music::resume_

source
#as_free_fn(resume_music_stream)
fn Music::resume_(self : Music) -> Unit

#
Music::seek

source
#as_free_fn(seek_music_stream)
fn Music::seek(self : Music, position : Float) -> Unit

#
Music::set_pan

source
#as_free_fn(set_music_pan)
fn Music::set_pan(self : Music, pan : Float) -> Unit

#
Music::set_pitch

source
#as_free_fn(set_music_pitch)
fn Music::set_pitch(self : Music, pitch : Float) -> Unit

#
Music::set_volume

source
#as_free_fn(set_music_volume)
fn Music::set_volume(self : Music, volume : Float) -> Unit

#
Music::stop

source
#as_free_fn(stop_music_stream)
fn Music::stop(self : Music) -> Unit

#
Music::time_length

source
#as_free_fn(get_music_time_length)
fn Music::time_length(self : Music) -> Float

#
Music::time_played

source
#as_free_fn(get_music_time_played)
fn Music::time_played(self : Music) -> Float

#
Music::unload

source
#as_free_fn(unload_music_stream)
fn Music::unload(self : Music) -> Unit

#
Music::update

source
#as_free_fn(update_music_stream)
fn Music::update(self : Music) -> Unit

#
NPatchInfo

source
pub struct NPatchInfo {
  source : Rectangle
  left : Int
  top : Int
  right : Int
  bottom : Int
  layout : Int
}

impl Eq for NPatchInfo
impl Show for NPatchInfo

#
NPatchInfo::from_bytes

source
fn NPatchInfo::from_bytes(b : Bytes) -> NPatchInfo

#
NPatchInfo::new

source
fn NPatchInfo::new(source : Rectangle, left : Int, top : Int, right : Int, bottom : Int, layout : Int) -> NPatchInfo

#
NPatchInfo::to_bytes

source
fn NPatchInfo::to_bytes(n : NPatchInfo) -> Bytes

#
Ray

source
pub struct Ray {
  position : Vector3
  direction : Vector3
}

impl Eq for Ray
impl Show for Ray

#
Ray::from_bytes

source
fn Ray::from_bytes(b : Bytes) -> Ray

#
Ray::new

source
fn Ray::new(position : Vector3, direction : Vector3) -> Ray

#
Ray::to_bytes

source
fn Ray::to_bytes(r : Ray) -> Bytes

#
RayCollision

source
pub struct RayCollision {
  hit : Bool
  distance : Float
  point : Vector3
  normal : Vector3
}

impl Eq for RayCollision

#
RayCollision::from_bytes

source
fn RayCollision::from_bytes(b : Bytes) -> RayCollision

#
RayCollision::new

source
fn RayCollision::new(hit : Bool, distance : Float, point : Vector3, normal : Vector3) -> RayCollision

#
Rectangle

source
pub struct Rectangle {
  x : Float
  y : Float
  width : Float
  height : Float
}

impl Eq for Rectangle
impl Show for Rectangle

#
Rectangle::from_bytes

source
fn Rectangle::from_bytes(b : Bytes) -> Rectangle

#
Rectangle::new

source
fn Rectangle::new(x : Float, y : Float, width : Float, height : Float) -> Rectangle

#
Rectangle::to_bytes

source
fn Rectangle::to_bytes(r : Rectangle) -> Bytes

#
RenderTexture

source
type RenderTexture

#
RenderTexture::begin_mode

source
#as_free_fn(begin_texture_mode)
fn RenderTexture::begin_mode(self : RenderTexture) -> Unit

#
RenderTexture::depth

source
#as_free_fn(get_render_texture_depth)
fn RenderTexture::depth(self : RenderTexture) -> Texture

#
RenderTexture::depth_id

source
#as_free_fn(get_render_texture_depth_id)
fn RenderTexture::depth_id(self : RenderTexture) -> UInt

#
RenderTexture::draw_ex

source
#as_free_fn(draw_render_texture_ex)
fn RenderTexture::draw_ex(self : RenderTexture, position : Vector2, rotation : Float, scale : Float, tint : Color) -> Unit

#
RenderTexture::draw_pro

source
#as_free_fn(draw_render_texture_pro)
fn RenderTexture::draw_pro(self : RenderTexture, source : Rectangle, dest : Rectangle, origin : Vector2, rotation : Float, tint : Color) -> Unit

#
RenderTexture::draw_rec

source
#as_free_fn(draw_render_texture_rec)
fn RenderTexture::draw_rec(self : RenderTexture, source : Rectangle, position : Vector2, tint : Color) -> Unit

#
RenderTexture::fbo_id

source
#deprecated("Use RenderTexture::id instead")
#as_free_fn(get_render_texture_fbo_id, deprecated="Use RenderTexture::id instead")
fn RenderTexture::fbo_id(self : RenderTexture) -> UInt

#
RenderTexture::height

source
#as_free_fn(get_render_texture_height)
fn RenderTexture::height(self : RenderTexture) -> Int

#
RenderTexture::id

source
#as_free_fn(get_render_texture_id)
fn RenderTexture::id(self : RenderTexture) -> UInt

#
RenderTexture::is_valid

source
#as_free_fn(is_render_texture_valid)
fn RenderTexture::is_valid(self : RenderTexture) -> Bool

#
RenderTexture::load

source
#as_free_fn(load_render_texture)
fn RenderTexture::load(width : Int, height : Int) -> RenderTexture

#
RenderTexture::load_depth_tex

source
#deprecated("Use RenderTexture::new with @rl helpers instead")
#as_free_fn(load_render_texture_depth_tex, deprecated="Use RenderTexture::new with @rl helpers instead")
fn RenderTexture::load_depth_tex(width : Int, height : Int) -> RenderTexture

Load a render texture with a depth texture attachment. @deprecated Use RenderTexture::new with @rl.load_framebuffer, @rl.load_texture, @rl.load_texture_depth, and @rl.framebuffer_attach instead.

#
RenderTexture::load_shadowmap

source
#deprecated("Use RenderTexture::new with @rl helpers instead")
#as_free_fn(load_shadowmap_render_texture, deprecated="Use RenderTexture::new with @rl helpers instead")
fn RenderTexture::load_shadowmap(width : Int, height : Int) -> RenderTexture

Load a depth-only shadowmap render texture. @deprecated Use RenderTexture::new with @rl.load_framebuffer, @rl.load_texture_depth, and @rl.framebuffer_attach instead.

#
RenderTexture::new

source
#as_free_fn(new_render_texture)
fn RenderTexture::new(id : UInt, texture : Texture, depth : Texture) -> RenderTexture

#
RenderTexture::set_filter

source
#as_free_fn(set_render_texture_filter)
fn RenderTexture::set_filter(self : RenderTexture, filter : Int) -> Unit

#
RenderTexture::texture

source
#as_free_fn(get_render_texture_texture)
fn RenderTexture::texture(self : RenderTexture) -> Texture

#
RenderTexture::unload

source
#as_free_fn(unload_render_texture)
fn RenderTexture::unload(self : RenderTexture) -> Unit

#
RenderTexture::unload_depth_tex

source
#deprecated("Use RenderTexture::unload instead")
#as_free_fn(unload_render_texture_depth_tex, deprecated="Use RenderTexture::unload instead")
fn RenderTexture::unload_depth_tex(self : RenderTexture) -> Unit

Unload a depth-texture render texture. @deprecated Use RenderTexture::unload instead.

#
RenderTexture::unload_shadowmap

source
#deprecated("Use RenderTexture::unload instead")
#as_free_fn(unload_shadowmap_render_texture, deprecated="Use RenderTexture::unload instead")
fn RenderTexture::unload_shadowmap(self : RenderTexture) -> Unit

Unload a shadowmap render texture. @deprecated Use RenderTexture::unload instead.

#
RenderTexture::width

source
#as_free_fn(get_render_texture_width)
fn RenderTexture::width(self : RenderTexture) -> Int

#
Shader

source
type Shader

#
Shader::begin_mode

source
#as_free_fn(begin_shader_mode)
fn Shader::begin_mode(self : Shader) -> Unit

#
Shader::get_location

source
#as_free_fn(get_shader_location)
fn Shader::get_location(self : Shader, uniform_name : String) -> Int

#
Shader::get_location_attrib

source
#as_free_fn(get_shader_location_attrib)
fn Shader::get_location_attrib(self : Shader, attrib_name : String) -> Int

#
Shader::id

source
#as_free_fn(get_shader_id)
fn Shader::id(self : Shader) -> UInt

#
Shader::is_valid

source
#as_free_fn(is_shader_valid)
fn Shader::is_valid(self : Shader) -> Bool

#
Shader::load

source
#as_free_fn(load_shader)
fn Shader::load(vs_file_name : String, fs_file_name : String) -> Shader

#
Shader::load_from_memory

source
#as_free_fn(load_shader_from_memory)
fn Shader::load_from_memory(vs_code : String, fs_code : String) -> Shader

#
Shader::set_locs

source
#as_free_fn(set_shader_locs)
#as_free_fn(set_shader_location, deprecated="Use Shader::set_locs or set_shader_locs instead")
fn Shader::set_locs(self : Shader, loc_index : Int, loc_value : Int) -> Unit

#
Shader::set_value

source
fn Shader::set_value(self : Shader, loc_index : Int, value : ShaderUniformData) -> Unit

#
Shader::set_value_matrix

source
#as_free_fn(set_shader_value_matrix)
fn Shader::set_value_matrix(self : Shader, loc_index : Int, mat : Matrix) -> Unit

#
Shader::set_value_texture

source
#as_free_fn(set_shader_value_texture)
fn Shader::set_value_texture(self : Shader, loc_index : Int, texture : Texture) -> Unit

#
Shader::set_value_v

source
fn Shader::set_value_v(self : Shader, loc_index : Int, values : ShaderUniformDataV) -> Unit

#
Shader::unload

source
#as_free_fn(unload_shader)
fn Shader::unload(self : Shader) -> Unit

#
ShaderUniformData

source
pub(all) enum ShaderUniformData {
  Float(Float)
  Vec2(Vector2)
  Vec3(Vector3)
  Vec4(Vector4)
  Int(Int)
  IVec2((Int, Int))
  IVec3((Int, Int, Int))
  IVec4((Int, Int, Int, Int))
  Sampler2D(Int)
}

#
ShaderUniformDataV

source
pub(all) enum ShaderUniformDataV {
  Float(Array[Float])
  Vec2(Array[Vector2])
  Vec3(Array[Vector3])
  Vec4(Array[Vector4])
  Int(Array[Int])
  IVec2(Array[(Int, Int)])
  IVec3(Array[(Int, Int, Int)])
  IVec4(Array[(Int, Int, Int, Int)])
  Sampler2D(Array[Int])
}

#
Sound

source
type Sound

#
Sound::is_playing

source
#as_free_fn(is_sound_playing)
fn Sound::is_playing(self : Sound) -> Bool

#
Sound::is_valid

source
#as_free_fn(is_sound_valid)
fn Sound::is_valid(self : Sound) -> Bool

#
Sound::load

source
#as_free_fn(load_sound)
fn Sound::load(file_name : String) -> Sound

#
Sound::load_alias

source
#as_free_fn(load_sound_alias)
fn Sound::load_alias(self : Sound) -> Sound

#
Sound::pause

source
#as_free_fn(pause_sound)
fn Sound::pause(self : Sound) -> Unit

#
Sound::play

source
#as_free_fn(play_sound)
fn Sound::play(self : Sound) -> Unit

#
Sound::resume_

source
#as_free_fn(resume_sound)
fn Sound::resume_(self : Sound) -> Unit

#
Sound::set_pan

source
#as_free_fn(set_sound_pan)
fn Sound::set_pan(self : Sound, pan : Float) -> Unit

#
Sound::set_pitch

source
#as_free_fn(set_sound_pitch)
fn Sound::set_pitch(self : Sound, pitch : Float) -> Unit

#
Sound::set_volume

source
#as_free_fn(set_sound_volume)
fn Sound::set_volume(self : Sound, volume : Float) -> Unit

#
Sound::stop

source
#as_free_fn(stop_sound)
fn Sound::stop(self : Sound) -> Unit

#
Sound::unload

source
#as_free_fn(unload_sound)
fn Sound::unload(self : Sound) -> Unit

#
Sound::unload_alias

source
#as_free_fn(unload_sound_alias)
fn Sound::unload_alias(self : Sound) -> Unit

#
Sound::update

source
#as_free_fn(update_sound)
fn Sound::update(self : Sound, data : Bytes, sample_count : Int) -> Unit

#
Texture

source
type Texture

#
Texture::draw

source
#as_free_fn(draw_texture)
fn Texture::draw(self : Texture, pos_x : Int, pos_y : Int, tint : Color) -> Unit

#
Texture::draw_ex

source
#as_free_fn(draw_texture_ex)
fn Texture::draw_ex(self : Texture, position : Vector2, rotation : Float, scale : Float, tint : Color) -> Unit

#
Texture::draw_npatch

source
#as_free_fn(draw_texture_npatch)
fn Texture::draw_npatch(self : Texture, npatch_info : NPatchInfo, dest : Rectangle, origin : Vector2, rotation : Float, tint : Color) -> Unit

#
Texture::draw_pro

source
#as_free_fn(draw_texture_pro)
fn Texture::draw_pro(self : Texture, source : Rectangle, dest : Rectangle, origin : Vector2, rotation : Float, tint : Color) -> Unit

#
Texture::draw_rec

source
#as_free_fn(draw_texture_rec)
fn Texture::draw_rec(self : Texture, source : Rectangle, position : Vector2, tint : Color) -> Unit

#
Texture::draw_v

source
#as_free_fn(draw_texture_v)
fn Texture::draw_v(self : Texture, position : Vector2, tint : Color) -> Unit

#
Texture::format

source
#as_free_fn(get_texture_format)
fn Texture::format(self : Texture) -> Int

#
Texture::from_id

source
#deprecated("Use Texture::new instead")
#as_free_fn(texture_from_id, deprecated="Use Texture::new instead")
fn Texture::from_id(id : UInt, width : Int, height : Int) -> Texture

#
Texture::gen_mipmaps

source
#as_free_fn(gen_texture_mipmaps)
fn Texture::gen_mipmaps(self : Texture) -> Unit

#
Texture::get_shapes

source
#as_free_fn(get_shapes_texture)
fn Texture::get_shapes() -> Texture

#
Texture::height

source
#as_free_fn(get_texture_height)
fn Texture::height(self : Texture) -> Int

#
Texture::id

source
#as_free_fn(get_texture_id)
fn Texture::id(self : Texture) -> UInt

#
Texture::is_valid

source
#as_free_fn(is_texture_valid)
fn Texture::is_valid(self : Texture) -> Bool

#
Texture::load

source
#as_free_fn(load_texture)
fn Texture::load(file_name : String) -> Texture

#
Texture::mipmaps

source
#as_free_fn(get_texture_mipmaps)
fn Texture::mipmaps(self : Texture) -> Int

#
Texture::new

source
#as_free_fn(new_texture)
fn Texture::new(id : UInt, width : Int, height : Int, mipmaps : Int, format : Int) -> Texture

#
Texture::set_filter

source
#as_free_fn(set_texture_filter)
fn Texture::set_filter(self : Texture, filter : Int) -> Unit

#
Texture::set_shapes

source
#as_free_fn(set_shapes_texture)
fn Texture::set_shapes(self : Texture, source : Rectangle) -> Unit

#
Texture::set_wrap

source
#as_free_fn(set_texture_wrap)
fn Texture::set_wrap(self : Texture, wrap : Int) -> Unit

#
Texture::unload

source
#as_free_fn(unload_texture)
fn Texture::unload(self : Texture) -> Unit

#
Texture::update

source
#as_free_fn(update_texture)
fn Texture::update(self : Texture, pixels : Bytes) -> Unit

#
Texture::update_from_image_frame

source
#as_free_fn(update_texture_from_image_frame)
fn Texture::update_from_image_frame(self : Texture, image : Image, frame : Int) -> Unit

#
Texture::update_rec

source
#as_free_fn(update_texture_rec)
fn Texture::update_rec(self : Texture, rec : Rectangle, pixels : Bytes) -> Unit

#
Texture::width

source
#as_free_fn(get_texture_width)
fn Texture::width(self : Texture) -> Int

#
UByteArray

source
type UByteArray

#
UByteArray::length

source
fn UByteArray::length(self : UByteArray) -> Int

#
UByteArray::op_get

source
fn UByteArray::op_get(self : UByteArray, index : Int) -> Int

#
UByteArray::op_set

source
fn UByteArray::op_set(self : UByteArray, index : Int, value : Byte) -> Unit

#
UShortArray

source
type UShortArray

#
UShortArray::length

source
fn UShortArray::length(self : UShortArray) -> Int

#
UShortArray::op_get

source
fn UShortArray::op_get(self : UShortArray, index : Int) -> Int

#
UShortArray::op_set

source
fn UShortArray::op_set(self : UShortArray, index : Int, value : UInt16) -> Unit

#
Vector2

source
pub struct Vector2 {
  x : Float
  y : Float
}

impl Eq for Vector2
impl Show for Vector2

#
Vector2::add

source
fn Vector2::add(v1 : Vector2, v2 : Vector2) -> Vector2

#
Vector2::add_value

source
fn Vector2::add_value(v : Vector2, add : Float) -> Vector2

#
Vector2::angle

source
fn Vector2::angle(v1 : Vector2, v2 : Vector2) -> Float

#
Vector2::clamp

source
fn Vector2::clamp(v : Vector2, min : Vector2, max : Vector2) -> Vector2

#
Vector2::clamp_value

source
fn Vector2::clamp_value(v : Vector2, min : Float, max : Float) -> Vector2

#
Vector2::distance

source
fn Vector2::distance(v1 : Vector2, v2 : Vector2) -> Float

#
Vector2::distance_sqr

source
fn Vector2::distance_sqr(v1 : Vector2, v2 : Vector2) -> Float

#
Vector2::divide

source
fn Vector2::divide(v1 : Vector2, v2 : Vector2) -> Vector2

#
Vector2::dot_product

source
fn Vector2::dot_product(v1 : Vector2, v2 : Vector2) -> Float

#
Vector2::equals

source
fn Vector2::equals(p : Vector2, q : Vector2) -> Bool

#
Vector2::from_bytes

source
fn Vector2::from_bytes(b : Bytes) -> Vector2

#
Vector2::invert

source
fn Vector2::invert(v : Vector2) -> Vector2

#
Vector2::length

source
fn Vector2::length(v : Vector2) -> Float

#
Vector2::length_sqr

source
fn Vector2::length_sqr(v : Vector2) -> Float

#
Vector2::lerp

source
fn Vector2::lerp(v1 : Vector2, v2 : Vector2, amount : Float) -> Vector2

#
Vector2::line_angle

source
fn Vector2::line_angle(start : Vector2, end_ : Vector2) -> Float

#
Vector2::max

source
fn Vector2::max(v1 : Vector2, v2 : Vector2) -> Vector2

#
Vector2::min

source
fn Vector2::min(v1 : Vector2, v2 : Vector2) -> Vector2

#
Vector2::move_towards

source
fn Vector2::move_towards(v : Vector2, target : Vector2, max_distance : Float) -> Vector2

#
Vector2::multiply

source
fn Vector2::multiply(v1 : Vector2, v2 : Vector2) -> Vector2

#
Vector2::negate

source
fn Vector2::negate(v : Vector2) -> Vector2

#
Vector2::new

source
fn Vector2::new(x : Float, y : Float) -> Vector2

#
Vector2::normalize

source
fn Vector2::normalize(v : Vector2) -> Vector2

#
Vector2::one

source
fn Vector2::one() -> Vector2

#
Vector2::reflect

source
fn Vector2::reflect(v : Vector2, normal : Vector2) -> Vector2

#
Vector2::refract

source
fn Vector2::refract(v : Vector2, n : Vector2, r : Float) -> Vector2

#
Vector2::rotate

source
fn Vector2::rotate(v : Vector2, angle : Float) -> Vector2

#
Vector2::scale

source
fn Vector2::scale(v : Vector2, scale : Float) -> Vector2

#
Vector2::subtract

source
fn Vector2::subtract(v1 : Vector2, v2 : Vector2) -> Vector2

#
Vector2::subtract_value

source
fn Vector2::subtract_value(v : Vector2, sub : Float) -> Vector2

#
Vector2::to_bytes

source
fn Vector2::to_bytes(v : Vector2) -> Bytes

#
Vector2::transform

source
fn Vector2::transform(v : Vector2, mat : Matrix) -> Vector2

#
Vector2::zero

source
fn Vector2::zero() -> Vector2

#
Vector3

source
pub struct Vector3 {
  x : Float
  y : Float
  z : Float
}

impl Eq for Vector3
impl Show for Vector3

#
Vector3::add

source
fn Vector3::add(v1 : Vector3, v2 : Vector3) -> Vector3

#
Vector3::add_value

source
fn Vector3::add_value(v : Vector3, add : Float) -> Vector3

#
Vector3::angle

source
fn Vector3::angle(v1 : Vector3, v2 : Vector3) -> Float

#
Vector3::barycenter

source
fn Vector3::barycenter(p : Vector3, a : Vector3, b : Vector3, c : Vector3) -> Vector3

#
Vector3::clamp

source
fn Vector3::clamp(v : Vector3, min : Vector3, max : Vector3) -> Vector3

#
Vector3::cross_product

source
fn Vector3::cross_product(v1 : Vector3, v2 : Vector3) -> Vector3

#
Vector3::distance

source
fn Vector3::distance(v1 : Vector3, v2 : Vector3) -> Float

#
Vector3::distance_sqr

source
fn Vector3::distance_sqr(v1 : Vector3, v2 : Vector3) -> Float

#
Vector3::dot_product

source
fn Vector3::dot_product(v1 : Vector3, v2 : Vector3) -> Float

#
Vector3::equals

source
fn Vector3::equals(p : Vector3, q : Vector3) -> Bool

#
Vector3::from_bytes

source
fn Vector3::from_bytes(b : Bytes) -> Vector3

#
Vector3::invert

source
fn Vector3::invert(v : Vector3) -> Vector3

#
Vector3::length

source
fn Vector3::length(v : Vector3) -> Float

#
Vector3::length_sqr

source
fn Vector3::length_sqr(v : Vector3) -> Float

#
Vector3::lerp

source
fn Vector3::lerp(v1 : Vector3, v2 : Vector3, amount : Float) -> Vector3

#
Vector3::max

source
fn Vector3::max(v1 : Vector3, v2 : Vector3) -> Vector3

#
Vector3::min

source
fn Vector3::min(v1 : Vector3, v2 : Vector3) -> Vector3

#
Vector3::move_towards

source
fn Vector3::move_towards(v : Vector3, target : Vector3, max_distance : Float) -> Vector3

#
Vector3::multiply

source
fn Vector3::multiply(v1 : Vector3, v2 : Vector3) -> Vector3

#
Vector3::new

source
fn Vector3::new(x : Float, y : Float, z : Float) -> Vector3

#
Vector3::normalize

source
fn Vector3::normalize(v : Vector3) -> Vector3

#
Vector3::one

source
fn Vector3::one() -> Vector3

#
Vector3::ortho_normalize

source
fn Vector3::ortho_normalize(v1 : Vector3, v2 : Vector3) -> (Vector3, Vector3)

#
Vector3::perpendicular

source
fn Vector3::perpendicular(v : Vector3) -> Vector3

#
Vector3::project

source
fn Vector3::project(v1 : Vector3, v2 : Vector3) -> Vector3

#
Vector3::reflect

source
fn Vector3::reflect(v : Vector3, normal : Vector3) -> Vector3

#
Vector3::refract

source
fn Vector3::refract(v : Vector3, n : Vector3, r : Float) -> Vector3

#
Vector3::reject

source
fn Vector3::reject(v1 : Vector3, v2 : Vector3) -> Vector3

#
Vector3::rotate_by_axis_angle

source
fn Vector3::rotate_by_axis_angle(v : Vector3, axis : Vector3, angle : Float) -> Vector3

#
Vector3::rotate_by_quaternion

source
fn Vector3::rotate_by_quaternion(v : Vector3, q : Vector4) -> Vector3

#
Vector3::scale

source
fn Vector3::scale(v : Vector3, scalar : Float) -> Vector3

#
Vector3::subtract

source
fn Vector3::subtract(v1 : Vector3, v2 : Vector3) -> Vector3

#
Vector3::subtract_value

source
fn Vector3::subtract_value(v : Vector3, sub : Float) -> Vector3

#
Vector3::to_bytes

source
fn Vector3::to_bytes(v : Vector3) -> Bytes

#
Vector3::transform

source
fn Vector3::transform(v : Vector3, mat : Matrix) -> Vector3

#
Vector3::unproject

source
fn Vector3::unproject(source : Vector3, projection : Matrix, view : Matrix) -> Vector3

#
Vector3::zero

source
fn Vector3::zero() -> Vector3

#
Vector4

source
pub struct Vector4 {
  x : Float
  y : Float
  z : Float
  w : Float
}

impl Eq for Vector4
impl Show for Vector4

#
Vector4::add

source
fn Vector4::add(v1 : Vector4, v2 : Vector4) -> Vector4

#
Vector4::add_value

source
fn Vector4::add_value(v : Vector4, add : Float) -> Vector4

#
Vector4::divide

source
fn Vector4::divide(v1 : Vector4, v2 : Vector4) -> Vector4

#
Vector4::equals

source
fn Vector4::equals(p : Vector4, q : Vector4) -> Bool

#
Vector4::from_bytes

source
fn Vector4::from_bytes(b : Bytes) -> Vector4

#
Vector4::length

source
fn Vector4::length(v : Vector4) -> Float

#
Vector4::max

source
fn Vector4::max(v1 : Vector4, v2 : Vector4) -> Vector4

#
Vector4::min

source
fn Vector4::min(v1 : Vector4, v2 : Vector4) -> Vector4

#
Vector4::multiply

source
fn Vector4::multiply(v1 : Vector4, v2 : Vector4) -> Vector4

#
Vector4::negate

source
fn Vector4::negate(v : Vector4) -> Vector4

#
Vector4::new

source
fn Vector4::new(x : Float, y : Float, z : Float, w : Float) -> Vector4

#
Vector4::normalize

source
fn Vector4::normalize(v : Vector4) -> Vector4

#
Vector4::one

source
fn Vector4::one() -> Vector4

#
Vector4::quat_add

source
fn Vector4::quat_add(q1 : Vector4, q2 : Vector4) -> Vector4

#
Vector4::quat_add_value

source
fn Vector4::quat_add_value(q : Vector4, add : Float) -> Vector4

#
Vector4::quat_cubic_hermite_spline

source
fn Vector4::quat_cubic_hermite_spline(q1 : Vector4, out_tangent1 : Vector4, q2 : Vector4, in_tangent2 : Vector4, t : Float) -> Vector4

#
Vector4::quat_divide

source
fn Vector4::quat_divide(q1 : Vector4, q2 : Vector4) -> Vector4

#
Vector4::quat_equals

source
fn Vector4::quat_equals(p : Vector4, q : Vector4) -> Bool

#
Vector4::quat_from_axis_angle

source
fn Vector4::quat_from_axis_angle(axis : Vector3, angle : Float) -> Vector4

#
Vector4::quat_from_euler

source
fn Vector4::quat_from_euler(pitch : Float, yaw : Float, roll : Float) -> Vector4

#
Vector4::quat_from_matrix

source
fn Vector4::quat_from_matrix(mat : Matrix) -> Vector4

#
Vector4::quat_from_vector3_to_vector3

source
fn Vector4::quat_from_vector3_to_vector3(from_ : Vector3, to : Vector3) -> Vector4

#
Vector4::quat_identity

source
fn Vector4::quat_identity() -> Vector4

#
Vector4::quat_invert

source
fn Vector4::quat_invert(q : Vector4) -> Vector4

#
Vector4::quat_length

source
fn Vector4::quat_length(q : Vector4) -> Float

#
Vector4::quat_lerp

source
fn Vector4::quat_lerp(q1 : Vector4, q2 : Vector4, amount : Float) -> Vector4

#
Vector4::quat_multiply

source
fn Vector4::quat_multiply(q1 : Vector4, q2 : Vector4) -> Vector4

#
Vector4::quat_nlerp

source
fn Vector4::quat_nlerp(q1 : Vector4, q2 : Vector4, amount : Float) -> Vector4

#
Vector4::quat_normalize

source
fn Vector4::quat_normalize(q : Vector4) -> Vector4

#
Vector4::quat_scale

source
fn Vector4::quat_scale(q : Vector4, mul : Float) -> Vector4

#
Vector4::quat_slerp

source
fn Vector4::quat_slerp(q1 : Vector4, q2 : Vector4, amount : Float) -> Vector4

#
Vector4::quat_subtract

source
fn Vector4::quat_subtract(q1 : Vector4, q2 : Vector4) -> Vector4

#
Vector4::quat_subtract_value

source
fn Vector4::quat_subtract_value(q : Vector4, sub : Float) -> Vector4

#
Vector4::quat_to_axis_angle

source
fn Vector4::quat_to_axis_angle(q : Vector4) -> (Vector3, Float)

#
Vector4::quat_to_euler

source
fn Vector4::quat_to_euler(q : Vector4) -> Vector3

#
Vector4::quat_to_matrix

source
fn Vector4::quat_to_matrix(q : Vector4) -> Matrix

#
Vector4::quat_transform

source
fn Vector4::quat_transform(q : Vector4, mat : Matrix) -> Vector4

#
Vector4::scale

source
fn Vector4::scale(v : Vector4, scalar : Float) -> Vector4

#
Vector4::subtract

source
fn Vector4::subtract(v1 : Vector4, v2 : Vector4) -> Vector4

#
Vector4::subtract_value

source
fn Vector4::subtract_value(v : Vector4, sub : Float) -> Vector4

#
Vector4::to_bytes

source
fn Vector4::to_bytes(v : Vector4) -> Bytes

#
Vector4::zero

source
fn Vector4::zero() -> Vector4

#
VrDeviceInfo

source
pub struct VrDeviceInfo {
  h_resolution : Int
  v_resolution : Int
  h_screen_size : Float
  v_screen_size : Float
  eye_to_screen_distance : Float
  lens_separation_distance : Float
  interpupillary_distance : Float
  lens_distortion_values : FixedArray[Float]
  chroma_ab_correction : FixedArray[Float]
}

#
VrDeviceInfo::new

source
fn VrDeviceInfo::new(h_resolution : Int, v_resolution : Int, h_screen_size : Float, v_screen_size : Float, eye_to_screen_distance : Float, lens_separation_distance : Float, interpupillary_distance : Float, lens_distortion_values : FixedArray[Float], chroma_ab_correction : FixedArray[Float]) -> VrDeviceInfo

#
VrDeviceInfo::to_bytes

source
fn VrDeviceInfo::to_bytes(info : VrDeviceInfo) -> Bytes

#
VrStereoConfig

source
type VrStereoConfig

#
VrStereoConfig::begin_mode

source
#as_free_fn(begin_vr_stereo_mode)
fn VrStereoConfig::begin_mode(self : VrStereoConfig) -> Unit

#
VrStereoConfig::left_lens_center

source
fn VrStereoConfig::left_lens_center(self : VrStereoConfig) -> Vector2

#
VrStereoConfig::left_screen_center

source
fn VrStereoConfig::left_screen_center(self : VrStereoConfig) -> Vector2

#
VrStereoConfig::load

source
#as_free_fn(load_vr_stereo_config)
fn VrStereoConfig::load(device : VrDeviceInfo) -> VrStereoConfig

#
VrStereoConfig::right_lens_center

source
fn VrStereoConfig::right_lens_center(self : VrStereoConfig) -> Vector2

#
VrStereoConfig::right_screen_center

source
fn VrStereoConfig::right_screen_center(self : VrStereoConfig) -> Vector2

#
VrStereoConfig::scale

source

#
VrStereoConfig::scale_in

source
fn VrStereoConfig::scale_in(self : VrStereoConfig) -> Vector2

#
VrStereoConfig::unload

source
#as_free_fn(unload_vr_stereo_config)
fn VrStereoConfig::unload(self : VrStereoConfig) -> Unit

#
Wave

source
type Wave

#
Wave::channels

source
#as_free_fn(get_wave_channels)
fn Wave::channels(self : Wave) -> Int

#
Wave::copy

source
#as_free_fn(wave_copy)
fn Wave::copy(self : Wave) -> Wave

#
Wave::crop

source
#as_free_fn(wave_crop)
fn Wave::crop(self : Wave, init_frame : Int, final_frame : Int) -> Unit

#
Wave::export_

source
#as_free_fn(export_wave)
fn Wave::export_(self : Wave, file_name : String) -> Bool

#
Wave::export_as_code

source
#as_free_fn(export_wave_as_code)
fn Wave::export_as_code(self : Wave, file_name : String) -> Bool

#
Wave::format

source
#as_free_fn(wave_format)
fn Wave::format(self : Wave, sample_rate : Int, sample_size : Int, channels : Int) -> Unit

#
Wave::frame_count

source
#as_free_fn(get_wave_frame_count)
fn Wave::frame_count(self : Wave) -> Int

#
Wave::is_valid

source
#as_free_fn(is_wave_valid)
fn Wave::is_valid(self : Wave) -> Bool

#
Wave::load

source
#as_free_fn(load_wave)
fn Wave::load(file_name : String) -> Wave

#
Wave::load_from_memory

source
#as_free_fn(load_wave_from_memory)
fn Wave::load_from_memory(file_type : String, file_data : Bytes, data_size : Int) -> Wave

#
Wave::load_samples

source
#as_free_fn(load_wave_samples)
fn Wave::load_samples(self : Wave) -> Bytes

#
Wave::load_sound

source
#as_free_fn(load_sound_from_wave)
fn Wave::load_sound(self : Wave) -> Sound

#
Wave::sample_rate

source
#as_free_fn(get_wave_sample_rate)
fn Wave::sample_rate(self : Wave) -> Int

#
Wave::sample_size

source
#as_free_fn(get_wave_sample_size)
fn Wave::sample_size(self : Wave) -> Int

#
Wave::unload

source
#as_free_fn(unload_wave)
fn Wave::unload(self : Wave) -> Unit

#
BlendAdditive

source
let BlendAdditive : Int

#
BlendAlpha

source
let BlendAlpha : Int

#
BlendCustom

source
let BlendCustom : Int

#
BlendMultiplied

source
let BlendMultiplied : Int

#
CameraCustom

source
let CameraCustom : Int

#
CameraFirstPerson

source
let CameraFirstPerson : Int

#
CameraFree

source
let CameraFree : Int

#
CameraOrbital

source
let CameraOrbital : Int

#
CameraOrthographic

source
let CameraOrthographic : Int

#
CameraPerspective

source
let CameraPerspective : Int

#
CameraThirdPerson

source
let CameraThirdPerson : Int

#
CubemapLayoutAutoDetect

source
let CubemapLayoutAutoDetect : Int

#
CubemapLayoutCrossFourByThree

source
let CubemapLayoutCrossFourByThree : Int

#
CubemapLayoutCrossThreeByFour

source
let CubemapLayoutCrossThreeByFour : Int

#
CubemapLayoutLineHorizontal

source
let CubemapLayoutLineHorizontal : Int

#
CubemapLayoutLineVertical

source
let CubemapLayoutLineVertical : Int

#
FlagBorderlessWindowedMode

source
let FlagBorderlessWindowedMode : Int

#
FlagFullscreenMode

source
let FlagFullscreenMode : Int

#
FlagInterlacedHint

source
let FlagInterlacedHint : Int

#
FlagMsaa4xHint

source
let FlagMsaa4xHint : Int

#
FlagVsyncHint

source
let FlagVsyncHint : Int

#
FlagWindowAlwaysRun

source
let FlagWindowAlwaysRun : Int

#
FlagWindowHidden

source
let FlagWindowHidden : Int

#
FlagWindowHighdpi

source
let FlagWindowHighdpi : Int

#
FlagWindowMaximized

source
let FlagWindowMaximized : Int

#
FlagWindowMinimized

source
let FlagWindowMinimized : Int

#
FlagWindowMousePassthrough

source
let FlagWindowMousePassthrough : Int

#
FlagWindowResizable

source
let FlagWindowResizable : Int

#
FlagWindowTopmost

source
let FlagWindowTopmost : Int

#
FlagWindowTransparent

source
let FlagWindowTransparent : Int

#
FlagWindowUndecorated

source
let FlagWindowUndecorated : Int

#
FlagWindowUnfocused

source
let FlagWindowUnfocused : Int

#
FontBitmap

source
let FontBitmap : Int

#
FontDefault

source
let FontDefault : Int

#
FontSdf

source
let FontSdf : Int

#
GamepadAxisLeftTrigger

source
let GamepadAxisLeftTrigger : Int

#
GamepadAxisLeftX

source
let GamepadAxisLeftX : Int

#
GamepadAxisLeftY

source
let GamepadAxisLeftY : Int

#
GamepadAxisRightTrigger

source
let GamepadAxisRightTrigger : Int

#
GamepadAxisRightX

source
let GamepadAxisRightX : Int

#
GamepadAxisRightY

source
let GamepadAxisRightY : Int

#
GamepadButtonLeftFaceDown

source
let GamepadButtonLeftFaceDown : Int

#
GamepadButtonLeftFaceLeft

source
let GamepadButtonLeftFaceLeft : Int

#
GamepadButtonLeftFaceRight

source
let GamepadButtonLeftFaceRight : Int

#
GamepadButtonLeftFaceUp

source
let GamepadButtonLeftFaceUp : Int

#
GamepadButtonLeftThumb

source
let GamepadButtonLeftThumb : Int

#
GamepadButtonLeftTrigger1

source
let GamepadButtonLeftTrigger1 : Int

#
GamepadButtonLeftTrigger2

source
let GamepadButtonLeftTrigger2 : Int

#
GamepadButtonMiddle

source
let GamepadButtonMiddle : Int

#
GamepadButtonMiddleLeft

source
let GamepadButtonMiddleLeft : Int

#
GamepadButtonMiddleRight

source
let GamepadButtonMiddleRight : Int

#
GamepadButtonRightFaceDown

source
let GamepadButtonRightFaceDown : Int

#
GamepadButtonRightFaceLeft

source
let GamepadButtonRightFaceLeft : Int

#
GamepadButtonRightFaceRight

source
let GamepadButtonRightFaceRight : Int

#
GamepadButtonRightFaceUp

source
let GamepadButtonRightFaceUp : Int

#
GamepadButtonRightThumb

source
let GamepadButtonRightThumb : Int

#
GamepadButtonRightTrigger1

source
let GamepadButtonRightTrigger1 : Int

#
GamepadButtonRightTrigger2

source
let GamepadButtonRightTrigger2 : Int

#
GamepadButtonUnknown

source
let GamepadButtonUnknown : Int

#
GestureDoubletap

source
let GestureDoubletap : Int

#
GestureDrag

source
let GestureDrag : Int

#
GestureHold

source
let GestureHold : Int

#
GestureNone

source
let GestureNone : Int

#
GesturePinchIn

source
let GesturePinchIn : Int

#
GesturePinchOut

source
let GesturePinchOut : Int

#
GestureSwipeDown

source
let GestureSwipeDown : Int

#
GestureSwipeLeft

source
let GestureSwipeLeft : Int

#
GestureSwipeRight

source
let GestureSwipeRight : Int

#
GestureSwipeUp

source
let GestureSwipeUp : Int

#
GestureTap

source
let GestureTap : Int

#
KeyA

source
let KeyA : Int

#
KeyApostrophe

source
let KeyApostrophe : Int

#
KeyB

source
let KeyB : Int

#
KeyBackslash

source
let KeyBackslash : Int

#
KeyBackspace

source
let KeyBackspace : Int

#
KeyC

source
let KeyC : Int

#
KeyCapsLock

source
let KeyCapsLock : Int

#
KeyComma

source
let KeyComma : Int

#
KeyD

source
let KeyD : Int

#
KeyDelete

source
let KeyDelete : Int

#
KeyDown

source
let KeyDown : Int

#
KeyE

source
let KeyE : Int

#
KeyEight

source
let KeyEight : Int

#
KeyEnd

source
let KeyEnd : Int

#
KeyEnter

source
let KeyEnter : Int

#
KeyEqual

source
let KeyEqual : Int

#
KeyEscape

source
let KeyEscape : Int

#
KeyF

source
let KeyF : Int

#
KeyF1

source
let KeyF1 : Int

#
KeyF10

source
let KeyF10 : Int

#
KeyF11

source
let KeyF11 : Int

#
KeyF12

source
let KeyF12 : Int

#
KeyF2

source
let KeyF2 : Int

#
KeyF3

source
let KeyF3 : Int

#
KeyF4

source
let KeyF4 : Int

#
KeyF5

source
let KeyF5 : Int

#
KeyF6

source
let KeyF6 : Int

#
KeyF7

source
let KeyF7 : Int

#
KeyF8

source
let KeyF8 : Int

#
KeyF9

source
let KeyF9 : Int

#
KeyFive

source
let KeyFive : Int

#
KeyFour

source
let KeyFour : Int

#
KeyG

source
let KeyG : Int

#
KeyGrave

source
let KeyGrave : Int

#
KeyH

source
let KeyH : Int

#
KeyHome

source
let KeyHome : Int

#
KeyI

source
let KeyI : Int

#
KeyInsert

source
let KeyInsert : Int

#
KeyJ

source
let KeyJ : Int

#
KeyK

source
let KeyK : Int

#
KeyKbMenu

source
let KeyKbMenu : Int

#
KeyKp0

source
let KeyKp0 : Int

#
KeyKp1

source
let KeyKp1 : Int

#
KeyKp2

source
let KeyKp2 : Int

#
KeyKp3

source
let KeyKp3 : Int

#
KeyKp4

source
let KeyKp4 : Int

#
KeyKp5

source
let KeyKp5 : Int

#
KeyKp6

source
let KeyKp6 : Int

#
KeyKp7

source
let KeyKp7 : Int

#
KeyKp8

source
let KeyKp8 : Int

#
KeyKp9

source
let KeyKp9 : Int

#
KeyL

source
let KeyL : Int

#
KeyLeft

source
let KeyLeft : Int

#
KeyLeftAlt

source
let KeyLeftAlt : Int

#
KeyLeftBracket

source
let KeyLeftBracket : Int

#
KeyLeftControl

source
let KeyLeftControl : Int

#
KeyLeftShift

source
let KeyLeftShift : Int

#
KeyLeftSuper

source
let KeyLeftSuper : Int

#
KeyM

source
let KeyM : Int

#
KeyMinus

source
let KeyMinus : Int

#
KeyN

source
let KeyN : Int

#
KeyNine

source
let KeyNine : Int

#
KeyNull

source
let KeyNull : Int

#
KeyNumLock

source
let KeyNumLock : Int

#
KeyO

source
let KeyO : Int

#
KeyOne

source
let KeyOne : Int

#
KeyP

source
let KeyP : Int

#
KeyPageDown

source
let KeyPageDown : Int

#
KeyPageUp

source
let KeyPageUp : Int

#
KeyPause

source
let KeyPause : Int

#
KeyPeriod

source
let KeyPeriod : Int

#
KeyPrintScreen

source
let KeyPrintScreen : Int

#
KeyQ

source
let KeyQ : Int

#
KeyR

source
let KeyR : Int

#
KeyRight

source
let KeyRight : Int

#
KeyRightAlt

source
let KeyRightAlt : Int

#
KeyRightBracket

source
let KeyRightBracket : Int

#
KeyRightControl

source
let KeyRightControl : Int

#
KeyRightShift

source
let KeyRightShift : Int

#
KeyRightSuper

source
let KeyRightSuper : Int

#
KeyS

source
let KeyS : Int

#
KeyScrollLock

source
let KeyScrollLock : Int

#
KeySemicolon

source
let KeySemicolon : Int

#
KeySeven

source
let KeySeven : Int

#
KeySix

source
let KeySix : Int

#
KeySlash

source
let KeySlash : Int

#
KeySpace

source
let KeySpace : Int

#
KeyT

source
let KeyT : Int

#
KeyTab

source
let KeyTab : Int

#
KeyThree

source
let KeyThree : Int

#
KeyTwo

source
let KeyTwo : Int

#
KeyU

source
let KeyU : Int

#
KeyUp

source
let KeyUp : Int

#
KeyV

source
let KeyV : Int

#
KeyW

source
let KeyW : Int

#
KeyX

source
let KeyX : Int

#
KeyY

source
let KeyY : Int

#
KeyZ

source
let KeyZ : Int

#
KeyZero

source
let KeyZero : Int

#
LogAll

source
let LogAll : Int

#
LogDebug

source
let LogDebug : Int

#
LogError

source
let LogError : Int

#
LogFatal

source
let LogFatal : Int

#
LogInfo

source
let LogInfo : Int

#
LogNone

source
let LogNone : Int

#
LogTrace

source
let LogTrace : Int

#
LogWarning

source
let LogWarning : Int

#
MaterialMapAlbedo

source
let MaterialMapAlbedo : Int

#
MaterialMapBrdf

source
let MaterialMapBrdf : Int

#
MaterialMapCubemap

source
let MaterialMapCubemap : Int

#
MaterialMapEmission

source
let MaterialMapEmission : Int

#
MaterialMapHeight

source
let MaterialMapHeight : Int

#
MaterialMapIrradiance

source
let MaterialMapIrradiance : Int

#
MaterialMapMetalness

source
let MaterialMapMetalness : Int

#
MaterialMapNormal

source
let MaterialMapNormal : Int

#
MaterialMapOcclusion

source
let MaterialMapOcclusion : Int

#
MaterialMapPrefilter

source
let MaterialMapPrefilter : Int

#
MaterialMapRoughness

source
let MaterialMapRoughness : Int

#
MouseButtonBack

source
let MouseButtonBack : Int

#
MouseButtonExtra

source
let MouseButtonExtra : Int

#
MouseButtonForward

source
let MouseButtonForward : Int

#
MouseButtonLeft

source
let MouseButtonLeft : Int

#
MouseButtonMiddle

source
let MouseButtonMiddle : Int

#
MouseButtonRight

source
let MouseButtonRight : Int

#
MouseButtonSide

source
let MouseButtonSide : Int

#
MouseCursorArrow

source
let MouseCursorArrow : Int

#
MouseCursorCrosshair

source
let MouseCursorCrosshair : Int

#
MouseCursorDefault

source
let MouseCursorDefault : Int

#
MouseCursorIbeam

source
let MouseCursorIbeam : Int

#
MouseCursorNotAllowed

source
let MouseCursorNotAllowed : Int

#
MouseCursorPointingHand

source
let MouseCursorPointingHand : Int

#
MouseCursorResizeAll

source
let MouseCursorResizeAll : Int

#
MouseCursorResizeEw

source
let MouseCursorResizeEw : Int

#
MouseCursorResizeNesw

source
let MouseCursorResizeNesw : Int

#
MouseCursorResizeNs

source
let MouseCursorResizeNs : Int

#
MouseCursorResizeNwse

source
let MouseCursorResizeNwse : Int

#
NpatchNinePatch

source
let NpatchNinePatch : Int

#
NpatchThreePatchHorizontal

source
let NpatchThreePatchHorizontal : Int

#
NpatchThreePatchVertical

source
let NpatchThreePatchVertical : Int

#
PixelformatUncompressedGrayAlpha

source
let PixelformatUncompressedGrayAlpha : Int

#
PixelformatUncompressedGrayscale

source
let PixelformatUncompressedGrayscale : Int

#
PixelformatUncompressedR32

source
let PixelformatUncompressedR32 : Int

#
PixelformatUncompressedR32g32b32

source
let PixelformatUncompressedR32g32b32 : Int

#
PixelformatUncompressedR32g32b32a32

source
let PixelformatUncompressedR32g32b32a32 : Int

#
PixelformatUncompressedR4g4b4a4

source
let PixelformatUncompressedR4g4b4a4 : Int

#
PixelformatUncompressedR5g5b5a1

source
let PixelformatUncompressedR5g5b5a1 : Int

#
PixelformatUncompressedR5g6b5

source
let PixelformatUncompressedR5g6b5 : Int

#
PixelformatUncompressedR8g8b8

source
let PixelformatUncompressedR8g8b8 : Int

#
PixelformatUncompressedR8g8b8a8

source
let PixelformatUncompressedR8g8b8a8 : Int

#
RlAttachmentColorChannel0

source
#deprecated("Use @rl.AttachmentColorChannel0 from tonyfettes/raylib/rl instead")
let RlAttachmentColorChannel0 : Int

#
RlAttachmentColorChannel1

source
#deprecated("Use @rl.AttachmentColorChannel1 from tonyfettes/raylib/rl instead")
let RlAttachmentColorChannel1 : Int

#
RlAttachmentColorChannel2

source
#deprecated("Use @rl.AttachmentColorChannel2 from tonyfettes/raylib/rl instead")
let RlAttachmentColorChannel2 : Int

#
RlAttachmentColorChannel3

source
#deprecated("Use @rl.AttachmentColorChannel3 from tonyfettes/raylib/rl instead")
let RlAttachmentColorChannel3 : Int

#
RlAttachmentCubemapNegativeX

source
#deprecated("Use @rl.AttachmentCubemapNegativeX from tonyfettes/raylib/rl instead")
let RlAttachmentCubemapNegativeX : Int

#
RlAttachmentCubemapNegativeY

source
#deprecated("Use @rl.AttachmentCubemapNegativeY from tonyfettes/raylib/rl instead")
let RlAttachmentCubemapNegativeY : Int

#
RlAttachmentCubemapNegativeZ

source
#deprecated("Use @rl.AttachmentCubemapNegativeZ from tonyfettes/raylib/rl instead")
let RlAttachmentCubemapNegativeZ : Int

#
RlAttachmentCubemapPositiveX

source
#deprecated("Use @rl.AttachmentCubemapPositiveX from tonyfettes/raylib/rl instead")
let RlAttachmentCubemapPositiveX : Int

#
RlAttachmentCubemapPositiveY

source
#deprecated("Use @rl.AttachmentCubemapPositiveY from tonyfettes/raylib/rl instead")
let RlAttachmentCubemapPositiveY : Int

#
RlAttachmentCubemapPositiveZ

source
#deprecated("Use @rl.AttachmentCubemapPositiveZ from tonyfettes/raylib/rl instead")
let RlAttachmentCubemapPositiveZ : Int

#
RlAttachmentDepth

source
#deprecated("Use @rl.AttachmentDepth from tonyfettes/raylib/rl instead")
let RlAttachmentDepth : Int

#
RlAttachmentRenderbuffer

source
#deprecated("Use @rl.AttachmentRenderbuffer from tonyfettes/raylib/rl instead")
let RlAttachmentRenderbuffer : Int

#
RlAttachmentStencil

source
#deprecated("Use @rl.AttachmentStencil from tonyfettes/raylib/rl instead")
let RlAttachmentStencil : Int

#
RlAttachmentTexture2d

source
#deprecated("Use @rl.AttachmentTexture2d from tonyfettes/raylib/rl instead")
let RlAttachmentTexture2d : Int

#
RlDrawFramebuffer

source
#deprecated("Use @rl.DrawFramebuffer from tonyfettes/raylib/rl instead")
let RlDrawFramebuffer : UInt

#
RlLines

source
#deprecated("Use @rl.Lines from tonyfettes/raylib/rl instead")
let RlLines : Int

#
RlQuads

source
#deprecated("Use @rl.Quads from tonyfettes/raylib/rl instead")
let RlQuads : Int

#
RlReadFramebuffer

source
#deprecated("Use @rl.ReadFramebuffer from tonyfettes/raylib/rl instead")
let RlReadFramebuffer : UInt

#
RlTriangles

source
#deprecated("Use @rl.Triangles from tonyfettes/raylib/rl instead")
let RlTriangles : Int

#
ShaderLocBoneMatrices

source
let ShaderLocBoneMatrices : Int

#
ShaderLocColorAmbient

source
let ShaderLocColorAmbient : Int

#
ShaderLocColorDiffuse

source
let ShaderLocColorDiffuse : Int

#
ShaderLocColorSpecular

source
let ShaderLocColorSpecular : Int

#
ShaderLocMapAlbedo

source
let ShaderLocMapAlbedo : Int

#
ShaderLocMapBrdf

source
let ShaderLocMapBrdf : Int

#
ShaderLocMapCubemap

source
let ShaderLocMapCubemap : Int

#
ShaderLocMapEmission

source
let ShaderLocMapEmission : Int

#
ShaderLocMapHeight

source
let ShaderLocMapHeight : Int

#
ShaderLocMapIrradiance

source
let ShaderLocMapIrradiance : Int

#
ShaderLocMapMetalness

source
let ShaderLocMapMetalness : Int

#
ShaderLocMapNormal

source
let ShaderLocMapNormal : Int

#
ShaderLocMapOcclusion

source
let ShaderLocMapOcclusion : Int

#
ShaderLocMapPrefilter

source
let ShaderLocMapPrefilter : Int

#
ShaderLocMapRoughness

source
let ShaderLocMapRoughness : Int

#
ShaderLocMatrixModel

source
let ShaderLocMatrixModel : Int

#
ShaderLocMatrixMvp

source
let ShaderLocMatrixMvp : Int

#
ShaderLocMatrixNormal

source
let ShaderLocMatrixNormal : Int

#
ShaderLocMatrixProjection

source
let ShaderLocMatrixProjection : Int

#
ShaderLocMatrixView

source
let ShaderLocMatrixView : Int

#
ShaderLocVectorView

source
let ShaderLocVectorView : Int

#
ShaderLocVertexBoneids

source
let ShaderLocVertexBoneids : Int

#
ShaderLocVertexBoneweights

source
let ShaderLocVertexBoneweights : Int

#
ShaderLocVertexColor

source
let ShaderLocVertexColor : Int

#
ShaderLocVertexNormal

source
let ShaderLocVertexNormal : Int

#
ShaderLocVertexPosition

source
let ShaderLocVertexPosition : Int

#
ShaderLocVertexTangent

source
let ShaderLocVertexTangent : Int

#
ShaderLocVertexTexcoord01

source
let ShaderLocVertexTexcoord01 : Int

#
ShaderLocVertexTexcoord02

source
let ShaderLocVertexTexcoord02 : Int

#
ShaderUniformFloat

source
let ShaderUniformFloat : Int

#
ShaderUniformInt

source
let ShaderUniformInt : Int

#
ShaderUniformIvec2

source
let ShaderUniformIvec2 : Int

#
ShaderUniformIvec3

source
let ShaderUniformIvec3 : Int

#
ShaderUniformIvec4

source
let ShaderUniformIvec4 : Int

#
ShaderUniformSampler2d

source
let ShaderUniformSampler2d : Int

#
ShaderUniformVec2

source
let ShaderUniformVec2 : Int

#
ShaderUniformVec3

source
let ShaderUniformVec3 : Int

#
ShaderUniformVec4

source
let ShaderUniformVec4 : Int

#
TextureFilterAnisotropic16x

source
let TextureFilterAnisotropic16x : Int

#
TextureFilterAnisotropic4x

source
let TextureFilterAnisotropic4x : Int

#
TextureFilterAnisotropic8x

source
let TextureFilterAnisotropic8x : Int

#
TextureFilterBilinear

source
let TextureFilterBilinear : Int

#
TextureFilterPoint

source
let TextureFilterPoint : Int

#
TextureFilterTrilinear

source
let TextureFilterTrilinear : Int

#
TextureWrapClamp

source
let TextureWrapClamp : Int

#
TextureWrapMirrorClamp

source
let TextureWrapMirrorClamp : Int

#
TextureWrapMirrorRepeat

source
let TextureWrapMirrorRepeat : Int

#
TextureWrapRepeat

source
let TextureWrapRepeat : Int

#
attach_audio_mixed_processor

source
fn attach_audio_mixed_processor(processor : FuncRef[(
AudioBuffer, UInt) -> Unit]) -> Unit

#
attach_music_stream_processor

source
fn attach_music_stream_processor(music : Music, processor : FuncRef[(
AudioBuffer, UInt) -> Unit]) -> Unit

#
audio_buffer_get_sample

source
fn audio_buffer_get_sample(buffer : 
AudioBuffer, index : UInt) -> Float

#
audio_buffer_set_sample

source
fn audio_buffer_set_sample(buffer : 
AudioBuffer, index : UInt, value : Float) -> Unit

#
begin_blend_mode

source
fn begin_blend_mode(mode : Int) -> Unit

#
begin_drawing

source
fn begin_drawing() -> Unit

#
begin_mode_2d

source
fn begin_mode_2d(camera : Camera2D) -> Unit

#
begin_mode_3d

source
fn begin_mode_3d(camera : Camera3D) -> Unit

#
begin_scissor_mode

source
fn begin_scissor_mode(x : Int, y : Int, width : Int, height : Int) -> Unit

#
beige

source
let beige : Color

#
black

source
let black : Color

#
blank

source
let blank : Color

#
blue

source
let blue : Color

#
brown

source
let brown : Color

#
change_directory

source
fn change_directory(dir : String) -> Bool

#
check_collision_box_sphere

source
fn check_collision_box_sphere(box_ : BoundingBox, center : Vector3, radius : Float) -> Bool

#
check_collision_boxes

source
fn check_collision_boxes(box1 : BoundingBox, box2 : BoundingBox) -> Bool

#
check_collision_circle_line

source
fn check_collision_circle_line(center : Vector2, radius : Float, p1 : Vector2, p2 : Vector2) -> Bool

#
check_collision_circle_rec

source
fn check_collision_circle_rec(center : Vector2, radius : Float, rec : Rectangle) -> Bool

#
check_collision_circles

source
fn check_collision_circles(center1 : Vector2, radius1 : Float, center2 : Vector2, radius2 : Float) -> Bool

#
check_collision_lines

source
fn check_collision_lines(start_pos1 : Vector2, end_pos1 : Vector2, start_pos2 : Vector2, end_pos2 : Vector2) -> Vector2?

#
check_collision_point_circle

source
fn check_collision_point_circle(point : Vector2, center : Vector2, radius : Float) -> Bool

#
check_collision_point_line

source
fn check_collision_point_line(point : Vector2, p1 : Vector2, p2 : Vector2, threshold : Int) -> Bool

#
check_collision_point_poly

source
fn check_collision_point_poly(point : Vector2, points : Array[Vector2]) -> Bool

#
check_collision_point_rec

source
fn check_collision_point_rec(point : Vector2, rec : Rectangle) -> Bool

#
check_collision_point_triangle

source
fn check_collision_point_triangle(point : Vector2, p1 : Vector2, p2 : Vector2, p3 : Vector2) -> Bool

#
check_collision_recs

source
fn check_collision_recs(rec1 : Rectangle, rec2 : Rectangle) -> Bool

#
check_collision_spheres

source
fn check_collision_spheres(center1 : Vector3, radius1 : Float, center2 : Vector3, radius2 : Float) -> Bool

#
clear_background

source
fn clear_background(color : Color) -> Unit

#
clear_window_state

source
fn clear_window_state(flags : Int) -> Unit

#
close_audio_device

source
fn close_audio_device() -> Unit

#
close_window

source
fn close_window() -> Unit

#
codepoint_to_utf8

source
fn codepoint_to_utf8(codepoint : Int) -> Bytes

#
color_alpha

source
fn color_alpha(color : Color, alpha : Float) -> Color

#
color_alpha_blend

source
fn color_alpha_blend(dst : Color, src : Color, tint : Color) -> Color

#
color_brightness

source
fn color_brightness(color : Color, factor : Float) -> Color

#
color_contrast

source
fn color_contrast(color : Color, contrast : Float) -> Color

#
color_from_hsv

source
fn color_from_hsv(hue : Float, saturation : Float, value : Float) -> Color

#
color_from_normalized

source
fn color_from_normalized(normalized : Vector4) -> Color

#
color_is_equal

source
fn color_is_equal(col1 : Color, col2 : Color) -> Bool

#
color_lerp

source
fn color_lerp(color1 : Color, color2 : Color, factor : Float) -> Color

#
color_normalize

source
fn color_normalize(color : Color) -> Vector4

#
color_tint

source
fn color_tint(color : Color, tint : Color) -> Color

#
color_to_hsv

source
fn color_to_hsv(color : Color) -> Vector3

#
color_to_int

source
fn color_to_int(color : Color) -> Int

#
compress_data

source
fn compress_data(data : Bytes) -> Bytes

#
compute_crc32

source
fn compute_crc32(data : Bytes) -> Int

#
compute_md5

source
fn compute_md5(data : Bytes) -> Bytes

#
compute_sha1

source
fn compute_sha1(data : Bytes) -> Bytes

#
darkblue

source
let darkblue : Color

#
darkbrown

source
let darkbrown : Color

#
darkgray

source
let darkgray : Color

#
darkgreen

source
let darkgreen : Color

#
darkpurple

source
let darkpurple : Color

#
decode_data_base64

source
fn decode_data_base64(data : String) -> Bytes

#
decompress_data

source
fn decompress_data(comp_data : Bytes) -> Bytes

#
detach_audio_mixed_processor

source
fn detach_audio_mixed_processor(processor : FuncRef[(
AudioBuffer, UInt) -> Unit]) -> Unit

#
detach_music_stream_processor

source
fn detach_music_stream_processor(music : Music, processor : FuncRef[(
AudioBuffer, UInt) -> Unit]) -> Unit

#
directory_exists

source
fn directory_exists(dir_path : String) -> Bool

#
disable_cursor

source
fn disable_cursor() -> Unit

#
disable_event_waiting

source
fn disable_event_waiting() -> Unit

#
draw_billboard

source
fn draw_billboard(camera : Camera3D, texture : Texture, position : Vector3, scale : Float, tint : Color) -> Unit

#
draw_billboard_pro

source
fn draw_billboard_pro(camera : Camera3D, texture : Texture, source : Rectangle, position : Vector3, up : Vector3, size : Vector2, origin : Vector2, rotation : Float, tint : Color) -> Unit

#
draw_billboard_rec

source
fn draw_billboard_rec(camera : Camera3D, texture : Texture, source : Rectangle, position : Vector3, size : Vector2, tint : Color) -> Unit

#
draw_bounding_box

source
fn draw_bounding_box(box_ : BoundingBox, color : Color) -> Unit

#
draw_capsule

source
fn draw_capsule(start_pos : Vector3, end_pos : Vector3, radius : Float, slices : Int, rings : Int, color : Color) -> Unit

#
draw_capsule_wires

source
fn draw_capsule_wires(start_pos : Vector3, end_pos : Vector3, radius : Float, slices : Int, rings : Int, color : Color) -> Unit

#
draw_circle

source
fn draw_circle(center_x : Int, center_y : Int, radius : Float, color : Color) -> Unit

#
draw_circle_3d

source
fn draw_circle_3d(center : Vector3, radius : Float, rot_axis : Vector3, rot_angle : Float, color : Color) -> Unit

#
draw_circle_gradient

source
fn draw_circle_gradient(center_x : Int, center_y : Int, radius : Float, inner : Color, outer : Color) -> Unit

#
draw_circle_lines

source
fn draw_circle_lines(center_x : Int, center_y : Int, radius : Float, color : Color) -> Unit

#
draw_circle_lines_v

source
fn draw_circle_lines_v(center : Vector2, radius : Float, color : Color) -> Unit

#
draw_circle_sector

source
fn draw_circle_sector(center : Vector2, radius : Float, start_angle : Float, end_angle : Float, segments : Int, color : Color) -> Unit

#
draw_circle_sector_lines

source
fn draw_circle_sector_lines(center : Vector2, radius : Float, start_angle : Float, end_angle : Float, segments : Int, color : Color) -> Unit

#
draw_circle_v

source
fn draw_circle_v(center : Vector2, radius : Float, color : Color) -> Unit

#
draw_cube

source
fn draw_cube(position : Vector3, width : Float, height : Float, length : Float, color : Color) -> Unit

#
draw_cube_v

source
fn draw_cube_v(position : Vector3, size : Vector3, color : Color) -> Unit

#
draw_cube_wires

source
fn draw_cube_wires(position : Vector3, width : Float, height : Float, length : Float, color : Color) -> Unit

#
draw_cube_wires_v

source
fn draw_cube_wires_v(position : Vector3, size : Vector3, color : Color) -> Unit

#
draw_cylinder

source
fn draw_cylinder(position : Vector3, radius_top : Float, radius_bottom : Float, height : Float, slices : Int, color : Color) -> Unit

#
draw_cylinder_ex

source
fn draw_cylinder_ex(start_pos : Vector3, end_pos : Vector3, start_radius : Float, end_radius : Float, sides : Int, color : Color) -> Unit

#
draw_cylinder_wires

source
fn draw_cylinder_wires(position : Vector3, radius_top : Float, radius_bottom : Float, height : Float, slices : Int, color : Color) -> Unit

#
draw_cylinder_wires_ex

source
fn draw_cylinder_wires_ex(start_pos : Vector3, end_pos : Vector3, start_radius : Float, end_radius : Float, sides : Int, color : Color) -> Unit

#
draw_ellipse

source
fn draw_ellipse(center_x : Int, center_y : Int, radius_h : Float, radius_v : Float, color : Color) -> Unit

#
draw_ellipse_lines

source
fn draw_ellipse_lines(center_x : Int, center_y : Int, radius_h : Float, radius_v : Float, color : Color) -> Unit

#
draw_fps

source
fn draw_fps(pos_x : Int, pos_y : Int) -> Unit

#
draw_grid

source
fn draw_grid(slices : Int, spacing : Float) -> Unit

#
draw_line

source
fn draw_line(start_x : Int, start_y : Int, end_x : Int, end_y : Int, color : Color) -> Unit

#
draw_line_3d

source
fn draw_line_3d(start_pos : Vector3, end_pos : Vector3, color : Color) -> Unit

#
draw_line_bezier

source
fn draw_line_bezier(start_pos : Vector2, end_pos : Vector2, thick : Float, color : Color) -> Unit

#
draw_line_ex

source
fn draw_line_ex(start_pos : Vector2, end_pos : Vector2, thick : Float, color : Color) -> Unit

#
draw_line_strip

source
fn draw_line_strip(points : Array[Vector2], color : Color) -> Unit

#
draw_line_v

source
fn draw_line_v(start_pos : Vector2, end_pos : Vector2, color : Color) -> Unit

#
draw_pixel

source
fn draw_pixel(pos_x : Int, pos_y : Int, color : Color) -> Unit

#
draw_pixel_v

source
fn draw_pixel_v(position : Vector2, color : Color) -> Unit

#
draw_plane

source
fn draw_plane(center : Vector3, size : Vector2, color : Color) -> Unit

#
draw_point_3d

source
fn draw_point_3d(position : Vector3, color : Color) -> Unit

#
draw_poly

source
fn draw_poly(center : Vector2, sides : Int, radius : Float, rotation : Float, color : Color) -> Unit

#
draw_poly_lines

source
fn draw_poly_lines(center : Vector2, sides : Int, radius : Float, rotation : Float, color : Color) -> Unit

#
draw_poly_lines_ex

source
fn draw_poly_lines_ex(center : Vector2, sides : Int, radius : Float, rotation : Float, line_thick : Float, color : Color) -> Unit

#
draw_ray

source
fn draw_ray(ray : Ray, color : Color) -> Unit

#
draw_rectangle

source
fn draw_rectangle(pos_x : Int, pos_y : Int, width : Int, height : Int, color : Color) -> Unit

#
draw_rectangle_gradient_ex

source
fn draw_rectangle_gradient_ex(rec : Rectangle, top_left : Color, bottom_left : Color, top_right : Color, bottom_right : Color) -> Unit

#
draw_rectangle_gradient_h

source
fn draw_rectangle_gradient_h(pos_x : Int, pos_y : Int, width : Int, height : Int, left : Color, right : Color) -> Unit

#
draw_rectangle_gradient_v

source
fn draw_rectangle_gradient_v(pos_x : Int, pos_y : Int, width : Int, height : Int, top : Color, bottom : Color) -> Unit

#
draw_rectangle_lines

source
fn draw_rectangle_lines(pos_x : Int, pos_y : Int, width : Int, height : Int, color : Color) -> Unit

#
draw_rectangle_lines_ex

source
fn draw_rectangle_lines_ex(rec : Rectangle, line_thick : Float, color : Color) -> Unit

#
draw_rectangle_pro

source
fn draw_rectangle_pro(rec : Rectangle, origin : Vector2, rotation : Float, color : Color) -> Unit

#
draw_rectangle_rec

source
fn draw_rectangle_rec(rec : Rectangle, color : Color) -> Unit

#
draw_rectangle_rounded

source
fn draw_rectangle_rounded(rec : Rectangle, roundness : Float, segments : Int, color : Color) -> Unit

#
draw_rectangle_rounded_lines

source
fn draw_rectangle_rounded_lines(rec : Rectangle, roundness : Float, segments : Int, color : Color) -> Unit

#
draw_rectangle_rounded_lines_ex

source
fn draw_rectangle_rounded_lines_ex(rec : Rectangle, roundness : Float, segments : Int, line_thick : Float, color : Color) -> Unit

#
draw_rectangle_v

source
fn draw_rectangle_v(position : Vector2, size : Vector2, color : Color) -> Unit

#
draw_ring

source
fn draw_ring(center : Vector2, inner_radius : Float, outer_radius : Float, start_angle : Float, end_angle : Float, segments : Int, color : Color) -> Unit

#
draw_ring_lines

source
fn draw_ring_lines(center : Vector2, inner_radius : Float, outer_radius : Float, start_angle : Float, end_angle : Float, segments : Int, color : Color) -> Unit

#
draw_sphere

source
fn draw_sphere(center : Vector3, radius : Float, color : Color) -> Unit

#
draw_sphere_ex

source
fn draw_sphere_ex(center : Vector3, radius : Float, rings : Int, slices : Int, color : Color) -> Unit

#
draw_sphere_wires

source
fn draw_sphere_wires(center : Vector3, radius : Float, rings : Int, slices : Int, color : Color) -> Unit

#
draw_spline_basis

source
fn draw_spline_basis(points : Array[Vector2], thick : Float, color : Color) -> Unit

#
draw_spline_bezier_cubic

source
fn draw_spline_bezier_cubic(points : Array[Vector2], thick : Float, color : Color) -> Unit

#
draw_spline_bezier_quadratic

source
fn draw_spline_bezier_quadratic(points : Array[Vector2], thick : Float, color : Color) -> Unit

#
draw_spline_catmull_rom

source
fn draw_spline_catmull_rom(points : Array[Vector2], thick : Float, color : Color) -> Unit

#
draw_spline_linear

source
fn draw_spline_linear(points : Array[Vector2], thick : Float, color : Color) -> Unit

#
draw_spline_segment_basis

source
fn draw_spline_segment_basis(p1 : Vector2, p2 : Vector2, p3 : Vector2, p4 : Vector2, thick : Float, color : Color) -> Unit

#
draw_spline_segment_bezier_cubic

source
fn draw_spline_segment_bezier_cubic(p1 : Vector2, p2 : Vector2, p3 : Vector2, p4 : Vector2, thick : Float, color : Color) -> Unit

#
draw_spline_segment_bezier_quadratic

source
fn draw_spline_segment_bezier_quadratic(p1 : Vector2, p2 : Vector2, p3 : Vector2, thick : Float, color : Color) -> Unit

#
draw_spline_segment_catmull_rom

source
fn draw_spline_segment_catmull_rom(p1 : Vector2, p2 : Vector2, p3 : Vector2, p4 : Vector2, thick : Float, color : Color) -> Unit

#
draw_spline_segment_linear

source
fn draw_spline_segment_linear(p1 : Vector2, p2 : Vector2, thick : Float, color : Color) -> Unit

#
draw_text

source
fn draw_text(text : String, pos_x : Int, pos_y : Int, font_size : Int, color : Color) -> Unit

#
draw_triangle

source
fn draw_triangle(v1 : Vector2, v2 : Vector2, v3 : Vector2, color : Color) -> Unit

#
draw_triangle_3d

source
fn draw_triangle_3d(v1 : Vector3, v2 : Vector3, v3 : Vector3, color : Color) -> Unit

#
draw_triangle_fan

source
fn draw_triangle_fan(points : Array[Vector2], color : Color) -> Unit

#
draw_triangle_lines

source
fn draw_triangle_lines(v1 : Vector2, v2 : Vector2, v3 : Vector2, color : Color) -> Unit

#
draw_triangle_strip

source
fn draw_triangle_strip(points : Array[Vector2], color : Color) -> Unit

#
draw_triangle_strip_3d

source
fn draw_triangle_strip_3d(points : Array[Vector3], color : Color) -> Unit

#
enable_cursor

source
fn enable_cursor() -> Unit

#
enable_event_waiting

source
fn enable_event_waiting() -> Unit

#
encode_data_base64

source
fn encode_data_base64(data : Bytes) -> String

#
end_blend_mode

source
fn end_blend_mode() -> Unit

#
end_drawing

source
fn end_drawing() -> Unit

#
end_mode_2d

source
fn end_mode_2d() -> Unit

#
end_mode_3d

source
fn end_mode_3d() -> Unit

#
end_scissor_mode

source
fn end_scissor_mode() -> Unit

#
end_shader_mode

source
fn end_shader_mode() -> Unit

#
end_texture_mode

source
fn end_texture_mode() -> Unit

#
end_vr_stereo_mode

source
fn end_vr_stereo_mode() -> Unit

#
export_data_as_code

source
fn export_data_as_code(data : Bytes, data_size : Int, file_name : String) -> Bool

#
fade

source
fn fade(color : Color, alpha : Float) -> Color

#
file_exists

source
fn file_exists(file_name : String) -> Bool

#
file_path_list_get

source
fn file_path_list_get(files : FilePathList, index : Int) -> String

#
gen_font_texture_mipmaps

source
#deprecated("Use font.texture().gen_mipmaps() instead")
fn gen_font_texture_mipmaps(font : Font) -> Unit

#
get_application_directory

source
fn get_application_directory() -> String

#
get_camera_matrix

source
fn get_camera_matrix(camera : Camera3D) -> Matrix

#
get_camera_matrix_2d

source
fn get_camera_matrix_2d(camera : Camera2D) -> Matrix

#
get_char_pressed

source
fn get_char_pressed() -> Int

#
get_clipboard_image

source
fn get_clipboard_image() -> Image

#
get_clipboard_text

source
fn get_clipboard_text() -> String

#
get_codepoint

source
fn get_codepoint(text : String) -> (Int, Int)

#
get_codepoint_count

source
fn get_codepoint_count(text : String) -> Int

#
get_codepoint_next

source
fn get_codepoint_next(text : String) -> (Int, Int)

#
get_codepoint_previous

source
fn get_codepoint_previous(text : String) -> (Int, Int)

#
get_collision_rec

source
fn get_collision_rec(rec1 : Rectangle, rec2 : Rectangle) -> Rectangle

#
get_color

source
fn get_color(hex_value : Int) -> Color

#
get_current_monitor

source
fn get_current_monitor() -> Int

#
get_directory_path

source
fn get_directory_path(file_path : String) -> String

#
get_file_extension

source
fn get_file_extension(file_name : String) -> String

#
get_file_length

source
fn get_file_length(file_name : String) -> Int

#
get_file_mod_time

source
fn get_file_mod_time(file_name : String) -> Int

#
get_file_name

source
fn get_file_name(file_path : String) -> String

#
get_file_name_without_ext

source
fn get_file_name_without_ext(file_path : String) -> String

#
get_fps

source
fn get_fps() -> Int

#
get_frame_time

source
fn get_frame_time() -> Float

#
get_gamepad_axis_count

source
fn get_gamepad_axis_count(gamepad : Int) -> Int

#
get_gamepad_axis_movement

source
fn get_gamepad_axis_movement(gamepad : Int, axis : Int) -> Float

#
get_gamepad_button_pressed

source
fn get_gamepad_button_pressed() -> Int

#
get_gamepad_name

source
fn get_gamepad_name(gamepad : Int) -> String

#
get_gesture_detected

source
fn get_gesture_detected() -> Int

#
get_gesture_drag_angle

source
fn get_gesture_drag_angle() -> Float

#
get_gesture_drag_vector

source
fn get_gesture_drag_vector() -> Vector2

#
get_gesture_hold_duration

source
fn get_gesture_hold_duration() -> Float

#
get_gesture_pinch_angle

source
fn get_gesture_pinch_angle() -> Float

#
get_gesture_pinch_vector

source
fn get_gesture_pinch_vector() -> Vector2

#
get_key_pressed

source
fn get_key_pressed() -> Int

#
get_master_volume

source
fn get_master_volume() -> Float

#
get_monitor_count

source
fn get_monitor_count() -> Int

#
get_monitor_height

source
fn get_monitor_height(monitor : Int) -> Int

#
get_monitor_name

source
fn get_monitor_name(monitor : Int) -> String

#
get_monitor_physical_height

source
fn get_monitor_physical_height(monitor : Int) -> Int

#
get_monitor_physical_width

source
fn get_monitor_physical_width(monitor : Int) -> Int

#
get_monitor_position

source
fn get_monitor_position(monitor : Int) -> Vector2

#
get_monitor_refresh_rate

source
fn get_monitor_refresh_rate(monitor : Int) -> Int

#
get_monitor_width

source
fn get_monitor_width(monitor : Int) -> Int

#
get_mouse_delta

source
fn get_mouse_delta() -> Vector2

#
get_mouse_position

source
fn get_mouse_position() -> Vector2

#
get_mouse_wheel_move

source
fn get_mouse_wheel_move() -> Float

#
get_mouse_wheel_move_v

source
fn get_mouse_wheel_move_v() -> Vector2

#
get_mouse_x

source
fn get_mouse_x() -> Int

#
get_mouse_y

source
fn get_mouse_y() -> Int

#
get_pixel_data_size

source
fn get_pixel_data_size(width : Int, height : Int, format : Int) -> Int

#
get_prev_directory_path

source
fn get_prev_directory_path(dir_path : String) -> String

#
get_random_value

source
fn get_random_value(min : Int, max : Int) -> Int

#
get_ray_collision_box

source
fn get_ray_collision_box(ray : Ray, box_ : BoundingBox) -> RayCollision

#
get_ray_collision_mesh

source
fn get_ray_collision_mesh(ray : Ray, mesh : Mesh, transform : Matrix) -> RayCollision

#
get_ray_collision_quad

source
fn get_ray_collision_quad(ray : Ray, p1 : Vector3, p2 : Vector3, p3 : Vector3, p4 : Vector3) -> RayCollision

#
get_ray_collision_sphere

source
fn get_ray_collision_sphere(ray : Ray, center : Vector3, radius : Float) -> RayCollision

#
get_ray_collision_triangle

source
fn get_ray_collision_triangle(ray : Ray, p1 : Vector3, p2 : Vector3, p3 : Vector3) -> RayCollision

#
get_render_height

source
fn get_render_height() -> Int

#
get_render_width

source
fn get_render_width() -> Int

#
get_screen_height

source
fn get_screen_height() -> Int

#
get_screen_to_world_2d

source
fn get_screen_to_world_2d(position : Vector2, camera : Camera2D) -> Vector2

#
get_screen_to_world_ray

source
fn get_screen_to_world_ray(position : Vector2, camera : Camera3D) -> Ray

#
get_screen_to_world_ray_ex

source
fn get_screen_to_world_ray_ex(position : Vector2, camera : Camera3D, width : Int, height : Int) -> Ray

#
get_screen_width

source
fn get_screen_width() -> Int

#
get_shapes_texture_rectangle

source
fn get_shapes_texture_rectangle() -> Rectangle

#
get_spline_point_basis

source
fn get_spline_point_basis(p1 : Vector2, p2 : Vector2, p3 : Vector2, p4 : Vector2, t : Float) -> Vector2

#
get_spline_point_bezier_cubic

source
fn get_spline_point_bezier_cubic(p1 : Vector2, p2 : Vector2, p3 : Vector2, p4 : Vector2, t : Float) -> Vector2

#
get_spline_point_bezier_quad

source
fn get_spline_point_bezier_quad(p1 : Vector2, p2 : Vector2, p3 : Vector2, t : Float) -> Vector2

#
get_spline_point_catmull_rom

source
fn get_spline_point_catmull_rom(p1 : Vector2, p2 : Vector2, p3 : Vector2, p4 : Vector2, t : Float) -> Vector2

#
get_spline_point_linear

source
fn get_spline_point_linear(start_pos : Vector2, end_pos : Vector2, t : Float) -> Vector2

#
get_time

source
fn get_time() -> Double

#
get_touch_point_count

source
fn get_touch_point_count() -> Int

#
get_touch_point_id

source
fn get_touch_point_id(index : Int) -> Int

#
get_touch_position

source
fn get_touch_position(index : Int) -> Vector2

#
get_touch_x

source
fn get_touch_x() -> Int

#
get_touch_y

source
fn get_touch_y() -> Int

#
get_window_position

source
fn get_window_position() -> Vector2

#
get_window_scale_dpi

source
fn get_window_scale_dpi() -> Vector2

#
get_working_directory

source
fn get_working_directory() -> String

#
get_world_to_screen

source
fn get_world_to_screen(position : Vector3, camera : Camera3D) -> Vector2

#
get_world_to_screen_2d

source
fn get_world_to_screen_2d(position : Vector2, camera : Camera2D) -> Vector2

#
get_world_to_screen_ex

source
fn get_world_to_screen_ex(position : Vector3, camera : Camera3D, width : Int, height : Int) -> Vector2

#
gold

source
let gold : Color

#
gray

source
let gray : Color

#
green

source
let green : Color

#
hide_cursor

source
fn hide_cursor() -> Unit

#
init_audio_device

source
fn init_audio_device() -> Unit

#
init_window

source
fn init_window(width : Int, height : Int, title : String) -> Unit

#
is_audio_device_ready

source
fn is_audio_device_ready() -> Bool

#
is_cursor_hidden

source
fn is_cursor_hidden() -> Bool

#
is_cursor_on_screen

source
fn is_cursor_on_screen() -> Bool

#
is_file_dropped

source
fn is_file_dropped() -> Bool

#
is_file_extension

source
fn is_file_extension(file_name : String, ext : String) -> Bool

#
is_file_name_valid

source
fn is_file_name_valid(file_name : String) -> Bool

#
is_gamepad_available

source
fn is_gamepad_available(gamepad : Int) -> Bool

#
is_gamepad_button_down

source
fn is_gamepad_button_down(gamepad : Int, button : Int) -> Bool

#
is_gamepad_button_pressed

source
fn is_gamepad_button_pressed(gamepad : Int, button : Int) -> Bool

#
is_gamepad_button_released

source
fn is_gamepad_button_released(gamepad : Int, button : Int) -> Bool

#
is_gamepad_button_up

source
fn is_gamepad_button_up(gamepad : Int, button : Int) -> Bool

#
is_gesture_detected

source
fn is_gesture_detected(gesture : Int) -> Bool

#
is_key_down

source
fn is_key_down(key : Int) -> Bool

#
is_key_pressed

source
fn is_key_pressed(key : Int) -> Bool

#
is_key_pressed_repeat

source
fn is_key_pressed_repeat(key : Int) -> Bool

#
is_key_released

source
fn is_key_released(key : Int) -> Bool

#
is_key_up

source
fn is_key_up(key : Int) -> Bool

#
is_mouse_button_down

source
fn is_mouse_button_down(button : Int) -> Bool

#
is_mouse_button_pressed

source
fn is_mouse_button_pressed(button : Int) -> Bool

#
is_mouse_button_released

source
fn is_mouse_button_released(button : Int) -> Bool

#
is_mouse_button_up

source
fn is_mouse_button_up(button : Int) -> Bool

#
is_path_file

source
fn is_path_file(path : String) -> Bool

#
is_window_focused

source
fn is_window_focused() -> Bool

#
is_window_fullscreen

source
fn is_window_fullscreen() -> Bool

#
is_window_hidden

source
fn is_window_hidden() -> Bool

#
is_window_maximized

source
fn is_window_maximized() -> Bool

#
is_window_minimized

source
fn is_window_minimized() -> Bool

#
is_window_ready

source
fn is_window_ready() -> Bool

#
is_window_resized

source
fn is_window_resized() -> Bool

#
is_window_state

source
fn is_window_state(flag : Int) -> Bool

#
lightgray

source
let lightgray : Color

#
lime

source
let lime : Color

#
load_codepoints

source
fn load_codepoints(text : String) -> Array[Int]

#
load_directory_files

source
fn load_directory_files(dir_path : String) -> FilePathList

#
load_directory_files_ex

source
fn load_directory_files_ex(base_path : String, filter : String, scan_subdirs : Bool) -> FilePathList

#
load_file_data

source
fn load_file_data(file_name : String) -> Bytes

#
load_file_text

source
fn load_file_text(file_name : String) -> String

#
load_image_anim

source
#deprecated("Use Image::load_anim instead (returns (Image, Int) with frame count)")
fn load_image_anim(file_name : String) -> Image

#
load_image_anim_from_memory

source
#deprecated("Use Image::load_anim_from_memory instead (returns (Image, Int) with frame count)")
fn load_image_anim_from_memory(file_type : String, file_data : Bytes, data_size : Int) -> Image

#
load_random_sequence

source
fn load_random_sequence(count : Int, min : Int, max : Int) -> Array[Int]

#
load_utf8

source
fn load_utf8(codepoints : Array[Int]) -> Bytes

#
magenta

source
let magenta : Color

#
make_directory

source
fn make_directory(dir_path : String) -> Int

#
maroon

source
let maroon : Color

#
maximize_window

source
fn maximize_window() -> Unit

#
measure_text

source
fn measure_text(text : String, font_size : Int) -> Int

#
minimize_window

source
fn minimize_window() -> Unit

#
open_url

source
fn open_url(url : String) -> Unit

#
orange

source
let orange : Color

#
pink

source
let pink : Color

#
play_automation_event

source
fn play_automation_event(event : AutomationEvent) -> Unit

#
poll_input_events

source
fn poll_input_events() -> Unit

#
purple

source
let purple : Color

#
raywhite

source
let raywhite : Color

#
red

source
let red : Color

#
restore_window

source
fn restore_window() -> Unit

#
rl_active_draw_buffers

source
#deprecated("Use @rl.active_draw_buffers from tonyfettes/raylib/rl instead")
fn rl_active_draw_buffers(count : Int) -> Unit

#
rl_active_texture_slot

source
#deprecated("Use @rl.active_texture_slot from tonyfettes/raylib/rl instead")
fn rl_active_texture_slot(slot : Int) -> Unit

#
rl_begin

source
#deprecated("Use @rl.begin from tonyfettes/raylib/rl instead")
fn rl_begin(mode : Int) -> Unit

#
rl_bind_framebuffer

source
#deprecated("Use @rl.bind_framebuffer from tonyfettes/raylib/rl instead")
fn rl_bind_framebuffer(target : UInt, fbo : UInt) -> Unit

#
rl_blit_framebuffer

source
#deprecated("Use @rl.blit_framebuffer from tonyfettes/raylib/rl instead")
fn rl_blit_framebuffer(src_x : Int, src_y : Int, src_w : Int, src_h : Int, dst_x : Int, dst_y : Int, dst_w : Int, dst_h : Int, buffer_mask : Int) -> Unit

#
rl_check_render_batch_limit

source
#deprecated("Use @rl.check_render_batch_limit from tonyfettes/raylib/rl instead")
fn rl_check_render_batch_limit(v_count : Int) -> Bool

#
rl_clear_screen_buffers

source
#deprecated("Use @rl.clear_screen_buffers from tonyfettes/raylib/rl instead")
fn rl_clear_screen_buffers() -> Unit

#
rl_color4ub

source
#deprecated("Use @rl.color4ub from tonyfettes/raylib/rl instead")
fn rl_color4ub(r : Byte, g : Byte, b : Byte, a : Byte) -> Unit

#
rl_disable_backface_culling

source
#deprecated("Use @rl.disable_backface_culling from tonyfettes/raylib/rl instead")
fn rl_disable_backface_culling() -> Unit

#
rl_disable_color_blend

source
#deprecated("Use @rl.disable_color_blend from tonyfettes/raylib/rl instead")
fn rl_disable_color_blend() -> Unit

#
rl_disable_depth_mask

source
#deprecated("Use @rl.disable_depth_mask from tonyfettes/raylib/rl instead")
fn rl_disable_depth_mask() -> Unit

#
rl_disable_depth_test

source
#deprecated("Use @rl.disable_depth_test from tonyfettes/raylib/rl instead")
fn rl_disable_depth_test() -> Unit

#
rl_disable_framebuffer

source
#deprecated("Use @rl.disable_framebuffer from tonyfettes/raylib/rl instead")
fn rl_disable_framebuffer() -> Unit

#
rl_disable_shader

source
#deprecated("Use @rl.disable_shader from tonyfettes/raylib/rl instead")
fn rl_disable_shader() -> Unit

#
rl_disable_texture

source
#deprecated("Use @rl.disable_texture from tonyfettes/raylib/rl instead")
fn rl_disable_texture() -> Unit

#
rl_draw_render_batch_active

source
#deprecated("Use @rl.draw_render_batch_active from tonyfettes/raylib/rl instead")
fn rl_draw_render_batch_active() -> Unit

#
rl_enable_backface_culling

source
#deprecated("Use @rl.enable_backface_culling from tonyfettes/raylib/rl instead")
fn rl_enable_backface_culling() -> Unit

#
rl_enable_color_blend

source
#deprecated("Use @rl.enable_color_blend from tonyfettes/raylib/rl instead")
fn rl_enable_color_blend() -> Unit

#
rl_enable_depth_mask

source
#deprecated("Use @rl.enable_depth_mask from tonyfettes/raylib/rl instead")
fn rl_enable_depth_mask() -> Unit

#
rl_enable_depth_test

source
#deprecated("Use @rl.enable_depth_test from tonyfettes/raylib/rl instead")
fn rl_enable_depth_test() -> Unit

#
rl_enable_framebuffer

source
#deprecated("Use @rl.enable_framebuffer from tonyfettes/raylib/rl instead")
fn rl_enable_framebuffer(id : UInt) -> Unit

#
rl_enable_shader

source
#deprecated("Use @rl.enable_shader from tonyfettes/raylib/rl instead")
fn rl_enable_shader(id : UInt) -> Unit

#
rl_enable_texture

source
#deprecated("Use @rl.enable_texture from tonyfettes/raylib/rl instead")
fn rl_enable_texture(id : UInt) -> Unit

#
rl_end

source
#deprecated("Use @rl.end_ from tonyfettes/raylib/rl instead")
fn rl_end() -> Unit

#
rl_framebuffer_attach

source
#deprecated("Use @rl.framebuffer_attach from tonyfettes/raylib/rl instead")
fn rl_framebuffer_attach(fbo_id : UInt, tex_id : UInt, attach_type : Int, tex_type : Int, mip_level : Int) -> Unit

#
rl_framebuffer_complete

source
#deprecated("Use @rl.framebuffer_complete from tonyfettes/raylib/rl instead")
fn rl_framebuffer_complete(id : UInt) -> Bool

#
rl_get_framebuffer_height

source
#deprecated("Use @rl.get_framebuffer_height from tonyfettes/raylib/rl instead")
fn rl_get_framebuffer_height() -> Int

#
rl_get_framebuffer_width

source
#deprecated("Use @rl.get_framebuffer_width from tonyfettes/raylib/rl instead")
fn rl_get_framebuffer_width() -> Int

#
rl_get_location_uniform

source
#deprecated("Use @rl.get_location_uniform from tonyfettes/raylib/rl instead")
fn rl_get_location_uniform(shader_id : UInt, uniform_name : String) -> Int

#
rl_get_matrix_modelview

source
#deprecated("Use @rl.get_matrix_modelview from tonyfettes/raylib/rl instead")
fn rl_get_matrix_modelview() -> Matrix

#
rl_get_matrix_projection

source
#deprecated("Use @rl.get_matrix_projection from tonyfettes/raylib/rl instead")
fn rl_get_matrix_projection() -> Matrix

#
rl_get_shader_id_default

source
#deprecated("Use @rl.get_shader_id_default from tonyfettes/raylib/rl instead")
fn rl_get_shader_id_default() -> UInt

#
rl_load_draw_cube

source
#deprecated("Use @rl.load_draw_cube from tonyfettes/raylib/rl instead")
fn rl_load_draw_cube() -> Unit

#
rl_load_draw_quad

source
#deprecated("Use @rl.load_draw_quad from tonyfettes/raylib/rl instead")
fn rl_load_draw_quad() -> Unit

#
rl_load_framebuffer

source
#deprecated("Use @rl.load_framebuffer from tonyfettes/raylib/rl instead")
fn rl_load_framebuffer() -> UInt

#
rl_load_texture

source
#deprecated("Use @rl.load_texture from tonyfettes/raylib/rl instead")
fn rl_load_texture(width : Int, height : Int, format : Int, mipmap_count : Int) -> UInt

#
rl_load_texture_depth

source
#deprecated("Use @rl.load_texture_depth from tonyfettes/raylib/rl instead")
fn rl_load_texture_depth(width : Int, height : Int, use_render_buffer : Bool) -> UInt

#
rl_mult_matrixf

source
#deprecated("Use @rl.mult_matrixf from tonyfettes/raylib/rl instead")
fn rl_mult_matrixf(matf : Bytes) -> Unit

#
rl_normal3f

source
#deprecated("Use @rl.normal3f from tonyfettes/raylib/rl instead")
fn rl_normal3f(x : Float, y : Float, z : Float) -> Unit

#
rl_pop_matrix

source
#deprecated("Use @rl.pop_matrix from tonyfettes/raylib/rl instead")
fn rl_pop_matrix() -> Unit

#
rl_push_matrix

source
#deprecated("Use @rl.push_matrix from tonyfettes/raylib/rl instead")
fn rl_push_matrix() -> Unit

#
rl_rotatef

source
#deprecated("Use @rl.rotatef from tonyfettes/raylib/rl instead")
fn rl_rotatef(angle : Float, x : Float, y : Float, z : Float) -> Unit

#
rl_scalef

source
#deprecated("Use @rl.scalef from tonyfettes/raylib/rl instead")
fn rl_scalef(x : Float, y : Float, z : Float) -> Unit

#
rl_set_blend_factors

source
#deprecated("Use @rl.set_blend_factors from tonyfettes/raylib/rl instead")
fn rl_set_blend_factors(gl_src_factor : Int, gl_dst_factor : Int, gl_equation : Int) -> Unit

#
rl_set_blend_mode

source
#deprecated("Use @rl.set_blend_mode from tonyfettes/raylib/rl instead")
fn rl_set_blend_mode(mode : Int) -> Unit

#
rl_set_texture

source
#deprecated("Use @rl.set_texture from tonyfettes/raylib/rl instead")
fn rl_set_texture(id : UInt) -> Unit

#
rl_set_uniform

source
#deprecated("Use @rl.set_uniform from tonyfettes/raylib/rl instead")
fn rl_set_uniform(loc_index : Int, value : Bytes, uniform_type : Int, count : Int) -> Unit

#
rl_set_uniform_sampler

source
#deprecated("Use @rl.set_uniform_sampler from tonyfettes/raylib/rl instead")
fn rl_set_uniform_sampler(loc_index : Int, texture_id : UInt) -> Unit

#
rl_tex_coord2f

source
#deprecated("Use @rl.tex_coord2f from tonyfettes/raylib/rl instead")
fn rl_tex_coord2f(x : Float, y : Float) -> Unit

#
rl_translatef

source
#deprecated("Use @rl.translatef from tonyfettes/raylib/rl instead")
fn rl_translatef(x : Float, y : Float, z : Float) -> Unit

#
rl_unload_framebuffer

source
#deprecated("Use @rl.unload_framebuffer from tonyfettes/raylib/rl instead")
fn rl_unload_framebuffer(id : UInt) -> Unit

#
rl_unload_texture

source
#deprecated("Use @rl.unload_texture from tonyfettes/raylib/rl instead")
fn rl_unload_texture(id : UInt) -> Unit

#
rl_vertex2f

source
#deprecated("Use @rl.vertex2f from tonyfettes/raylib/rl instead")
fn rl_vertex2f(x : Float, y : Float) -> Unit

#
rl_vertex3f

source
#deprecated("Use @rl.vertex3f from tonyfettes/raylib/rl instead")
fn rl_vertex3f(x : Float, y : Float, z : Float) -> Unit

#
rl_viewport

source
#deprecated("Use @rl.viewport from tonyfettes/raylib/rl instead")
fn rl_viewport(x : Int, y : Int, width : Int, height : Int) -> Unit

#
save_file_data

source
fn save_file_data(file_name : String, data : Bytes, data_size : Int) -> Bool

#
save_file_text

source
fn save_file_text(file_name : String, text : String) -> Bool

#
set_audio_stream_buffer_size_default

source
fn set_audio_stream_buffer_size_default(size : Int) -> Unit

#
set_automation_event_base_frame

source
fn set_automation_event_base_frame(frame : Int) -> Unit

#
set_clipboard_text

source
fn set_clipboard_text(text : String) -> Unit

#
set_config_flags

source
fn set_config_flags(flags : Int) -> Unit

#
set_exit_key

source
fn set_exit_key(key : Int) -> Unit

#
set_font_texture_filter

source
#deprecated("Use font.texture().set_filter(filter) instead")
fn set_font_texture_filter(font : Font, filter : Int) -> Unit

#
set_gamepad_mappings

source
fn set_gamepad_mappings(mappings : String) -> Int

#
set_gamepad_vibration

source
fn set_gamepad_vibration(gamepad : Int, left_motor : Float, right_motor : Float, duration : Float) -> Unit

#
set_gestures_enabled

source
fn set_gestures_enabled(flags : Int) -> Unit

#
set_master_volume

source
fn set_master_volume(volume : Float) -> Unit

#
set_mouse_cursor

source
fn set_mouse_cursor(cursor : Int) -> Unit

#
set_mouse_offset

source
fn set_mouse_offset(offset_x : Int, offset_y : Int) -> Unit

#
set_mouse_position

source
fn set_mouse_position(x : Int, y : Int) -> Unit

#
set_mouse_scale

source
fn set_mouse_scale(scale_x : Float, scale_y : Float) -> Unit

#
set_random_seed

source
fn set_random_seed(seed : Int) -> Unit

#
set_shader_value

source
#deprecated("Use Shader::set_value instead")
fn set_shader_value(shader : Shader, loc_index : Int, value : Bytes, uniform_type : Int) -> Unit

#
set_shader_value_v

source
#deprecated("Use Shader::set_value_v instead")
fn set_shader_value_v(shader : Shader, loc_index : Int, value : Bytes, uniform_type : Int, count : Int) -> Unit

#
set_target_fps

source
fn set_target_fps(fps : Int) -> Unit

#
set_text_line_spacing

source
fn set_text_line_spacing(spacing : Int) -> Unit

#
set_trace_log_level

source
fn set_trace_log_level(log_level : Int) -> Unit

#
set_window_focused

source
fn set_window_focused() -> Unit

#
set_window_icon

source
fn set_window_icon(image : Image) -> Unit

#
set_window_max_size

source
fn set_window_max_size(width : Int, height : Int) -> Unit

#
set_window_min_size

source
fn set_window_min_size(width : Int, height : Int) -> Unit

#
set_window_monitor

source
fn set_window_monitor(monitor : Int) -> Unit

#
set_window_opacity

source
fn set_window_opacity(opacity : Float) -> Unit

#
set_window_position

source
fn set_window_position(x : Int, y : Int) -> Unit

#
set_window_size

source
fn set_window_size(width : Int, height : Int) -> Unit

#
set_window_state

source
fn set_window_state(flags : Int) -> Unit

#
set_window_title

source
fn set_window_title(title : String) -> Unit

#
show_cursor

source
fn show_cursor() -> Unit

#
skyblue

source
let skyblue : Color

#
start_automation_event_recording

source
fn start_automation_event_recording() -> Unit

#
stop_automation_event_recording

source
fn stop_automation_event_recording() -> Unit

#
swap_screen_buffer

source
fn swap_screen_buffer() -> Unit

#
take_screenshot

source
fn take_screenshot(file_name : String) -> Unit

#
toggle_borderless_windowed

source
fn toggle_borderless_windowed() -> Unit

#
toggle_fullscreen

source
fn toggle_fullscreen() -> Unit

#
trace_log

source
fn trace_log(log_level : Int, text : String) -> Unit

#
unload_directory_files

source
fn unload_directory_files(files : FilePathList) -> Unit

#
unload_dropped_files

source
fn unload_dropped_files(files : FilePathList) -> Unit

#
update_camera

source
fn update_camera(camera : Camera3D, mode : Int) -> Camera3D

#
update_camera_pro

source
fn update_camera_pro(camera : Camera3D, movement : Vector3, rotation : Vector3, zoom : Float) -> Camera3D

#
upload_mesh

source
#deprecated("Use Mesh::upload instead")
fn upload_mesh(mesh : Mesh, dynamic : Int) -> Unit

#
violet

source
let violet : Color

#
vr_stereo_config_left_lens_center

source
#deprecated("Use VrStereoConfig::left_lens_center instead")
fn vr_stereo_config_left_lens_center(config : VrStereoConfig) -> Bytes

#
vr_stereo_config_left_screen_center

source
#deprecated("Use VrStereoConfig::left_screen_center instead")
fn vr_stereo_config_left_screen_center(config : VrStereoConfig) -> Bytes

#
vr_stereo_config_right_lens_center

source
#deprecated("Use VrStereoConfig::right_lens_center instead")
fn vr_stereo_config_right_lens_center(config : VrStereoConfig) -> Bytes

#
vr_stereo_config_right_screen_center

source
#deprecated("Use VrStereoConfig::right_screen_center instead")
fn vr_stereo_config_right_screen_center(config : VrStereoConfig) -> Bytes

#
vr_stereo_config_scale

source
#deprecated("Use VrStereoConfig::scale instead")
fn vr_stereo_config_scale(config : VrStereoConfig) -> Bytes

#
vr_stereo_config_scale_in

source
#deprecated("Use VrStereoConfig::scale_in instead")
fn vr_stereo_config_scale_in(config : VrStereoConfig) -> Bytes

#
wait_time

source
fn wait_time(seconds : Double) -> Unit

#
white

source
let white : Color

#
window_should_close

source
fn window_should_close() -> Bool

#
yellow

source
let yellow : Color

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io