gpu

import gpu from "gpu";
import io from "io";
import ui from "ui";
import bytes from "bytes";

pub struct Dot { pos: gpu.Vec2; vel: gpu.Vec2; }
pub struct Step { dt: f32; count: u32; }
pub struct View { size: f32; tint: gpu.Vec4; }

@tape { gpu.gen_uniforms(Step); }
@tape { gpu.gen_uniforms(View); }
@tape { bytes.gen_of(Dot); }

fn run(dev: *gpu.Device) -> void or gpu.GpuError {
    let step = dev.compute_pipeline(&advance) or return;
    let draw = dev.render_pipeline(&dot_vs, &dot_ps, gpu.RenderOptions {
        primitive: gpu.Primitive.TriangleStrip;
    }) or return;
    let s_dots = step.slot("dots");
    let s_corner = draw.slot("corner");
    let s_dot = draw.slot("d");

    var start: [1024]Dot;
    for (i in 0..1024) {
        let a = i as f32 * 2.399;
        start[i] = Dot { pos: gpu.splat2(0.0); vel: gpu.vec2(gpu.cos(a), gpu.sin(a)) * 0.3; };
    }
    let dots = dev.buffer(1024 * 16, gpu.STORAGE | gpu.VERTEX) or return;
    dots.write(dev, 0, of_Dot(start[0..]));
    let corners = [0.0 as f32, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0];
    let quad = dev.buffer(32, gpu.VERTEX) or return;
    quad.write(dev, 0, bytes.of_f32(corners[0..]));

    var su = Step { dt: 0.016; count: 1024; };
    var vu = View { size: 0.02; tint: gpu.vec4(1.0, 0.8, 0.2, 1.0); };
    while (!dev.closed()) {
        while (true) {
            let ev = dev.poll() or { break; };
            match (ev) {
                gpu.Event.Key { e } => { if (e.key == ui.Key.Escape) { return; } }
                _ => {}
            }
        }
        var cp = dev.compute();                 // move the dots
        cp.pipeline(&step);
        uniforms_Step(&cp, &su);
        cp.storage(s_dots, &dots, 0);
        cp.dispatch_for(1024);
        cp.end();

        var rp = dev.render(null, gpu.vec4(0.05, 0.05, 0.08, 1.0));   // draw them
        rp.pipeline(&draw);
        uniforms_View(&rp, &vu);
        rp.vertices(s_corner, &quad, 0);
        rp.vertices(s_dot, &dots, 0);           // what the compute pass wrote, as instances
        rp.draw(4, 1024);
        rp.end();
        dev.present() or return;
    }
}

fn main() -> i32 {
    var dev = gpu.open(800, 600, "dots", gpu.Options {}) or {
        io.println(err.desc());
        return 1;
    };
    run(&dev) or { io.println(err.desc()); };
    dev.close();
    return 0;
}

#shader
import gpu from "gpu";

compute(64) fn advance(dots: []Dot, u: uniform Step) {
    let i = gpu.global_id().x;
    if (i >= u.count) { return; }
    var d = dots[i];
    d.pos = d.pos + d.vel * u.dt;
    if (d.pos.x < -1.0 || d.pos.x > 1.0) { d.vel.x = -d.vel.x; }
    if (d.pos.y < -1.0 || d.pos.y > 1.0) { d.vel.y = -d.vel.y; }
    dots[i] = d;
}

pub struct DotOut { position: gpu.Vec4; uv: gpu.Vec2; }

vertex fn dot_vs(corner: gpu.Vec2, d: instance Dot, u: uniform View) -> DotOut {
    let p = d.pos + (corner - gpu.splat2(0.5)) * u.size;
    return DotOut { position: gpu.vec4(p.x, p.y, 0.0, 1.0); uv: corner; };
}

pixel fn dot_ps(v: DotOut, u: uniform View) -> gpu.Vec4 {
    return u.tint;
}

pub struct Options {
    vsync: bool = true;
    visible: bool = true;          // false: a hidden window, shown later with dev.show()
    debug: bool = false;           // OpenGL: a debug context; Metal: the API validation layer
}

pub struct Display {
    x: i64; y: i64; width: i64; height: i64;              // the whole screen
    work_x: i64; work_y: i64; work_width: i64; work_height: i64;   // less the taskbar, dock, panels
    scale: f64;                                            // the desktop's scaling: 1.0, 1.5, 2.0
}

let d = gpu.primary_display();
var dev = gpu.open(d.work_width * 8 / 10, d.work_height * 8 / 10, "game", gpu.Options {}) or return;
// ... on F11:
if (dev.mode() == gpu.Mode.Windowed) { dev.set_mode(gpu.Mode.Fullscreen); }
else { dev.set_mode(gpu.Mode.Windowed); }

import ui from "ui";

pub tagged Event {
    Key { e: ui.KeyEvent; }
    Pointer { e: ui.PointerEvent; }
    Resize { width: i64; height: i64; }
    Focus { focused: bool; }
    Close;
}

pub const VERTEX: u32 = 1;         // usages, combined with |
pub const STORAGE: u32 = 2;
pub const READ: u32 = 4;           // the CPU reads it back

pub enum Format : u32 { Bgra8 = 1; Rgba8 = 2; Rgba32f = 3; R32f = 4; R32u = 5; }
pub enum Filter : u8 { Nearest = 0; Linear = 1; }
pub enum Wrap : u8 { Clamp = 0; Repeat = 1; }
pub struct Sampler { filter: Filter = Filter.Nearest; wrap: Wrap = Wrap.Clamp; }

pub enum Format : u32 { Bgra8 = 1; Rgba8 = 2; Rgba32f = 3; R32f = 4; R32u = 5; }
pub enum Primitive : u8 { Triangles = 0; TriangleStrip = 1; Lines = 2; Points = 3; }
pub enum Blend : u8 { None = 0; Premultiplied = 1; Alpha = 2; Additive = 3; }

pub struct RenderOptions {
    primitive: Primitive = Primitive.Triangles;
    blend: Blend = Blend.None;
    format: Format = Format.Bgra8;   // the target's: the window's is Bgra8
}

pub enum Stage : u8 { Vertex = 0: "vertex"; Pixel = 1: "pixel"; Compute = 2: "compute"; }

pub tagged GpuError {
    Unsupported { what: string; }                 // the platform or driver lacks it
    NoDevice { reason: string; }                  // no GPU, no OpenGL 4.3: what the system gave
    NoWindow;                                     // the window could not be made
    Compile { stage: Stage; log: string; }        // the driver rejected the shader's text
    Link { log: string; }                         // the pipeline could not be made
    OutOfMemory { what: string; }                 // "buffer of 536870912 bytes: ..."
    Lost { reason: string; }                      // the device was lost (driver reset, GPU removed)
}

import gpu from "gpu";
import io from "io";

fn sum_back(dev: *gpu.Device, vals: *const gpu.Buffer) -> void or gpu.GpuError {
    var out: [256]u32;
    vals.read(dev, 0, (&out[0] as *u8)[0..1024]) or return;     // waits for the work that used vals
    var total: u64 = 0;
    for (i in 0..256) { total = total + out[i] as u64; }
    io.println("sum {total}");
}

fn main() -> i32 { return 0; }

import gpu from "gpu";

fn show_time(dev: *gpu.Device) {
    let ms = dev.gpu_ms() or { return; };
    dev.set_title("gpu {ms} ms");
}

fn main() -> i32 { return 0; }