• App
• App.default_test_size : { width : I32, height : I32 }
• App.default : Config
• App.init : Config, InitCallback(model, errors) -> Init(model, errors)
• App.init_for_args : ConfigForArgs, InitCallback(model, errors) -> Init(model, errors)
• App.Dropped : { path : Str, position : { x : F32, y : F32 } }
• App.Input := { devices : Snapshot, window : Snapshot, time : Cycle, messages : List(msg), capture : Status, dropped : List(Dropped), dropped_overflow : Bool }
• App.Input.fields : Input(msg) -> { devices : Snapshot, window : Snapshot, time : Cycle, messages : List(msg), capture : Status, dropped : List(Dropped), dropped_overflow : Bool }
• App.Input.from_fields : { devices : Snapshot, window : Snapshot, time : Cycle, messages : List(msg), capture : Status, dropped : List(Dropped), dropped_overflow : Bool } -> Input(msg)
• App.Input.for_tests : {} -> Input(msg)
• App.Input.with_devices : Input(msg), Snapshot -> Input(msg)
• App.Input.with_window : Input(msg), Snapshot -> Input(msg)
• App.Input.with_time : Input(msg), Cycle -> Input(msg)
• App.Input.with_messages : Input(msg), List(msg) -> Input(msg)
• App.Input.with_message : Input(msg), msg -> Input(msg)
• App.Input.with_capture : Input(msg), Status -> Input(msg)
• App.Input.with_dropped : Input(msg), List(Dropped) -> Input(msg)
• App.Input.with_dropped_overflow : Input(msg), Bool -> Input(msg)
• App.FramePacing : AppFramePacing
• App.ExitKey : ExitKey
• App.CloseRequest : [Exit, Deliver]
• App.Config
• App.Config.with_title : Config, Str -> Config
• App.Config.with_size : Config, { width : I32, height : I32 } -> Config
• App.Config.with_min_size : Config, { width : I32, height : I32 } -> Config
• App.Config.with_frame_pacing : Config, FramePacing -> Config
• App.Config.with_exit_key : Config, ExitKey -> Config
• App.Config.with_close_request : Config, CloseRequest -> Config
• App.Config.with_cursor_mode : Config, CursorMode -> Config
• App.Config.with_resizable : Config, Bool -> Config
• App.Config.with_fullscreen : Config, Bool -> Config
• App.Config.with_visible : Config, Bool -> Config
• App.Config.with_output_dir : Config, Str -> Config
• App.Config.with_recording : Config, Recording -> Config
• App.Config.without_recording : Config -> Config
• App.Config.with_default_font : Config, { path : Str, size : I32 } -> Config
• App.Config.with_app_id : Config, Str -> Config
• App.Config.with_permission : Config, Permission -> Config
• App.Config.with_permissions : Config, List(Permission) -> Config
• App.Config.title : Config -> Str
• App.Config.size : Config -> { width : I32, height : I32 }
• App.Config.min_size : Config -> { width : I32, height : I32 }
• App.Config.frame_pacing : Config -> FramePacing
• App.Config.cursor_mode : Config -> CursorMode
• App.Config.resizable : Config -> Bool
• App.Config.fullscreen : Config -> Bool
• App.Config.exit_key : Config -> ExitKey
• App.Config.close_request : Config -> CloseRequest
• App.Config.visible : Config -> Bool
• App.Config.output_dir : Config -> Str
• App.Config.recording : Config -> [NoRecording, Record(Recording)]
• App.Config.default_font : Config -> { path : Str, size : I32 }
• App.Config.app_id : Config -> Str
• App.Config.permissions : Config -> List(Permission)
• App.Io
• App.Io.for_host : Authority -> Io
• App.Io.stub : Io
• App.Io.files : Io -> Access
• App.Io.http : Io -> Client
• App.Io.commands : Io -> Runner
• App.Io.stdout : Io -> Writer
• App.Io.stderr : Io -> Writer
• App.Io.udp : Io -> Network
• App.Io.sqlite : Io -> Service
• App.Io.clipboard : Io -> Clipboard
• App.Io.capture : Io -> Writer
• App.Io.env : Io -> Environment
• App.Io.exit! : Io, I32 => {}
• App.Io.args! : Io => List(Str)
• App.Io.entropy! : Io => U64
• App.Io.random_i32! : Io, I32, I32 => I32
• App.Io.suggest_window_size! : Io, { width : I32, height : I32 } => Try({}, [InvalidSize, NotSupported])
• App.Io.suggest_window_min_size! : Io, { width : I32, height : I32 } => {}
• App.Io.set_target_fps! : Io, I32 => {}
• App.Io.set_exit_key! : Io, ExitKey => {}
• App.Io.set_cursor_mode! : Io, CursorMode => {}
• App.Io.set_cursor! : Io, Cursor => {}
• App.Io.default_font! : Io => Try(Font, [PermissionDenied, AssetPathInvalid, AssetNotFound, AssetReadFailed, FontLoadFailed, ResourceLimit])
• App.Environment
• App.Environment.read! : Environment, Str => Try(Str, [NotFound, PermissionDenied])
• App.InitCallback : Io => Try(model, [Exit(I64), ..errors])
• App.ConfigForArgs : List(Str) -> Config
• App.Init : { config : ConfigForArgs, run! : InitCallback(model, errors) }
• Assets
• Assets.open! : ReadDir, ManifestPolicy => Try(Store, [PermissionDenied, PathInvalid, RootNotFound, RootNotDirectory, RootUnreadable, InvalidExpectedContentHash, ManifestMissing, ManifestUnreadable, ManifestMalformed, AssetSetMismatch, SchemaMismatch, ContentVersionMismatch, ContentHashMismatch, ResourceLimit])
• Assets.rgba_byte_size : List(Rgba) -> U64
• Assets.load_texture! : Store, Str => Try(Texture, [PathInvalid, NotFound, ReadFailed, TextureLoadFailed, ResourceLimit])
• Assets.texture_from_bytes! : TextureBytes => Try(Texture, [TextureLoadFailed, ResourceLimit])
• Assets.generate_color_texture! : GenerateColorTexture => Try(Texture, [TextureGenerationFailed, ResourceLimit])
• Assets.generate_checked_texture! : GenerateCheckedTexture => Try(Texture, [TextureGenerationFailed, ResourceLimit])
• Assets.update_texture! : Texture, List(Rgba) => Try({}, [PixelCountMismatch])
• Assets.update_texture_region! : Texture, Region => Try({}, [PixelCountMismatch, RegionOutOfBounds])
• Assets.set_texture_filter! : Texture, TextureFilter => {}
• Assets.set_texture_wrap! : Texture, TextureWrap => {}
• Assets.Texture : Texture
• Assets.Store
• Assets.Store.stub : Store
• Assets.ManifestPolicy := [IgnoreManifest, RequireManifest(ManifestExpectation)]
• Assets.ContentExpectation := [AnyContent, Sha256(Str)]
• Assets.ManifestExpectation : { asset_set : Str, schema : U32, content_version : U32, content : ContentExpectation }
• Assets.OpenError : [PermissionDenied, PathInvalid, RootNotFound, RootNotDirectory, RootUnreadable, InvalidExpectedContentHash, ManifestMissing, ManifestUnreadable, ManifestMalformed, AssetSetMismatch, SchemaMismatch, ContentVersionMismatch, ContentHashMismatch, ResourceLimit]
• Assets.ImageFormat := [Png, Jpeg, Bmp, Gif, Qoi]
• Assets.TextureBytes : { format : ImageFormat, bytes : List(U8) }
• Assets.Region : { x : I32, y : I32, width : I32, height : I32, pixels : List(Rgba) }
• Assets.TextureFilter := [Point, Bilinear, Trilinear, Anisotropic4x, Anisotropic8x, Anisotropic16x]
• Assets.TextureFilter.is_eq : _
• Assets.TextureWrap := [Repeat, Clamp, MirrorRepeat, MirrorClamp]
• Assets.TextureWrap.is_eq : _
• Assets.GenerateColorTexture : { width : I32, height : I32, color : Rgba }
• Assets.GenerateCheckedTexture : { width : I32, height : I32, checks_x : I32, checks_y : I32, color_a : Rgba, color_b : Rgba }
• Audio
• Audio.max_generated_ms : I32
• Audio.gen_sound! : GenSound => Try(Sound, [SoundGenerationFailed, ResourceLimit])
• Audio.gen_tone! : { freq : F32, ms : I32 } => Try(Sound, [SoundGenerationFailed, ResourceLimit])
• Audio.set_master_volume! : F32 => {}
• Audio.load_sound! : Store, Str => Try(Sound, [PathInvalid, NotFound, ReadFailed, SoundLoadFailed, ResourceLimit])
• Audio.load_music! : Store, Str => Try(Music, [PathInvalid, NotFound, ReadFailed, MusicLoadFailed, ResourceLimit])
• Audio.Sound
• Audio.Sound.play! : Sound => {}
• Audio.Sound.stop! : Sound => {}
• Audio.Sound.pause! : Sound => {}
• Audio.Sound.resume! : Sound => {}
• Audio.Sound.is_playing! : Sound => Bool
• Audio.Sound.playback : Sound -> Playback
• Audio.Sound.stub : Sound
• Audio.Playback := { sound : Sound, volume : F32, pitch : F32, pan : F32 }
• Audio.Playback.with_volume : Playback, F32 -> Playback
• Audio.Playback.with_pitch : Playback, F32 -> Playback
• Audio.Playback.with_pan : Playback, F32 -> Playback
• Audio.Playback.play! : Playback => {}
• Audio.Music
• Audio.Music.play! : Music => {}
• Audio.Music.stop! : Music => {}
• Audio.Music.pause! : Music => {}
• Audio.Music.resume! : Music => {}
• Audio.Music.set_volume! : Music, F32 => {}
• Audio.Music.set_pitch! : Music, F32 => {}
• Audio.Music.set_pan! : Music, F32 => {}
• Audio.Music.set_looping! : Music, Bool => {}
• Audio.Music.is_playing! : Music => Bool
• Audio.Music.seek! : Music, F32 => {}
• Audio.Music.length! : Music => F32
• Audio.Music.time_played! : Music => F32
• Audio.Music.stub : Music
• Audio.Waveform := [Sine, Square, Triangle, Saw, Noise]
• Audio.GenSound : { waveform : Waveform, freq_start : F32, freq_end : F32, ms : I32, attack_ms : I32, decay_ms : I32, sustain : F32, release_ms : I32, volume : F32 }
• Camera
• Camera.perspective : PerspectiveSettings -> Camera3D
• Camera.fallback_zoom : F32
• Camera.default : Camera2D
• Camera.new : Settings -> Camera2D
• Camera.centered : Vec2, Vec2 -> Camera2D
• Camera.follow : Vec2, { screen : Vec2, zoom : F32 } -> Camera2D
• Camera.Settings : { target : Vec2, offset : Vec2, rotation : F32, zoom : F32 }
• Camera.Camera2D
• Camera.Camera2D.target : Camera2D -> Vec2
• Camera.Camera2D.offset : Camera2D -> Vec2
• Camera.Camera2D.rotation : Camera2D -> F32
• Camera.Camera2D.zoom : Camera2D -> F32
• Camera.Camera2D.with_target : Camera2D, Vec2 -> Camera2D
• Camera.Camera2D.with_offset : Camera2D, Vec2 -> Camera2D
• Camera.Camera2D.with_rotation : Camera2D, F32 -> Camera2D
• Camera.Camera2D.with_zoom : Camera2D, F32 -> Camera2D
• Camera.Camera2D.clamp_zoom : Camera2D, { min : F32, max : F32 } -> Camera2D
• Camera.Camera2D.world_to_screen : Camera2D, Vec2 -> Vec2
• Camera.Camera2D.screen_to_world : Camera2D, Vec2 -> Vec2
• Camera.Camera2D.viewport : Camera2D, Vec2 -> Rect
• Camera.PerspectiveSettings : { position : Vec3, target : Vec3, up : Vec3, fovy : F32 }
• Camera.Camera3D
• Camera.Camera3D.position : Camera3D -> Vec3
• Camera.Camera3D.target : Camera3D -> Vec3
• Camera.Camera3D.up : Camera3D -> Vec3
• Camera.Camera3D.fovy : Camera3D -> F32
• Capture
• Capture.default : Recording
• Capture.pixel_at! : Source, { x : I32, y : I32 } => Try(Rgba, PixelReadError)
• Capture.read_region! : Source, Region => Try(List(U8), PixelReadError)
• Capture.max_readback_bytes : U64
• Capture.Format : CaptureFormat
• Capture.Scale : CaptureScale
• Capture.Timing : CaptureTiming
• Capture.Cursor : CaptureCursor
• Capture.Quality : CaptureQuality
• Capture.Recording
• Capture.Recording.is_eq : _
• Capture.Recording.with_path : Recording, Str -> Recording
• Capture.Recording.with_format : Recording, Format -> Recording
• Capture.Recording.with_fps : Recording, I32 -> Recording
• Capture.Recording.with_max_frames : Recording, U64 -> Recording
• Capture.Recording.with_scale : Recording, Scale -> Recording
• Capture.Recording.with_every_nth : Recording, U32 -> Recording
• Capture.Recording.with_timing : Recording, Timing -> Recording
• Capture.Recording.with_cursor : Recording, Cursor -> Recording
• Capture.Recording.with_quality : Recording, Quality -> Recording
• Capture.Recording.path : Recording -> Str
• Capture.Recording.format : Recording -> Format
• Capture.Recording.fps : Recording -> I32
• Capture.Recording.max_frames : Recording -> U64
• Capture.Recording.scale : Recording -> Scale
• Capture.Recording.every_nth : Recording -> U32
• Capture.Recording.timing : Recording -> Timing
• Capture.Recording.cursor : Recording -> Cursor
• Capture.Recording.quality : Recording -> Quality
• Capture.Status : [Idle, Active({ frames : U64, dropped : U64 }), Finished({ frames : U64, bytes : U64 }), Failed({ frames : U64, reason : FailureReason })]
• Capture.FailureReason : [PathInvalid, PathEscapesOutputDir, AlreadyRecording, BudgetExceeded, UnsupportedFormat, OutOfMemory, WriteFailed, EncodeFailed, Unknown]
• Capture.ScreenshotError : [PermissionDenied, PathInvalid, PathEscapesOutputDir, AlreadyPending, WriteFailed, Busy, Unavailable]
• Capture.TextureExportError : [PermissionDenied, PathInvalid, PathEscapesOutputDir, TargetUnavailable, BudgetExceeded, Busy, OutOfMemory, ReadbackFailed, WriteFailed, Unavailable]
• Capture.Source : [Screen, Target(RenderTexture)]
• Capture.Region : { x : I32, y : I32, width : I32, height : I32 }
• Capture.PixelReadError : [RegionOutOfBounds, TargetUnavailable, Busy, ReadbackFailed, Unavailable]
• Capture.Writer
• Capture.Writer.for_host : Authority -> Writer
• Capture.Writer.screenshot! : Writer, Str => Try({}, ScreenshotError)
• Capture.Writer.screenshot_texture! : Writer, RenderTexture, Str => Try({}, TextureExportError)
• Capture.Writer.start! : Writer, Recording => Try({}, [PermissionDenied])
• Capture.Writer.stop! : Writer => Try({}, [PermissionDenied])
• Cmd
• Cmd.default_timeout_ms : U64
• Cmd.default_output_limit_bytes : U64
• Cmd.new : Str -> Cmd
• Cmd.with_arg : Cmd, Str -> Cmd
• Cmd.with_args : Cmd, List(Str) -> Cmd
• Cmd.with_env : Cmd, Str, Str -> Cmd
• Cmd.with_envs : Cmd, List({ name : Str, value : Str }) -> Cmd
• Cmd.with_clear_envs : Cmd, Bool -> Cmd
• Cmd.with_working_dir : Cmd, Str -> Cmd
• Cmd.with_timeout_ms : Cmd, U64 -> Cmd
• Cmd.with_stdout_limit : Cmd, U64 -> Cmd
• Cmd.with_stderr_limit : Cmd, U64 -> Cmd
• Cmd.Output : { exit_code : I64, stdout : List(U8), stderr : List(U8) }
• Cmd.Utf8Output : { exit_code : I64, stdout : Str, stderr : Str }
• Cmd.CmdErr : [CommandNotFound, AccessRefused, PermissionDenied, SpawnFailed, Busy, Unavailable, Timeout(Output), StdoutLimitExceeded, StderrLimitExceeded]
• Cmd.Runner
• Cmd.Runner.for_host : Authority -> Runner
• Cmd.Runner.run! : Runner, Cmd => Try(Output, CmdErr)
• Cmd.Runner.run_utf8! : Runner, Cmd => Try(Utf8Output, CmdErr)
• Color
• Color.rgba : U8, U8, U8, U8 -> Rgba
• Color.rgb : U8, U8, U8 -> Rgba
• Color.with_alpha : Rgba, U8 -> Rgba
• Color.from_hex_rgb : U32 -> Rgba
• Color.from_hex_rgba : U32 -> Rgba
• Color.transparent : Rgba
• Color.black : Rgba
• Color.blue : Rgba
• Color.dark_gray : Rgba
• Color.gray : Rgba
• Color.green : Rgba
• Color.light_gray : Rgba
• Color.orange : Rgba
• Color.pink : Rgba
• Color.purple : Rgba
• Color.ray_white : Rgba
• Color.red : Rgba
• Color.white : Rgba
• Color.yellow : Rgba
• Color.Rgba := { r : U8, g : U8, b : U8, a : U8 }
• Color.Rgba.encoder_for : encoding -> (Rgba, state -> Try(state, err)) where [encoding.encode_color : Rgba, state -> Try(state, err)]
• Color.Rgba.is_eq : _
• Devices
• Devices.none : Snapshot
• Devices.empty : Snapshot
• Devices.Snapshot := { keys : List(U8), text_input : List(U32), text_input_overflow : Bool, events : List(Event), events_overflow : Bool, gamepads : Snapshot, mouse : Snapshot }
• Devices.Snapshot.key_down : Snapshot, Key -> Bool
• Devices.Snapshot.key_up : Snapshot, Key -> Bool
• Devices.Snapshot.key_pressed : Snapshot, Key -> Bool
• Devices.Snapshot.key_released : Snapshot, Key -> Bool
• Devices.Snapshot.gamepad : Snapshot, Id -> [Connected(View), Disconnected]
• Devices.Snapshot.with_key_down : Snapshot, Key -> Snapshot
• Devices.Snapshot.with_key_pressed : Snapshot, Key -> Snapshot
• Devices.Snapshot.with_key_released : Snapshot, Key -> Snapshot
• Devices.Snapshot.with_mouse_position : Snapshot, { x : F32, y : F32 } -> Snapshot
• Devices.Snapshot.with_mouse_delta : Snapshot, { x : F32, y : F32 } -> Snapshot
• Devices.Snapshot.with_mouse_wheel : Snapshot, { x : F32, y : F32 } -> Snapshot
• Devices.Snapshot.with_mouse_button_down : Snapshot, Button -> Snapshot
• Devices.Snapshot.with_mouse_button_pressed : Snapshot, Button -> Snapshot
• Devices.Snapshot.with_mouse_button_released : Snapshot, Button -> Snapshot
• Devices.Snapshot.with_text_input : Snapshot, List(U32) -> Snapshot
• Devices.Snapshot.with_text_input_overflow : Snapshot, Bool -> Snapshot
• Devices.Snapshot.with_events : Snapshot, List(Event) -> Snapshot
• Devices.Snapshot.with_events_overflow : Snapshot, Bool -> Snapshot
• Devices.Event : [KeyPressed(Key), KeyReleased(Key), ButtonPressed(Button, { x : F32, y : F32 }), ButtonReleased(Button, { x : F32, y : F32 }), Wheel({ x : F32, y : F32 }), Text(U32)]
• Draw
• Draw.from_rgba : { r : U8, g : U8, b : U8, a : U8 } -> Rgba
• Draw.alpha_blend : BlendMode
• Draw.additive_blend : BlendMode
• Draw.multiplied_blend : BlendMode
• Draw.add_colors_blend : BlendMode
• Draw.subtract_colors_blend : BlendMode
• Draw.premultiplied_alpha_blend : BlendMode
• Draw.filled : Rgba -> ShapeStyle
• Draw.stroke : Rgba, F32 -> Stroke
• Draw.outlined : Rgba, F32 -> ShapeStyle
• Draw.filled_and_outlined : Rgba, Rgba, F32 -> ShapeStyle
• Draw.default_font! : () => Font
• Draw.default_spacing : F32
• Draw.center_in_rect : Rectangle, TextSize -> Vector2
• Draw.clear! : Frame, Rgba => {}
• Draw.rectangle_gradient_v! : Frame, RectangleGradientV => {}
• Draw.rectangle_gradient_h! : Frame, RectangleGradientH => {}
• Draw.circle_gradient! : Frame, CircleGradient => {}
• Draw.fps! : Frame, Fps => {}
• Draw.rectangle! : Frame, Rectangle => {}
• Draw.rounded_rectangle! : Frame, RoundedRectangle => {}
• Draw.circle! : Frame, Circle => {}
• Draw.line! : Frame, Line => {}
• Draw.triangle! : Frame, Triangle => {}
• Draw.convex_polygon! : Frame, ConvexPolygon => {}
• Draw.triangles! : Frame, TrianglePoints => {}
• Draw.triangle_fan! : Frame, TrianglePoints => {}
• Draw.triangle_strip! : Frame, TrianglePoints => {}
• Draw.line_strip! : Frame, LineStrip => {}
• Draw.circle_sector! : Frame, CircleSector => {}
• Draw.ellipse! : Frame, Ellipse => {}
• Draw.ring! : Frame, Ring => {}
• Draw.load_store_font! : Store, LoadFont => Try(Font, [PathInvalid, NotFound, ReadFailed, FontLoadFailed, ResourceLimit])
• Draw.font_from_bytes! : FontBytes => Try(Font, [FontLoadFailed, ResourceLimit])
• Draw.texture_draw : Texture -> TextureDraw
• Draw.texture_at : Texture, Vec2 -> TextureDraw
• Draw.texture! : Frame, TextureDraw => {}
• Draw.textured_triangles_3d! : Frame, TexturedTriangles3D => {}
• Draw.texture_instances! : Frame, Texture, List(TextureInstance) => {}
• Draw.projective_texture! : Frame, ProjectiveTexture => {}
• Draw.with_render_texture! : Frame, RenderTexture, (Frame => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])) => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])
• Draw.with_shader! : Frame, Shader(uniforms), (Frame => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])) => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])
• Draw.with_blend_mode! : Frame, BlendMode, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])
• Draw.with_camera! : Frame, Camera2D, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])
• Draw.with_camera_3d! : Frame, Camera3D, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])
• Draw.with_scissor! : Frame, Rect, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])
• Draw.text! : Frame, Text => {}
• Draw.debug_text! : Frame, DebugText => {}
• Draw.text_at! : Frame, SimpleText => {}
• Draw.Frame
• Draw.Frame.triangles! : Frame, TrianglePoints => {}
• Draw.Frame.triangle_fan! : Frame, TrianglePoints => {}
• Draw.Frame.triangle_strip! : Frame, TrianglePoints => {}
• Draw.Frame.line_strip! : Frame, LineStrip => {}
• Draw.Frame.circle_sector! : Frame, CircleSector => {}
• Draw.Frame.ellipse! : Frame, Ellipse => {}
• Draw.Frame.ring! : Frame, Ring => {}
• Draw.Frame.clear! : Frame, Rgba => {}
• Draw.Frame.rectangle_gradient_v! : Frame, RectangleGradientV => {}
• Draw.Frame.rectangle_gradient_h! : Frame, RectangleGradientH => {}
• Draw.Frame.circle_gradient! : Frame, CircleGradient => {}
• Draw.Frame.fps! : Frame, Fps => {}
• Draw.Frame.rectangle! : Frame, Rectangle => {}
• Draw.Frame.rounded_rectangle! : Frame, RoundedRectangle => {}
• Draw.Frame.circle! : Frame, Circle => {}
• Draw.Frame.line! : Frame, Line => {}
• Draw.Frame.triangle! : Frame, Triangle => {}
• Draw.Frame.convex_polygon! : Frame, ConvexPolygon => {}
• Draw.Frame.texture! : Frame, TextureDraw => {}
• Draw.Frame.textured_triangles_3d! : Frame, TexturedTriangles3D => {}
• Draw.Frame.texture_instances! : Frame, Texture, List(TextureInstance) => {}
• Draw.Frame.projective_texture! : Frame, ProjectiveTexture => {}
• Draw.Frame.with_render_texture! : Frame, RenderTexture, (Frame => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])) => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])
• Draw.Frame.with_shader! : Frame, Shader(uniforms), (Frame => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])) => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])
• Draw.Frame.with_blend_mode! : Frame, BlendMode, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])
• Draw.Frame.with_camera! : Frame, Camera2D, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])
• Draw.Frame.with_camera_3d! : Frame, Camera3D, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])
• Draw.Frame.with_scissor! : Frame, Rect, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])
• Draw.Frame.text! : Frame, Text => {}
• Draw.Frame.debug_text! : Frame, DebugText => {}
• Draw.Frame.text_at! : Frame, SimpleText => {}
• Draw.Frame.size! : Frame => FrameSize
• Draw.FrameSize : { width : F32, height : F32 }
• Draw.Texture : Texture
• Draw.Vector2 : Vec2
• Draw.Rect : Rect
• Draw.Camera2D : Camera2D
• Draw.Camera3D : Camera3D
• Draw.Vector3 : Vec3
• Draw.TexturedVertex3D : { position : Vector3, uv : Vector2, tint : Rgba }
• Draw.TexturedTriangles3D : { texture : Texture, vertices : List(TexturedVertex3D), indices : List(U32) }
• Draw.Fill : [NoFill, Fill(Rgba)]
• Draw.Stroke : [NoStroke, Stroke({ color : Rgba, thickness : F32 })]
• Draw.ShapeStyle : { fill : Fill, stroke : Stroke }
• Draw.Rectangle : { x : F32, y : F32, width : F32, height : F32, style : ShapeStyle }
• Draw.RoundedRectangle : { x : F32, y : F32, width : F32, height : F32, radius : F32, segments : I32, style : ShapeStyle }
• Draw.RectangleGradientV : { x : F32, y : F32, width : F32, height : F32, color_top : Rgba, color_bottom : Rgba }
• Draw.RectangleGradientH : { x : F32, y : F32, width : F32, height : F32, color_left : Rgba, color_right : Rgba }
• Draw.Circle : { center : Vector2, radius : F32, style : ShapeStyle }
• Draw.CircleGradient : { center : Vector2, radius : F32, color_inner : Rgba, color_outer : Rgba }
• Draw.Line : { start : Vector2, end : Vector2, stroke : Stroke }
• Draw.Triangle : { a : Vector2, b : Vector2, c : Vector2, style : ShapeStyle }
• Draw.ConvexPolygon : { points : List(Vector2), style : ShapeStyle }
• Draw.TrianglePoints : { points : List(Vector2), color : Rgba }
• Draw.LineStrip : { points : List(Vector2), stroke : Stroke }
• Draw.CircleSector : { center : Vector2, radius : F32, start_angle : F32, end_angle : F32, segments : I32, style : ShapeStyle }
• Draw.Ellipse : { center : Vector2, radius_x : F32, radius_y : F32, style : ShapeStyle }
• Draw.Ring : { center : Vector2, inner_radius : F32, outer_radius : F32, start_angle : F32, end_angle : F32, segments : I32, style : ShapeStyle }
• Draw.Fps : { pos : Vector2, size : F32, color : Rgba }
• Draw.GlyphMetrics : { codepoint : U32, advance_x : F32, offset_x : F32, offset_y : F32, width : F32, height : F32 }
• Draw.TextSize : { width : F32, height : F32 }
• Draw.Text : { pos : Vector2, text : Str, size : F32, spacing : F32, color : Rgba, font : Font }
• Draw.DebugText : { pos : Vector2, text : Str, size : F32, color : Rgba }
• Draw.SimpleText : { pos : Vector2, text : Str, size : F32, color : Rgba }
• Draw.LoadFont : { path : Str, size : I32 }
• Draw.TextureDraw : TextureDrawConfig
• Draw.TextureInstance : TextureInstanceConfig
• Draw.ProjectiveQuadCorners : { top_left : Vec2, bottom_left : Vec2, bottom_right : Vec2, top_right : Vec2 }
• Draw.ProjectiveQuad
• Draw.ProjectiveQuad.from_corners : ProjectiveQuadCorners -> Try(ProjectiveQuad, [NonFiniteQuad, DegenerateQuad, NonConvexQuad, ProjectiveHorizon])
• Draw.ProjectiveQuad.project : ProjectiveQuad, Vec2 -> Vec2
• Draw.ProjectiveTexture : { texture : Texture, source : Rect, quad : ProjectiveQuad, tint : Rgba }
• Draw.RenderTexture
• Draw.RenderTexture.load! : RenderTextureSize => Try(RenderTexture, [RenderTextureLoadFailed, ResourceLimit])
• Draw.RenderTexture.texture : RenderTexture -> Texture
• Draw.RenderTexture.source : RenderTexture -> Rect
• Draw.RenderTexture.stub : RenderTexture
• Draw.RenderTextureSize : { width : I32, height : I32 }
• Draw.FontFormat := [Ttf, Otf]
• Draw.FontBytes : { format : FontFormat, bytes : List(U8), size : I32 }
• Draw.BlendMode : [Alpha, Additive, Multiplied, AddColors, SubtractColors, AlphaPremultiply]
• Draw.ScopeError : [ScopeLimit, ScopeUnavailable]
• Files
• Files.Entry : { name : Str, kind : EntryKind }
• Files.EntryKind : [File, Dir, Other]
• Files.ReadTextError : [PermissionDenied, PathInvalid, NotFound, ReadFailed, Busy, Unavailable, TooLarge, NotUtf8]
• Files.ReadBytesError : [PermissionDenied, PathInvalid, NotFound, ReadFailed, Busy, Unavailable, TooLarge]
• Files.ListError : [PermissionDenied, PathInvalid, NotFound, NotADirectory, ReadFailed, Busy, Unavailable, TooLarge]
• Files.Metadata : { kind : EntryKind, size_bytes : U64, modified : Timestamp }
• Files.MetadataError : [NotFound, AccessRefused, PathInvalid, PermissionDenied, ReadFailed, Unavailable]
• Files.WriteError : [NotFound, AccessRefused, PathInvalid, PermissionDenied, NoSpace, WriteFailed, Unavailable]
• Files.OpenError : [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable]
• Files.PathInvalid : [PathInvalid]
• Files.ReadDir
• Files.ReadDir.stub : ReadDir
• Files.ReadDir.subdir : ReadDir, Str -> Try(ReadDir, [PathInvalid])
• Files.ReadDir.read_text! : ReadDir, Str => Try(Str, ReadTextError)
• Files.ReadDir.read_bytes! : ReadDir, Str => Try(List(U8), ReadBytesError)
• Files.ReadDir.list! : ReadDir, Str => Try(List(Entry), ListError)
• Files.ReadDir.metadata! : ReadDir, Str => Try(Metadata, MetadataError)
• Files.ReadDir.for_host : ReadDir -> { authority : Authority, root : Str, path : Str }
• Files.Dir
• Files.Dir.stub : Dir
• Files.Dir.read_only : Dir -> ReadDir
• Files.Dir.subdir : Dir, Str -> Try(Dir, [PathInvalid])
• Files.Dir.read_text! : Dir, Str => Try(Str, ReadTextError)
• Files.Dir.read_bytes! : Dir, Str => Try(List(U8), ReadBytesError)
• Files.Dir.list! : Dir, Str => Try(List(Entry), ListError)
• Files.Dir.metadata! : Dir, Str => Try(Metadata, MetadataError)
• Files.Dir.write_text! : Dir, Str, Str => Try({}, WriteError)
• Files.Dir.write_bytes! : Dir, Str, List(U8) => Try({}, WriteError)
• Files.Dir.for_host : Dir -> { authority : Authority, root : Str, path : Str }
• Files.Designated
• Files.Designated.stub : Designated
• Files.Designated.path : Designated -> Str
• Files.Designated.read_text! : Designated => Try(Str, ReadTextError)
• Files.Designated.read_bytes! : Designated => Try(List(U8), ReadBytesError)
• Files.Designated.metadata! : Designated => Try(Metadata, MetadataError)
• Files.Designated.dir : Designated -> ReadDir
• Files.Access
• Files.Access.for_host : Authority -> Access
• Files.Access.app_data! : Access => Try(Dir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.app_config! : Access => Try(Dir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.app_cache! : Access => Try(Dir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.beside_executable! : Access => Try(ReadDir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.working_directory! : Access => Try(Dir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.working_directory_read! : Access => Try(ReadDir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.open_dir! : Access, Str => Try(Dir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.accept_drop! : Access, Str => Try(Designated, [PermissionDenied])
• Files.Access.from_arg! : Access, Str => Try(Designated, [PermissionDenied])
• Files.Access.open_dir_read! : Access, Str => Try(ReadDir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Font
• Font.stub : Font
• Font.measure : Font, Measure -> Size
• Font.FontHandle : Font
• Font.GlyphMetrics : { codepoint : U32, advance_x : F32, offset_x : F32, offset_y : F32, width : F32, height : F32 }
• Font.FontMetrics : { base_size : F32, line_spacing : F32, fallback_index : U64, glyphs : List(GlyphMetrics) }
• Font.Measure : { text : Str, size : F32, spacing : F32 }
• Font.Size : { width : F32, height : F32 }
• Gamepad
• Gamepad.from_index : U64 -> Try(Id, [InvalidGamepadIndex])
• Gamepad.lookup : Snapshot, Id -> [Connected(View), Disconnected]
• Gamepad.button_down : { ..state, buttons : List(U8) }, Id, Button -> Bool
• Gamepad.button_up : { ..state, buttons : List(U8) }, Id, Button -> Bool
• Gamepad.button_pressed : { ..state, buttons : List(U8) }, Id, Button -> Bool
• Gamepad.button_released : { ..state, buttons : List(U8) }, Id, Button -> Bool
• Gamepad.axis : { ..state, axes : List(F32) }, Id, Axis -> F32
• Gamepad.left_stick : { ..state, axes : List(F32) }, Id -> { x : F32, y : F32 }
• Gamepad.right_stick : { ..state, axes : List(F32) }, Id -> { x : F32, y : F32 }
• Gamepad.Snapshot := { connected : List(U8), buttons : List(U8), axes : List(F32) }
• Gamepad.Snapshot.lookup : Snapshot, Id -> [Connected(View), Disconnected]
• Gamepad.Id := [One, Two, Three, Four]
• Gamepad.Id.is_eq : _
• Gamepad.Button := [Unknown, DpadUp, DpadRight, DpadDown, DpadLeft, FaceUp, FaceRight, FaceDown, FaceLeft, LeftBumper, LeftTrigger, RightBumper, RightTrigger, Select, Guide, Start, LeftStick, RightStick]
• Gamepad.Axis := [LeftX, LeftY, RightX, RightY, LeftTriggerAxis, RightTriggerAxis]
• Gamepad.View
• Gamepad.View.id : View -> Id
• Gamepad.View.button_down : View, Button -> Bool
• Gamepad.View.button_up : View, Button -> Bool
• Gamepad.View.button_pressed : View, Button -> Bool
• Gamepad.View.button_released : View, Button -> Bool
• Gamepad.View.axis : View, Axis -> F32
• Gamepad.View.left_stick : View -> { x : F32, y : F32 }
• Gamepad.View.right_stick : View -> { x : F32, y : F32 }
• Http
• Http.default_config : Config
• Http.with_json_body : Request, _ -> Try(Request, [JsonErr(_)])
• Http.decode_json_response : Response -> Try(_, [BadBody(Str), JsonErr(_)])
• Http.TransportErr : [Timeout, NetworkError, MalformedResponse, Other(List(U8))]
• Http.Config : { timeout_ms : U64, max_response_bytes : U64 }
• Http.Client
• Http.Client.for_host : Authority -> Client
• Http.Client.send! : Client, Request => Try(Response, [PermissionDenied, InvalidUrl(ParseErr), HttpErr(TransportErr)])
• Http.Client.send_with! : Client, Config, Request => Try(Response, [PermissionDenied, InvalidUrl(ParseErr), HttpErr(TransportErr)])
• Http.Client.send_json! : Client, Request, _ => Try(Response, [PermissionDenied, JsonErr(_), InvalidUrl(ParseErr), HttpErr(TransportErr)])
• Http.Client.get_utf8! : Client, Url => Try(Str, [PermissionDenied, BadBody(Str), InvalidUrl(ParseErr), HttpErr(TransportErr)])
• Http.Client.get! : Client, Url => Try(_, [PermissionDenied, BadBody(Str), InvalidUrl(ParseErr), HttpErr(TransportErr), JsonErr(_)])
• Keys
• Keys.from_code : U64 -> Try(Key, [InvalidKeyCode])
• Keys.key_code : Key -> U64
• Keys.key_down : { ..state, keys : List(U8) }, Key -> Bool
• Keys.key_up : { ..state, keys : List(U8) }, Key -> Bool
• Keys.key_pressed : { ..state, keys : List(U8) }, Key -> Bool
• Keys.key_released : { ..state, keys : List(U8) }, Key -> Bool
• Keys.set_exit_key! : ExitKey => {}
• Keys.holding : List(Key) -> Source
• Keys.set_source! : Source => {}
• Keys.typing : Str -> List(U32)
• Keys.set_text! : List(U32) => {}
• Keys.Key := [KeyAndroidBack, KeyAndroidMenu, KeyVolumeUp, KeyVolumeDown, KeyApostrophe, KeyComma, KeyMinus, KeyPeriod, KeySlash, Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8, Key9, KeySemicolon, KeyEqual, KeyA, KeyB, KeyC, KeyD, KeyE, KeyF, KeyG, KeyH, KeyI, KeyJ, KeyK, KeyL, KeyM, KeyN, KeyO, KeyP, KeyQ, KeyR, KeyS, KeyT, KeyU, KeyV, KeyW, KeyX, KeyY, KeyZ, KeyLeftBracket, KeyBackslash, KeyRightBracket, KeyGrave, KeySpace, KeyEscape, KeyEnter, KeyTab, KeyBackspace, KeyInsert, KeyDelete, KeyRight, KeyLeft, KeyDown, KeyUp, KeyPageUp, KeyPageDown, KeyHome, KeyEnd, KeyCapsLock, KeyScrollLock, KeyNumLock, KeyPrintScreen, KeyPause, KeyF1, KeyF2, KeyF3, KeyF4, KeyF5, KeyF6, KeyF7, KeyF8, KeyF9, KeyF10, KeyF11, KeyF12, KeyLeftShift, KeyLeftControl, KeyLeftAlt, KeyLeftSuper, KeyRightShift, KeyRightControl, KeyRightAlt, KeyRightSuper, KeyKbMenu, KeyKp0, KeyKp1, KeyKp2, KeyKp3, KeyKp4, KeyKp5, KeyKp6, KeyKp7, KeyKp8, KeyKp9, KeyKpDecimal, KeyKpDivide, KeyKpMultiply, KeyKpSubtract, KeyKpAdd, KeyKpEnter, KeyKpEqual, Raw(U64)]
• Keys.Key.is_eq : _
• Keys.ExitKey := [NoExitKey, ExitKey(Key)]
• Keys.ExitKey.is_eq : ExitKey, ExitKey -> Bool
• Keys.Source : [Hardware, Virtual(List(Key))]
• Math
• Math.vec3 : F32, F32, F32 -> Vec3
• Math.vec4 : F32, F32, F32, F32 -> Vec4
• Math.vec2 : F32, F32 -> Vec2
• Math.zero : Vec2
• Math.rect : F32, F32, F32, F32 -> Rect
• Math.circle : Vec2, F32 -> Circle
• Math.clamp : F32, F32, F32 -> F32
• Math.clamp01 : F32 -> F32
• Math.lerp : F32, F32, F32 -> F32
• Math.sqrt : F32 -> F32
• Math.add : Vec2, Vec2 -> Vec2
• Math.sub : Vec2, Vec2 -> Vec2
• Math.scale : Vec2, F32 -> Vec2
• Math.dot : Vec2, Vec2 -> F32
• Math.length_squared : Vec2 -> F32
• Math.length : Vec2 -> F32
• Math.distance_squared : Vec2, Vec2 -> F32
• Math.distance : Vec2, Vec2 -> F32
• Math.normalize : Vec2 -> Vec2
• Math.lerp_vec2 : Vec2, Vec2, F32 -> Vec2
• Math.left : Rect -> F32
• Math.right : Rect -> F32
• Math.top : Rect -> F32
• Math.bottom : Rect -> F32
• Math.center : Rect -> Vec2
• Math.closest_point : Rect, Vec2 -> Vec2
• Math.contains : Rect, Vec2 -> Bool
• Math.circle_contains : Circle, Vec2 -> Bool
• Math.overlaps : Rect, Rect -> Bool
• Math.circle_overlaps : Circle, Circle -> Bool
• Math.circle_rect : Circle, Rect -> Bool
• Math.contains_point : Circle, Vec2 -> Bool
• Math.overlaps_circle : Circle, Circle -> Bool
• Math.overlaps_rect : Circle, Rect -> Bool
• Math.Vec2 := { x : F32, y : F32 }
• Math.Vec2.circle : Vec2, F32 -> Circle
• Math.Vec2.add : Vec2, Vec2 -> Vec2
• Math.Vec2.sub : Vec2, Vec2 -> Vec2
• Math.Vec2.scale : Vec2, F32 -> Vec2
• Math.Vec2.dot : Vec2, Vec2 -> F32
• Math.Vec2.length_squared : Vec2 -> F32
• Math.Vec2.length : Vec2 -> F32
• Math.Vec2.distance_squared : Vec2, Vec2 -> F32
• Math.Vec2.distance : Vec2, Vec2 -> F32
• Math.Vec2.normalize : Vec2 -> Vec2
• Math.Vec2.lerp_vec2 : Vec2, Vec2, F32 -> Vec2
• Math.Vec2.encoder_for : encoding -> (Vec2, state -> Try(state, err)) where [encoding.encode_vec2 : Vec2, state -> Try(state, err)]
• Math.Vec2.is_eq : Vec2, Vec2 -> Bool
• Math.Vec3 := { x : F32, y : F32, z : F32 }
• Math.Vec3.encoder_for : encoding -> (Vec3, state -> Try(state, err)) where [encoding.encode_vec3 : Vec3, state -> Try(state, err)]
• Math.Vec3.is_eq : Vec3, Vec3 -> Bool
• Math.Vec4 := { x : F32, y : F32, z : F32, w : F32 }
• Math.Vec4.encoder_for : encoding -> (Vec4, state -> Try(state, err)) where [encoding.encode_vec4 : Vec4, state -> Try(state, err)]
• Math.Rect := { x : F32, y : F32, width : F32, height : F32 }
• Math.Rect.left : Rect -> F32
• Math.Rect.right : Rect -> F32
• Math.Rect.top : Rect -> F32
• Math.Rect.bottom : Rect -> F32
• Math.Rect.center : Rect -> Vec2
• Math.Rect.closest_point : Rect, Vec2 -> Vec2
• Math.Rect.contains : Rect, Vec2 -> Bool
• Math.Rect.overlaps : Rect, Rect -> Bool
• Math.Rect.is_eq : Rect, Rect -> Bool
• Math.Circle := { center : Vec2, radius : F32 }
• Math.Circle.circle_contains : Circle, Vec2 -> Bool
• Math.Circle.circle_overlaps : Circle, Circle -> Bool
• Math.Circle.circle_rect : Circle, Rect -> Bool
• Math.Circle.contains_point : Circle, Vec2 -> Bool
• Math.Circle.overlaps_circle : Circle, Circle -> Bool
• Math.Circle.overlaps_rect : Circle, Rect -> Bool
• Math.Circle.is_eq : Circle, Circle -> Bool
• Mouse
• Mouse.position : { ..state, x : F32, y : F32 } -> { x : F32, y : F32 }
• Mouse.delta : { ..state, delta_x : F32, delta_y : F32 } -> { x : F32, y : F32 }
• Mouse.wheel_delta : { ..state, wheel_x : F32, wheel_y : F32 } -> { x : F32, y : F32 }
• Mouse.virtual_at : { x : F32, y : F32 } -> Source
• Mouse.virtual_click_at : { x : F32, y : F32 } -> Source
• Mouse.button_down : { ..state, buttons : List(U8) }, Button -> Bool
• Mouse.button_up : { ..state, buttons : List(U8) }, Button -> Bool
• Mouse.button_pressed : { ..state, buttons : List(U8) }, Button -> Bool
• Mouse.button_released : { ..state, buttons : List(U8) }, Button -> Bool
• Mouse.set_source! : Source => {}
• Mouse.set_cursor! : Cursor => {}
• Mouse.set_cursor_mode! : CursorMode => {}
• Mouse.Snapshot := { buttons : List(U8), left : Bool, middle : Bool, right : Bool, wheel : F32, wheel_x : F32, wheel_y : F32, delta_x : F32, delta_y : F32, x : F32, y : F32 }
• Mouse.Snapshot.button_down : Snapshot, Button -> Bool
• Mouse.Snapshot.button_up : Snapshot, Button -> Bool
• Mouse.Snapshot.button_pressed : Snapshot, Button -> Bool
• Mouse.Snapshot.button_released : Snapshot, Button -> Bool
• Mouse.Snapshot.position : Snapshot -> { x : F32, y : F32 }
• Mouse.Snapshot.delta : Snapshot -> { x : F32, y : F32 }
• Mouse.Snapshot.wheel_delta : Snapshot -> { x : F32, y : F32 }
• Mouse.Cursor := [Default, Arrow, IBeam, Crosshair, PointingHand, ResizeEastWest, ResizeNorthSouth, ResizeNorthwestSoutheast, ResizeNortheastSouthwest, ResizeAll, NotAllowed]
• Mouse.Cursor.is_eq : _
• Mouse.Button := [Left, Right, Middle, Side, Extra, Forward, Back]
• Mouse.Button.is_eq : _
• Mouse.Source := [Hardware, Virtual({ x : F32, y : F32, left : Bool, middle : Bool, right : Bool, wheel : F32 })]
• Mouse.CursorMode : [Visible, Hidden, Locked]
• Permission
• Permission.is_eq : _
• Physics
• Physics.point : F32, F32, F32 -> Point
• Physics.point_xy : F32, F32 -> Point
• Physics.origin : Point
• Physics.vector : F32, F32, F32 -> Vector
• Physics.vector_xy : F32, F32 -> Vector
• Physics.zero : Vector
• Physics.coords : Point -> Coords
• Physics.components : Vector -> Coords
• Physics.xy : Point -> Vec2
• Physics.vector_xy_components : Vector -> Vec2
• Physics.point_coeffs : Point -> PointCoeffs
• Physics.vector_coeffs : Vector -> VectorCoeffs
• Physics.plane_coeffs : Plane -> PlaneCoeffs
• Physics.line_coeffs : Line -> LineCoeffs
• Physics.motor_coeffs : Motor -> MotorCoeffs
• Physics.add : Point, Vector -> Point
• Physics.sub : Point, Point -> Vector
• Physics.add_vec : Vector, Vector -> Vector
• Physics.sub_vec : Vector, Vector -> Vector
• Physics.scale : Vector, F32 -> Vector
• Physics.dot : Vector, Vector -> F32
• Physics.cross : Vector, Vector -> Vector
• Physics.length_squared : Vector -> F32
• Physics.length : Vector -> F32
• Physics.normalize : Vector -> Vector
• Physics.reflect : Vector, Vector -> Vector
• Physics.distance : Point, Point -> F32
• Physics.plane : Vector, F32 -> Plane
• Physics.plane_from_point_normal : Point, Vector -> Plane
• Physics.signed_distance : Plane, Point -> F32
• Physics.project_point_plane : Plane, Point -> Point
• Physics.line_from_points : Point, Point -> Line
• Physics.motor_identity : Motor
• Physics.translation : Vector -> Motor
• Physics.translation_vector : Motor -> Vector
• Physics.apply_motor_point : Motor, Point -> Point
• Physics.body : Point, Vector -> Body
• Physics.apply_acceleration : Body, Vector, F32 -> Body
• Physics.integrate_body : Body, F32 -> Body
• Physics.clamp_y : Vector, F32, F32 -> Vector
• Physics.Point := { e032 : F32, e013 : F32, e021 : F32, e123 : F32 }
• Physics.Point.coords : Point -> Coords
• Physics.Point.xy : Point -> Vec2
• Physics.Point.point_coeffs : Point -> PointCoeffs
• Physics.Point.add : Point, Vector -> Point
• Physics.Point.sub : Point, Point -> Vector
• Physics.Point.distance : Point, Point -> F32
• Physics.Point.plane_from_point_normal : Point, Vector -> Plane
• Physics.Point.line_from_points : Point, Point -> Line
• Physics.Point.body : Point, Vector -> Body
• Physics.Vector := { e032 : F32, e013 : F32, e021 : F32 }
• Physics.Vector.components : Vector -> Coords
• Physics.Vector.vector_xy_components : Vector -> Vec2
• Physics.Vector.vector_coeffs : Vector -> VectorCoeffs
• Physics.Vector.add_vec : Vector, Vector -> Vector
• Physics.Vector.sub_vec : Vector, Vector -> Vector
• Physics.Vector.scale : Vector, F32 -> Vector
• Physics.Vector.dot : Vector, Vector -> F32
• Physics.Vector.cross : Vector, Vector -> Vector
• Physics.Vector.length_squared : Vector -> F32
• Physics.Vector.length : Vector -> F32
• Physics.Vector.normalize : Vector -> Vector
• Physics.Vector.reflect : Vector, Vector -> Vector
• Physics.Vector.plane : Vector, F32 -> Plane
• Physics.Vector.translation : Vector -> Motor
• Physics.Vector.clamp_y : Vector, F32, F32 -> Vector
• Physics.Plane := { e0 : F32, e1 : F32, e2 : F32, e3 : F32 }
• Physics.Plane.plane_coeffs : Plane -> PlaneCoeffs
• Physics.Plane.signed_distance : Plane, Point -> F32
• Physics.Plane.project_point_plane : Plane, Point -> Point
• Physics.Line := { e01 : F32, e02 : F32, e03 : F32, e23 : F32, e31 : F32, e12 : F32 }
• Physics.Line.line_coeffs : Line -> LineCoeffs
• Physics.Motor := { s : F32, e23 : F32, e31 : F32, e12 : F32, e01 : F32, e02 : F32, e03 : F32, e0123 : F32 }
• Physics.Motor.motor_coeffs : Motor -> MotorCoeffs
• Physics.Motor.translation_vector : Motor -> Vector
• Physics.Motor.apply_motor_point : Motor, Point -> Point
• Physics.Body := { position : Point, velocity : Vector }
• Physics.Body.apply_acceleration : Body, Vector, F32 -> Body
• Physics.Body.integrate_body : Body, F32 -> Body
• Physics.Coords : { x : F32, y : F32, z : F32 }
• Physics.PointCoeffs : { e032 : F32, e013 : F32, e021 : F32, e123 : F32 }
• Physics.VectorCoeffs : { e032 : F32, e013 : F32, e021 : F32 }
• Physics.PlaneCoeffs : { e0 : F32, e1 : F32, e2 : F32, e3 : F32 }
• Physics.LineCoeffs : { e01 : F32, e02 : F32, e03 : F32, e23 : F32, e31 : F32, e12 : F32 }
• Physics.MotorCoeffs : { s : F32, e23 : F32, e31 : F32, e12 : F32, e01 : F32, e02 : F32, e03 : F32, e0123 : F32 }
• Random
• Random.seed : U32 -> State
• Random.seed_variant : U32, U32 -> State
• Random.step : State, Generator(value) -> Generation(value)
• Random.next : Generation(_), Generator(value) -> Generation(value)
• Random.static : value -> Generator(value)
• Random.map : Generator(a), (a -> b) -> Generator(b)
• Random.map2 : Generator(a), Generator(b), (a, b -> c) -> Generator(c)
• Random.chain : Generator(a), (a -> Generator(b)) -> Generator(b)
• Random.list : Generator(a), U64 -> Generator(List(a))
• Random.shuffle : List(a) -> Generator(List(a))
• Random.bool : Generator(Bool)
• Random.u8 : Generator(U8)
• Random.i8 : Generator(I8)
• Random.u16 : Generator(U16)
• Random.i16 : Generator(I16)
• Random.u32 : Generator(U32)
• Random.i32 : Generator(I32)
• Random.u64 : Generator(U64)
• Random.i64 : Generator(I64)
• Random.bounded_u8 : U8, U8 -> Generator(U8)
• Random.bounded_i8 : I8, I8 -> Generator(I8)
• Random.bounded_u16 : U16, U16 -> Generator(U16)
• Random.bounded_i16 : I16, I16 -> Generator(I16)
• Random.bounded_u32 : U32, U32 -> Generator(U32)
• Random.bounded_i32 : I32, I32 -> Generator(I32)
• Random.bounded_u64 : U64, U64 -> Generator(U64)
• Random.bounded_i64 : I64, I64 -> Generator(I64)
• Random.f32 : F32, F32 -> Generator(F32)
• Random.f64 : F64, F64 -> Generator(F64)
• Random.choice : a, List(a) -> Generator(a)
• Random.choice_try : List(a) -> Try(Generator(a), [ListWasEmpty])
• Random.choice_weighted : (a, F64), List((a, F64)) -> Generator(a)
• Random.choice_weighted_try : List((a, F64)) -> Try(Generator(a), [ListWasEmpty])
• Random.State : State
• Random.Generator : Generator(value)
• Random.Generation : Generation(value)
• Shader
• Shader.from_source! : LoadShaderSource, uniforms => Try(Shader(uniforms), [ShaderLoadFailed, ResourceLimit, UniformNotFound(Str), UniformReflectionUnavailable, UniformTypeMismatch({ name : Str, expected : ShaderUniformType, actual : ShaderUniformType }), UnsupportedUniformType(Str)]) where [uniforms.encoder_for : UniformFormat -> (uniforms, UniformState -> Try(UniformState, UniformEncodeError))]
• Shader.from_store! : Store, LoadShader, uniforms => Try(Shader(uniforms), [PathInvalid, NotFound, ReadFailed, ShaderLoadFailed, ResourceLimit, UniformNotFound(Str), UniformReflectionUnavailable, UniformTypeMismatch({ name : Str, expected : ShaderUniformType, actual : ShaderUniformType }), UnsupportedUniformType(Str)]) where [uniforms.encoder_for : UniformFormat -> (uniforms, UniformState -> Try(UniformState, UniformEncodeError))]
• Shader.with_uniforms : Shader(uniforms), uniforms -> Shader(uniforms) where [uniforms.encoder_for : UniformFormat -> (uniforms, UniformState -> Try(UniformState, UniformEncodeError))]
• Shader.stub : uniforms -> Shader(uniforms) where [uniforms.encoder_for : UniformFormat -> (uniforms, UniformState -> Try(UniformState, UniformEncodeError))]
• Shader.for_frame : Shader(uniforms) -> { resource : Shader, values : List(ShaderUniformValue) }
• Sprite
• Sprite.source : Sprite, Rect -> Sprite
• Sprite.pos : Sprite, Vec2 -> Sprite
• Sprite.origin : Sprite, Vec2 -> Sprite
• Sprite.centered : Sprite -> Sprite
• Sprite.rotation : Sprite, F32 -> Sprite
• Sprite.scale_xy : Sprite, Vec2 -> Sprite
• Sprite.scale : Sprite, F32 -> Sprite
• Sprite.tint : Sprite, Rgba -> Sprite
• Sprite.to_texture_draw : Sprite -> TextureDraw
• Sprite.draw! : Sprite, Frame => {}
• Sprite.from_texture : Texture -> Sprite
• Sprite.sheet_frame : { frame_size : Vec2, row : U64, col : U64 } -> Rect
• Sprite.animation : { frame_count : U64, fps : F32 } -> Animation
• Sprite.step : Animation, F32 -> Animation
• Sprite.animation_source : Animation, { frame_size : Vec2, row : U64 } -> Rect
• Sprite.Animation : { frame : U64, frame_count : U64, fps : F32, elapsed : F32 }
• Sqlite
• Sqlite.default_config : Config
• Sqlite.errcode_to_str : ErrCode -> Str
• Sqlite.Value : [Null, Integer(I64), Real(F64), String(Str), Bytes(List(U8))]
• Sqlite.ValueKind : [Null, Integer, Real, String, Bytes]
• Sqlite.Binding : { name : Str, value : Value }
• Sqlite.ErrCode : [Error, Internal, Perm, Abort, Busy, Locked, NoMem, ReadOnly, Interrupt, IOErr, Corrupt, NotFound, Full, CanNotOpen, Protocol, Empty, Schema, TooBig, Constraint, Mismatch, Misuse, NoLFS, AuthDenied, Format, OutOfRange, NotADatabase, Notice, Warning, Row, Done, Unknown(I64)]
• Sqlite.OpenErr : [PermissionDenied, PathInvalid, SqliteErr(ErrCode, Str), TooManyConnections]
• Sqlite.PrepareErr : [SqliteErr(ErrCode, Str), TooManyStatements, MultipleStatements]
• Sqlite.QueryErr : [SqliteErr(ErrCode, Str), ResultTooLarge, MultipleStatements]
• Sqlite.ExecuteErr : [SqliteErr(ErrCode, Str), ResultTooLarge, MultipleStatements, RowsReturnedUseQueryInstead]
• Sqlite.ExactlyOneErr : [SqliteErr(ErrCode, Str), ResultTooLarge, MultipleStatements, NoRowsReturned, TooManyRowsReturned]
• Sqlite.DecodeErr : [NoSuchField(Str), UnexpectedType(ValueKind), IntOutOfBounds]
• Sqlite.Mode : [ReadWriteCreate, ReadWrite, ReadOnly]
• Sqlite.Config : { mode : Mode, busy_timeout_ms : U64, max_result_bytes : U64 }
• Sqlite.Outcome : { changes : I64, last_insert_rowid : I64 }
• Sqlite.Db
• Sqlite.Db.close! : Db => Try({}, [SqliteErr(ErrCode, Str)])
• Sqlite.Db.prepare! : Db, Str => Try(Stmt, PrepareErr)
• Sqlite.Db.execute! : Db, Str, List(Binding) => Try(Outcome, ExecuteErr)
• Sqlite.Db.query! : Db, Str, List(Binding) => Try(List(Row), QueryErr)
• Sqlite.Db.query_exactly_one! : Db, Str, List(Binding) => Try(Row, ExactlyOneErr)
• Sqlite.Db.exec_script! : Db, Str => Try({}, [SqliteErr(ErrCode, Str)])
• Sqlite.Db.stub : Db
• Sqlite.Row := { names : List(Str), values : List(Value) }
• Sqlite.Row.is_eq : _
• Sqlite.Row.names : Row -> List(Str)
• Sqlite.Row.values : Row -> List(Value)
• Sqlite.Row.value : Row, Str -> Try(Value, [NoSuchField(Str)])
• Sqlite.Row.str : Row, Str -> Try(Str, DecodeErr)
• Sqlite.Row.bytes : Row, Str -> Try(List(U8), DecodeErr)
• Sqlite.Row.f64 : Row, Str -> Try(F64, DecodeErr)
• Sqlite.Row.i64 : Row, Str -> Try(I64, DecodeErr)
• Sqlite.Row.i32 : Row, Str -> Try(I32, DecodeErr)
• Sqlite.Row.i16 : Row, Str -> Try(I16, DecodeErr)
• Sqlite.Row.i8 : Row, Str -> Try(I8, DecodeErr)
• Sqlite.Row.u64 : Row, Str -> Try(U64, DecodeErr)
• Sqlite.Row.u32 : Row, Str -> Try(U32, DecodeErr)
• Sqlite.Row.u16 : Row, Str -> Try(U16, DecodeErr)
• Sqlite.Row.u8 : Row, Str -> Try(U8, DecodeErr)
• Sqlite.Row.nullable_str : Row, Str -> Try([NotNull(Str), Null], DecodeErr)
• Sqlite.Row.nullable_bytes : Row, Str -> Try([NotNull(List(U8)), Null], DecodeErr)
• Sqlite.Row.nullable_f64 : Row, Str -> Try([NotNull(F64), Null], DecodeErr)
• Sqlite.Row.nullable_i64 : Row, Str -> Try([NotNull(I64), Null], DecodeErr)
• Sqlite.Row.for_tests : List(Str), List(Value) -> Row
• Sqlite.Stmt
• Sqlite.Stmt.execute! : Stmt, List(Binding) => Try(Outcome, ExecuteErr)
• Sqlite.Stmt.query! : Stmt, List(Binding) => Try(List(Row), QueryErr)
• Sqlite.Stmt.query_exactly_one! : Stmt, List(Binding) => Try(Row, ExactlyOneErr)
• Sqlite.Stmt.stub : Stmt
• Sqlite.Service
• Sqlite.Service.for_host : Authority -> Service
• Sqlite.Service.open! : Service, Dir, Str => Try(Db, OpenErr)
• Sqlite.Service.open_with! : Service, Dir, Str, Config => Try(Db, OpenErr)
• Sqlite.Service.open_read! : Service, ReadDir, Str => Try(Db, OpenErr)
• Sqlite.Service.open_memory! : Service => Try(Db, OpenErr)
• Stderr
• Stderr.WriteError : [PermissionDenied, BufferFull, TooLarge, Unavailable]
• Stderr.Writer
• Stderr.Writer.for_host : Authority -> Writer
• Stderr.Writer.line! : Writer, Str => Try({}, WriteError)
• Stderr.Writer.write! : Writer, Str => Try({}, WriteError)
• Stderr.Writer.write_bytes! : Writer, List(U8) => Try({}, WriteError)
• Stdout
• Stdout.WriteError : [PermissionDenied, BufferFull, TooLarge, Unavailable]
• Stdout.Writer
• Stdout.Writer.for_host : Authority -> Writer
• Stdout.Writer.line! : Writer, Str => Try({}, WriteError)
• Stdout.Writer.write! : Writer, Str => Try({}, WriteError)
• Stdout.Writer.write_bytes! : Writer, List(U8) => Try({}, WriteError)
• Task
• Task.spawn! : Input(msg), (() => msg) => {}
• Task.spawn_with! : Input(msg), (() => a), (a -> msg) => {}
• Task.sleep! : U64 => {}
• Text
• Text.font_stub : Font
• Text.default_spacing : F32
• Text.from : Str, Font -> Builder
• Text.align_offset : Size, Align -> Vec2
• Text.origin_for : Vec2, Size, Align -> Vec2
• Text.draw_prepared! : Frame, PreparedPlacement => {}
• Text.Font : Font
• Text.HAlign : [Left, Center, Right]
• Text.VAlign : [Top, Middle, Bottom]
• Text.Align : (VAlign, HAlign)
• Text.Size : { width : F32, height : F32 }
• Text.Placement := { pos : Vec2, color : Rgba, align : Align ?? (Top, Left) }
• Text.Builder
• Text.Builder.size : Builder, F32 -> Builder
• Text.Builder.spacing : Builder, F32 -> Builder
• Text.Builder.font : Builder, Font -> Builder
• Text.Builder.draw! : Builder, Frame, Placement => {}
• Text.Builder.prepare! : Builder => Try(Prepared, [ResourceLimit])
• Text.Prepared
• Text.Prepared.bounds : Prepared -> Size
• Text.Prepared.draw! : Prepared, Frame, Placement => {}
• Text.Prepared.stub : Prepared
• Text.PreparedPlacement := { text : Prepared, pos : Vec2, color : Rgba, align : Align ?? (Top, Left) }
• Texture
• Texture.encoder_for : encoding -> (Texture, state -> Try(state, err)) where [encoding.encode_texture : Texture, state -> Try(state, err)]
• Texture.stub : Texture
• Texture.TextureHandle : Texture
• Tilemap
• Tilemap.empty_raw_map : TilemapRawMap
• Tilemap.empty : Tilemap
• Tilemap.from_raw : TilemapRawMap -> TilemapBuilder
• Tilemap.raw_map : Tilemap -> TilemapRawMap
• Tilemap.layer_role_for : Tilemap, TilemapRawLayer -> TilemapLayerRole
• Tilemap.object_role_for : Tilemap, TilemapRawObject -> TilemapObjectRole
• Tilemap.objects : Tilemap -> List(TilemapRawObject)
• Tilemap.objects_named : Tilemap, Str -> List(TilemapRawObject)
• Tilemap.objects_typed : Tilemap, Str -> List(TilemapRawObject)
• Tilemap.objects_with_role : Tilemap, TilemapObjectRole -> List(TilemapRawObject)
• Tilemap.first_object : Tilemap, TilemapObjectRole -> Try(TilemapRawObject, [NotFound])
• Tilemap.object_center : TilemapRawObject -> Vec2
• Tilemap.object_rect : TilemapRawObject -> Rect
• Tilemap.object_circle : TilemapRawObject -> Circle
• Tilemap.object_world_center : Tilemap, TilemapRawObject -> Vec2
• Tilemap.object_world_rect : Tilemap, TilemapRawObject -> Rect
• Tilemap.object_world_circle : Tilemap, TilemapRawObject -> Circle
• Tilemap.property_named : TilemapRawMap, U64, U64, Str -> Try(TilemapRawProperty, [NotFound])
• Tilemap.object_property : TilemapRawMap, TilemapRawObject, Str -> Try(TilemapRawProperty, [NotFound])
• Tilemap.layer_property : TilemapRawMap, TilemapRawLayer, Str -> Try(TilemapRawProperty, [NotFound])
• Tilemap.property_str : TilemapRawMap, TilemapRawObject, Str, Str -> Str
• Tilemap.property_f32 : TilemapRawMap, TilemapRawObject, Str, F32 -> F32
• Tilemap.property_i64 : TilemapRawMap, TilemapRawObject, Str, I64 -> I64
• Tilemap.property_bool : TilemapRawMap, TilemapRawObject, Str, Bool -> Bool
• Tilemap.cell_at_world : Tilemap, Vec2 -> Try(TilemapCell, [OutOfBounds])
• Tilemap.cell_range_for_world_rect : Tilemap, Rect -> Try(TilemapCellRange, [OutOfBounds])
• Tilemap.world_rect_for_cell : Tilemap, TilemapCell -> Rect
• Tilemap.gid_at : Tilemap, Str, TilemapCell -> Try(U64, [NotFound, OutOfBounds])
• Tilemap.solid_cell : Tilemap, TilemapCell -> Bool
• Tilemap.solid_at_world : Tilemap, Vec2 -> Bool
• Tilemap.circle_touches_solid : Tilemap, Circle -> Bool
• Tilemap.draw_layer! : Tilemap, Frame, Str => {}
• Tilemap.draw_layer_in! : Tilemap, Frame, Str, Rect => {}
• Tilemap.draw_layers! : Tilemap, Frame, TilemapDrawRole => {}
• Tilemap.draw_layers_in! : Tilemap, Frame, TilemapDrawRole, Rect => {}
• Tilemap.draw_all! : Tilemap, Frame => {}
• Tilemap.draw_all_in! : Tilemap, Frame, Rect => {}
• Tilemap.viewport_for_camera : Camera2D, Vec2 -> Rect
• Tilemap.draw_all_for_camera! : Tilemap, Frame, Camera2D, Vec2 => {}
• Tilemap.flip_for_gid : U64 -> TilemapFlip
• Tilemap.clean_gid : U64 -> U64
• Tilemap.load_tmx! : Store, Str => Try(TilemapRawMap, [PathInvalid, NotFound, ReadFailed, ParseFailed, Unsupported])
• Tilemap.RawMap : TilemapRawMap
• Tilemap.RawLayer : TilemapRawLayer
• Tilemap.RawObject : TilemapRawObject
• Tilemap.RawProperty : TilemapRawProperty
• Tilemap.RawTileset : TilemapRawTileset
• Tilemap.RawPoint : TilemapRawPoint
• Tilemap.Cell : TilemapCell
• Tilemap.CellRange : TilemapCellRange
• Tilemap.Flip : TilemapFlip
• Tilemap.ResolvedTileset : TilemapResolvedTileset
• Tilemap.LayerRole : TilemapLayerRole
• Tilemap.DrawRole : TilemapDrawRole
• Tilemap.ObjectRole : TilemapObjectRole
• Tilemap.Builder : TilemapBuilder
• Time
• Time.first_cycle : Cycle
• Time.to_seconds : U64 -> F32
• Time.delta_seconds : U64, U64 -> F32
• Time.now! : () => Timestamp
• Time.Cycle : { cycle_count : U64, simulation_nanos : U64, monotonic_nanos : U64, elapsed_seconds : F32 }
• Time.Timestamp
• Time.Timestamp.is_eq : _
• Time.Timestamp.epoch : Timestamp
• Time.Timestamp.from_parts : { seconds : I64, nanosecond : U32 } -> Try(Timestamp, [InvalidNanosecond])
• Time.Timestamp.from_nanos_since_epoch : I128 -> Try(Timestamp, [OutOfRange])
• Time.Timestamp.seconds_since_epoch : Timestamp -> I64
• Time.Timestamp.subsecond_nanoseconds : Timestamp -> U32
• Time.Timestamp.nanos_since_epoch : Timestamp -> I128
• Time.Timestamp.difference_nanos : Timestamp, Timestamp -> I128
• Time.Timestamp.to_iso_8601 : Timestamp -> Str
• Time.Timestamp.to_iso_8601_nanos : Timestamp -> Str
• Time.Timestamp.to_file_stamp : Timestamp -> Str
• Trace
• Trace.mark! : Str => {}
• Trace.begin! : Str => Zone
• Trace.end! : Zone => {}
• Trace.sample_i64! : Str, I64, Unit => {}
• Trace.sample_f64! : Str, F64, Unit => {}
• Trace.Zone
• Trace.Unit : [Bytes, Count, Nanoseconds, Microseconds, Milliseconds, Ratio]
• Udp
• Udp.default_receive : ReceiveConfig
• Udp.max_datagram_bytes : U64
• Udp.Address : { ip : Str, port : U16 }
• Udp.Datagram : { from : Address, bytes : List(U8) }
• Udp.ReceiveConfig : { timeout_ms : U64, max_datagrams : U32 }
• Udp.BindError : [InvalidAddress, AddressInUse, AddressUnavailable, AccessRefused, PermissionDenied, ResourceLimit, Unavailable]
• Udp.SendError : [InvalidAddress, TooLarge, WouldBlock, Unreachable, AccessRefused, PermissionDenied, SendFailed, Unavailable]
• Udp.ReceiveError : [Timeout, AlreadyReceiving, ReceiveFailed, Unavailable]
• Udp.Socket := { handle : Socket, local : Address }
• Udp.Socket.local_address : Socket -> Address
• Udp.Socket.send! : Socket, Address, List(U8) => Try({}, SendError)
• Udp.Socket.receive! : Socket, ReceiveConfig => Try(List(Datagram), ReceiveError)
• Udp.Socket.stub : Socket
• Udp.Network
• Udp.Network.for_host : Authority -> Network
• Udp.Network.bind! : Network, Address => Try(Socket, BindError)
• Url
• Url.parse : Str -> Try(Url, ParseErr)
• Url.from_quote : Str -> Try(Url, [BadQuotedBytes(Str)])
• Url.parser_for : encoding -> (state -> Try({ value : Url, rest : state }, err)) where [encoding.parse_str : encoding, state -> Try({ value : Str, rest : state }, err), encoding.invalid_value : encoding, state -> err]
• Url.encoder_for : encoding -> (Url, state -> Try(state, err)) where [encoding.encode_str : Str, state -> Try(state, err)]
• Url.to_str : Url -> Str
• Url.to_inspect : Url -> Str
• Url.is_eq : Url, Url -> Bool
• Url.to_hash : Url, Hasher -> Hasher
• Url.scheme : Url -> [Http, Https]
• Url.host : Url -> Str
• Url.port : Url -> [None, Some(U16)]
• Url.path : Url -> Str
• Url.query : Url -> [None, Some(Str)]
• Url.fragment : Url -> [None, Some(Str)]
• Url.without_fragment : Url -> Url
• Url.resolve : Url, Str -> Try(Url, ParseErr)
• Url.append_path_segments : Url, List(Str) -> Url
• Url.append_query_param : Url, Str, Str -> Url
• Url.query_pairs : Url -> List((Str, Str))
• Url.with_query : Url, [None, Some(Str)] -> Try(Url, ParseErr)
• Url.with_fragment : Url, [None, Some(Str)] -> Try(Url, ParseErr)
• Url.ParseErr : [CredentialsNotAllowed, EmptyHost, InternationalHostUnsupported, InvalidCharacter(U8), InvalidHost(Str), InvalidIpv4(Str), InvalidIpv6(Str), InvalidPercentEncoding(U64), InvalidPort(Str), MissingAuthority, MissingScheme, PortOutOfRange(U64), UnsupportedScheme(Str)]
• Window
• Window.suggest_size! : { width : I32, height : I32 } => {}
• Window.suggest_min_size! : { width : I32, height : I32 } => {}
• Window.set_target_fps! : I32 => {}
• Window.scale! : () => { x : F32, y : F32 }
• Window.monitors! : () => List(Monitor)
• Window.suggest_position! : { x : I32, y : I32 } => {}
• Window.suggest_monitor! : I32 => {}
• Window.Snapshot : { size : { width : I32, height : I32 }, focused : Bool, minimized : Bool, close_requested : Bool }
• Window.ClipboardReadError : [PermissionDenied, Unavailable, TooLarge, Busy]
• Window.Monitor : { index : I32, name : Str, size : { width : I32, height : I32 }, position : { x : I32, y : I32 }, refresh_hz : I32 }
• Window.Clipboard
• Window.Clipboard.for_host : Authority -> Clipboard
• Window.Clipboard.read_text! : Clipboard => Try(Str, ClipboardReadError)
• Window.Clipboard.set_text! : Clipboard, Str => Try({}, [PermissionDenied])

Draw

Immediate-mode 2D drawing, text, textures, cameras, and render effects.

render! is handed a Frame, and everything drawn is drawn through it:

render! = |model, frame| {
    frame.clear!(Color.from_hex_rgb(0x0d1425))
    frame.rectangle!({ x: 40, y: 40, width: 200, height: 90, style: Draw.filled(Color.white) })
    frame.circle!({ center: model.pointer, radius: 18, style: Draw.outlined(Color.red, 3) })
    Ok({})
}

Frame is render-scoped authority. Pass the callback's frame through draw helpers; do not retain it in the model. Nested camera, shader, scissor, render-texture, and blend scopes restore their outer state even when their callback returns Err.

Every effect that takes a Frame is legal only in render!. Resource constructors default_font!, font_from_bytes!, RenderTexture.load! and Shader.from_source! allocate host resources from what the app already has, so they are legal in init!, update!, and tasks. The two that read files out of an asset store, load_store_font! and Shader.from_store!, wait instead: each is legal in init!, where it blocks startup, and in tasks, where it parks the task, and refused in update! and render!. Create long-lived resources in init! and retain them in the model.

Most shapes support equivalent method and free-function forms, such as frame.circle!(cfg) and Draw.circle!(frame, cfg).

Draw.text! draws at an already-resolved top-left origin without a layout pass. Use Text for optional anchor alignment or prepared text.

from_rgba : { r : U8, g : U8, b : U8, a : U8 } -> Rgba

Convert a structural RGBA value at an adapter boundary into roc-ray's color.

alpha_blend : BlendMode

Conventional source-alpha compositing.

additive_blend : BlendMode

Add source and destination colors, useful for light and glow effects.

multiplied_blend : BlendMode

Multiply source and destination colors.

add_colors_blend : BlendMode

Add source and destination color channels.

subtract_colors_blend : BlendMode

Subtract source color channels from the destination.

premultiplied_alpha_blend : BlendMode

Alpha compositing for textures whose RGB channels are premultiplied.

filled : Rgba -> ShapeStyle

Create a fill-only shape style.

stroke : Rgba, F32 -> Stroke

Create a stroke with color and thickness in logical pixels.

outlined : Rgba, F32 -> ShapeStyle

Create a stroke-only shape style.

filled_and_outlined : Rgba, Rgba, F32 -> ShapeStyle

Create a shape style with both fill and outline.

default_font! : () => Font

Snapshot raylib's built-in font, metrics included.

Legal in init!, update!, and tasks; refused in render!.

default_spacing : F32

Default text glyph spacing in logical pixels.

center_in_rect : Rectangle, TextSize -> Vector2

Find the top-left position that centers measured text in a rectangle.

clear! : Frame, Rgba => {}

Clear the active drawing target to a solid color.

Legal in render! only.

rectangle_gradient_v! : Frame, RectangleGradientV => {}

Draw a vertical rectangle gradient.

Legal in render! only.

rectangle_gradient_h! : Frame, RectangleGradientH => {}

Draw a horizontal rectangle gradient.

Legal in render! only.

circle_gradient! : Frame, CircleGradient => {}

Draw a radial circle gradient.

Legal in render! only.

fps! : Frame, Fps => {}

Draw raylib's current frames-per-second counter.

Legal in render! only.

rectangle! : Frame, Rectangle => {}

Draw a filled and/or outlined axis-aligned rectangle.

Legal in render! only.

rounded_rectangle! : Frame, RoundedRectangle => {}

Draw a filled and/or outlined rounded rectangle.

Legal in render! only.

circle! : Frame, Circle => {}

Draw a filled and/or outlined circle.

Legal in render! only.

line! : Frame, Line => {}

Draw a stroked line segment. NoStroke performs no drawing.

Legal in render! only.

triangle! : Frame, Triangle => {}

Draw a filled and/or outlined triangle.

Legal in render! only.

convex_polygon! : Frame, ConvexPolygon => {}

Draw a convex filled polygon and/or an ordered polygon outline. The host triangulates the fill without allocating; fewer than three points do not fill.

Legal in render! only.

triangles! : Frame, TrianglePoints => {}

Draw independent triangles. Every consecutive triple is one triangle. An empty list is a no-op; a non-empty count not divisible by three is a programmer error. Legal in render! only.

triangle_fan! : Frame, TrianglePoints => {}

Draw a triangle fan: the first point is the centre and later points form its perimeter. Fewer than three points are a no-op. Legal in render! only.

triangle_strip! : Frame, TrianglePoints => {}

Draw a triangle strip. Each point after the first two adds one triangle. Fewer than three points are a no-op. Legal in render! only.

line_strip! : Frame, LineStrip => {}

Draw an open polyline. NoStroke and fewer than two points are no-ops. Curve flattening and dash splitting remain pure Roc policy. Legal in render! only.

circle_sector! : Frame, CircleSector => {}

Draw a filled and/or outlined circular sector. Angles are degrees and segments must be at least three. Legal in render! only.

ellipse! : Frame, Ellipse => {}

Draw a filled and/or outlined axis-aligned ellipse. Legal in render! only.

ring! : Frame, Ring => {}

Draw a filled and/or outlined annular sector. Angles are degrees and segments must be at least three. Legal in render! only.

load_store_font! : Store, LoadFont => Try(Font, [PathInvalid, NotFound, ReadFailed, FontLoadFailed, ResourceLimit])

Load a font relative to an explicit asset store.

Legal in init!, where it blocks startup, and in tasks, where it parks the task; refused in update! and render!. The file is read off the frame thread and rasterized when the bytes are back. To load a font from update!, use font_from_bytes! with bytes the app already holds.

font_from_bytes! : FontBytes => Try(Font, [FontLoadFailed, ResourceLimit])

Decode an authored, compile-time embedded font.

The bytes are borrowed while raylib copies and decodes them, so no extra Roc payload-sized buffer is created. Legal in init!, update!, and tasks; refused in render!.

texture_draw : Texture -> TextureDraw

Create a draw configuration covering the whole texture at the origin.

texture_at : Texture, Vec2 -> TextureDraw

Create a draw configuration covering the whole texture at pos.

texture! : Frame, TextureDraw => {}

Draw a texture with explicit source, destination, origin, rotation, and tint.

Legal in render! only.

textured_triangles_3d! : Frame, TexturedTriangles3D => {}

Draw one borrowed indexed batch of perspective-correct textured triangles. The vertex and index list lengths explicitly bound all work in this call; the host consumes both synchronously and retains no geometry. The index count must be a multiple of three and every index must name a vertex. Violating either condition is a programmer error.

Legal in render! only. Normally called inside with_camera_3d!.

texture_instances! : Frame, Texture, List(TextureInstance) => {}

Draw many instances of one texture, in list order, with a single hosted call.

texture! crosses the Roc/host boundary once per sprite, and that crossing is what caps how many sprites a frame can afford. This crosses once for the whole batch and lets the host loop over it, so the cost per instance is the DrawTexturePro call alone. Build the list from application state and pass it straight through; an empty list does not cross at all.

Legal in render! only.

projective_texture! : Frame, ProjectiveTexture => {}

Project a texture onto a validated planar quad with exact homogeneous UV interpolation. This remains one hosted call and preserves active shaders.

Legal in render! only.

with_render_texture! : Frame, RenderTexture, (Frame => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])) => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])

Scope offscreen rendering so BeginTextureMode/EndTextureMode stay paired. Callback errors are returned only after the native target has been restored.

Legal in render! only.

with_shader! : Frame, Shader(uniforms), (Frame => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])) => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])

Scope shader application and upload its complete uniform record before the callback draws. Callback errors are returned only after the previous shader and all of its uniform values have been restored.

Legal in render! only.

with_blend_mode! : Frame, BlendMode, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])

Scope one of raylib's built-in blend equations. Custom blend factors are deliberately excluded until they can be represented without global state.

Legal in render! only.

with_camera! : Frame, Camera2D, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])

Draw the callback in world space using this camera.

Legal in render! only.

with_camera_3d! : Frame, Camera3D, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])

Draw the callback in 3D world space using a perspective camera. Depth testing and depth writes are active until the callback returns.

Legal in render! only.

with_scissor! : Frame, Rect, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])

Restrict callback drawing to screen-space bounds, and close the scissor however the callback ends, error included.

bounds is in the same logical coordinates as every other drawing call, so it is a rectangle on the surface rather than in framebuffer pixels.

Legal in render! only.

text! : Frame, Text => {}

Draw text using an explicit font, spacing, color, and resolved top-left origin. This performs no measurement or alignment pass.

Legal in render! only.

debug_text! : Frame, DebugText => {}

Draw top-left aligned text with the built-in font and default spacing.

Legal in render! only.

text_at! : Frame, SimpleText => {}

Draw simple top-left aligned text with the built-in font.

Legal in render! only.

Frame

Draw.Frame :: # (opaque)

Opaque, zero-sized authority the host supplies only while it runs render!.

Holding one is what makes a draw call expressible, so drawing cannot happen in init! or update!. Roc does not enforce affine use or encode a frame epoch, so do not retain a Frame in the model: pass the callback's own frame down through helpers.

triangles! : Frame, TrianglePoints => {}

Draw independent triangles. Every consecutive triple is one triangle. An empty list is a no-op; a non-empty count not divisible by three is a programmer error. Legal in render! only.

triangle_fan! : Frame, TrianglePoints => {}

Draw a triangle fan: the first point is the centre and later points form its perimeter. Fewer than three points are a no-op. Legal in render! only.

triangle_strip! : Frame, TrianglePoints => {}

Draw a triangle strip. Each point after the first two adds one triangle. Fewer than three points are a no-op. Legal in render! only.

line_strip! : Frame, LineStrip => {}

Draw an open polyline. NoStroke and fewer than two points are no-ops. Curve flattening and dash splitting remain pure Roc policy. Legal in render! only.

circle_sector! : Frame, CircleSector => {}

Draw a filled and/or outlined circular sector. Angles are degrees and segments must be at least three. Legal in render! only.

ellipse! : Frame, Ellipse => {}

Draw a filled and/or outlined axis-aligned ellipse. Legal in render! only.

ring! : Frame, Ring => {}

Draw a filled and/or outlined annular sector. Angles are degrees and segments must be at least three. Legal in render! only.

clear! : Frame, Rgba => {}

Clear the active drawing target to a solid color.

Legal in render! only.

rectangle_gradient_v! : Frame, RectangleGradientV => {}

Draw a vertical rectangle gradient.

Legal in render! only.

rectangle_gradient_h! : Frame, RectangleGradientH => {}

Draw a horizontal rectangle gradient.

Legal in render! only.

circle_gradient! : Frame, CircleGradient => {}

Draw a radial circle gradient.

Legal in render! only.

fps! : Frame, Fps => {}

Draw raylib's current frames-per-second counter.

Legal in render! only.

rectangle! : Frame, Rectangle => {}

Draw a filled and/or outlined axis-aligned rectangle.

Legal in render! only.

rounded_rectangle! : Frame, RoundedRectangle => {}

Draw a filled and/or outlined rounded rectangle.

Legal in render! only.

circle! : Frame, Circle => {}

Draw a filled and/or outlined circle.

Legal in render! only.

line! : Frame, Line => {}

Draw a stroked line segment. NoStroke performs no drawing.

Legal in render! only.

triangle! : Frame, Triangle => {}

Draw a filled and/or outlined triangle.

Legal in render! only.

convex_polygon! : Frame, ConvexPolygon => {}

Draw a convex filled polygon and/or an ordered polygon outline. The host triangulates the fill without allocating; fewer than three points do not fill.

Legal in render! only.

texture! : Frame, TextureDraw => {}

Draw a texture with explicit source, destination, origin, rotation, and tint.

Legal in render! only.

textured_triangles_3d! : Frame, TexturedTriangles3D => {}

Draw one borrowed indexed batch of perspective-correct textured triangles. The vertex and index list lengths explicitly bound all work in this call; the host consumes both synchronously and retains no geometry. The index count must be a multiple of three and every index must name a vertex. Violating either condition is a programmer error.

Legal in render! only. Normally called inside with_camera_3d!.

texture_instances! : Frame, Texture, List(TextureInstance) => {}

Draw many instances of one texture, in list order, with a single hosted call.

texture! crosses the Roc/host boundary once per sprite, and that crossing is what caps how many sprites a frame can afford. This crosses once for the whole batch and lets the host loop over it, so the cost per instance is the DrawTexturePro call alone. Build the list from application state and pass it straight through; an empty list does not cross at all.

Legal in render! only.

projective_texture! : Frame, ProjectiveTexture => {}

Project a texture onto a validated planar quad with exact homogeneous UV interpolation. This remains one hosted call and preserves active shaders.

Legal in render! only.

with_render_texture! : Frame, RenderTexture, (Frame => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])) => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])

Scope offscreen rendering so BeginTextureMode/EndTextureMode stay paired. Callback errors are returned only after the native target has been restored.

Legal in render! only.

with_shader! : Frame, Shader(uniforms), (Frame => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])) => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])

Scope shader application and upload its complete uniform record before the callback draws. Callback errors are returned only after the previous shader and all of its uniform values have been restored.

Legal in render! only.

with_blend_mode! : Frame, BlendMode, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])

Scope one of raylib's built-in blend equations. Custom blend factors are deliberately excluded until they can be represented without global state.

Legal in render! only.

with_camera! : Frame, Camera2D, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])

Draw the callback in world space using this camera.

Legal in render! only.

with_camera_3d! : Frame, Camera3D, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])

Draw the callback in 3D world space using a perspective camera. Depth testing and depth writes are active until the callback returns.

Legal in render! only.

with_scissor! : Frame, Rect, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])

Restrict callback drawing to screen-space bounds, and close the scissor however the callback ends, error included.

bounds is in the same logical coordinates as every other drawing call, so it is a rectangle on the surface rather than in framebuffer pixels.

Legal in render! only.

text! : Frame, Text => {}

Draw text using an explicit font, spacing, color, and resolved top-left origin. This performs no measurement or alignment pass.

Legal in render! only.

debug_text! : Frame, DebugText => {}

Draw top-left aligned text with the built-in font and default spacing.

Legal in render! only.

text_at! : Frame, SimpleText => {}

Draw simple top-left aligned text with the built-in font.

Legal in render! only.

size! : Frame => FrameSize

How big the surface being drawn to right now is.

Normally this is the window's logical drawing size -- the same value Window.Snapshot.size reports, in the same coordinate space as mouse input and every drawing call. Inside with_render_texture! it is the render target's size instead, because that is what the callback's coordinates are relative to.

This is the size of the drawing surface, so it is F32 where Window.Snapshot.size is I32: it feeds rectangles, text anchors and centre points directly, and a render target's dimensions are already F32 on Texture. Window.Snapshot.size stays I32 because it is also the thing Window.suggest_size! asks for.

Reach for this when laying something out against the surface -- a HUD in a corner, a title centred across the top. Layout decisions that update! also has to make, such as which arrangement to use or what the pointer is over, belong on input.window where the rest of application logic can see them.

Legal in render! only.

FrameSize : {
    width : F32,
    height : F32,
}

Dimensions of the surface render! is currently drawing to.

Texture : Texture

Host-owned GPU texture, the same type Assets loads and generates.

Named here as well so drawing code can keep a texture in its model without importing Assets; Draw.Texture, Assets.Texture and the platform's Texture are one type, not three.

Vector2 : Vec2

Two-dimensional vector used by drawing records.

Rect : Rect

Axis-aligned rectangle used by drawing records.

Camera2D : Camera2D

Pure 2D camera settings.

Camera3D : Camera3D

Pure perspective camera settings.

Vector3 : Vec3

Three-dimensional vector used by 3D drawing records.

TexturedVertex3D : { position : Vector3, uv : Vector2, tint : Rgba }

One vertex in an immediate textured triangle batch.

TexturedTriangles3D : { texture : Texture, vertices : List(TexturedVertex3D), indices : List(U32) }

A borrowed indexed triangle batch. Every consecutive group of three indices is one triangle. Indices must be in range and their count a multiple of three.

Fill : [NoFill, Fill(Rgba)]

Optional shape fill.

Stroke : [NoStroke, Stroke({ color : Rgba, thickness : F32 })]

Optional shape outline with color and thickness.

ShapeStyle : {
    fill : Fill,
    stroke : Stroke,
}

Combined fill and outline applied by shape helpers.

Rectangle : {
    x : F32,
    y : F32,
    width : F32,
    height : F32,
    style : ShapeStyle,
}

Axis-aligned rectangle and its style.

RoundedRectangle : {
    x : F32,
    y : F32,
    width : F32,
    height : F32,
    radius : F32,
    segments : I32,
    style : ShapeStyle,
}

Rounded rectangle; radius and segment count control corner tessellation.

RectangleGradientV : {
    x : F32,
    y : F32,
    width : F32,
    height : F32,
    color_top : Rgba,
    color_bottom : Rgba,
}

Vertical rectangle gradient from top to bottom.

RectangleGradientH : {
    x : F32,
    y : F32,
    width : F32,
    height : F32,
    color_left : Rgba,
    color_right : Rgba,
}

Horizontal rectangle gradient from left to right.

Circle : {
    center : Vector2,
    radius : F32,
    style : ShapeStyle,
}

Circle and its style.

CircleGradient : {
    center : Vector2,
    radius : F32,
    color_inner : Rgba,
    color_outer : Rgba,
}

Radial gradient from inner to outer color.

Line : {
    start : Vector2,
    end : Vector2,
    stroke : Stroke,
}

Line segment and stroke.

Triangle : {
    a : Vector2,
    b : Vector2,
    c : Vector2,
    style : ShapeStyle,
}

Triangle vertices and style.

ConvexPolygon : {
    points : List(Vector2),
    style : ShapeStyle,
}

A simple convex polygon. Points must be ordered around the boundary (clockwise or counter-clockwise). Filled concave or self-intersecting polygons are not supported; outlines accept any ordered point path.

TrianglePoints : {
    points : List(Vector2),
    color : Rgba,
}

Positions already assembled into a triangle topology, all drawn in one color. points is not a path: contour, winding, and hole handling belong to the pure Roc tessellator that produced this list.

LineStrip : {
    points : List(Vector2),
    stroke : Stroke,
}

An ordered, open polyline. Each adjacent pair is drawn with stroke.

CircleSector : {
    center : Vector2,
    radius : F32,
    start_angle : F32,
    end_angle : F32,
    segments : I32,
    style : ShapeStyle,
}

A circular sector from start_angle to end_angle, measured in degrees.

Ellipse : {
    center : Vector2,
    radius_x : F32,
    radius_y : F32,
    style : ShapeStyle,
}

An axis-aligned ellipse with independent horizontal and vertical radii.

Ring : {
    center : Vector2,
    inner_radius : F32,
    outer_radius : F32,
    start_angle : F32,
    end_angle : F32,
    segments : I32,
    style : ShapeStyle,
}

An annular sector from start_angle to end_angle, measured in degrees.

Fps : {
    pos : Vector2,
    size : F32,
    color : Rgba,
}

Position, size, and color for the FPS counter.

GlyphMetrics : {
    codepoint : U32,
    advance_x : F32,
    offset_x : F32,
    offset_y : F32,
    width : F32,
    height : F32,
}

Scalar metrics for one glyph, shared with platform-independent packages.

TextSize : { width : F32, height : F32 }

Text measurement result.

Text : {
    pos : Vector2,
    text : Str,
    size : F32,
    spacing : F32,
    color : Rgba,
    font : Font,
}

Fully configured text draw at a resolved top-left origin.

DebugText : {
    pos : Vector2,
    text : Str,
    size : F32,
    color : Rgba,
}

Built-in-font text intended for quick diagnostics.

SimpleText : {
    pos : Vector2,
    text : Str,
    size : F32,
    color : Rgba,
}

Built-in-font text with default spacing.

LoadFont : {
    path : Str,
    size : I32,
}

Font path and base pixel size.

TextureDraw : TextureDrawConfig

Resolved texture draw configuration: which texture, which part of it, where it goes, and how it is rotated and tinted.

TextureDrawConfig in the signature is the module-private record this aliases; Draw.TextureDraw is the name to write. Build one with texture_draw, texture_at, or the TextureDrawBuilder combinators.

TextureInstance : TextureInstanceConfig

One instance of a batched texture draw. These are the fields of TextureDraw minus the texture, which the batch supplies once.

TextureInstanceConfig in the signature is the module-private record this aliases; Draw.TextureInstance is the name to write.

ProjectiveQuadCorners : {
    top_left : Vec2,
    bottom_left : Vec2,
    bottom_right : Vec2,
    top_right : Vec2,
}

Four ordered corners of a projected planar surface.

ProjectiveQuad

Draw.ProjectiveQuad :: # (opaque)

A finite, convex planar projection with a bounded homography. Construct it with ProjectiveQuad.from_corners; the opaque representation holds the homogeneous weights needed for exact perspective-correct interpolation.

from_corners : ProjectiveQuadCorners -> Try(ProjectiveQuad, [NonFiniteQuad, DegenerateQuad, NonConvexQuad, ProjectiveHorizon])

Validate four boundary-ordered corners and solve their projective weights. A single homography cannot represent a concave, self-intersecting, or horizon-crossing destination, so those states are rejected here.

project : ProjectiveQuad, Vec2 -> Vec2

Project a unit-square coordinate onto the destination surface. This uses the same homography as rendering and is useful for aligned overlays.

ProjectiveTexture : {
    texture : Texture,
    source : Rect,
    quad : ProjectiveQuad,
    tint : Rgba,
}

Texture and source region projected exactly onto a validated planar quad.

RenderTexture

Draw.RenderTexture :: # (opaque)

Host-owned framebuffer. Its texture-shaped box has a distinct host kind; the host rejects ordinary textures before entering an offscreen scope. Releasing the final reference unloads the framebuffer and both attachments.

load! : RenderTextureSize => Try(RenderTexture, [RenderTextureLoadFailed, ResourceLimit])

Allocate an offscreen framebuffer.

Legal in init!, update!, and tasks; refused in render!.

texture : RenderTexture -> Texture

Read-only view of this render target's color attachment.

source : RenderTexture -> Rect

Vertically inverted full-source rectangle for drawing the color attachment.

stub : RenderTexture

Resource-free render target for pure tests.

The handle never resolves to a host resource, so entering a scope with it is refused the way a released target is. Its color attachment is Texture.stub with zero dimensions; copy it with the dimensions the test needs. Do not use it to test drawing, offscreen scopes, or resource lifetime.

RenderTextureSize : {
    width : I32,
    height : I32,
}

Pixel dimensions for a new offscreen render target.

FontFormat

:= [Ttf, Otf]

Which font file format FontBytes holds. The bytes are decoded by format rather than by sniffing them, so a mislabelled file fails to load instead of loading as something else.

FontBytes : { format : FontFormat, bytes : List(U8), size : I32 }

An authored font embedded with a compile-time file import, plus the pixel size to rasterize its glyph atlas at. size is baked into the atlas, so drawing at a much larger size scales that atlas up rather than re-rasterizing; load the font again at the size you need instead.

BlendMode : [
    Alpha,
    Additive,
    Multiplied,
    AddColors,
    SubtractColors,
    AlphaPremultiply,
]

Built-in blend equations with scoped application through with_blend_mode!.

ScopeError : [ScopeLimit, ScopeUnavailable]

A scoped renderer could not be opened because its bounded native stack is full or a transferred host resource no longer resolves.