#![allow(unused_imports)]
use super::*;
use crate::controls::transform::{
gizmo::{Group, MATERIALS},
CameraState, ObjectState, Pointer, PropValue, TcEvent,
};
use crate::controls::{FlyControls, TransformControls};
fn m4(s: &[f64]) -> [f64; 16] {
let mut m = [0.0; 16];
for (d, v) in m.iter_mut().zip(s) {
*d = *v;
}
m
}
fn camera_of(c: &[f64]) -> CameraState {
let at = |i: usize, d: f64| c.get(i).copied().unwrap_or(d);
CameraState {
matrix_world: m4(c.get(0..16).unwrap_or(&[])),
projection_matrix_inverse: m4(c.get(16..32).unwrap_or(&[])),
orthographic: at(32, 0.0) != 0.0,
near: at(33, 0.1),
far: at(34, 2000.0),
fov: at(35, 50.0),
zoom: at(36, 1.0),
top: at(37, 1.0),
bottom: at(38, -1.0),
}
}
fn object_of(o: &Option<Vec<f64>>) -> Option<ObjectState> {
let o = o.as_deref()?;
if o.len() < 27 {
return None;
}
Some(ObjectState {
position: [o[0], o[1], o[2]],
quaternion: [o[3], o[4], o[5], o[6]],
scale: [o[7], o[8], o[9]],
matrix_world: m4(&o[10..26]),
parent_matrix_world: (o[26] != 0.0 && o.len() >= 43).then(|| m4(&o[27..43])),
})
}
fn prop_of(v: &JsValue) -> PropValue {
if let Some(b) = v.as_bool() {
PropValue::Bool(b)
} else if let Some(n) = v.as_f64() {
PropValue::Num(n)
} else if let Some(s) = v.as_string() {
PropValue::Str(s)
} else {
PropValue::Null
}
}
fn prop_to_js(v: &PropValue) -> JsValue {
match v {
PropValue::Null => JsValue::NULL,
PropValue::Bool(b) => JsValue::from_bool(*b),
PropValue::Num(n) => JsValue::from_f64(*n),
PropValue::Str(s) => JsValue::from_str(s),
}
}
fn events_to_js(events: &[TcEvent]) -> js_sys::Array {
let out = js_sys::Array::new();
let nums = |v: &[f64]| -> JsValue { js_sys::Float64Array::from(v).into() };
for e in events {
let o = js_sys::Object::new();
let (kind, extra): (&str, Option<(&str, JsValue)>) = match e {
TcEvent::Prop(name, value) => {
js_set(&o, "name", &JsValue::from_str(name));
("prop", Some(("value", prop_to_js(value))))
}
TcEvent::SetPosition(p) => ("position", Some(("value", nums(p)))),
TcEvent::SetQuaternion(q) => ("quaternion", Some(("value", nums(q)))),
TcEvent::SetScale(s) => ("scale", Some(("value", nums(s)))),
TcEvent::Change => ("change", None),
TcEvent::ObjectChange => ("objectChange", None),
TcEvent::MouseDown(m) => ("mouseDown", Some(("mode", JsValue::from_str(m)))),
TcEvent::MouseUp(m) => ("mouseUp", Some(("mode", JsValue::from_str(m)))),
};
js_set(&o, "type", &JsValue::from_str(kind));
if let Some((k, v)) = extra {
js_set(&o, k, &v);
}
out.push(&o.into());
}
out
}
fn pointer_of(has: bool, x: f64, y: f64, button: i32) -> Option<Pointer> {
has.then_some(Pointer { x, y, button })
}
#[wasm_bindgen]
pub struct WebTransformControls {
inner: TransformControls,
}
#[wasm_bindgen]
impl WebTransformControls {
#[wasm_bindgen(constructor)]
pub fn new() -> WebTransformControls {
WebTransformControls {
inner: TransformControls::new(),
}
}
#[wasm_bindgen(js_name = handleCount)]
pub fn handle_count(&self) -> usize {
self.inner.handles().len()
}
#[wasm_bindgen(js_name = handleInfo)]
pub fn handle_info(&self, i: usize) -> JsValue {
let Some(h) = self.inner.handles().get(i) else {
return JsValue::UNDEFINED;
};
let o = js_sys::Object::new();
let group = match h.group {
Group::Gizmo => "gizmo",
Group::Picker => "picker",
Group::Helper => "helper",
};
js_set(&o, "group", &JsValue::from_str(group));
js_set(&o, "mode", &JsValue::from_str(h.mode.name()));
js_set(&o, "name", &JsValue::from_str(h.name));
js_set(
&o,
"tag",
&if h.helper {
JsValue::from_str("helper")
} else {
JsValue::UNDEFINED
},
);
js_set(&o, "line", &JsValue::from_bool(h.line));
js_set(&o, "material", &JsValue::from_f64(h.material as f64));
o.into()
}
#[wasm_bindgen(js_name = handleGeometry)]
pub fn handle_geometry(&self, i: usize) -> JsValue {
match self.inner.handles().get(i) {
Some(h) => geometry_to_js(&h.geometry),
None => JsValue::UNDEFINED,
}
}
#[wasm_bindgen(js_name = planeGeometry)]
pub fn plane_geometry() -> JsValue {
geometry_to_js(&crate::controls::transform::gizmo::plane())
}
#[wasm_bindgen(js_name = materialInfo)]
pub fn material_info(i: usize) -> JsValue {
let Some(m) = MATERIALS.get(i) else {
return JsValue::UNDEFINED;
};
let o = js_sys::Object::new();
js_set(&o, "line", &JsValue::from_bool(m.line));
js_set(&o, "color", &JsValue::from_f64(m.color as f64));
js_set(&o, "opacity", &JsValue::from_f64(m.opacity));
o.into()
}
#[wasm_bindgen(js_name = materialCount)]
pub fn material_count() -> usize {
MATERIALS.len()
}
#[wasm_bindgen(js_name = getProperty)]
pub fn get_property(&self, name: &str) -> JsValue {
let t = &self.inner;
let opt = |v: Option<f64>| v.map(JsValue::from_f64).unwrap_or(JsValue::NULL);
let [x, y, z] = t.show();
match name {
"enabled" => JsValue::from_bool(t.enabled),
"axis" => t.axis().map(JsValue::from_str).unwrap_or(JsValue::NULL),
"mode" => JsValue::from_str(t.mode()),
"space" => JsValue::from_str(t.space()),
"size" => JsValue::from_f64(t.size()),
"dragging" => JsValue::from_bool(t.dragging()),
"translationSnap" => opt(t.translation_snap()),
"rotationSnap" => opt(t.rotation_snap()),
"scaleSnap" => opt(t.scale_snap()),
"showX" => JsValue::from_bool(x),
"showY" => JsValue::from_bool(y),
"showZ" => JsValue::from_bool(z),
"rotationAngle" => JsValue::from_f64(t.rotation_angle()),
_ => JsValue::UNDEFINED,
}
}
#[wasm_bindgen(js_name = setProperty)]
pub fn set_property(&mut self, name: &str, value: JsValue) -> js_sys::Array {
events_to_js(&self.inner.set_property(name, prop_of(&value)))
}
#[wasm_bindgen(js_name = setHasObject)]
pub fn set_has_object(&mut self, on: bool) {
self.inner.set_has_object(on);
}
pub fn detach(&mut self) -> js_sys::Array {
events_to_js(&self.inner.detach())
}
#[wasm_bindgen(js_name = updateMatrixWorld)]
pub fn update_matrix_world(
&mut self,
object: Option<Vec<f64>>,
camera: &[f64],
controls_world: &[f64],
) {
let o = object_of(&object);
self.inner
.update_matrix_world(o.as_ref(), &camera_of(camera), &m4(controls_world));
}
#[wasm_bindgen(js_name = handleStates)]
pub fn handle_states(&self) -> Vec<f64> {
let mut out = Vec::with_capacity(self.inner.handle_states().len() * 11);
for s in self.inner.handle_states() {
out.extend_from_slice(&s.position);
out.extend_from_slice(&s.quaternion);
out.extend_from_slice(&s.scale);
out.push(if s.visible { 1.0 } else { 0.0 });
}
out
}
#[wasm_bindgen(js_name = materialStates)]
pub fn material_states(&self) -> Vec<f64> {
self.inner
.material_states()
.iter()
.flat_map(|m| [m.color as f64, m.opacity])
.collect()
}
#[wasm_bindgen(js_name = planeTransform)]
pub fn plane_transform(&self) -> Vec<f64> {
let (p, q) = self.inner.plane_transform();
vec![p[0], p[1], p[2], q[0], q[1], q[2], q[3]]
}
#[wasm_bindgen(js_name = worldState)]
pub fn world_state(&self) -> Vec<f64> {
let t = &self.inner;
let mut v = Vec::with_capacity(33);
v.extend_from_slice(&t.world_position);
v.extend_from_slice(&t.world_position_start);
v.extend_from_slice(&t.world_quaternion);
v.extend_from_slice(&t.world_quaternion_start);
v.extend_from_slice(&t.camera_position);
v.extend_from_slice(&t.camera_quaternion);
v.extend_from_slice(&t.point_start);
v.extend_from_slice(&t.point_end);
v.extend_from_slice(&t.rotation_axis);
v.extend_from_slice(&t.eye);
v
}
#[wasm_bindgen(js_name = wantsHover)]
pub fn wants_hover(&self) -> bool {
self.inner.wants_hover()
}
#[wasm_bindgen(js_name = pointerHover)]
pub fn pointer_hover(&mut self, hit: Option<String>) -> js_sys::Array {
events_to_js(&self.inner.pointer_hover(hit.as_deref()))
}
#[wasm_bindgen(js_name = pointerDown)]
#[allow(clippy::too_many_arguments)]
pub fn pointer_down(
&mut self,
has_pointer: bool,
x: f64,
y: f64,
button: i32,
object: Option<Vec<f64>>,
camera: &[f64],
) -> js_sys::Array {
let o = object_of(&object);
events_to_js(&self.inner.pointer_down(
pointer_of(has_pointer, x, y, button),
o.as_ref(),
&camera_of(camera),
))
}
#[wasm_bindgen(js_name = pointerMove)]
#[allow(clippy::too_many_arguments)]
pub fn pointer_move(
&mut self,
has_pointer: bool,
x: f64,
y: f64,
button: i32,
object: Option<Vec<f64>>,
camera: &[f64],
) -> js_sys::Array {
let o = object_of(&object);
events_to_js(&self.inner.pointer_move(
pointer_of(has_pointer, x, y, button),
o.as_ref(),
&camera_of(camera),
))
}
#[wasm_bindgen(js_name = pointerUp)]
pub fn pointer_up(&mut self, has_pointer: bool, button: i32) -> js_sys::Array {
events_to_js(
&self
.inner
.pointer_up(pointer_of(has_pointer, 0.0, 0.0, button)),
)
}
pub fn reset(&mut self) -> js_sys::Array {
events_to_js(&self.inner.reset())
}
}
impl Default for WebTransformControls {
fn default() -> Self {
Self::new()
}
}
fn geometry_to_js(g: &crate::controls::transform::gizmo::GizmoGeometry) -> JsValue {
let o = js_sys::Object::new();
js_set(
&o,
"position",
&js_sys::Float32Array::from(&g.position[..]).into(),
);
if !g.normal.is_empty() {
js_set(
&o,
"normal",
&js_sys::Float32Array::from(&g.normal[..]).into(),
);
}
if !g.uv.is_empty() {
js_set(&o, "uv", &js_sys::Float32Array::from(&g.uv[..]).into());
}
if let Some(i) = &g.index {
js_set(&o, "index", &js_sys::Uint32Array::from(&i[..]).into());
}
o.into()
}
#[wasm_bindgen]
pub struct WebFlyControls {
inner: FlyControls,
}
#[wasm_bindgen]
impl WebFlyControls {
#[wasm_bindgen(constructor)]
pub fn new() -> WebFlyControls {
WebFlyControls {
inner: FlyControls::new(),
}
}
#[wasm_bindgen(getter)]
pub fn enabled(&self) -> bool {
self.inner.enabled
}
#[wasm_bindgen(setter)]
pub fn set_enabled(&mut self, v: bool) {
self.inner.enabled = v;
}
#[wasm_bindgen(getter, js_name = movementSpeed)]
pub fn movement_speed(&self) -> f64 {
self.inner.movement_speed
}
#[wasm_bindgen(setter, js_name = movementSpeed)]
pub fn set_movement_speed(&mut self, v: f64) {
self.inner.movement_speed = v;
}
#[wasm_bindgen(getter, js_name = rollSpeed)]
pub fn roll_speed(&self) -> f64 {
self.inner.roll_speed
}
#[wasm_bindgen(setter, js_name = rollSpeed)]
pub fn set_roll_speed(&mut self, v: f64) {
self.inner.roll_speed = v;
}
#[wasm_bindgen(getter, js_name = dragToLook)]
pub fn drag_to_look(&self) -> bool {
self.inner.drag_to_look
}
#[wasm_bindgen(setter, js_name = dragToLook)]
pub fn set_drag_to_look(&mut self, v: bool) {
self.inner.drag_to_look = v;
}
#[wasm_bindgen(getter, js_name = autoForward)]
pub fn auto_forward(&self) -> bool {
self.inner.auto_forward
}
#[wasm_bindgen(setter, js_name = autoForward)]
pub fn set_auto_forward(&mut self, v: bool) {
self.inner.auto_forward = v;
}
#[wasm_bindgen(getter, js_name = movementSpeedMultiplier)]
pub fn movement_speed_multiplier(&self) -> f64 {
self.inner.movement_speed_multiplier
}
#[wasm_bindgen(getter)]
pub fn status(&self) -> i32 {
self.inner.status
}
#[wasm_bindgen(js_name = moveState)]
pub fn move_state(&self) -> Vec<f64> {
let s = &self.inner.move_state;
vec![
s.up,
s.down,
s.left,
s.right,
s.forward,
s.back,
s.pitch_up,
s.pitch_down,
s.yaw_left,
s.yaw_right,
s.roll_left,
s.roll_right,
]
}
#[wasm_bindgen(js_name = setMoveState)]
pub fn set_move_state(&mut self, v: &[f64]) {
if v.len() < 12 {
return;
}
let s = &mut self.inner.move_state;
[
s.up,
s.down,
s.left,
s.right,
s.forward,
s.back,
s.pitch_up,
s.pitch_down,
s.yaw_left,
s.yaw_right,
s.roll_left,
s.roll_right,
] = [
v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8], v[9], v[10], v[11],
];
}
pub fn vectors(&self) -> Vec<f64> {
let (m, r) = (self.inner.move_vector, self.inner.rotation_vector);
vec![m[0], m[1], m[2], r[0], r[1], r[2]]
}
#[wasm_bindgen(js_name = updateMovementVector)]
pub fn update_movement_vector(&mut self) {
self.inner.update_movement_vector();
}
#[wasm_bindgen(js_name = updateRotationVector)]
pub fn update_rotation_vector(&mut self) {
self.inner.update_rotation_vector();
}
#[wasm_bindgen(js_name = keyDown)]
pub fn key_down(&mut self, code: &str, alt: bool) {
self.inner.key_down(code, alt);
}
#[wasm_bindgen(js_name = keyUp)]
pub fn key_up(&mut self, code: &str) {
self.inner.key_up(code);
}
#[wasm_bindgen(js_name = pointerDown)]
pub fn pointer_down(&mut self, button: i32) {
self.inner.pointer_down(button);
}
#[wasm_bindgen(js_name = pointerMove)]
#[allow(clippy::too_many_arguments)]
pub fn pointer_move(&mut self, page_x: f64, page_y: f64, w: f64, h: f64, ox: f64, oy: f64) {
self.inner.pointer_move(page_x, page_y, [w, h], [ox, oy]);
}
#[wasm_bindgen(js_name = pointerUp)]
pub fn pointer_up(&mut self, button: i32) {
self.inner.pointer_up(button);
}
#[wasm_bindgen(js_name = pointerCancel)]
pub fn pointer_cancel(&mut self) {
self.inner.pointer_cancel();
}
pub fn update(&mut self, delta: f64, pose: &[f64]) -> Option<Vec<f64>> {
if pose.len() < 7 {
return None;
}
let (p, q, changed) = self.inner.update(
delta,
[pose[0], pose[1], pose[2]],
[pose[3], pose[4], pose[5], pose[6]],
)?;
Some(vec![
p[0],
p[1],
p[2],
q[0],
q[1],
q[2],
q[3],
if changed { 1.0 } else { 0.0 },
])
}
}
impl Default for WebFlyControls {
fn default() -> Self {
Self::new()
}
}
#[wasm_bindgen]
impl WebOrbitControls {
#[wasm_bindgen(js_name = setScreenSpacePanning)]
pub fn set_screen_space_panning(&mut self, on: bool) {
self.inner.screen_space_panning = on;
}
}
#[wasm_bindgen]
pub struct WebOrbitControls {
pub(super) inner: crate::OrbitControls,
}
#[wasm_bindgen]
impl WebOrbitControls {
#[wasm_bindgen(constructor)]
pub fn new(camera: &WebCamera) -> WebOrbitControls {
let c = match &camera.inner {
CameraInner::Perspective(p) => p.clone(),
_ => crate::PerspectiveCamera::new(60.0, 1.0, 0.1, 100.0),
};
WebOrbitControls {
inner: crate::OrbitControls::new(&c),
}
}
#[wasm_bindgen(js_name = setLimits)]
#[allow(clippy::too_many_arguments)]
pub fn set_limits(
&mut self,
min_distance: f32,
max_distance: f32,
min_polar_angle: f32,
max_polar_angle: f32,
rotate_speed: f32,
zoom_speed: f32,
pan_speed: f32,
damping: f32,
) {
self.inner.min_distance = min_distance.max(0.0);
self.inner.max_distance = max_distance.max(self.inner.min_distance);
self.inner.min_polar_angle = min_polar_angle;
self.inner.max_polar_angle = max_polar_angle;
self.inner.rotate_speed = rotate_speed;
self.inner.zoom_speed = zoom_speed;
self.inner.pan_speed = pan_speed;
self.inner.damping = damping;
self.inner.enable_damping = damping > 0.0;
}
#[wasm_bindgen(js_name = setMotion)]
pub fn set_motion(
&mut self,
enable_damping: bool,
damping: f32,
auto_rotate: bool,
auto_rotate_speed: f32,
) {
self.inner.enable_damping = enable_damping;
self.inner.damping = damping.clamp(0.0, 1.0);
self.inner.auto_rotate = auto_rotate;
self.inner.auto_rotate_speed = auto_rotate_speed;
}
pub fn update(
&mut self,
camera: &mut WebCamera,
dx: f32,
dy: f32,
wheel: f32,
rotating: bool,
panning: bool,
w: f32,
h: f32,
) {
self.update_dt(camera, dx, dy, wheel, rotating, panning, w, h, 1.0 / 60.0);
}
#[wasm_bindgen(js_name = updateDt)]
#[allow(clippy::too_many_arguments)]
pub fn update_dt(
&mut self,
camera: &mut WebCamera,
dx: f32,
dy: f32,
wheel: f32,
rotating: bool,
panning: bool,
w: f32,
h: f32,
dt: f32,
) {
let ev = crate::PointerEvent {
dx,
dy,
wheel,
rotating,
panning,
cursor: (0.0, 0.0),
};
if let CameraInner::Perspective(c) = &mut camera.inner {
self.inner.update_dt(ev, c, (w, h), dt);
}
}
#[wasm_bindgen(js_name = reseedFromCamera)]
pub fn reseed_from_camera(&mut self, camera: &WebCamera) {
if let CameraInner::Perspective(c) = &camera.inner {
self.inner.reseed_from_camera(c);
}
}
#[wasm_bindgen(js_name = setTarget)]
pub fn set_target(&mut self, x: f32, y: f32, z: f32) {
self.inner.target = crate::Vector3::new(x, y, z);
}
}
#[wasm_bindgen]
pub struct WebTrackballControls {
pub(super) inner: crate::TrackballControls,
}
#[wasm_bindgen]
impl WebTrackballControls {
#[wasm_bindgen(constructor)]
pub fn new(camera: &WebCamera) -> WebTrackballControls {
let c = match &camera.inner {
CameraInner::Perspective(p) => p.clone(),
_ => crate::PerspectiveCamera::new(60.0, 1.0, 0.1, 100.0),
};
WebTrackballControls {
inner: crate::TrackballControls::new(&c),
}
}
pub fn update(
&mut self,
camera: &mut WebCamera,
dx: f32,
dy: f32,
wheel: f32,
rotating: bool,
panning: bool,
w: f32,
h: f32,
) {
let ev = crate::PointerEvent {
dx,
dy,
wheel,
rotating,
panning,
cursor: (0.0, 0.0),
};
if let CameraInner::Perspective(c) = &mut camera.inner {
self.inner.update(ev, c, (w, h));
}
}
}
#[wasm_bindgen]
pub struct WebArcballControls {
pub(super) inner: crate::ArcballControls,
}
#[wasm_bindgen]
impl WebArcballControls {
#[wasm_bindgen(constructor)]
pub fn new(camera: &WebCamera) -> WebArcballControls {
let c = match &camera.inner {
CameraInner::Perspective(p) => p.clone(),
_ => crate::PerspectiveCamera::new(60.0, 1.0, 0.1, 100.0),
};
WebArcballControls {
inner: crate::ArcballControls::new(&c),
}
}
#[wasm_bindgen(js_name = setTarget)]
pub fn set_target(&mut self, x: f32, y: f32, z: f32) {
self.inner.target = crate::Vector3::new(x, y, z);
}
pub fn update(
&mut self,
camera: &mut WebCamera,
ndc_x: f32,
ndc_y: f32,
wheel: f32,
rotating: bool,
) {
let ev = crate::PointerEvent {
dx: 0.0,
dy: 0.0,
wheel,
rotating,
panning: false,
cursor: (0.0, 0.0),
};
let ndc = crate::Vector2::new(ndc_x, ndc_y);
if let CameraInner::Perspective(c) = &mut camera.inner {
self.inner.update(ndc, ev, c);
}
}
}
#[wasm_bindgen]
pub struct WebFirstPersonControls {
pub(super) inner: crate::FirstPersonControls,
}
#[wasm_bindgen]
impl WebFirstPersonControls {
#[wasm_bindgen(constructor)]
pub fn new(camera: &WebCamera) -> WebFirstPersonControls {
let c = match &camera.inner {
CameraInner::Perspective(p) => p.clone(),
_ => crate::PerspectiveCamera::new(60.0, 1.0, 0.1, 100.0),
};
WebFirstPersonControls {
inner: crate::FirstPersonControls::new(&c),
}
}
pub fn update(&mut self, camera: &mut WebCamera, dx: f32, dy: f32, dt: f32, rotating: bool) {
let ev = crate::PointerEvent {
dx,
dy,
wheel: 0.0,
rotating,
panning: false,
cursor: (0.0, 0.0),
};
if let CameraInner::Perspective(c) = &mut camera.inner {
self.inner.update(ev, c, dt);
}
}
#[wasm_bindgen(js_name = setMoveInput)]
pub fn set_move_input(&mut self, forward: f32, right: f32, up: f32) {
self.inner.move_input = crate::Vector3::new(forward, right, up);
}
}
#[wasm_bindgen]
pub struct WebPointerLockControls {
pub(super) inner: crate::PointerLockControls,
}
#[wasm_bindgen]
impl WebPointerLockControls {
#[wasm_bindgen(constructor)]
pub fn new(camera: &WebCamera) -> WebPointerLockControls {
let c = match &camera.inner {
CameraInner::Perspective(p) => p.clone(),
_ => crate::PerspectiveCamera::new(60.0, 1.0, 0.1, 100.0),
};
WebPointerLockControls {
inner: crate::PointerLockControls::new(&c),
}
}
}