Engine crates for the plus3 games.

[dependencies]
voon-fx = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use std::sync::Arc;
use glam::{Vec2, Vec3};
use voon_fx::view::ViewDesc;
use voon_fx::{FramePacket, Library, Settings, SpawnParams, Tier, View, World};

let mut lib = Library::new();
lib.load_dir(std::path::Path::new(voon_fx::EFFECTS)); // stock effects; load your own dir too
lib.finish();
let mut world = World::new(Arc::new(lib), Settings::tier(Tier::High));

world.spawn_by_name("combo_explosion", SpawnParams::at(Vec3::ZERO));

let mut packet = FramePacket::default();
// Each frame:
world.update(dt, &scene, camera_pos); // scene: impl voon_fx::SceneQuery (voon-phys has one)
world.extract(&View::new(&ViewDesc {
    view, proj, prev_view_proj: None, near: 0.05, size: [w, h],
    time, dt, frame, jitter: Vec2::ZERO, cut: false,
}), &mut packet);
// packet.lights -> your lighting, packet.shake -> your camera, packet -> voon-fx-gpu

// effects/combo_missile.ron: effects compose other effects
(
    bounds: (min: (-2.0, -2.0, -2.0), max: (2.0, 2.0, 2.0)),
    duration: Loop,
    priority: 3,
    elements: [
        (kind: Sub((effect: "ribbon_missile", inherit_velocity: 0.0))),
        (kind: Sub((effect: "combo_explosion", at: Stop))), // boom when it stops
    ],
)

[dependencies]
voon-fx-gpu = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use voon_fx_gpu::{Fx, GpuConfig, Phase, Targets};

// mem: anything implementing voon_fx_gpu::GpuMemory (voon-gpumem does, feature "fx")
let mut fx = Fx::new(&device, &mut mem, &GpuConfig {
    hdr_format, depth_format, frames: 2, cache, tier: Tier::High,
})?;
fx.resize(&device, &mut mem, &Targets {
    extent, hdr: hdr_image, hdr_view, depth: depth_image, depth_view, scene_copy: None,
})?;

// Each frame, after waiting on this slot's fence:
for e in fx.take_events() {
    world.spawn(e.effect, SpawnParams::facing(e.pos, e.normal)); // GPU collisions spawn effects
}
world.update(dt, &scene, camera_pos);
world.extract(&view, &mut packet);
fx.prepare(&device, &mut mem, slot, &lights, &packet)?;

unsafe {
    fx.record(&device, cb, slot, Phase::Compute);
    draw_opaque_scene(cb);
    for phase in Phase::ORDER.into_iter().skip(1) {
        fx.record(&device, cb, slot, phase); // decals, refraction, volumes, overlays...
    }
}
fx.finish();

[dependencies]
voon-gpumem = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0", features = ["fx"] }

use voon_gpumem::{Allocator, AllocatorDesc, Request, Usage};

let mem = Allocator::new(&AllocatorDesc {
    budget: true,   // VK_EXT_memory_budget
    priority: true, // VK_EXT_memory_priority
    ..AllocatorDesc::new(&instance, physical, &device)
});

// Freed on drop; the label shows up in report() and leak listings.
let mut boxes = mem.buffer(
    Request::new("boxes", Usage::Upload),
    1 << 20,
    vk::BufferUsageFlags::STORAGE_BUFFER,
)?;
boxes.write(0, bytemuck::cast_slice(&data))?;

for line in mem.report().lines() {
    log::info!("{line}"); // per-pool usage, fragmentation, per-label totals
}

use voon_gpumem::Tlsf;

// The sub-allocator on its own, for any range you manage (one big buffer, an atlas...).
let mut heap = Tlsf::new(64 << 20);
let r = heap.alloc(4096, 256).unwrap(); // r.offset, r.size, r.id
heap.free(r.id);

[dependencies]
voon-fluid = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use glam::{Vec2, Vec3};
use voon_fluid::{Disturb, Surface, SurfaceDesc, Wave, STEP};

let mut pool = Surface::new(
    SurfaceDesc {
        origin: Vec2::splat(-2.0), size: Vec2::splat(4.0), level: 0.6, cell: 0.1,
        waves: vec![Wave { dir: Vec2::new(1.0, 0.3), amplitude: 0.02, length: 2.0, ..Wave::default() }],
        ..SurfaceDesc::default()
    },
    |_x, _z| Some(0.0), // floor height under each cell
);

pool.disturb(Disturb { pos: Vec3::new(1.0, 0.6, 1.0), radius: 0.4, amount: 0.08 }); // a splash
pool.step(STEP); // fixed step, same result on every machine

// Gameplay reads the same water the renderer draws:
let s = pool.sample(0.9, -0.4).unwrap(); // height, normal, velocity, depth

[dependencies]
voon-phys = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use glam::{Quat, Vec3};
use voon_phys::{Layer, Matter, Phys, Shape};

let mut phys = Phys::new(Vec3::new(0.0, -9.81, 0.0)).unwrap();
phys.add_static(&Shape::Box(Vec3::new(20.0, 0.5, 20.0)), Vec3::new(0.0, -0.5, 0.0),
                Quat::IDENTITY, 0.6, Layer::default());
let crate_body = phys.add_dynamic(7, &[Shape::Box(Vec3::splat(0.25))], Vec3::new(0.0, 3.0, 0.0),
                                  Quat::from_rotation_z(0.3), Matter::default(), Layer::default()).unwrap();

// Each frame:
phys.step(dt, 4);
for m in phys.moves() {
    entities[m.key as usize].set(m.pos, m.rot); // only bodies that moved
}
// The collider mirror answers voon-fx scene queries: sparks bounce off crates.
world.update(dt, phys.scene(), camera_pos);

[dependencies]
voon-ragdoll = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use std::sync::Arc;
use glam::{Mat4, Vec3};
use voon_ragdoll::{Archetype, Boxes, Hit, Impact, Ragdoll, RagdollDef, Tuning, MAX_CATCHUP_TICKS};

let tuning = Tuning::default();
// Bones map to the twelve capsules by name.
let def = Arc::new(RagdollDef::build(&skeleton, &Archetype::humanoid(), &tuning)?);
let ground = Boxes { floor: Some(0.0), boxes: Vec::new() };

let hit = Impact::Hit(Hit { point: Vec3::new(0.0, 1.3, 0.1), dir: Vec3::NEG_Z, impulse: 90.0, role: None });
let mut body = Ragdoll::spawn(def, &prev_pose, &pose, pose_dt, model, velocity, Some(hit), seed, &tuning);

// Fixed ticks, deterministic per seed; catches up if a frame was slow.
while !body.settled() {
    since += dt as f64;
    body.advance(&ground, &tuning, since / tuning.dt as f64, MAX_CATCHUP_TICKS);
    body.bone_matrices(&mut bones); // -> your skinning
}

[dependencies]
voon-render = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use voon_render::pipeline::{Blend, Depth, Desc};
use voon_render::spv;

let pipe = voon_render::pipeline::graphics(&device, cache, layout, &Desc {
    vert: spv!("scene.vert"), // SPIR-V compiled by voon-slang in build.rs
    frag: Some(spv!("scene.frag")),
    input: vertex_input,
    colors: vec![(vk::Format::R16G16B16A16_SFLOAT, true)],
    depth: Depth::Write,
    depth_format: vk::Format::D32_SFLOAT,
    cull: vk::CullModeFlags::BACK,
    bias: false,
    clamp: false,
    topology: vk::PrimitiveTopology::TRIANGLE_LIST,
    blend: Blend::None,
})?;

// Screenshots: read back the LDR target, then
let rgba = voon_render::shot::opaque_rgba(bytes, extent, bgra);
voon_render::shot::save_png(&rgba, extent.width, extent.height, path)?;

[build-dependencies]
voon-slang = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

// build.rs: compile a self-contained Slang shader set with slangc 2026.18.2
use std::path::PathBuf;

fn main() {
    let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    voon_slang::compile(&voon_slang::Compile {
        roots: vec![root.join("shaders")],
        includes: vec![root.join("shaders")],
        extra: Vec::new(),
        prebuilt: Some(root.join("prebuilt")), // used when slangc is missing
        env: "GAME",
        variants: &[("smoke.frag", "smoke_mrt.frag", &["-DMRT=1"])],
    });
}

// Then, in the crate: voon_render::spv!("smoke.frag")

[dependencies]
voon-splash = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use voon_splash::{Bar, Pass, Splash};

let pass = Pass::new(&device, swapchain_format, pipeline_cache)?; // prebuilt SPIR-V, no slangc
let mut splash = Splash::new(true);
let mut bar: Option<Bar> = None;

// Each frame:
if splash.playing() {
    if let Some(j) = splash.step(dt) {
        play(voon_splash::jingle(48_000), j.delay_s); // mono f32 PCM, your audio backend
    }
    pass.record(&device, cb, extent, splash.t(), 1.0);
} else {
    let bar = bar.get_or_insert_with(|| Bar::new(false));
    bar.report(loaded_fraction, next_ceiling); // eases toward progress, never backwards
    if loading_done {
        bar.ready();
    }
    bar.step(dt);
}

[dependencies]
voon-vars = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use voon_vars::{var_enum, vars, Build, VarStore};

var_enum! { pub Mode { Windowed, Borderless "Borderless window", Fullscreen } }

// Each line: name: type = default, optional range/step/unit/flags, "help text".
vars! {
    pub struct GameVars;
    video: Video "Display" {
        mode: Mode = Windowed, "Window mode";
        fov: f32 = 90.0, range 60.0..=120.0, step 1.0, unit "deg", "Field of view";
        vsync: bool = true, "Wait for vblank";
    }
    dev: Dev "Developer" {
        lines: bool = false, flags [dev, ephemeral], "Debug lines, never saved";
    }
}

let store = VarStore::new(GameVars::default(), Build { dev: cfg!(debug_assertions) });
let fov = store.vars.video.fov; // plain typed fields, no lookups

// Your context owns the Console and the stores (impl voon_vars::Ctx), then:
voon_vars::run_line(&mut ctx, "set video.fov 100");
voon_vars::run_line(&mut ctx, "toggle video.vsync");

[dependencies]
voon-console = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use voon_console::{ConfigPaths, Shell};
use voon_vars::{Build, Console};

pub const CONFIG: ConfigPaths = ConfigPaths {
    app: "game", file: "game.cfg", env: "GAME_CONFIG", dev: false,
};

const DEFAULT_BINDS: &str = r#"
bind ` toggleconsole
bind F5 "toggle video.vsync"
"#;

let build = Build { dev: true };
let defaults = voon_console::parse_default_binds(DEFAULT_BINDS);
let mut console: Console<Game> = Console::new(build); // Game: your context type
console.register(&voon_console::commands()); // toggleconsole, vars, binds, bind, ...
console.binds = defaults.clone();
let shell = Shell::new(build, defaults); // your ctx implements ConsoleApp to hand it out

// Commands coming back from the console page:
voon_console::dispatch(&mut ctx, &cmd);

[dependencies]
voon-gewy = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use voon_gewy::gewy::vulkan::DeviceRef;
use voon_gewy::{ConsoleOptions, ConsoleSurface, UiConfig, UiHost};

mod pages {
    include!(concat!(env!("OUT_DIR"), "/bundle.rs")); // gewy_embed::emit_bundle("ui", ..) in build.rs
}

let cfg = UiConfig {
    app: "game",
    dev_dir_env: Some("GAME_UI_DEV"), // serve pages from disk while you edit them
    devtools_env: Some("GAME_DEVTOOLS"),
    runtime: None,
    pages: pages::BUNDLE,
    console_id: 1,
    console: ConsoleOptions { title: "game".into(), ..Default::default() },
    surfaces: vec![(0, "gewy://ui/hud/index.html".to_string())], // your own pages
    keep_env: Vec::new(),
    memory: Some(allocator.clone()), // a voon_gpumem::Allocator
};
let dev = DeviceRef { instance: &instance, physical, device: &device, queue_family: family, queue };
let mut host = UiHost::launch(dev, [width, height], window.scale_factor() as f32, cfg)?;
let mut console = ConsoleSurface::default();

// Each frame: run what the page asked for, then publish vars and binds back to it.
for cmd in host.console_cmds() {
    voon_console::dispatch(&mut ctx, &cmd);
}
console.publish(&mut host, &mut ctx);

[dependencies]
voon-log = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

fn main() {
    // -v / -vv / --verbose on the command line raise the level; GAME_LOG overrides the filter.
    voon_log::init(voon_log::FileLog {
        app: "game",
        version: env!("CARGO_PKG_VERSION"),
        env: "GAME_LOG",
        file_name: "game.log",
        candidates: Vec::new(), // extra directories to try for the log file
        min_verbosity: 0,
        filter_for: |_level| None,
        mirror: true, // also feed warnings to the in-game console
    });
    log::info!("filter: {}", voon_log::spec());

    // Later, from a console command:
    voon_log::set_filter("info,game::net=debug").unwrap();
}

[dependencies]
voon-perf = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use voon_perf::Limits;

voon_perf::set_app("game");
voon_perf::start("startup", Limits { max_secs: 30, ..Limits::default() });

loop {
    {
        let _z = voon_perf::zone!("update"); // a span until the end of scope
        voon_perf::plot!("enemies", enemies.len() as f64);
        update();
    }
    // Returns the capture once a limit is hit (or after voon_perf::stop()).
    if let Some(cap) = voon_perf::frame_mark() {
        std::fs::write("trace.json", voon_perf::chrome::to_vec(&cap))?; // open in Perfetto
        break;
    }
}

[build-dependencies]
voon-build = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

// build.rs
fn main() {
    let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    voon_build::emit("GAME", &root, voon_build::Version::Pkg);
}

// main.rs: GAME_VERSION, GAME_GIT_HASH, GAME_BUILD_NUM, GAME_GIT_BRANCH, GAME_COMMIT_DATE
const BUILD: &str = concat!(env!("GAME_VERSION"), "+", env!("GAME_GIT_HASH"));

[dependencies]
voon-blob = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use voon_blob::{Msg, Receiver, Sender, Start, State, CHUNK, SPAN};

let mut tx = Sender::new();
tx.start(Start {
    peer: 3, id: 1, src: data.clone(), at: 0, // data: Arc<[u8]>
    rate: 64 * CHUNK as u32, rate_max: 8 << 20, window: SPAN, ping, // ping: Duration
}, now);
let mut rx = Receiver::new(1, data.len() as u32, 1 << 30, now).unwrap();

loop {
    for (_peer, d) in tx.pump(now, budget, |_| true) {
        send_unreliable(d); // paced 1 KiB chunks, any lossy lane
    }
    for d in received() {
        rx.on_data(now, &d);
    }
    if rx.state() == &State::Done {
        break;
    }
    for m in rx.service(now) {
        match m {
            Msg::Ack(a) => tx.ack(3, &a, ping, now),       // selective acks
            Msg::Get(g) => { tx.rewind(3, &g, ping, now); } // send Get reliably
        }
    }
}
let bytes = rx.finish().unwrap();

[dependencies]
voon-discord = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0", features = ["sdk"] }

use std::time::Instant;
use voon_discord::{Config, Discord, Presence};

// No SDK on this machine? open() returns None and the game carries on.
let Some(mut discord) = Discord::open(&Config { app_id, sdk_env: None, search: vec![] }) else {
    return;
};

let presence = Presence {
    details: "Island 3, day 12".into(),
    state: "Fishing".into(),
    since: Some("session".into()), // start time latches while this key stays the same
    ..Presence::default()
};

// Call every frame; the feed throttles, dedupes and backs off for you.
let now = Instant::now();
discord.apply(presence.clone(), now);
discord.tick(now);
for event in discord.drain() {
    log::info!("discord: {event:?}");
}

[dependencies]
voon-assets = { git = "https://scm.oiko.lol/plus3/voon.git", tag = "v0.1.0" }

use std::time::Duration;
use voon_assets::{Config, Event, Library, Root};

let lib = Library::open(Config {
    roots: vec![Root { name: "synty".into(), path: "/home/me/Documents/synty".into() }],
    cache: "/home/me/.cache/assets".into(), // SQLite index + thumbnails
    threads: 4,
    thumbs: true,
}, |event| match event {
    Event::Status(s) => println!("{} {}/{}", s.stage, s.done, s.todo),
    Event::Changed(generation) => println!("index changed: {generation}"),
})?;
lib.start();                          // scan zips, rars, tars and folders in place
lib.watch(Duration::from_secs(3))?;   // rescan when files change

just demo                       # every scenario, with a gewy overlay to pick them
just shot all                   # headless PNGs into shots/
just shot 2_explosion --size 3840x2160 --no-validation
just editor                     # the asset library over your model folders
just editor-audit --json        # index headless and report what each pack resolves