mt-lang 0.2.0 → 0.2.1

data/std/raylib/easing.mt

@@ -0,0 +1,388 @@
+import std.math as math
+
+public const PI: float = 3.14159265358979323846
+
+public const EASE_LINEAR_NONE: int = 0
+public const EASE_LINEAR_IN: int = 1
+public const EASE_LINEAR_OUT: int = 2
+public const EASE_LINEAR_IN_OUT: int = 3
+public const EASE_SINE_IN: int = 4
+public const EASE_SINE_OUT: int = 5
+public const EASE_SINE_IN_OUT: int = 6
+public const EASE_CIRC_IN: int = 7
+public const EASE_CIRC_OUT: int = 8
+public const EASE_CIRC_IN_OUT: int = 9
+public const EASE_CUBIC_IN: int = 10
+public const EASE_CUBIC_OUT: int = 11
+public const EASE_CUBIC_IN_OUT: int = 12
+public const EASE_QUAD_IN: int = 13
+public const EASE_QUAD_OUT: int = 14
+public const EASE_QUAD_IN_OUT: int = 15
+public const EASE_EXPO_IN: int = 16
+public const EASE_EXPO_OUT: int = 17
+public const EASE_EXPO_IN_OUT: int = 18
+public const EASE_BACK_IN: int = 19
+public const EASE_BACK_OUT: int = 20
+public const EASE_BACK_IN_OUT: int = 21
+public const EASE_BOUNCE_OUT: int = 22
+public const EASE_BOUNCE_IN: int = 23
+public const EASE_BOUNCE_IN_OUT: int = 24
+public const EASE_ELASTIC_IN: int = 25
+public const EASE_ELASTIC_OUT: int = 26
+public const EASE_ELASTIC_IN_OUT: int = 27
+public const EASING_NONE: int = 28
+
+
+function sinf(value: float) -> float:
+    return float<-math.sin(double<-value)
+
+
+function cosf(value: float) -> float:
+    return float<-math.cos(double<-value)
+
+
+function sqrtf(value: float) -> float:
+    return float<-math.sqrt(double<-value)
+
+
+function powf(base: float, exponent: float) -> float:
+    return float<-math.pow(double<-base, double<-exponent)
+
+
+public function linear_none(t: float, b: float, c: float, d: float) -> float:
+    return (c * t / d) + b
+
+
+public function linear_in(t: float, b: float, c: float, d: float) -> float:
+    return linear_none(t, b, c, d)
+
+
+public function linear_out(t: float, b: float, c: float, d: float) -> float:
+    return linear_none(t, b, c, d)
+
+
+public function linear_in_out(t: float, b: float, c: float, d: float) -> float:
+    return linear_none(t, b, c, d)
+
+
+public function sine_in(t: float, b: float, c: float, d: float) -> float:
+    return (-c * cosf((t / d) * (PI / 2.0)) + c + b)
+
+
+public function sine_out(t: float, b: float, c: float, d: float) -> float:
+    return (c * sinf((t / d) * (PI / 2.0)) + b)
+
+
+public function sine_in_out(t: float, b: float, c: float, d: float) -> float:
+    return (-c / 2.0 * (cosf(PI * t / d) - 1.0) + b)
+
+
+public function circ_in(t: float, b: float, c: float, d: float) -> float:
+    let current = t / d
+    return (-c * (sqrtf(1.0 - current * current) - 1.0) + b)
+
+
+public function circ_out(t: float, b: float, c: float, d: float) -> float:
+    let current = (t / d) - 1.0
+    return (c * sqrtf(1.0 - current * current) + b)
+
+
+public function circ_in_out(t: float, b: float, c: float, d: float) -> float:
+    var current = t / (d / 2.0)
+    if current < 1.0:
+        return (-c / 2.0 * (sqrtf(1.0 - current * current) - 1.0) + b)
+
+    current -= 2.0
+    return (c / 2.0 * (sqrtf(1.0 - current * current) + 1.0) + b)
+
+
+public function cubic_in(t: float, b: float, c: float, d: float) -> float:
+    let current = t / d
+    return (c * current * current * current + b)
+
+
+public function cubic_out(t: float, b: float, c: float, d: float) -> float:
+    let current = (t / d) - 1.0
+    return (c * (current * current * current + 1.0) + b)
+
+
+public function cubic_in_out(t: float, b: float, c: float, d: float) -> float:
+    var current = t / (d / 2.0)
+    if current < 1.0:
+        return (c / 2.0 * current * current * current + b)
+
+    current -= 2.0
+    return (c / 2.0 * (current * current * current + 2.0) + b)
+
+
+public function quad_in(t: float, b: float, c: float, d: float) -> float:
+    let current = t / d
+    return (c * current * current + b)
+
+
+public function quad_out(t: float, b: float, c: float, d: float) -> float:
+    let current = t / d
+    return (-c * current * (current - 2.0) + b)
+
+
+public function quad_in_out(t: float, b: float, c: float, d: float) -> float:
+    let current = t / (d / 2.0)
+    if current < 1.0:
+        return (c / 2.0 * current * current + b)
+
+    return (-c / 2.0 * (((current - 1.0) * (current - 3.0)) - 1.0) + b)
+
+
+public function expo_in(t: float, b: float, c: float, d: float) -> float:
+    if t == 0.0:
+        return b
+
+    return (c * powf(2.0, 10.0 * ((t / d) - 1.0)) + b)
+
+
+public function expo_out(t: float, b: float, c: float, d: float) -> float:
+    if t == d:
+        return b + c
+
+    return (c * (-powf(2.0, (-10.0 * t) / d) + 1.0) + b)
+
+
+public function expo_in_out(t: float, b: float, c: float, d: float) -> float:
+    if t == 0.0:
+        return b
+    if t == d:
+        return b + c
+
+    let current = t / (d / 2.0)
+    if current < 1.0:
+        return (c / 2.0 * powf(2.0, 10.0 * (current - 1.0)) + b)
+
+    return (c / 2.0 * (-powf(2.0, -10.0 * (current - 1.0)) + 2.0) + b)
+
+
+public function back_in(t: float, b: float, c: float, d: float) -> float:
+    let s = 1.70158
+    let current = t / d
+    return (c * current * current * (((s + 1.0) * current) - s) + b)
+
+
+public function back_out(t: float, b: float, c: float, d: float) -> float:
+    let s = 1.70158
+    let current = (t / d) - 1.0
+    return (c * (current * current * (((s + 1.0) * current) + s) + 1.0) + b)
+
+
+public function back_in_out(t: float, b: float, c: float, d: float) -> float:
+    var s: float = 1.70158
+    var current = t / (d / 2.0)
+    if current < 1.0:
+        s *= 1.525
+        return (c / 2.0 * (current * current * (((s + 1.0) * current) - s)) + b)
+
+    current -= 2.0
+    s *= 1.525
+    return (c / 2.0 * (current * current * (((s + 1.0) * current) + s) + 2.0) + b)
+
+
+public function bounce_out(t: float, b: float, c: float, d: float) -> float:
+    let current = t / d
+    if current < (1.0 / 2.75):
+        return (c * (7.5625 * current * current) + b)
+    else if current < (2.0 / 2.75):
+        let post_fix = current - (1.5 / 2.75)
+        return (c * (7.5625 * post_fix * post_fix + 0.75) + b)
+    else if current < (2.5 / 2.75):
+        let post_fix = current - (2.25 / 2.75)
+        return (c * (7.5625 * post_fix * post_fix + 0.9375) + b)
+
+    let post_fix = current - (2.625 / 2.75)
+    return (c * (7.5625 * post_fix * post_fix + 0.984375) + b)
+
+
+public function bounce_in(t: float, b: float, c: float, d: float) -> float:
+    return (c - bounce_out(d - t, 0.0, c, d) + b)
+
+
+public function bounce_in_out(t: float, b: float, c: float, d: float) -> float:
+    if t < d / 2.0:
+        return (bounce_in(t * 2.0, 0.0, c, d) * 0.5 + b)
+
+    return (bounce_out(t * 2.0 - d, 0.0, c, d) * 0.5 + c * 0.5 + b)
+
+
+public function elastic_in(t: float, b: float, c: float, d: float) -> float:
+    if t == 0.0:
+        return b
+
+    var current = t / d
+    if current == 1.0:
+        return b + c
+
+    let p = d * 0.3
+    let a = c
+    let s = p / 4.0
+    current -= 1.0
+    let post_fix = a * powf(2.0, 10.0 * current)
+    return (-(post_fix * sinf(((current * d) - s) * ((2.0 * PI) / p))) + b)
+
+
+public function elastic_out(t: float, b: float, c: float, d: float) -> float:
+    if t == 0.0:
+        return b
+
+    let current = t / d
+    if current == 1.0:
+        return b + c
+
+    let p = d * 0.3
+    let a = c
+    let s = p / 4.0
+    return (a * powf(2.0, -10.0 * current) * sinf(((current * d) - s) * ((2.0 * PI) / p)) + c + b)
+
+
+public function elastic_in_out(t: float, b: float, c: float, d: float) -> float:
+    if t == 0.0:
+        return b
+
+    var current = t / (d / 2.0)
+    if current == 2.0:
+        return b + c
+
+    let p = d * (0.3 * 1.5)
+    let a = c
+    let s = p / 4.0
+
+    if current < 1.0:
+        current -= 1.0
+        let post_fix = a * powf(2.0, 10.0 * current)
+        return (-0.5 * (post_fix * sinf(((current * d) - s) * ((2.0 * PI) / p))) + b)
+
+    current -= 1.0
+    let post_fix = a * powf(2.0, -10.0 * current)
+    return (post_fix * sinf(((current * d) - s) * ((2.0 * PI) / p)) * 0.5 + c + b)
+
+
+public function no_ease(_t: float, b: float, _c: float, _d: float) -> float:
+    return b
+
+
+public function by_kind(kind: int, t: float, b: float, c: float, d: float) -> float:
+    if kind == EASE_LINEAR_NONE:
+        return linear_none(t, b, c, d)
+    else if kind == EASE_LINEAR_IN:
+        return linear_in(t, b, c, d)
+    else if kind == EASE_LINEAR_OUT:
+        return linear_out(t, b, c, d)
+    else if kind == EASE_LINEAR_IN_OUT:
+        return linear_in_out(t, b, c, d)
+    else if kind == EASE_SINE_IN:
+        return sine_in(t, b, c, d)
+    else if kind == EASE_SINE_OUT:
+        return sine_out(t, b, c, d)
+    else if kind == EASE_SINE_IN_OUT:
+        return sine_in_out(t, b, c, d)
+    else if kind == EASE_CIRC_IN:
+        return circ_in(t, b, c, d)
+    else if kind == EASE_CIRC_OUT:
+        return circ_out(t, b, c, d)
+    else if kind == EASE_CIRC_IN_OUT:
+        return circ_in_out(t, b, c, d)
+    else if kind == EASE_CUBIC_IN:
+        return cubic_in(t, b, c, d)
+    else if kind == EASE_CUBIC_OUT:
+        return cubic_out(t, b, c, d)
+    else if kind == EASE_CUBIC_IN_OUT:
+        return cubic_in_out(t, b, c, d)
+    else if kind == EASE_QUAD_IN:
+        return quad_in(t, b, c, d)
+    else if kind == EASE_QUAD_OUT:
+        return quad_out(t, b, c, d)
+    else if kind == EASE_QUAD_IN_OUT:
+        return quad_in_out(t, b, c, d)
+    else if kind == EASE_EXPO_IN:
+        return expo_in(t, b, c, d)
+    else if kind == EASE_EXPO_OUT:
+        return expo_out(t, b, c, d)
+    else if kind == EASE_EXPO_IN_OUT:
+        return expo_in_out(t, b, c, d)
+    else if kind == EASE_BACK_IN:
+        return back_in(t, b, c, d)
+    else if kind == EASE_BACK_OUT:
+        return back_out(t, b, c, d)
+    else if kind == EASE_BACK_IN_OUT:
+        return back_in_out(t, b, c, d)
+    else if kind == EASE_BOUNCE_OUT:
+        return bounce_out(t, b, c, d)
+    else if kind == EASE_BOUNCE_IN:
+        return bounce_in(t, b, c, d)
+    else if kind == EASE_BOUNCE_IN_OUT:
+        return bounce_in_out(t, b, c, d)
+    else if kind == EASE_ELASTIC_IN:
+        return elastic_in(t, b, c, d)
+    else if kind == EASE_ELASTIC_OUT:
+        return elastic_out(t, b, c, d)
+    else if kind == EASE_ELASTIC_IN_OUT:
+        return elastic_in_out(t, b, c, d)
+
+    return no_ease(t, b, c, d)
+
+
+public function kind_name(kind: int) -> str:
+    if kind == EASE_LINEAR_NONE:
+        return "EaseLinearNone"
+    else if kind == EASE_LINEAR_IN:
+        return "EaseLinearIn"
+    else if kind == EASE_LINEAR_OUT:
+        return "EaseLinearOut"
+    else if kind == EASE_LINEAR_IN_OUT:
+        return "EaseLinearInOut"
+    else if kind == EASE_SINE_IN:
+        return "EaseSineIn"
+    else if kind == EASE_SINE_OUT:
+        return "EaseSineOut"
+    else if kind == EASE_SINE_IN_OUT:
+        return "EaseSineInOut"
+    else if kind == EASE_CIRC_IN:
+        return "EaseCircIn"
+    else if kind == EASE_CIRC_OUT:
+        return "EaseCircOut"
+    else if kind == EASE_CIRC_IN_OUT:
+        return "EaseCircInOut"
+    else if kind == EASE_CUBIC_IN:
+        return "EaseCubicIn"
+    else if kind == EASE_CUBIC_OUT:
+        return "EaseCubicOut"
+    else if kind == EASE_CUBIC_IN_OUT:
+        return "EaseCubicInOut"
+    else if kind == EASE_QUAD_IN:
+        return "EaseQuadIn"
+    else if kind == EASE_QUAD_OUT:
+        return "EaseQuadOut"
+    else if kind == EASE_QUAD_IN_OUT:
+        return "EaseQuadInOut"
+    else if kind == EASE_EXPO_IN:
+        return "EaseExpoIn"
+    else if kind == EASE_EXPO_OUT:
+        return "EaseExpoOut"
+    else if kind == EASE_EXPO_IN_OUT:
+        return "EaseExpoInOut"
+    else if kind == EASE_BACK_IN:
+        return "EaseBackIn"
+    else if kind == EASE_BACK_OUT:
+        return "EaseBackOut"
+    else if kind == EASE_BACK_IN_OUT:
+        return "EaseBackInOut"
+    else if kind == EASE_BOUNCE_OUT:
+        return "EaseBounceOut"
+    else if kind == EASE_BOUNCE_IN:
+        return "EaseBounceIn"
+    else if kind == EASE_BOUNCE_IN_OUT:
+        return "EaseBounceInOut"
+    else if kind == EASE_ELASTIC_IN:
+        return "EaseElasticIn"
+    else if kind == EASE_ELASTIC_OUT:
+        return "EaseElasticOut"
+    else if kind == EASE_ELASTIC_IN_OUT:
+        return "EaseElasticInOut"
+
+    return "None"

data/std/raylib/packed_assets.mt

@@ -0,0 +1,255 @@
+import std.asset_pack as pack
+import std.bytes as bytes
+import std.raylib as rl
+import std.string as string
+import std.str as text
+
+public enum Error: int
+    open_failed = 1
+    closed = 2
+    invalid_magic = 3
+    unsupported_version = 4
+    unsupported_flags = 5
+    range = 6
+    malformed_header = 7
+    malformed_index = 8
+    entry_not_found = 9
+    io = 10
+    missing_file_type = 101
+    invalid_image = 102
+    invalid_texture = 103
+    invalid_wave = 104
+    invalid_sound = 105
+    invalid_music = 106
+
+public type Reader = pack.Reader
+
+public struct PackedMusic:
+    music: rl.Music
+    backing_data: bytes.Bytes
+
+
+extending PackedMusic:
+    public function is_valid() -> bool:
+        return rl.is_music_valid(this.music)
+
+
+    public function play() -> void:
+        rl.play_music_stream(this.music)
+
+
+    public function is_playing() -> bool:
+        return rl.is_music_stream_playing(this.music)
+
+
+    public function update() -> void:
+        rl.update_music_stream(this.music)
+
+
+    public function stop() -> void:
+        rl.stop_music_stream(this.music)
+
+
+    public function pause() -> void:
+        rl.pause_music_stream(this.music)
+
+
+    public function resume() -> void:
+        rl.resume_music_stream(this.music)
+
+
+    public function seek(position: float) -> void:
+        rl.seek_music_stream(this.music, position)
+
+
+    public function set_volume(volume: float) -> void:
+        rl.set_music_volume(this.music, volume)
+
+
+    public function set_pitch(pitch: float) -> void:
+        rl.set_music_pitch(this.music, pitch)
+
+
+    public function set_pan(pan: float) -> void:
+        rl.set_music_pan(this.music, pan)
+
+
+    public function time_length() -> float:
+        return rl.get_music_time_length(this.music)
+
+
+    public function time_played() -> float:
+        return rl.get_music_time_played(this.music)
+
+
+    public editable function release() -> void:
+        if rl.is_music_valid(this.music):
+            rl.unload_music_stream(this.music)
+
+        this.music = zero[rl.Music]
+        this.backing_data.release()
+
+
+public function open_assets_pack_if_present() -> Result[Option[Reader], Error]:
+    let open_result = open_pack_relative_to_application("assets.mtpack")
+    match open_result:
+        Result.failure as payload:
+            if payload.error == Error.open_failed:
+                return Result[Option[Reader], Error].success(value= Option[Reader].none)
+
+            return Result[Option[Reader], Error].failure(error= payload.error)
+        Result.success as payload:
+            return Result[Option[Reader], Error].success(value= Option[Reader].some(value= payload.value))
+
+
+public function open_assets_pack() -> Result[Reader, Error]:
+    return open_pack_relative_to_application("assets.mtpack")
+
+
+public function close_reader(reader: ref[Reader]) -> void:
+    reader.close()
+
+
+public function load_image(reader: pack.Reader, logical_path: str) -> Result[rl.Image, Error]:
+    let file_type = detect_file_type(logical_path)?
+    var data = map_pack_result(reader.read_bytes(logical_path))?
+    defer data.release()
+
+    let image = rl.load_image_from_memory(file_type, data.as_span())
+    if not rl.is_image_valid(image):
+        return Result[rl.Image, Error].failure(error= Error.invalid_image)
+
+    return Result[rl.Image, Error].success(value= image)
+
+
+public function load_texture(reader: pack.Reader, logical_path: str) -> Result[rl.Texture2D, Error]:
+    let image = load_image(reader, logical_path)?
+    defer rl.unload_image(image)
+
+    let texture = rl.load_texture_from_image(image)
+    if not rl.is_texture_valid(texture):
+        return Result[rl.Texture2D, Error].failure(error= Error.invalid_texture)
+
+    return Result[rl.Texture2D, Error].success(value= texture)
+
+
+public function load_wave(reader: pack.Reader, logical_path: str) -> Result[rl.Wave, Error]:
+    let file_type = detect_file_type(logical_path)?
+    var data = map_pack_result(reader.read_bytes(logical_path))?
+    defer data.release()
+
+    let wave = rl.load_wave_from_memory(file_type, data.as_span())
+    if not rl.is_wave_valid(wave):
+        return Result[rl.Wave, Error].failure(error= Error.invalid_wave)
+
+    return Result[rl.Wave, Error].success(value= wave)
+
+
+public function load_sound(reader: pack.Reader, logical_path: str) -> Result[rl.Sound, Error]:
+    let wave = load_wave(reader, logical_path)?
+    defer rl.unload_wave(wave)
+
+    let sound = rl.load_sound_from_wave(wave)
+    if not rl.is_sound_valid(sound):
+        return Result[rl.Sound, Error].failure(error= Error.invalid_sound)
+
+    return Result[rl.Sound, Error].success(value= sound)
+
+
+public function load_music(reader: pack.Reader, logical_path: str) -> Result[PackedMusic, Error]:
+    let file_type = detect_file_type(logical_path)?
+    var data = map_pack_result(reader.read_bytes(logical_path))?
+    let span = data.as_span()
+    let music = rl.load_music_stream_from_memory(file_type, span.data, int<-span.len)
+    if rl.is_music_valid(music):
+        return Result[PackedMusic, Error].success(value= PackedMusic(
+            music = music,
+            backing_data = data
+        ))
+
+    data.release()
+    return Result[PackedMusic, Error].failure(error= Error.invalid_music)
+
+
+function open_pack_relative_to_application(pack_name: str) -> Result[pack.Reader, Error]:
+    var application_path = application_relative_path(pack_name)
+    defer application_path.release()
+
+    let application_result = pack.open(application_path.as_str())
+    match application_result:
+        Result.success as payload:
+            return Result[pack.Reader, Error].success(value= payload.value)
+        Result.failure as payload:
+            if payload.error != pack.Error.open_failed:
+                return Result[pack.Reader, Error].failure(error= from_pack_error(payload.error))
+
+            return map_pack_result(pack.open(pack_name))
+
+
+function application_relative_path(relative_path: str) -> string.String:
+    let application_dir = text.cstr_as_str(rl.get_application_directory())
+    var result = string.String.from_str(application_dir)
+
+    if application_dir.len > 0:
+        let last = application_dir.byte_at(application_dir.len - 1)
+        if last != 47 and last != 92:
+            result.append("/")
+
+    result.append(relative_path)
+    return result
+
+
+function detect_file_type(logical_path: str) -> Result[str, Error]:
+    match file_type(logical_path):
+        Option.some as payload:
+            return Result[str, Error].success(value= payload.value)
+        Option.none:
+            return Result[str, Error].failure(error= Error.missing_file_type)
+
+
+function from_pack_error(error: pack.Error) -> Error:
+    match error:
+        pack.Error.open_failed:
+            return Error.open_failed
+        pack.Error.closed:
+            return Error.closed
+        pack.Error.invalid_magic:
+            return Error.invalid_magic
+        pack.Error.unsupported_version:
+            return Error.unsupported_version
+        pack.Error.unsupported_flags:
+            return Error.unsupported_flags
+        pack.Error.range:
+            return Error.range
+        pack.Error.malformed_header:
+            return Error.malformed_header
+        pack.Error.malformed_index:
+            return Error.malformed_index
+        pack.Error.entry_not_found:
+            return Error.entry_not_found
+        pack.Error.io:
+            return Error.io
+
+
+function map_pack_result[T](result: Result[T, pack.Error]) -> Result[T, Error]:
+    return result.map_error(proc(e: pack.Error) -> Error:
+        from_pack_error(e)
+    )
+
+
+function file_type(logical_path: str) -> Option[str]:
+    var index = logical_path.len
+    while index > 0:
+        index -= 1
+
+        let value = logical_path.byte_at(index)
+        if value == 47:
+            return Option[str].none
+
+        if value == 46:
+            if index + 1 == logical_path.len:
+                return Option[str].none
+
+            return Option[str].some(value= logical_path.slice(index, logical_path.len - index))
+
+    return Option[str].none

data/std/raylib/runtime.mt

@@ -0,0 +1,30 @@
+import std.raylib as rl
+import std.libc as libc
+
+
+public function env_flag(name: str) -> bool:
+    return libc.get_environment_variable(name) != null
+
+
+public function require_ptr[T](value: ptr[T]?, message: str) -> ptr[T]:
+    if value == null:
+        fatal(message)
+
+    return ptr[T]<-value
+
+
+public function enter_asset_directory(directory_name: str) -> bool:
+    let working_dir = rl.get_working_directory()
+    let application_dir = rl.get_application_directory()
+
+    if rl.change_directory(application_dir):
+        if rl.change_directory(directory_name):
+            return true
+
+        rl.change_directory(working_dir)
+
+    return rl.change_directory(directory_name)
+
+
+public function enter_assets_directory() -> bool:
+    return enter_asset_directory("assets")

data/std/raylib/tracy_gpu.mt

@@ -0,0 +1,37 @@
+import std.tracy as tracy
+
+public const GPU_CALIBRATION_QUERY_COUNT: int = 32
+
+
+public function begin_gpu_zone(srcloc: const_ptr[tracy.SourceLocation], active: int) -> tracy.Zone:
+    return tracy.emit_gpu_zone_begin(srcloc, active)
+
+
+public function end_gpu_zone(zone: tracy.Zone) -> void:
+    tracy.emit_gpu_zone_end(zone)
+
+
+public function gpu_zone_value(zone: tracy.Zone, value: long) -> void:
+    tracy.emit_gpu_zone_value(zone, value)
+
+
+public function gpu_calibrate(zone: tracy.Zone) -> void:
+    tracy.emit_gpu_calibration(zone)
+
+
+public function submit_gpu_time(gpu_time: long, query_id: ushort, context: ubyte) -> void:
+    let data = tracy.GpuTime(
+        gpu_time = gpu_time,
+        query_id = query_id,
+        context = context
+    )
+    tracy.emit_gpu_time(const_ptr_of(data))
+
+
+public function submit_gpu_time_sync(gpu_time: long, query_id: ushort, context: ubyte) -> void:
+    let data = tracy.GpuTime(
+        gpu_time = gpu_time,
+        query_id = query_id,
+        context = context
+    )
+    tracy.emit_gpu_time_sync(const_ptr_of(data))