mt-lang 0.2.0 → 0.2.1

data/std/queue.mt

@@ -0,0 +1,55 @@
+import std.deque as deque
+
+public struct Queue[T]:
+    values: deque.Deque[T]
+
+
+extending Queue[T]:
+    public static function create() -> Queue[T]:
+        return Queue[T](values = deque.Deque[T].create())
+
+
+    public static function with_capacity(capacity: ptr_uint) -> Queue[T]:
+        var result = Queue[T].create()
+        result.reserve(capacity)
+        return result
+
+
+    public function len() -> ptr_uint:
+        return this.values.len()
+
+
+    public function capacity() -> ptr_uint:
+        return this.values.capacity()
+
+
+    public function is_empty() -> bool:
+        return this.values.is_empty()
+
+
+    public function iter() -> deque.Iter[T]:
+        return this.values.iter()
+
+
+    public function peek() -> ptr[T]?:
+        return this.values.first()
+
+
+    public editable function clear() -> void:
+        this.values.clear()
+
+
+    public editable function release() -> void:
+        this.values.release()
+
+
+    public editable function reserve(min_capacity: ptr_uint) -> void:
+        this.values.reserve(min_capacity)
+
+
+    public editable function enqueue(value: T) -> void:
+        this.values.push_back(value)
+
+
+    public editable function dequeue() -> Option[T]:
+        return this.values.pop_front()

data/std/random.mt

@@ -0,0 +1,146 @@
+import std.vec as vec
+
+const pcg_multiplier: ulong = 0x5851F42D4C957F2D
+
+public struct Rng:
+    state: ulong
+    increment: ulong
+
+
+public function from_seed(seed: ulong) -> Rng:
+    var rng = Rng(state = 0ul, increment = (seed << 1ul) | 1ul)
+    rng.next_u32()
+    rng.state = rng.state + seed
+    rng.next_u32()
+    return rng
+
+
+public function from_seed_str(seed_str: str) -> Rng:
+    var hash: ulong = 5381ul
+    var i: ptr_uint = 0
+    while i < seed_str.len:
+        unsafe:
+            let byte_val = ulong<-ubyte<-read(seed_str.data + i)
+            hash = ((hash << 5ul) + hash) + byte_val
+            i += 1
+    return from_seed(hash)
+
+
+extending Rng:
+    public editable function next_u32() -> uint:
+        let oldstate = this.state
+        this.state = oldstate * pcg_multiplier + this.increment
+        let xorshifted = uint<-(((oldstate >> 18ul) ^ oldstate) >> 27ul)
+        let rot = uint<-(oldstate >> 59ul)
+        return (xorshifted >> rot) | (xorshifted << (32u - rot))
+
+
+    public editable function next_u64() -> ulong:
+        let hi = ulong<-this.next_u32()
+        let lo = ulong<-this.next_u32()
+        return (hi << 32ul) | lo
+
+
+    public editable function next_f64() -> double:
+        let val = this.next_u32()
+        return double<-val / 4294967296.0
+
+
+    public editable function next_f32() -> float:
+        let val = this.next_u32()
+        return float<-val / 4294967296.0
+
+
+    public editable function next_ubyte() -> ubyte:
+        let val = this.next_u32()
+        return ubyte<-(val & 0xFFu)
+
+
+    public editable function next_bool() -> bool:
+        let val = this.next_u32()
+        return (val & 1u) != 0u
+
+
+    public editable function next_uint() -> uint:
+        return this.next_u32()
+
+
+    public editable function next_ulong() -> ulong:
+        return this.next_u64()
+
+
+    public editable function next_uint_range(min: uint, max: uint) -> uint:
+        if min >= max:
+            return min
+        let range = max - min
+        return min + (this.next_u32() % range)
+
+
+    public editable function next_int_range(min: int, max: int) -> int:
+        if min >= max:
+            return min
+        let range = uint<-(max - min)
+        let offset = this.next_u32() % range
+        return min + int<-offset
+
+
+    public editable function next_f64_range(min: double, max: double) -> double:
+        let t = this.next_f64()
+        return min + (max - min) * t
+
+
+    public editable function next_f32_range(min: float, max: float) -> float:
+        let t = this.next_f32()
+        return min + (max - min) * t
+
+
+    public editable function chance(probability: double) -> bool:
+        return this.next_f64() < probability
+
+
+    public editable function pick_ref[T](items: span[T]) -> ptr[T]?:
+        let len = items.len
+        if len == 0z:
+            return null
+        let index = ptr_uint<-this.next_uint_range(0u, uint<-len)
+        return items.data + index
+
+
+    public editable function pick[T](items: ref[vec.Vec[T]]) -> Option[T]:
+        let len = items.len()
+        if len == 0z:
+            return Option[T].none()
+        let index = ptr_uint<-this.next_uint_range(0u, uint<-len)
+        let ptr = items.get(index) else:
+            return Option[T].none()
+        return Option[T].some(value = unsafe: read(ptr))
+
+
+    public editable function shuffle[T](items: ref[vec.Vec[T]]) -> void:
+        let n = items.len()
+        if n <= 1z:
+            return
+        var i: ptr_uint = n - 1z
+        while i > 0z:
+            let j = ptr_uint<-this.next_uint_range(0u, uint<-(i + 1z))
+            items.swap(i, j)
+            i -= 1
+
+
+    public editable function skip(count: ptr_uint) -> void:
+        var i: ptr_uint = 0
+        while i < count:
+            this.next_u32()
+            i += 1
+
+
+    public editable function fork() -> Rng:
+        let seed = this.next_u64()
+        return from_seed(seed)
+
+
+    public editable function seeds() -> array[ulong, 4]:
+        return array[ulong, 4](
+            this.next_u64(), this.next_u64(),
+            this.next_u64(), this.next_u64()
+        )

data/std/raygui.mt

@@ -0,0 +1,99 @@
+# generated by mtc imported-bindings from std.c.raygui using bindings/imported/raygui.binding.json
+
+import std.c.raygui as c
+import std.raylib as rl
+
+public type Vector2 = rl.Vector2
+public type Vector3 = rl.Vector3
+public type Color = rl.Color
+public type Rectangle = rl.Rectangle
+public type Font = rl.Font
+public type StyleProp = c.GuiStyleProp
+public type Result_ = c.GuiResult
+public type State = c.GuiState
+public type TextAlignment = c.GuiTextAlignment
+public type TextAlignmentVertical = c.GuiTextAlignmentVertical
+public type TextWrapMode = c.GuiTextWrapMode
+public type Control = c.GuiControl
+public type ControlProperty = c.GuiControlProperty
+public type DefaultProperty = c.GuiDefaultProperty
+public type ToggleProperty = c.GuiToggleProperty
+public type SliderProperty = c.GuiSliderProperty
+public type ProgressBarProperty = c.GuiProgressBarProperty
+public type ScrollBarProperty = c.GuiScrollBarProperty
+public type CheckBoxProperty = c.GuiCheckBoxProperty
+public type ComboBoxProperty = c.GuiComboBoxProperty
+public type DropdownBoxProperty = c.GuiDropdownBoxProperty
+public type TextBoxProperty = c.GuiTextBoxProperty
+public type ValueBoxProperty = c.GuiValueBoxProperty
+public type TabBarProperty = c.GuiTabBarProperty
+public type ListViewProperty = c.GuiListViewProperty
+public type ColorPickerProperty = c.GuiColorPickerProperty
+public type IconName = c.GuiIconName
+
+public const RAYGUI_VERSION_MAJOR: int = c.RAYGUI_VERSION_MAJOR
+public const RAYGUI_VERSION_MINOR: int = c.RAYGUI_VERSION_MINOR
+public const RAYGUI_VERSION_PATCH: int = c.RAYGUI_VERSION_PATCH
+public const SCROLLBAR_LEFT_SIDE: int = c.SCROLLBAR_LEFT_SIDE
+public const SCROLLBAR_RIGHT_SIDE: int = c.SCROLLBAR_RIGHT_SIDE
+
+public foreign function enable() -> void = c.GuiEnable
+public foreign function disable() -> void = c.GuiDisable
+public foreign function lock() -> void = c.GuiLock
+public foreign function unlock() -> void = c.GuiUnlock
+public foreign function is_locked() -> bool = c.GuiIsLocked
+public foreign function set_alpha(alpha: float) -> void = c.GuiSetAlpha
+public foreign function set_state(state: State) -> void = c.GuiSetState(int<-state)
+public foreign function get_state() -> State = State<-c.GuiGetState()
+public foreign function set_font(font: Font) -> void = c.GuiSetFont
+public foreign function get_font() -> Font = c.GuiGetFont
+public foreign function set_style(control: Control, property: int, value: int) -> void = c.GuiSetStyle(int<-control, property, value)
+public foreign function get_style(control: Control, property: int) -> int = c.GuiGetStyle(int<-control, property)
+public foreign function load_style(file_name: str as cstr) -> void = c.GuiLoadStyle
+public foreign function load_style_from_memory(file_data: const_ptr[ubyte], data_size: int) -> void = c.GuiLoadStyleFromMemory
+public foreign function load_style_default() -> void = c.GuiLoadStyleDefault
+public foreign function enable_tooltip() -> void = c.GuiEnableTooltip
+public foreign function disable_tooltip() -> void = c.GuiDisableTooltip
+public foreign function set_tooltip(tooltip: str as cstr) -> void = c.GuiSetTooltip
+public foreign function icon_text(icon_id: IconName, text: str as cstr) -> cstr = c.GuiIconText(int<-icon_id, text)
+public foreign function set_icon_scale(scale: int) -> void = c.GuiSetIconScale
+public foreign function get_icons() -> span[uint] = span[uint](data = c.GuiGetIcons(), len = 2048)
+public foreign function load_icons_from_memory(file_data: const_ptr[ubyte], data_size: int, load_icons_name: bool) -> ptr[ptr[char]] = c.GuiLoadIconsFromMemory
+public foreign function draw_icon(icon_id: IconName, pos_x: int, pos_y: int, pixel_size: int, color: Color) -> void = c.GuiDrawIcon(int<-icon_id, pos_x, pos_y, pixel_size, color)
+public foreign function get_text_width(text: str as cstr) -> int = c.GuiGetTextWidth
+public foreign function window_box(bounds: Rectangle, title: str as cstr) -> int = c.GuiWindowBox
+public foreign function group_box(bounds: Rectangle, text: str as cstr) -> int = c.GuiGroupBox
+public foreign function line(bounds: Rectangle, text: str as cstr) -> int = c.GuiLine
+public foreign function panel(bounds: Rectangle, text: str as cstr) -> int = c.GuiPanel
+public foreign function scroll_panel(bounds: Rectangle, text: str as cstr, content: Rectangle, inout scroll: Vector2, out view: Rectangle) -> int = c.GuiScrollPanel
+public foreign function label(bounds: Rectangle, text: str as cstr) -> int = c.GuiLabel
+public foreign function button(bounds: Rectangle, text: str as cstr) -> int = c.GuiButton
+public foreign function label_button(bounds: Rectangle, text: str as cstr) -> int = c.GuiLabelButton
+public foreign function toggle(bounds: Rectangle, text: str as cstr, inout active: bool) -> int = c.GuiToggle
+public foreign function toggle_group(bounds: Rectangle, text: str as cstr, inout active: int) -> int = c.GuiToggleGroup
+public foreign function toggle_slider(bounds: Rectangle, text: str as cstr, inout active: int) -> int = c.GuiToggleSlider
+public foreign function check_box(bounds: Rectangle, text: str as cstr, inout checked: bool) -> int = c.GuiCheckBox
+public foreign function combo_box(bounds: Rectangle, text: str as cstr, inout active: int) -> int = c.GuiComboBox
+public foreign function dropdown_box(bounds: Rectangle, text: str as cstr, inout active: int, edit_mode: bool) -> int = c.GuiDropdownBox
+public foreign function spinner(bounds: Rectangle, text: str as cstr, inout value: int, min_value: int, max_value: int, edit_mode: bool) -> int = c.GuiSpinner
+public foreign function value_box(bounds: Rectangle, text: str as cstr, inout value: int, min_value: int, max_value: int, edit_mode: bool) -> int = c.GuiValueBox
+public foreign function value_box_float[N](bounds: Rectangle, text: str as cstr, text_value: str_buffer[N] as ptr[char], inout value: float, edit_mode: bool) -> int = c.GuiValueBoxFloat(bounds, text, text_value, value, edit_mode)
+public foreign function text_box[N](bounds: Rectangle, text: str_buffer[N] as ptr[char], edit_mode: bool) -> int = c.GuiTextBox(bounds, text, int<-(text_public.capacity() + 1), edit_mode)
+public foreign function slider(bounds: Rectangle, text_left: str as cstr, text_right: str as cstr, inout value: float, min_value: float, max_value: float) -> int = c.GuiSlider
+public foreign function slider_bar(bounds: Rectangle, text_left: str as cstr, text_right: str as cstr, inout value: float, min_value: float, max_value: float) -> int = c.GuiSliderBar
+public foreign function progress_bar(bounds: Rectangle, text_left: str as cstr, text_right: str as cstr, inout value: float, min_value: float, max_value: float) -> int = c.GuiProgressBar
+public foreign function status_bar(bounds: Rectangle, text: str as cstr) -> int = c.GuiStatusBar
+public foreign function dummy_rec(bounds: Rectangle, text: str as cstr) -> int = c.GuiDummyRec
+public foreign function grid(bounds: Rectangle, text: str as cstr, spacing: float, subdivs: int, out mouse_cell: Vector2) -> int = c.GuiGrid
+public foreign function list_view(bounds: Rectangle, text: str as cstr, inout scroll_index: int, inout active: int) -> int = c.GuiListView
+public foreign function list_view_ex(bounds: Rectangle, text: span[str] as span[ptr[char]], inout scroll_index: int, inout active: int, inout focus: int) -> int = c.GuiListViewEx(bounds, text.data, int<-text.len, scroll_index, active, focus)
+public foreign function tab_bar(bounds: Rectangle, text: str as cstr, inout hscroll: int, inout active: int) -> int = c.GuiTabBar
+public foreign function tab_bar_ex(bounds: Rectangle, text: span[str] as span[ptr[char]], inout hscroll: int, inout active: int, inout focus: int) -> int = c.GuiTabBarEx(bounds, text.data, int<-text.len, hscroll, active, focus)
+public foreign function message_box(bounds: Rectangle, title: str as cstr, message: str as cstr, buttons: str as cstr, out btn_active: int) -> int = c.GuiMessageBox
+public foreign function text_input_box[N](bounds: Rectangle, title: str as cstr, message: str as cstr, buttons: str as cstr, text: str_buffer[N] as ptr[char], out btn_active: int, inout secret_view_active: bool) -> int = c.GuiTextInputBox(bounds, title, message, buttons, text, int<-(text_public.capacity() + 1), btn_active, secret_view_active)
+public foreign function color_picker(bounds: Rectangle, text: str as cstr, inout color: Color) -> int = c.GuiColorPicker
+public foreign function color_panel(bounds: Rectangle, text: str as cstr, inout color: Color) -> int = c.GuiColorPanel
+public foreign function color_bar_alpha(bounds: Rectangle, text: str as cstr, inout alpha: float) -> int = c.GuiColorBarAlpha
+public foreign function color_bar_hue(bounds: Rectangle, text: str as cstr, inout value: float) -> int = c.GuiColorBarHue
+public foreign function color_picker_hsv(bounds: Rectangle, text: str as cstr, inout color_hsv: Vector3) -> int = c.GuiColorPickerHSV
+public foreign function color_panel_hsv(bounds: Rectangle, text: str as cstr, inout color_hsv: Vector3) -> int = c.GuiColorPanelHSV

data/std/raylib/debug_console.mt

@@ -0,0 +1,71 @@
+import std.raylib as rl
+
+public struct DebugState:
+    enabled: bool
+    visible: bool
+
+
+public function debug_init() -> DebugState:
+    return DebugState(
+        enabled = true,
+        visible = false
+    )
+
+
+public function debug_update(state: ref[DebugState]) -> void:
+    let key_f3 = rl.is_key_pressed(rl.KeyboardKey.KEY_F3)
+    if key_f3:
+        state.visible = not(state.visible)
+
+
+public function debug_draw(state: const_ptr[DebugState], font_size: int) -> void:
+    var visible = false
+    unsafe:
+        visible = read(state).visible
+
+    if not visible:
+        return
+
+    let width = rl.get_screen_width()
+    let height = rl.get_screen_height()
+    let panel_x = width - 290
+    let panel_y = 10
+    let panel_width = 280
+    let panel_height = 160
+
+    rl.draw_rectangle(
+        panel_x,
+        panel_y,
+        panel_width,
+        panel_height,
+        rl.Color(r = 0, g = 0, b = 0, a = 200)
+    )
+
+    let fps = rl.get_fps()
+    let fps_text = f"FPS: #{fps}"
+    rl.draw_text(
+        fps_text,
+        panel_x + 4,
+        panel_y + 4,
+        font_size,
+        rl.Color(r = 0, g = 255, b = 0, a = 255)
+    )
+
+    let dt = rl.get_frame_time() * 1000.0
+    let dt_text = f"Frame: #{dt} ms"
+    rl.draw_text(
+        dt_text,
+        panel_x + 4,
+        panel_y + 4 + font_size + 4,
+        font_size,
+        rl.Color(r = 255, g = 255, b = 0, a = 255)
+    )
+
+    let screen_text = f"#{width}x#{height}"
+    rl.draw_text(
+        screen_text,
+        panel_x + 4,
+        panel_y + 4 + (font_size + 4) * 2,
+        font_size,
+        rl.Color(r = 200, g = 200, b = 200, a = 255)
+    )