isokit: engine core, theme and Rhai scene runtime with prefab library
This commit is contained in:
grabowski committed
commit
95c80ec6b1
32 files changed
+5896
No files matched your search
@@ -0,0 +1,486 @@
|
||||
//! Functions and the `Sprite` type registered into the Rhai engine.
|
||||
|
||||
use crate::conv::*;
|
||||
use crate::State;
|
||||
use isokit_core::fmt::{hash, round1, thousands};
|
||||
use isokit_core::{classes, LayerOpts, Sprite, C};
|
||||
use rhai::{Array, Dynamic, Engine, FnPtr, Map, NativeCallContext};
|
||||
use std::cell::RefCell;
|
||||
use std::rc::Rc;
|
||||
|
||||
/// Script handle to a sprite: copies share the same sprite.
|
||||
#[derive(Clone)]
|
||||
pub struct SpriteH(pub Rc<RefCell<Sprite>>);
|
||||
|
||||
type Shared = Rc<RefCell<State>>;
|
||||
type D = Dynamic;
|
||||
|
||||
fn ok(s: &SpriteH) -> RR<SpriteH> {
|
||||
Ok(s.clone())
|
||||
}
|
||||
|
||||
fn opt_id(d: &str) -> Option<String> {
|
||||
if d.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(d.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn new_sprite(st: &Shared, ctx: Option<&NativeCallContext>, id: Option<&str>, cls: &str) -> SpriteH {
|
||||
let mut s = st.borrow_mut();
|
||||
let id = id.map(str::to_string).or_else(|| s.obj.clone()).unwrap_or_default();
|
||||
let mut sp = Sprite::new(id, classes(cls)).with_frame(s.xf);
|
||||
sp.obj = s.obj.clone();
|
||||
if let Some(ctx) = ctx {
|
||||
if let Some(line) = ctx.call_position().line() {
|
||||
let src = ctx.call_source().unwrap_or(&s.main).to_string();
|
||||
sp.src = Some(format!("{src}:{line}"));
|
||||
}
|
||||
}
|
||||
let h = SpriteH(Rc::new(RefCell::new(sp)));
|
||||
let layer = s.layer.clone();
|
||||
s.sprites.push((layer, h.clone()));
|
||||
h
|
||||
}
|
||||
|
||||
/// Sprite methods (no scene state needed).
|
||||
pub fn register_sprite(e: &mut Engine) {
|
||||
e.register_type_with_name::<SpriteH>("Sprite");
|
||||
e.register_get("id", |s: &mut SpriteH| s.0.borrow().id.clone());
|
||||
|
||||
// solids
|
||||
e.register_fn("box", |s: &mut SpriteH, x0: D, y0: D, x1: D, y1: D, z0: D, z1: D, mat: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().cuboid(n(&x0)?, n(&y0)?, n(&x1)?, n(&y1)?, n(&z0)?, n(&z1)?, style(mat, None));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn(
|
||||
"box",
|
||||
|s: &mut SpriteH, x0: D, y0: D, x1: D, y1: D, z0: D, z1: D, mat: &str, o: Map| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().cuboid(n(&x0)?, n(&y0)?, n(&x1)?, n(&y1)?, n(&z0)?, n(&z1)?, style(mat, Some(&o)));
|
||||
ok(s)
|
||||
},
|
||||
);
|
||||
e.register_fn("prism", |s: &mut SpriteH, p: D, z0: D, z1: D, mat: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().prism(pts(&p)?, zs(&z0)?, zs(&z1)?, style(mat, None));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("prism", |s: &mut SpriteH, p: D, z0: D, z1: D, mat: &str, o: Map| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().prism(pts(&p)?, zs(&z0)?, zs(&z1)?, style(mat, Some(&o)));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("cyl", |s: &mut SpriteH, cx: D, cy: D, r: D, z0: D, z1: D, mat: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().cyl(n(&cx)?, n(&cy)?, n(&r)?, n(&z0)?, n(&z1)?, style(mat, None));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("cyl", |s: &mut SpriteH, cx: D, cy: D, r: D, z0: D, z1: D, mat: &str, o: Map| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().cyl(n(&cx)?, n(&cy)?, n(&r)?, n(&z0)?, n(&z1)?, style(mat, Some(&o)));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn(
|
||||
"frust",
|
||||
|s: &mut SpriteH, cx: D, cy: D, r0: D, r1: D, z0: D, z1: D, mat: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().frust(n(&cx)?, n(&cy)?, n(&r0)?, n(&r1)?, n(&z0)?, n(&z1)?, 10, style(mat, None));
|
||||
ok(s)
|
||||
},
|
||||
);
|
||||
e.register_fn(
|
||||
"frust",
|
||||
|s: &mut SpriteH, cx: D, cy: D, r0: D, r1: D, z0: D, z1: D, mat: &str, sides: D| -> RR<SpriteH> {
|
||||
let k = n(&sides)? as u32;
|
||||
s.0.borrow_mut().frust(n(&cx)?, n(&cy)?, n(&r0)?, n(&r1)?, n(&z0)?, n(&z1)?, k, style(mat, None));
|
||||
ok(s)
|
||||
},
|
||||
);
|
||||
e.register_fn(
|
||||
"frust",
|
||||
|s: &mut SpriteH, cx: D, cy: D, r0: D, r1: D, z0: D, z1: D, mat: &str, sides: D, o: Map| -> RR<SpriteH> {
|
||||
let k = n(&sides)? as u32;
|
||||
s.0.borrow_mut().frust(n(&cx)?, n(&cy)?, n(&r0)?, n(&r1)?, n(&z0)?, n(&z1)?, k, style(mat, Some(&o)));
|
||||
ok(s)
|
||||
},
|
||||
);
|
||||
e.register_fn(
|
||||
"slope",
|
||||
|s: &mut SpriteH, x0: D, x1: D, y0: D, y1: D, za: D, zb: D, th: D, mat: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().slope(n(&x0)?, n(&x1)?, n(&y0)?, n(&y1)?, n(&za)?, n(&zb)?, n(&th)?, &classes(mat));
|
||||
ok(s)
|
||||
},
|
||||
);
|
||||
|
||||
// surfaces
|
||||
e.register_fn("open", |s: &mut SpriteH, a: D, b: D, list: D, cls: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().open(p2(&a)?, p2(&b)?, quads(&list, "openings")?, &classes(cls), None);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("open", |s: &mut SpriteH, a: D, b: D, list: D, cls: &str, id: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().open(p2(&a)?, p2(&b)?, quads(&list, "openings")?, &classes(cls), opt_id(id));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("flat", |s: &mut SpriteH, p: D, z: D, cls: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().flat(polys(&p)?, n(&z)?, &classes(cls), None);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("flat", |s: &mut SpriteH, p: D, z: D, cls: &str, id: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().flat(polys(&p)?, n(&z)?, &classes(cls), opt_id(id));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("lines", |s: &mut SpriteH, segs: D, z: D, cls: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().lines(quads(&segs, "segments")?, n(&z)?, &classes(cls));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("disc", |s: &mut SpriteH, cx: D, cy: D, z: D, r: D, cls: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().disc(n(&cx)?, n(&cy)?, n(&z)?, n(&r)?, &classes(cls), None);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("disc", |s: &mut SpriteH, cx: D, cy: D, z: D, r: D, cls: &str, id: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().disc(n(&cx)?, n(&cy)?, n(&z)?, n(&r)?, &classes(cls), opt_id(id));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("face", |s: &mut SpriteH, p: D, mat: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().face(pts3(&p)?, &classes(mat), None, false);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("face", |s: &mut SpriteH, p: D, mat: &str, o: Map| -> RR<SpriteH> {
|
||||
let id = o.get("id").map(|v| v.to_string());
|
||||
let two = o.get("two_sided").and_then(|v| v.as_bool().ok()).unwrap_or(false);
|
||||
s.0.borrow_mut().face(pts3(&p)?, &classes(mat), id, two);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("poly", |s: &mut SpriteH, p: D, cls: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().poly(polys3(&p)?, &classes(cls), None);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("poly", |s: &mut SpriteH, p: D, cls: &str, id: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().poly(polys3(&p)?, &classes(cls), opt_id(id));
|
||||
ok(s)
|
||||
});
|
||||
|
||||
// screen-space details
|
||||
e.register_fn("circle", |s: &mut SpriteH, x: D, y: D, z: D, r: D, cls: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().circle([n(&x)?, n(&y)?, n(&z)?], n(&r)?, [0.0, 0.0], &classes(cls));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn(
|
||||
"circle",
|
||||
|s: &mut SpriteH, x: D, y: D, z: D, r: D, cls: &str, dx: D, dy: D| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().circle([n(&x)?, n(&y)?, n(&z)?], n(&r)?, [n(&dx)?, n(&dy)?], &classes(cls));
|
||||
ok(s)
|
||||
},
|
||||
);
|
||||
e.register_fn("stem", |s: &mut SpriteH, x: D, y: D, z0: D, z1: D, w: D, cls: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().stem(n(&x)?, n(&y)?, n(&z0)?, n(&z1)?, n(&w)?, &classes(cls));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("head", |s: &mut SpriteH, x: D, y: D, z: D, r: D| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().head(n(&x)?, n(&y)?, n(&z)?, n(&r)?);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("person", |s: &mut SpriteH, x: D, y: D, z: D| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().person(n(&x)?, n(&y)?, n(&z)?, "iso-hivis");
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("person", |s: &mut SpriteH, x: D, y: D, z: D, cls: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().person(n(&x)?, n(&y)?, n(&z)?, &classes(cls));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("sit", |s: &mut SpriteH, x: D, y: D, z: D, cls: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().sit(n(&x)?, n(&y)?, n(&z)?, &classes(cls));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("led", |s: &mut SpriteH, x: D, y: D, z: D| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().led(n(&x)?, n(&y)?, n(&z)?, "");
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("led", |s: &mut SpriteH, x: D, y: D, z: D, cls: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().led(n(&x)?, n(&y)?, n(&z)?, &classes(cls));
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("puffs", |s: &mut SpriteH, x: D, y: D, z: D| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().puffs(n(&x)?, n(&y)?, n(&z)?, "iso-puff", 3, 3.2);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("puffs", |s: &mut SpriteH, x: D, y: D, z: D, kind: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().puffs(n(&x)?, n(&y)?, n(&z)?, &classes(kind), 3, 3.2);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn(
|
||||
"puffs",
|
||||
|s: &mut SpriteH, x: D, y: D, z: D, kind: &str, k: D, dur: D| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().puffs(n(&x)?, n(&y)?, n(&z)?, &classes(kind), n(&k)? as u32, n(&dur)?);
|
||||
ok(s)
|
||||
},
|
||||
);
|
||||
e.register_fn("fan", |s: &mut SpriteH, x: D, y: D, z: D, r: D| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().fan(n(&x)?, n(&y)?, n(&z)?, n(&r)?);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("raw", |s: &mut SpriteH, svg: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().raw(None, svg);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("raw", |s: &mut SpriteH, x: D, y: D, z: D, svg: &str| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().raw(Some([n(&x)?, n(&y)?, n(&z)?]), svg);
|
||||
ok(s)
|
||||
});
|
||||
|
||||
// extents
|
||||
e.register_fn("ext", |s: &mut SpriteH, x: D, y: D, z: D| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().ext(n(&x)?, n(&y)?, n(&z)?);
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn("ext_box", |s: &mut SpriteH, x0: D, y0: D, x1: D, y1: D, z0: D, z1: D| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().ext_box(n(&x0)?, n(&y0)?, n(&x1)?, n(&y1)?, n(&z0)?, n(&z1)?);
|
||||
ok(s)
|
||||
});
|
||||
|
||||
// structure
|
||||
e.register_fn("begin", |s: &mut SpriteH, cls: &str| -> SpriteH {
|
||||
s.0.borrow_mut().begin_group(&classes(cls), "");
|
||||
s.clone()
|
||||
});
|
||||
e.register_fn("begin", |s: &mut SpriteH, cls: &str, css: &str| -> SpriteH {
|
||||
s.0.borrow_mut().begin_group(&classes(cls), css);
|
||||
s.clone()
|
||||
});
|
||||
e.register_fn("end", |s: &mut SpriteH| -> SpriteH {
|
||||
s.0.borrow_mut().end_group();
|
||||
s.clone()
|
||||
});
|
||||
e.register_fn("group", |ctx: NativeCallContext, s: &mut SpriteH, cls: &str, f: FnPtr| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().begin_group(&classes(cls), "");
|
||||
let r = f.call_within_context::<Dynamic>(&ctx, (s.clone(),));
|
||||
s.0.borrow_mut().end_group();
|
||||
let _ = r?;
|
||||
ok(s)
|
||||
});
|
||||
e.register_fn(
|
||||
"group",
|
||||
|ctx: NativeCallContext, s: &mut SpriteH, cls: &str, css: &str, f: FnPtr| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().begin_group(&classes(cls), css);
|
||||
let r = f.call_within_context::<Dynamic>(&ctx, (s.clone(),));
|
||||
s.0.borrow_mut().end_group();
|
||||
let _ = r?;
|
||||
ok(s)
|
||||
},
|
||||
);
|
||||
// items: [[x, y, |s| { ... }], ...] drawn back to front by the anchor's depth
|
||||
e.register_fn("seq", |ctx: NativeCallContext, s: &mut SpriteH, items: Array| -> RR<SpriteH> {
|
||||
s.0.borrow_mut().begin_seq();
|
||||
for it in items {
|
||||
let a = it.into_array().map_err(|t| format!("seq: expected [x, y, fn], got {t}"))?;
|
||||
if a.len() < 3 {
|
||||
s.0.borrow_mut().end_seq();
|
||||
return err("seq: expected [x, y, fn]");
|
||||
}
|
||||
let f = a[2].clone().try_cast::<FnPtr>().ok_or("seq: the third entry must be a function")?;
|
||||
s.0.borrow_mut().seq_item([n(&a[0])?, n(&a[1])?]);
|
||||
if let Err(e) = f.call_within_context::<Dynamic>(&ctx, (s.clone(),)) {
|
||||
s.0.borrow_mut().end_seq();
|
||||
return Err(e);
|
||||
}
|
||||
}
|
||||
s.0.borrow_mut().end_seq();
|
||||
ok(s)
|
||||
});
|
||||
}
|
||||
|
||||
/// Scene-level functions (they read and write the shared build state).
|
||||
pub(crate) fn register_scene(e: &mut Engine, st: &Shared) {
|
||||
let s = st.clone();
|
||||
e.register_fn("sprite", move |ctx: NativeCallContext| new_sprite(&s, Some(&ctx), None, ""));
|
||||
let s = st.clone();
|
||||
e.register_fn("sprite", move |ctx: NativeCallContext, id: &str| new_sprite(&s, Some(&ctx), Some(id), ""));
|
||||
let s = st.clone();
|
||||
e.register_fn("sprite", move |ctx: NativeCallContext, id: &str, cls: &str| {
|
||||
new_sprite(&s, Some(&ctx), Some(id), cls)
|
||||
});
|
||||
// the shared ground sprite (unsorted layer "ground", no pick id)
|
||||
let s = st.clone();
|
||||
e.register_fn("ground", move || {
|
||||
if let Some(g) = s.borrow().ground.clone() {
|
||||
return g;
|
||||
}
|
||||
let saved = std::mem::replace(&mut s.borrow_mut().layer, "ground".into());
|
||||
let (obj, xf) = {
|
||||
let mut b = s.borrow_mut();
|
||||
(b.obj.take(), std::mem::take(&mut b.xf))
|
||||
};
|
||||
let g = new_sprite(&s, None, Some(""), "");
|
||||
let mut b = s.borrow_mut();
|
||||
b.layer = saved;
|
||||
b.obj = obj;
|
||||
b.xf = xf;
|
||||
b.ground = Some(g.clone());
|
||||
g
|
||||
});
|
||||
let s = st.clone();
|
||||
e.register_fn("layer", move |name: &str| {
|
||||
let mut b = s.borrow_mut();
|
||||
b.scene.layer_mut(name);
|
||||
b.layer = name.to_string();
|
||||
});
|
||||
let s = st.clone();
|
||||
e.register_fn("layer", move |name: &str, o: Map| {
|
||||
let mut b = s.borrow_mut();
|
||||
let opts = LayerOpts {
|
||||
sort: o.get("sort").and_then(|v| v.as_bool().ok()).unwrap_or(true),
|
||||
zfirst: o.get("zfirst").and_then(|v| v.as_bool().ok()).unwrap_or(false),
|
||||
cls: o.get("cls").map(|v| classes(&v.to_string())).unwrap_or_else(|| "iso-sprites".into()),
|
||||
};
|
||||
let before = o.get("before").map(|v| v.to_string());
|
||||
b.scene.add_layer(name, opts, before.as_deref());
|
||||
b.layer = name.to_string();
|
||||
});
|
||||
let s = st.clone();
|
||||
e.register_fn("current_layer", move || s.borrow().layer.clone());
|
||||
|
||||
// tags and info
|
||||
fn tag(s: &Shared, x: D, y: D, z: D, text: &str, prio: f64, id: Option<&str>, kind: &str) -> RR<()> {
|
||||
let mut b = s.borrow_mut();
|
||||
let p = b.xf.p3([n(&x)?, n(&y)?, n(&z)?]);
|
||||
let id = id.map(str::to_string).or_else(|| b.obj.clone()).unwrap_or_default();
|
||||
b.scene.tag(p, text, prio, id, classes(kind));
|
||||
Ok(())
|
||||
}
|
||||
let s = st.clone();
|
||||
e.register_fn("tag", move |x: D, y: D, z: D, t: &str| tag(&s, x, y, z, t, 1.0, None, ""));
|
||||
let s = st.clone();
|
||||
e.register_fn("tag", move |x: D, y: D, z: D, t: &str, p: D| tag(&s, x, y, z, t, n(&p)?, None, ""));
|
||||
let s = st.clone();
|
||||
e.register_fn("tag", move |x: D, y: D, z: D, t: &str, p: D, id: &str| tag(&s, x, y, z, t, n(&p)?, Some(id), ""));
|
||||
let s = st.clone();
|
||||
e.register_fn("tag", move |x: D, y: D, z: D, t: &str, p: D, id: &str, k: &str| {
|
||||
tag(&s, x, y, z, t, n(&p)?, Some(id), k)
|
||||
});
|
||||
let s = st.clone();
|
||||
e.register_fn("info", move |id: &str, name: &str| s.borrow_mut().scene.info(id, name, ""));
|
||||
let s = st.clone();
|
||||
e.register_fn("info", move |id: &str, name: &str, detail: &str| s.borrow_mut().scene.info(id, name, detail));
|
||||
let s = st.clone();
|
||||
e.register_fn("info", move |id: &str, m: Map| {
|
||||
let g = |k: &str| m.get(k).map(|v| v.to_string()).unwrap_or_default();
|
||||
let mut b = s.borrow_mut();
|
||||
b.scene.info(id, g("name"), g("detail"));
|
||||
if let Some(rows) = m.get("rows").and_then(|r| r.read_lock::<Array>().map(|a| a.clone())) {
|
||||
let rows: Vec<(String, String)> = rows
|
||||
.iter()
|
||||
.filter_map(|r| r.read_lock::<Array>().map(|a| a.clone()))
|
||||
.filter(|a| a.len() >= 2)
|
||||
.map(|a| (a[0].to_string(), a[1].to_string()))
|
||||
.collect();
|
||||
if let Some(i) = b.scene.info.get_mut(id) {
|
||||
i.rows = rows;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// framing
|
||||
let s = st.clone();
|
||||
e.register_fn("focus", move |x: D, y: D, z: D| -> RR<()> {
|
||||
let mut b = s.borrow_mut();
|
||||
let p = b.xf.p3([n(&x)?, n(&y)?, n(&z)?]);
|
||||
b.scene.focus = Some(p);
|
||||
Ok(())
|
||||
});
|
||||
let s = st.clone();
|
||||
e.register_fn("bounds", move |x0: D, y0: D, x1: D, y1: D| -> RR<()> {
|
||||
let mut b = s.borrow_mut();
|
||||
let r = b.xf.rect(n(&x0)?, n(&y0)?, n(&x1)?, n(&y1)?);
|
||||
b.scene.bounds = Some((r, -1.6));
|
||||
Ok(())
|
||||
});
|
||||
let s = st.clone();
|
||||
e.register_fn("bounds", move |x0: D, y0: D, x1: D, y1: D, zb: D| -> RR<()> {
|
||||
let mut b = s.borrow_mut();
|
||||
let r = b.xf.rect(n(&x0)?, n(&y0)?, n(&x1)?, n(&y1)?);
|
||||
b.scene.bounds = Some((r, -n(&zb)?.abs()));
|
||||
Ok(())
|
||||
});
|
||||
let s = st.clone();
|
||||
e.register_fn("defs", move |svg: &str| s.borrow_mut().scene.defs.push(svg.to_string()));
|
||||
let s = st.clone();
|
||||
e.register_fn("warn", move |msg: &str| s.borrow_mut().scene.warnings.push(msg.to_string()));
|
||||
|
||||
// view and inputs
|
||||
let s = st.clone();
|
||||
e.register_fn("level", move || s.borrow().level.clone());
|
||||
let s = st.clone();
|
||||
e.register_fn("rot", move || s.borrow().proj.rot as i64);
|
||||
let s = st.clone();
|
||||
e.register_fn("cfg", move || s.borrow().cfg.clone());
|
||||
let s = st.clone();
|
||||
e.register_fn("cfg", move |k: &str| s.borrow().cfg.get(k).cloned().unwrap_or(Dynamic::UNIT));
|
||||
let s = st.clone();
|
||||
e.register_fn("objects", move || s.borrow().all_objects.clone());
|
||||
// is a face with outward normal (nx, ny) (object coordinates) turned towards the viewer?
|
||||
let s = st.clone();
|
||||
e.register_fn("vis", move |nx: D, ny: D| -> RR<bool> {
|
||||
let b = s.borrow();
|
||||
let w = b.xf.v(n(&nx)?, n(&ny)?);
|
||||
Ok(b.proj.vis(w[0], w[1]).is_some())
|
||||
});
|
||||
let s = st.clone();
|
||||
e.register_fn("dv", move |dx: D, dy: D, dz: D| -> RR<Array> {
|
||||
let b = s.borrow();
|
||||
let w = b.xf.v(n(&dx)?, n(&dy)?);
|
||||
let v = b.proj.dv(w[0], w[1], n(&dz)?);
|
||||
Ok(vec![Dynamic::from_float(round1(v[0])), Dynamic::from_float(round1(v[1]))])
|
||||
});
|
||||
// should a mover run along its x axis? (x is then the axis the depth sort compares second)
|
||||
let s = st.clone();
|
||||
e.register_fn("along_x", move || {
|
||||
let b = s.borrow();
|
||||
let w = b.xf.v(1.0, 0.0);
|
||||
b.proj.r(w[0], w[1])[0].abs() < 1e-9
|
||||
});
|
||||
let s = st.clone();
|
||||
e.register_fn("depth", move |x: D, y: D| -> RR<f64> {
|
||||
let b = s.borrow();
|
||||
let p = b.xf.p(n(&x)?, n(&y)?);
|
||||
Ok(b.proj.depth(p[0], p[1]))
|
||||
});
|
||||
|
||||
// helpers
|
||||
e.register_fn("px", || C);
|
||||
e.register_fn("hash", |x: D| -> RR<f64> { Ok(hash(n(&x)?)) });
|
||||
e.register_fn("fmt", |x: D| -> RR<String> { Ok(thousands(n(&x)?)) });
|
||||
e.register_fn("round1", |x: D| -> RR<f64> { Ok(round1(n(&x)?)) });
|
||||
e.register_fn("num", |x: D| -> RR<f64> { n(&x) });
|
||||
e.register_fn("fmin", |a: D, b: D| -> RR<f64> { Ok(n(&a)?.min(n(&b)?)) });
|
||||
e.register_fn("fmax", |a: D, b: D| -> RR<f64> { Ok(n(&a)?.max(n(&b)?)) });
|
||||
e.register_fn("clamp", |x: D, lo: D, hi: D| -> RR<f64> { Ok(n(&x)?.max(n(&lo)?).min(n(&hi)?)) });
|
||||
e.register_fn("rect", |x0: D, y0: D, x1: D, y1: D| -> RR<Array> {
|
||||
let (x0, y0, x1, y1) = (n(&x0)?, n(&y0)?, n(&x1)?, n(&y1)?);
|
||||
Ok(vec![arr_f(&[x0, y0]), arr_f(&[x1, y0]), arr_f(&[x1, y1]), arr_f(&[x0, y1])])
|
||||
});
|
||||
e.register_fn("ellipse", |cx: D, cy: D, a: D, b: D, k: D| -> RR<Array> {
|
||||
let (cx, cy, a, b, k) = (n(&cx)?, n(&cy)?, n(&a)?, n(&b)?, n(&k)?.max(3.0) as usize);
|
||||
Ok((0..k)
|
||||
.map(|i| {
|
||||
let t = i as f64 / k as f64 * std::f64::consts::TAU;
|
||||
arr_f(&[cx + a * t.cos(), cy + b * t.sin()])
|
||||
})
|
||||
.collect())
|
||||
});
|
||||
// outline segments of a rectangle [x0, y0, x1, y1]
|
||||
e.register_fn("rsegs", |r: D| -> RR<Array> {
|
||||
let r = rect4(&r)?;
|
||||
Ok(vec![
|
||||
arr_f(&[r[0], r[1], r[2], r[1]]),
|
||||
arr_f(&[r[2], r[1], r[2], r[3]]),
|
||||
arr_f(&[r[2], r[3], r[0], r[3]]),
|
||||
arr_f(&[r[0], r[3], r[0], r[1]]),
|
||||
])
|
||||
});
|
||||
// the four faces of a rectangle as [from, to] with the outward normal on the right
|
||||
e.register_fn("sides", |x0: D, y0: D, x1: D, y1: D| -> RR<Map> {
|
||||
let (x0, y0, x1, y1) = (n(&x0)?, n(&y0)?, n(&x1)?, n(&y1)?);
|
||||
let mut m = Map::new();
|
||||
m.insert("S".into(), arr_pts(&[[x0, y0], [x1, y0]]));
|
||||
m.insert("E".into(), arr_pts(&[[x1, y0], [x1, y1]]));
|
||||
m.insert("N".into(), arr_pts(&[[x1, y1], [x0, y1]]));
|
||||
m.insert("W".into(), arr_pts(&[[x0, y1], [x0, y0]]));
|
||||
Ok(m)
|
||||
});
|
||||
}
|
||||
Reference in new issue
Block a user