mt-lang 0.3.1 → 0.3.4

data/std/simd.mt

@@ -0,0 +1,100 @@
+## SIMD helpers — load, store, and reduction operations
+## for the built-in simd[T, N] type constructor.
+##
+## Load and store use unsafe ptr casts internally; the user-facing
+## surface is safe because only valid pointer dereferencing is involved.
+##
+## Usage:
+##   import std.simd as simd
+##   let v = simd.load_aligned_float4(ptr)
+##   let s = simd.horizontal_sum_float4(v)
+
+import std.mem.ptr as ptr
+
+## ── simd[float, 4] ──────────────────────────────────────────────────
+
+public function load_aligned_float4(p: ptr[float]) -> simd[float, 4]:
+    let sp = unsafe: ptr[simd[float, 4]]<-p
+    return sp.load()
+
+public function load_unaligned_float4(p: ptr[float]) -> simd[float, 4]:
+    return load_aligned_float4(p)
+
+public function store_aligned_float4(p: ptr[float], value: simd[float, 4]) -> void:
+    let sp = unsafe: ptr[simd[float, 4]]<-p
+    sp.store(value)
+
+public function store_unaligned_float4(p: ptr[float], value: simd[float, 4]) -> void:
+    store_aligned_float4(p, value)
+
+public function horizontal_sum_float4(v: simd[float, 4]) -> float:
+    return v[0] + v[1] + v[2] + v[3]
+
+public function dot_float4(a: simd[float, 4], b: simd[float, 4]) -> float:
+    return horizontal_sum_float4(a * b)
+
+## ── simd[int, 4] ────────────────────────────────────────────────────
+
+public function load_aligned_int4(p: ptr[int]) -> simd[int, 4]:
+    let sp = unsafe: ptr[simd[int, 4]]<-p
+    return sp.load()
+
+public function load_unaligned_int4(p: ptr[int]) -> simd[int, 4]:
+    return load_aligned_int4(p)
+
+public function store_aligned_int4(p: ptr[int], value: simd[int, 4]) -> void:
+    let sp = unsafe: ptr[simd[int, 4]]<-p
+    sp.store(value)
+
+public function store_unaligned_int4(p: ptr[int], value: simd[int, 4]) -> void:
+    store_aligned_int4(p, value)
+
+public function horizontal_sum_int4(v: simd[int, 4]) -> int:
+    return v[0] + v[1] + v[2] + v[3]
+
+public function dot_int4(a: simd[int, 4], b: simd[int, 4]) -> int:
+    return horizontal_sum_int4(a * b)
+
+## ── simd[float, 8] (AVX) ────────────────────────────────────────────
+
+public function load_aligned_float8(p: ptr[float]) -> simd[float, 8]:
+    let sp = unsafe: ptr[simd[float, 8]]<-p
+    return sp.load()
+
+public function load_unaligned_float8(p: ptr[float]) -> simd[float, 8]:
+    return load_aligned_float8(p)
+
+public function store_aligned_float8(p: ptr[float], value: simd[float, 8]) -> void:
+    let sp = unsafe: ptr[simd[float, 8]]<-p
+    sp.store(value)
+
+public function store_unaligned_float8(p: ptr[float], value: simd[float, 8]) -> void:
+    store_aligned_float8(p, value)
+
+public function horizontal_sum_float8(v: simd[float, 8]) -> float:
+    return v[0] + v[1] + v[2] + v[3] + v[4] + v[5] + v[6] + v[7]
+
+public function dot_float8(a: simd[float, 8], b: simd[float, 8]) -> float:
+    return horizontal_sum_float8(a * b)
+
+## ── simd[double, 2] ─────────────────────────────────────────────────
+
+public function load_aligned_double2(p: ptr[double]) -> simd[double, 2]:
+    let sp = unsafe: ptr[simd[double, 2]]<-p
+    return sp.load()
+
+public function load_unaligned_double2(p: ptr[double]) -> simd[double, 2]:
+    return load_aligned_double2(p)
+
+public function store_aligned_double2(p: ptr[double], value: simd[double, 2]) -> void:
+    let sp = unsafe: ptr[simd[double, 2]]<-p
+    sp.store(value)
+
+public function store_unaligned_double2(p: ptr[double], value: simd[double, 2]) -> void:
+    store_aligned_double2(p, value)
+
+public function horizontal_sum_double2(v: simd[double, 2]) -> double:
+    return v[0] + v[1]
+
+public function dot_double2(a: simd[double, 2], b: simd[double, 2]) -> double:
+    return horizontal_sum_double2(a * b)

data/std/steering.mt

@@ -0,0 +1,132 @@
+## Steering behaviors — Craig Reynolds' autonomous motion.
+##
+## Pure-function steering forces for autonomous agents.
+## Seek, flee, arrive, pursuit, evade, wander, and flocking
+## (separation, alignment, cohesion). All return steering
+## force vectors to be accumulated and applied by the caller.
+##
+##   import std.steering as steer
+##   var force = steer.Steer.seek(pos, vel, target, max_speed)
+##   force = force + steer.Steer.separation(pos, neighbors, r, max_speed)
+
+import std.linear_algebra as la
+import std.math as math
+
+
+# ── internal helpers ──
+
+function set_magnitude(v: vec2, magnitude: float) -> vec2:
+    let len = v.length()
+    if len <= 0.0:
+        return v
+    return v * (magnitude / len)
+
+
+function limit_force(steering: vec2, max_force: float) -> vec2:
+    let mag = steering.length()
+    if mag > max_force:
+        return steering * (max_force / mag)
+    return steering
+
+
+# ── public API ──
+
+extending vec2:
+    public static function seek(position: vec2, velocity: vec2, target: vec2, max_speed: float) -> vec2:
+        let desired = target - position
+        let desired_vel = set_magnitude(desired, max_speed)
+        return desired_vel - velocity
+
+
+    public static function flee(position: vec2, velocity: vec2, threat: vec2, max_speed: float) -> vec2:
+        let desired = position - threat
+        let desired_vel = set_magnitude(desired, max_speed)
+        return desired_vel - velocity
+
+
+    public static function arrive(position: vec2, velocity: vec2, target: vec2, max_speed: float, slowing_distance: float) -> vec2:
+        let offset = target - position
+        let distance = offset.length()
+        if distance < 0.001:
+            return zero[vec2]
+        let speed = if distance < slowing_distance: max_speed * distance / slowing_distance else: max_speed
+        let desired_vel = offset * (speed / distance)
+        return desired_vel - velocity
+
+
+    public static function pursuit(position: vec2, velocity: vec2, target_pos: vec2, target_vel: vec2, max_speed: float) -> vec2:
+        let offset = target_pos - position
+        let distance = offset.length()
+        let my_speed = velocity.length()
+        var look_ahead: float = distance / (max_speed + 0.001)
+        if my_speed > 0.001:
+            look_ahead = distance / my_speed
+        let future = target_pos + target_vel * look_ahead
+        return vec2.seek(position, velocity, future, max_speed)
+
+
+    public static function evade(position: vec2, velocity: vec2, threat_pos: vec2, threat_vel: vec2, max_speed: float) -> vec2:
+        let offset = threat_pos - position
+        let distance = offset.length()
+        let my_speed = velocity.length()
+        var look_ahead: float = distance / (max_speed + 0.001)
+        if my_speed > 0.001:
+            look_ahead = distance / my_speed
+        let future = threat_pos + threat_vel * look_ahead
+        return vec2.flee(position, velocity, future, max_speed)
+
+
+    public static function wander(velocity: vec2, wander_angle: float, wander_distance: float, wander_radius: float) -> vec2:
+        if velocity.length() < 0.001:
+            return zero[vec2]
+        let forward = set_magnitude(velocity, 1.0)
+        let circle_center = forward * wander_distance
+        let wx = circle_center.x + wander_radius * float<-(math.cos(double<-(wander_angle)))
+        let wy = circle_center.y + wander_radius * float<-(math.sin(double<-(wander_angle)))
+        let displacement = vec2(x = wx, y = wy)
+        return displacement
+
+
+    public static function separation(position: vec2, neighbors: span[vec2], desired_separation: float) -> vec2:
+        var steer: vec2 = zero[vec2]
+        var count: ptr_uint = 0
+        for n in neighbors:
+            let d = position - n
+            let distance = d.length()
+            if distance > 0.0 and distance < desired_separation:
+                let repulsion = d * (1.0 / distance)
+                steer = steer + repulsion
+                count += 1
+        if count > 0:
+            steer = steer / float<-(count)
+        return steer
+
+
+    public static function alignment(velocity: vec2, neighbor_velocities: span[vec2]) -> vec2:
+        var sum: vec2 = zero[vec2]
+        var count: ptr_uint = 0
+        for nv in neighbor_velocities:
+            sum = sum + nv
+            count += 1
+        if count > 0:
+            let avg = sum / float<-(count)
+            return avg - velocity
+        return zero[vec2]
+
+
+    public static function cohesion(position: vec2, neighbor_positions: span[vec2], radius: float) -> vec2:
+        var sum: vec2 = zero[vec2]
+        var count: ptr_uint = 0
+        for np in neighbor_positions:
+            let d = position - np
+            if d.length() < radius:
+                sum = sum + np
+                count += 1
+        if count > 0:
+            let center = sum / float<-(count)
+            return center - position
+        return zero[vec2]
+
+
+    public static function limit(steering: vec2, max_force: float) -> vec2:
+        return limit_force(steering, max_force)

data/std/timer.mt

@@ -0,0 +1,81 @@
+## Timer — countdown and repeating timers.
+##
+## Accumulate delta time and fire when duration is reached.
+## Supports one-shot (auto-stop) and repeating (auto-reset).
+##
+##   import std.timer as time
+##   var cooldown = time.Timer.create(0.5, false)
+##   var regen = time.Timer.create(1.0, true)
+##   ...
+##   if cooldown.step(dt): do_ability()
+##   if regen.step(dt): heal(1)
+
+
+public struct Timer:
+    duration: float
+    elapsed: float
+    active: bool
+    repeating: bool
+
+
+# ── public API ──
+
+extending Timer:
+    public static function create(duration: float, repeating: bool) -> Timer:
+        return Timer(
+            duration = duration,
+            elapsed = 0.0,
+            active = true,
+            repeating = repeating
+        )
+
+
+    public editable function step(dt: float) -> bool:
+        if not this.active:
+            return false
+        this.elapsed = this.elapsed + dt
+        if this.elapsed >= this.duration:
+            if this.repeating:
+                this.elapsed = this.elapsed - this.duration
+            else:
+                this.elapsed = this.duration
+                this.active = false
+            return true
+        return false
+
+
+    public function progress() -> float:
+        if this.duration <= 0.0:
+            return 1.0
+        let p = this.elapsed / this.duration
+        if p > 1.0: return 1.0
+        return p
+
+
+    public function time_left() -> float:
+        let t = this.duration - this.elapsed
+        if t < 0.0: return 0.0
+        return t
+
+
+    public editable function reset() -> void:
+        this.elapsed = 0.0
+        this.active = true
+
+
+    public editable function restart(duration: float) -> void:
+        this.duration = duration
+        this.elapsed = 0.0
+        this.active = true
+
+
+    public editable function stop() -> void:
+        this.active = false
+
+
+    public editable function pause() -> void:
+        this.active = false
+
+
+    public editable function resume() -> void:
+        this.active = true

data/std/tween.mt

@@ -0,0 +1,374 @@
+## Tweening and easing — smooth value interpolation.
+##
+## Normalized easing functions map [0,1] linear progress to
+## eased progress, following the Robert Penner convention.
+## A Tween struct tracks elapsed time and computes the
+## current interpolated value.
+##
+##   import std.tween as tw
+##   var t = tw.Tween.create(0.0, 100.0, 2.0, tw.Easing.ease_out_cubic)
+##   while t.active:
+##       let v = t.value()
+##       apply_position(v)
+##       t.step(dt)
+
+import std.math as math
+
+
+public enum Easing: ubyte
+    linear = 0
+    ease_in_quad = 1
+    ease_out_quad = 2
+    ease_in_out_quad = 3
+    ease_in_cubic = 4
+    ease_out_cubic = 5
+    ease_in_out_cubic = 6
+    ease_in_quart = 7
+    ease_out_quart = 8
+    ease_in_out_quart = 9
+    ease_in_quint = 10
+    ease_out_quint = 11
+    ease_in_out_quint = 12
+    ease_in_sine = 13
+    ease_out_sine = 14
+    ease_in_out_sine = 15
+    ease_in_expo = 17
+    ease_out_expo = 18
+    ease_in_out_expo = 19
+    ease_in_circ = 20
+    ease_out_circ = 21
+    ease_in_out_circ = 22
+    ease_in_back = 23
+    ease_out_back = 24
+    ease_in_out_back = 25
+    ease_in_elastic = 26
+    ease_out_elastic = 27
+    ease_in_out_elastic = 28
+    ease_in_bounce = 29
+    ease_out_bounce = 30
+    ease_in_out_bounce = 31
+
+
+public struct Tween:
+    duration: float
+    elapsed: float
+    from: float
+    to: float
+    easing: Easing
+    active: bool
+
+
+# ── math helpers ──
+
+function pow_f(base: float, exp: float) -> float:
+    return float<-(math.pow(double<-(base), double<-(exp)))
+
+
+function sin_f(x: float) -> float:
+    return float<-(math.sin(double<-(x)))
+
+
+function cos_f(x: float) -> float:
+    return float<-(math.cos(double<-(x)))
+
+
+function sqrt_f(x: float) -> float:
+    return float<-(math.sqrt(double<-(x)))
+
+
+function ease_out_bounce_f(t: float) -> float:
+    let n1 = 7.5625
+    let d1 = 2.75
+    if t < 1.0 / d1:
+        return n1 * t * t
+    if t < 2.0 / d1:
+        let t1 = t - 1.5 / d1
+        return n1 * t1 * t1 + 0.75
+    if t < 2.5 / d1:
+        let t1 = t - 2.25 / d1
+        return n1 * t1 * t1 + 0.9375
+    let t1 = t - 2.625 / d1
+    return n1 * t1 * t1 + 0.984375
+
+
+# ── tween ──
+
+extending Tween:
+    public static function apply_easing(easing: Easing, t: float) -> float:
+        if easing == Easing.linear:
+            return t
+
+        if easing == Easing.ease_in_quad:
+            return t * t
+        if easing == Easing.ease_out_quad:
+            return t * (2.0 - t)
+        if easing == Easing.ease_in_out_quad:
+            if t < 0.5:
+                return 2.0 * t * t
+            return -1.0 + (4.0 - 2.0 * t) * t
+
+        if easing == Easing.ease_in_cubic:
+            return t * t * t
+        if easing == Easing.ease_out_cubic:
+            let t1 = t - 1.0
+            return t1 * t1 * t1 + 1.0
+        if easing == Easing.ease_in_out_cubic:
+            if t < 0.5:
+                return 4.0 * t * t * t
+            let t1 = -2.0 * t + 2.0
+            return 1.0 - t1 * t1 * t1 / 2.0
+
+        if easing == Easing.ease_in_quart:
+            return t * t * t * t
+        if easing == Easing.ease_out_quart:
+            let t1 = t - 1.0
+            return 1.0 - t1 * t1 * t1 * t1
+        if easing == Easing.ease_in_out_quart:
+            if t < 0.5:
+                return 8.0 * t * t * t * t
+            let t1 = t - 1.0
+            return 1.0 - 8.0 * t1 * t1 * t1 * t1
+
+        if easing == Easing.ease_in_quint:
+            return t * t * t * t * t
+        if easing == Easing.ease_out_quint:
+            let t1 = t - 1.0
+            return 1.0 + t1 * t1 * t1 * t1 * t1
+        if easing == Easing.ease_in_out_quint:
+            if t < 0.5:
+                return 16.0 * t * t * t * t * t
+            let t1 = -2.0 * t + 2.0
+            return 1.0 - t1 * t1 * t1 * t1 * t1 / 2.0
+
+        if easing == Easing.ease_in_sine:
+            return 1.0 - cos_f(t * 1.5707963)
+        if easing == Easing.ease_out_sine:
+            return sin_f(t * 1.5707963)
+        if easing == Easing.ease_in_out_sine:
+            return -(cos_f(3.14159265 * t) - 1.0) / 2.0
+
+        if easing == Easing.ease_in_expo:
+            if t <= 0.0: return 0.0
+            return pow_f(2.0, 10.0 * (t - 1.0))
+        if easing == Easing.ease_out_expo:
+            if t >= 1.0: return 1.0
+            return 1.0 - pow_f(2.0, -10.0 * t)
+        if easing == Easing.ease_in_out_expo:
+            if t <= 0.0: return 0.0
+            if t >= 1.0: return 1.0
+            if t < 0.5:
+                return pow_f(2.0, 20.0 * t - 10.0) / 2.0
+            return (2.0 - pow_f(2.0, -20.0 * t + 10.0)) / 2.0
+
+        if easing == Easing.ease_in_circ:
+            return 1.0 - sqrt_f(1.0 - t * t)
+        if easing == Easing.ease_out_circ:
+            return sqrt_f(1.0 - (t - 1.0) * (t - 1.0))
+        if easing == Easing.ease_in_out_circ:
+            if t < 0.5:
+                return (1.0 - sqrt_f(1.0 - 4.0 * t * t)) / 2.0
+            return (sqrt_f(1.0 - (-2.0 * t + 2.0) * (-2.0 * t + 2.0)) + 1.0) / 2.0
+
+        if easing == Easing.ease_in_back:
+            let c1 = 1.70158
+            return (c1 + 1.0) * t * t * t - c1 * t * t
+        if easing == Easing.ease_out_back:
+            let c1 = 1.70158
+            let t1 = t - 1.0
+            return 1.0 + (c1 + 1.0) * t1 * t1 * t1 + c1 * t1 * t1
+        if easing == Easing.ease_in_out_back:
+            let c1 = 1.70158
+            let c2 = c1 * 1.525
+            if t < 0.5:
+                return (4.0 * t * t * ((c2 + 1.0) * 2.0 * t - c2)) / 2.0
+            let t1 = t - 1.0
+            return (4.0 * t1 * t1 * ((c2 + 1.0) * 2.0 * t1 + c2) + 2.0) / 2.0
+
+        if easing == Easing.ease_in_elastic:
+            if t <= 0.0: return 0.0
+            if t >= 1.0: return 1.0
+            return -pow_f(2.0, 10.0 * t - 10.0) * sin_f((t * 10.0 - 10.75) * 2.0943951)
+        if easing == Easing.ease_out_elastic:
+            if t <= 0.0: return 0.0
+            if t >= 1.0: return 1.0
+            return pow_f(2.0, -10.0 * t) * sin_f((t * 10.0 - 0.75) * 2.0943951) + 1.0
+        if easing == Easing.ease_in_out_elastic:
+            if t <= 0.0: return 0.0
+            if t >= 1.0: return 1.0
+            if t < 0.5:
+                return -(pow_f(2.0, 20.0 * t - 10.0) * sin_f((20.0 * t - 11.125) * 1.3962634)) / 2.0
+            return (pow_f(2.0, -20.0 * t + 10.0) * sin_f((20.0 * t - 11.125) * 1.3962634)) / 2.0 + 1.0
+
+        if easing == Easing.ease_in_bounce:
+            return 1.0 - ease_out_bounce_f(1.0 - t)
+        if easing == Easing.ease_out_bounce:
+            return ease_out_bounce_f(t)
+        if easing == Easing.ease_in_out_bounce:
+            if t < 0.5:
+                return (1.0 - ease_out_bounce_f(1.0 - 2.0 * t)) / 2.0
+            return (1.0 + ease_out_bounce_f(2.0 * t - 1.0)) / 2.0
+
+        return t
+
+
+    public static function create(from: float, to: float, duration: float, easing: Easing) -> Tween:
+        return Tween(
+            duration = duration,
+            elapsed = 0.0,
+            from = from,
+            to = to,
+            easing = easing,
+            active = true
+        )
+
+
+    public function value() -> float:
+        if this.duration <= 0.0:
+            return this.to
+        let progress = this.elapsed / this.duration
+        if progress >= 1.0:
+            return this.to
+        if progress <= 0.0:
+            return this.from
+        let eased = Tween.apply_easing(this.easing, progress)
+        return this.from + (this.to - this.from) * eased
+
+
+    public editable function step(dt: float) -> bool:
+        if not this.active:
+            return false
+        this.elapsed = this.elapsed + dt
+        if this.elapsed >= this.duration:
+            this.elapsed = this.duration
+            this.active = false
+            return true
+        return false
+
+
+    public editable function reset(from: float, to: float, duration: float, easing: Easing) -> void:
+        this.from = from
+        this.to = to
+        this.duration = duration
+        this.easing = easing
+        this.elapsed = 0.0
+        this.active = true
+
+
+    public editable function stop() -> void:
+        this.active = false
+
+
+# ── multi-type tweens ──
+
+public struct Tween2:
+    x: Tween
+    y: Tween
+
+
+public struct Tween3:
+    x: Tween
+    y: Tween
+    z: Tween
+
+
+public struct Tween4:
+    x: Tween
+    y: Tween
+    z: Tween
+    w: Tween
+
+
+extending Tween2:
+    public static function create(from: vec2, to: vec2, duration: float, easing: Easing) -> Tween2:
+        return Tween2(
+            x = Tween.create(from.x, to.x, duration, easing),
+            y = Tween.create(from.y, to.y, duration, easing)
+        )
+
+
+    public function value() -> vec2:
+        return vec2(x = this.x.value(), y = this.y.value())
+
+
+    public editable function step(dt: float) -> bool:
+        let done_x = this.x.step(dt)
+        let done_y = this.y.step(dt)
+        return done_x or done_y
+
+
+    public editable function reset(from: vec2, to: vec2, duration: float, easing: Easing) -> void:
+        this.x.reset(from.x, to.x, duration, easing)
+        this.y.reset(from.y, to.y, duration, easing)
+
+
+    public editable function stop() -> void:
+        this.x.stop()
+        this.y.stop()
+
+
+extending Tween3:
+    public static function create(from: vec3, to: vec3, duration: float, easing: Easing) -> Tween3:
+        return Tween3(
+            x = Tween.create(from.x, to.x, duration, easing),
+            y = Tween.create(from.y, to.y, duration, easing),
+            z = Tween.create(from.z, to.z, duration, easing)
+        )
+
+
+    public function value() -> vec3:
+        return vec3(x = this.x.value(), y = this.y.value(), z = this.z.value())
+
+
+    public editable function step(dt: float) -> bool:
+        let dx = this.x.step(dt)
+        let dy = this.y.step(dt)
+        let dz = this.z.step(dt)
+        return dx or dy or dz
+
+
+    public editable function reset(from: vec3, to: vec3, duration: float, easing: Easing) -> void:
+        this.x.reset(from.x, to.x, duration, easing)
+        this.y.reset(from.y, to.y, duration, easing)
+        this.z.reset(from.z, to.z, duration, easing)
+
+
+    public editable function stop() -> void:
+        this.x.stop()
+        this.y.stop()
+        this.z.stop()
+
+
+extending Tween4:
+    public static function create(from: vec4, to: vec4, duration: float, easing: Easing) -> Tween4:
+        return Tween4(
+            x = Tween.create(from.x, to.x, duration, easing),
+            y = Tween.create(from.y, to.y, duration, easing),
+            z = Tween.create(from.z, to.z, duration, easing),
+            w = Tween.create(from.w, to.w, duration, easing)
+        )
+
+
+    public function value() -> vec4:
+        return vec4(x = this.x.value(), y = this.y.value(), z = this.z.value(), w = this.w.value())
+
+
+    public editable function step(dt: float) -> bool:
+        let dx = this.x.step(dt)
+        let dy = this.y.step(dt)
+        let dz = this.z.step(dt)
+        let dw = this.w.step(dt)
+        return dx or dy or dz or dw
+
+
+    public editable function reset(from: vec4, to: vec4, duration: float, easing: Easing) -> void:
+        this.x.reset(from.x, to.x, duration, easing)
+        this.y.reset(from.y, to.y, duration, easing)
+        this.z.reset(from.z, to.z, duration, easing)
+        this.w.reset(from.w, to.w, duration, easing)
+
+
+    public editable function stop() -> void:
+        this.x.stop()
+        this.y.stop()
+        this.z.stop()
+        this.w.stop()