mod beams;
mod effects;
#[cfg(test)]
mod tests;
use super::{
Canvas, Effect, Frame, HostId, HostSpec, InkError, Input, LITE_ENTER_MS, LITE_LEAVE_MS,
MAX_SHAPES, Options, Quality, Render, Shape, Stats,
};
use beams::{beam_geometry, brand_default, group_thousands};
struct Rng {
state: u64,
}
impl Rng {
const fn new(seed: u64) -> Self {
let state = if seed == 0 {
0x9E37_79B9_7F4A_7C15
} else {
seed
};
Self { state }
}
fn next_u64(&mut self) -> u64 {
self.state = self.state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut zed = self.state;
zed = (zed ^ zed.wrapping_shr(30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
zed = (zed ^ zed.wrapping_shr(27)).wrapping_mul(0x94D0_49BB_1331_11EB);
zed ^ zed.wrapping_shr(31)
}
fn unit(&mut self) -> f64 {
let [b0, b1, b2, b3, _, _, _, _] = self.next_u64().to_be_bytes();
f64::from(u32::from_be_bytes([b0, b1, b2, b3])) / 4_294_967_296.0
}
fn range(&mut self, low: f64, high: f64) -> f64 {
low + (high - low) * self.unit()
}
}
fn clamp01(value: f64) -> f64 {
value.clamp(0.0, 1.0)
}
fn settle(time: f64) -> f64 {
1.0 - (1.0 - time).powi(5)
}
fn in_out(time: f64) -> f64 {
if time < 0.5 {
4.0 * time * time * time
} else {
let value = -2.0 * time + 2.0;
1.0 - value.powi(3) / 2.0
}
}
#[derive(Clone, Copy, Debug)]
struct Drop {
centre_x: f64,
centre_y: f64,
velocity_y: f64,
radius: f64,
landed: bool,
}
#[derive(Clone, Copy, Debug)]
struct Bit {
centre_x: f64,
centre_y: f64,
velocity_x: f64,
velocity_y: f64,
radius: f64,
}
#[derive(Clone, Copy, Debug)]
struct Spot {
centre_x: f64,
centre_y: f64,
elapsed: f64,
petals: f64,
phase: f64,
}
struct HostState {
elapsed: f64,
accumulator: f64,
phase: u8,
phase_time: f64,
level: f64,
mark_time: f64,
hang: f64,
puddle: f64,
puddle_amplitude: f64,
wobble_current: f64,
pour_level: f64,
pour_target: f64,
cursor_alive: f64,
beads: Vec<(f64, f64)>,
wander: f64,
drops: Vec<Drop>,
bits: Vec<Bit>,
spots: Vec<Spot>,
auto_accumulator: f64,
columns: Vec<f64>,
column_sizes: Vec<f64>,
}
impl HostState {
fn new() -> Self {
Self {
elapsed: 0.0,
accumulator: 0.0,
phase: 0,
phase_time: 0.0,
level: 0.0,
mark_time: 0.0,
hang: 2.0,
puddle: 5.0,
puddle_amplitude: 0.0,
wobble_current: 0.0,
pour_level: 0.0,
pour_target: 0.0,
cursor_alive: 0.0,
beads: Vec::new(),
wander: 0.0,
drops: Vec::new(),
bits: Vec::new(),
spots: Vec::new(),
auto_accumulator: 0.0,
columns: Vec::new(),
column_sizes: Vec::new(),
}
}
}
struct Host {
id: HostId,
effect: Effect,
canvas: Canvas,
visible: bool,
priority: bool,
options: Options,
state: HostState,
rng: Rng,
input: Input,
finished: bool,
}
impl Host {
fn push(frame: &mut Frame, shape: Shape) {
if frame.shapes.len() < MAX_SHAPES {
frame.shapes.push(shape);
}
}
}
pub struct InkEngine {
hosts: Vec<Host>,
quality: Quality,
lite: bool,
ema_ms: f64,
last_switch_ms: f64,
clock_ms: f64,
speed_milli: u32,
paused: bool,
reduce_motion: bool,
frames: u64,
stride_skips: u64,
seed: u64,
next_id: u32,
}
impl InkEngine {
#[must_use]
pub fn new(seed: u64) -> Self {
Self {
hosts: Vec::new(),
quality: Quality::Auto,
lite: false,
ema_ms: 16.7,
last_switch_ms: 0.0,
clock_ms: 0.0,
speed_milli: 1000,
paused: false,
reduce_motion: false,
frames: 0,
stride_skips: 0,
seed,
next_id: 0,
}
}
pub fn add_host(&mut self, spec: HostSpec) -> HostId {
let id = HostId(self.next_id);
self.next_id = self.next_id.wrapping_add(1);
let host_seed = self
.seed
.wrapping_add(u64::from(id.0).wrapping_mul(0x9E37_79B9_7F4A_7C15));
let mut rng = Rng::new(host_seed);
let mut state = HostState::new();
state.columns = Vec::with_capacity(24);
state.column_sizes = Vec::with_capacity(24);
for _ in 0..24 {
state.columns.push(rng.range(0.0, std::f64::consts::TAU));
state.column_sizes.push(rng.range(16.0, 36.0));
}
self.hosts.push(Host {
id,
effect: spec.effect,
canvas: spec.canvas,
visible: spec.visible,
priority: matches!(
spec.effect,
Effect::Cursor | Effect::Ripple | Effect::Wobble
),
options: Options::new(),
state,
rng,
input: Input::default(),
finished: false,
});
id
}
pub fn set_visible(&mut self, id: HostId, visible: bool) {
if let Some(host) = self.hosts.iter_mut().find(|host| host.id == id) {
host.visible = visible;
host.finished = false;
}
}
pub fn set_options(&mut self, id: HostId, options: Options) -> Result<(), InkError> {
options.validate()?;
if let Some(host) = self.hosts.iter_mut().find(|host| host.id == id) {
host.options = options;
host.finished = false;
}
Ok(())
}
pub fn set_input(&mut self, id: HostId, input: Input) -> Result<(), InkError> {
let finite = |point: Option<(f64, f64)>| {
point.is_none_or(|(point_x, point_y)| point_x.is_finite() && point_y.is_finite())
};
if !(finite(input.pointer) && finite(input.click)) {
lgwks_std::trace::debug!(
pointer = ?input.pointer,
click = ?input.click,
"ink input refused: a coordinate is not finite; the host keeps its previous input"
);
return Err(InkError::InvalidInput);
}
if let Some(host) = self.hosts.iter_mut().find(|host| host.id == id) {
host.input = input;
}
Ok(())
}
pub fn set_quality(&mut self, quality: Quality) {
self.quality = quality;
self.lite = matches!(quality, Quality::Lite);
}
pub fn set_speed_milli(&mut self, speed_milli: u32) {
self.speed_milli = speed_milli;
}
pub fn set_paused(&mut self, paused: bool) {
self.paused = paused;
}
pub fn set_reduce_motion(&mut self, reduce_motion: bool) {
if self.reduce_motion != reduce_motion {
for host in &mut self.hosts {
host.finished = false;
}
}
self.reduce_motion = reduce_motion;
}
#[must_use]
pub fn stats(&self) -> Stats {
let live = self
.hosts
.iter()
.filter(|host| host.visible && !host.finished)
.fold(0_u32, |live, _| live.saturating_add(1));
Stats {
frames: self.frames,
live,
lite: self.lite,
ema_ms: self.ema_ms,
stride_skips: self.stride_skips,
}
}
pub fn step(&mut self, dt_ms: f64) -> Result<Vec<Render>, InkError> {
if !(dt_ms.is_finite() && dt_ms >= 0.0) {
lgwks_std::trace::debug!(
dt_ms,
"ink step refused: the delta is negative or not finite"
);
return Err(InkError::InvalidDelta);
}
self.frames = self.frames.wrapping_add(1);
self.clock_ms += dt_ms;
if self.paused {
return Ok(Vec::new());
}
self.ema_ms += (dt_ms - self.ema_ms) * 0.04;
self.update_quality();
let speed = f64::from(self.speed_milli) / 1000.0;
let stride: u64 = if self.lite { 2 } else { 1 };
let frame_index = self.frames;
let reduce = self.reduce_motion;
let mut renders = Vec::with_capacity(self.hosts.len());
for (index, host) in (0_u64..).zip(self.hosts.iter_mut()) {
if !host.visible || host.finished {
host.state.accumulator = 0.0;
continue;
}
if !reduce
&& !host.priority
&& stride > 1
&& !frame_index.wrapping_add(index).is_multiple_of(stride)
{
self.stride_skips = self.stride_skips.wrapping_add(1);
continue;
}
host.state.accumulator = (host.state.accumulator + dt_ms * speed).min(200.0);
let advanced = host.state.accumulator;
host.state.accumulator = 0.0;
let frame = if reduce {
host.resolve()
} else {
host.advance(advanced)
};
renders.push(Render {
host: host.id,
frame,
});
}
Ok(renders)
}
fn update_quality(&mut self) {
match self.quality {
Quality::Lite => self.lite = true,
Quality::Full => self.lite = false,
Quality::Auto => {
let entered = !self.lite
&& self.ema_ms > LITE_ENTER_MS
&& self.clock_ms - self.last_switch_ms > 3000.0;
let recovered = self.lite
&& self.ema_ms < LITE_LEAVE_MS
&& self.clock_ms - self.last_switch_ms > 8000.0;
if entered {
self.lite = true;
self.last_switch_ms = self.clock_ms;
} else if recovered {
self.lite = false;
self.last_switch_ms = self.clock_ms;
}
}
}
}
}
impl Host {
fn advance(&mut self, dt_ms: f64) -> Frame {
let mut frame = Frame::resolved();
match self.effect {
Effect::Mark => self.advance_mark(dt_ms, &mut frame),
Effect::Text => self.advance_text(dt_ms, &mut frame),
Effect::Wipe => self.advance_wipe(dt_ms, &mut frame, false),
Effect::Drops => self.advance_drops(dt_ms, &mut frame),
Effect::Wobble => self.advance_wobble(dt_ms, &mut frame),
Effect::Loader => self.advance_loader(dt_ms, &mut frame),
Effect::Pour => self.advance_pour(dt_ms, &mut frame),
Effect::Cursor => self.advance_cursor(dt_ms, &mut frame),
Effect::Ripple => self.advance_ripple(dt_ms, &mut frame),
Effect::Count => self.advance_count(dt_ms, &mut frame),
Effect::Reveal => self.advance_wipe(dt_ms, &mut frame, true),
}
if self.state.elapsed > 1_000_000.0 {
self.finished = true;
}
frame
}
fn resolve(&mut self) -> Frame {
self.finished = true;
match self.effect {
Effect::Text => Frame {
shapes: Vec::new(),
alpha: 1.0,
blur: 0.0,
displacement: 0.0,
label: None,
},
Effect::Count => {
let mut frame = Frame::resolved();
frame.label = Some(self.count_label(1.0));
frame
}
Effect::Mark => {
let mut frame = Frame::resolved();
for beam in beam_geometry() {
Host::push(&mut frame, beam.quad());
}
frame
}
_ => Frame::resolved(),
}
}
fn count_label(&self, progress: f64) -> String {
let from = brand_default(self.options.count_from, 0.0);
let to = brand_default(self.options.count_to, 1200.0);
let value = from + (to - from) * progress;
let decimals = brand_default(self.options.count_decimals, 0);
let number = format!("{value:.decimals$}");
let prefix = brand_default(self.options.count_prefix, "");
let suffix = brand_default(self.options.count_suffix, "");
format!("{prefix}{}{suffix}", group_thousands(&number))
}
}