use std::f64::consts::PI;
use std::rc::Rc;
use crate::cameras::{OrthographicCamera, PerspectiveCamera, RenderCamera};
use crate::core::{BufferAttribute, BufferGeometry, Object3D, ObjectRef, Raycaster};
use crate::geometries::{
box_geometry, cylinder_geometry, octahedron_geometry, plane_geometry, sphere_geometry,
torus_geometry, torus_geometry_full,
};
use crate::materials::{MeshBasicNodeMaterial, Side};
use crate::math::{Color, Euler, Matrix4, Quaternion, Vector2, Vector3, Vector4};
use crate::objects::{Line, Mesh, Payload};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Mode {
#[default]
Translate,
Rotate,
Scale,
}
impl Mode {
pub fn as_str(self) -> &'static str {
match self {
Mode::Translate => "translate",
Mode::Rotate => "rotate",
Mode::Scale => "scale",
}
}
fn index(self) -> usize {
match self {
Mode::Translate => 0,
Mode::Rotate => 1,
Mode::Scale => 2,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Space {
#[default]
World,
Local,
}
impl Space {
pub fn as_str(self) -> &'static str {
match self {
Space::World => "world",
Space::Local => "local",
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Axis {
X,
Y,
Z,
XY,
YZ,
XZ,
XYZ,
XYZE,
E,
}
impl Axis {
pub fn as_str(self) -> &'static str {
match self {
Axis::X => "X",
Axis::Y => "Y",
Axis::Z => "Z",
Axis::XY => "XY",
Axis::YZ => "YZ",
Axis::XZ => "XZ",
Axis::XYZ => "XYZ",
Axis::XYZE => "XYZE",
Axis::E => "E",
}
}
pub fn from_name(name: &str) -> Option<Axis> {
Some(match name {
"X" => Axis::X,
"Y" => Axis::Y,
"Z" => Axis::Z,
"XY" => Axis::XY,
"YZ" => Axis::YZ,
"XZ" => Axis::XZ,
"XYZ" => Axis::XYZ,
"XYZE" => Axis::XYZE,
"E" => Axis::E,
_ => return None,
})
}
fn has(self, s: &str) -> bool {
self.as_str().contains(s)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TransformControlsEvent {
Change,
ObjectChange,
MouseDown(Mode),
MouseUp(Mode),
PropertyChanged(&'static str),
}
impl TransformControlsEvent {
pub fn type_name(&self) -> String {
match self {
TransformControlsEvent::Change => "change".to_string(),
TransformControlsEvent::ObjectChange => "objectChange".to_string(),
TransformControlsEvent::MouseDown(_) => "mouseDown".to_string(),
TransformControlsEvent::MouseUp(_) => "mouseUp".to_string(),
TransformControlsEvent::PropertyChanged(name) => format!("{name}-changed"),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PointerType {
Mouse,
Pen,
Touch,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Pointer {
pub x: f64,
pub y: f64,
pub button: i32,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TransformPointerEvent {
pub pointer_type: PointerType,
pub button: i32,
pub x: f64,
pub y: f64,
}
pub trait TransformCamera: RenderCamera {
fn gizmo_factor(&self, distance: f64) -> f64;
}
impl TransformCamera for PerspectiveCamera {
fn gizmo_factor(&self, distance: f64) -> f64 {
distance * js_min(1.9 * (PI * self.fov / 360.0).tan() / self.zoom, 7.0)
}
}
impl TransformCamera for OrthographicCamera {
fn gizmo_factor(&self, _distance: f64) -> f64 {
(self.top - self.bottom) / self.zoom
}
}
fn js_round(x: f64) -> f64 {
if !x.is_finite() {
return x;
}
let floor = x.floor();
let rounded = if x - floor >= 0.5 { floor + 1.0 } else { floor };
if rounded == 0.0 && x < 0.0 {
-0.0
} else {
rounded
}
}
fn js_min(a: f64, b: f64) -> f64 {
if a.is_nan() || b.is_nan() {
f64::NAN
} else if a < b || (a == b && a.is_sign_negative()) {
a
} else {
b
}
}
fn js_max(a: f64, b: f64) -> f64 {
if a.is_nan() || b.is_nan() {
f64::NAN
} else if a > b || (a == b && a.is_sign_positive()) {
a
} else {
b
}
}
fn snap_on(snap: Option<f64>) -> Option<f64> {
snap.filter(|s| *s != 0.0 && !s.is_nan())
}
fn or_number(x: f64, fallback: f64) -> f64 {
if x == 0.0 || x.is_nan() {
fallback
} else {
x
}
}
const UNIT_X: Vector3 = Vector3::new(1.0, 0.0, 0.0);
const UNIT_Y: Vector3 = Vector3::new(0.0, 1.0, 0.0);
const UNIT_Z: Vector3 = Vector3::new(0.0, 0.0, 1.0);
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Slot {
Invisible,
Helper,
Red,
Green,
Blue,
RedTransparent,
GreenTransparent,
BlueTransparent,
WhiteTransparent,
YellowTransparent,
Gray,
}
impl Slot {
fn opacity(self) -> f64 {
match self {
Slot::Invisible => 0.15,
Slot::Helper => 0.5,
Slot::RedTransparent | Slot::GreenTransparent | Slot::BlueTransparent => 0.5,
Slot::WhiteTransparent | Slot::YellowTransparent => 0.25,
Slot::Red | Slot::Green | Slot::Blue | Slot::Gray => 1.0,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
struct Palette {
x_axis: Color,
y_axis: Color,
z_axis: Color,
active: Color,
}
impl Default for Palette {
fn default() -> Self {
Self {
x_axis: Color::from_hex(0xff0000),
y_axis: Color::from_hex(0x00ff00),
z_axis: Color::from_hex(0x0000ff),
active: Color::from_hex(0xffff00),
}
}
}
impl Palette {
fn color(&self, slot: Slot) -> Color {
match slot {
Slot::Invisible | Slot::Helper | Slot::WhiteTransparent => Color::from_hex(0xffffff),
Slot::Red | Slot::RedTransparent => self.x_axis,
Slot::Green | Slot::GreenTransparent => self.y_axis,
Slot::Blue | Slot::BlueTransparent => self.z_axis,
Slot::YellowTransparent => self.active,
Slot::Gray => Color::from_hex(0x787878),
}
}
}
#[derive(Clone, Copy, Debug)]
enum Geo {
Arrow,
ScaleHandle,
Line,
Line2,
Circle(f64, f64),
TranslateHelper,
Octahedron(f64, usize),
Box(f64, f64, f64),
Cylinder(f64, f64, f64, usize),
Sphere(f64, usize, usize),
Torus(f64, f64, usize, usize),
}
impl Geo {
fn build(self) -> BufferGeometry {
match self {
Geo::Arrow => {
let mut g = cylinder_geometry(0.0, 0.04, 0.1, 12);
g.translate(0.0, 0.05, 0.0);
g
}
Geo::ScaleHandle => {
let mut g = box_geometry(0.08, 0.08, 0.08, 1, 1, 1);
g.translate(0.0, 0.04, 0.0);
g
}
Geo::Line => line_geometry(&[0.0, 0.0, 0.0, 1.0, 0.0, 0.0]),
Geo::Line2 => {
let mut g = cylinder_geometry(0.0075, 0.0075, 0.5, 3);
g.translate(0.0, 0.25, 0.0);
g
}
Geo::Circle(radius, arc) => {
let mut g =
torus_geometry_full(radius, 0.0075, 3, 64, arc * PI * 2.0, 0.0, PI * 2.0);
g.rotate_y(PI / 2.0);
g.rotate_x(PI / 2.0);
g
}
Geo::TranslateHelper => line_geometry(&[0.0, 0.0, 0.0, 1.0, 1.0, 1.0]),
Geo::Octahedron(radius, detail) => octahedron_geometry(radius, detail),
Geo::Box(w, h, d) => box_geometry(w, h, d, 1, 1, 1),
Geo::Cylinder(top, bottom, height, segments) => {
cylinder_geometry(top, bottom, height, segments)
}
Geo::Sphere(radius, ws, hs) => sphere_geometry(radius, ws, hs),
Geo::Torus(radius, tube, rs, ts) => torus_geometry(radius, tube, rs, ts),
}
}
fn is_line(self) -> bool {
matches!(self, Geo::Line | Geo::TranslateHelper)
}
}
fn line_geometry(points: &[f32]) -> BufferGeometry {
let mut g = BufferGeometry::new();
g.set_attribute("position", BufferAttribute::new(points.to_vec(), 3));
g
}
struct Entry {
geo: Geo,
slot: Slot,
position: Option<[f64; 3]>,
rotation: Option<[f64; 3]>,
scale: Option<[f64; 3]>,
helper: bool,
}
fn e(geo: Geo, slot: Slot, position: Option<[f64; 3]>, rotation: Option<[f64; 3]>) -> Entry {
Entry {
geo,
slot,
position,
rotation,
scale: None,
helper: false,
}
}
fn h(
geo: Geo,
position: Option<[f64; 3]>,
rotation: Option<[f64; 3]>,
scale: Option<[f64; 3]>,
) -> Entry {
Entry {
geo,
slot: Slot::Helper,
position,
rotation,
scale,
helper: true,
}
}
type GizmoMap = Vec<(&'static str, Vec<Entry>)>;
#[derive(Clone, Debug)]
struct Handle {
node: ObjectRef,
name: &'static str,
helper: bool,
slot: Slot,
}
#[derive(Clone, Debug)]
struct Group {
node: ObjectRef,
handles: Vec<Handle>,
}
#[derive(Clone, Debug)]
struct Gizmo {
node: ObjectRef,
gizmo: [Group; 3],
picker: [Group; 3],
helper: [Group; 3],
}
const HALF_PI: f64 = PI / 2.0;
fn gizmo_translate() -> GizmoMap {
use Geo::*;
use Slot::*;
vec![
(
"X",
vec![
e(
Arrow,
Red,
Some([0.5, 0.0, 0.0]),
Some([0.0, 0.0, -HALF_PI]),
),
e(
Arrow,
Red,
Some([-0.5, 0.0, 0.0]),
Some([0.0, 0.0, HALF_PI]),
),
e(
Line2,
Red,
Some([0.0, 0.0, 0.0]),
Some([0.0, 0.0, -HALF_PI]),
),
],
),
(
"Y",
vec![
e(Arrow, Green, Some([0.0, 0.5, 0.0]), None),
e(Arrow, Green, Some([0.0, -0.5, 0.0]), Some([PI, 0.0, 0.0])),
e(Line2, Green, None, None),
],
),
(
"Z",
vec![
e(
Arrow,
Blue,
Some([0.0, 0.0, 0.5]),
Some([HALF_PI, 0.0, 0.0]),
),
e(
Arrow,
Blue,
Some([0.0, 0.0, -0.5]),
Some([-HALF_PI, 0.0, 0.0]),
),
e(Line2, Blue, None, Some([HALF_PI, 0.0, 0.0])),
],
),
(
"XYZ",
vec![e(
Octahedron(0.1, 0),
WhiteTransparent,
Some([0.0, 0.0, 0.0]),
None,
)],
),
(
"XY",
vec![e(
Box(0.15, 0.15, 0.01),
BlueTransparent,
Some([0.15, 0.15, 0.0]),
None,
)],
),
(
"YZ",
vec![e(
Box(0.15, 0.15, 0.01),
RedTransparent,
Some([0.0, 0.15, 0.15]),
Some([0.0, HALF_PI, 0.0]),
)],
),
(
"XZ",
vec![e(
Box(0.15, 0.15, 0.01),
GreenTransparent,
Some([0.15, 0.0, 0.15]),
Some([-HALF_PI, 0.0, 0.0]),
)],
),
]
}
fn picker_arrows() -> GizmoMap {
use Geo::*;
use Slot::*;
let cone = Cylinder(0.2, 0.0, 0.6, 4);
vec![
(
"X",
vec![
e(
cone,
Invisible,
Some([0.3, 0.0, 0.0]),
Some([0.0, 0.0, -HALF_PI]),
),
e(
cone,
Invisible,
Some([-0.3, 0.0, 0.0]),
Some([0.0, 0.0, HALF_PI]),
),
],
),
(
"Y",
vec![
e(cone, Invisible, Some([0.0, 0.3, 0.0]), None),
e(
cone,
Invisible,
Some([0.0, -0.3, 0.0]),
Some([0.0, 0.0, PI]),
),
],
),
(
"Z",
vec![
e(
cone,
Invisible,
Some([0.0, 0.0, 0.3]),
Some([HALF_PI, 0.0, 0.0]),
),
e(
cone,
Invisible,
Some([0.0, 0.0, -0.3]),
Some([-HALF_PI, 0.0, 0.0]),
),
],
),
]
}
fn picker_planes() -> GizmoMap {
use Geo::*;
use Slot::*;
let plane = Box(0.2, 0.2, 0.01);
vec![
(
"XY",
vec![e(plane, Invisible, Some([0.15, 0.15, 0.0]), None)],
),
(
"YZ",
vec![e(
plane,
Invisible,
Some([0.0, 0.15, 0.15]),
Some([0.0, HALF_PI, 0.0]),
)],
),
(
"XZ",
vec![e(
plane,
Invisible,
Some([0.15, 0.0, 0.15]),
Some([-HALF_PI, 0.0, 0.0]),
)],
),
]
}
fn picker_translate() -> GizmoMap {
let mut map = picker_arrows();
map.push((
"XYZ",
vec![e(Geo::Octahedron(0.2, 0), Slot::Invisible, None, None)],
));
map.extend(picker_planes());
map
}
fn helper_axes() -> GizmoMap {
let long = Some([1e6, 1.0, 1.0]);
vec![
("X", vec![h(Geo::Line, Some([-1e3, 0.0, 0.0]), None, long)]),
(
"Y",
vec![h(
Geo::Line,
Some([0.0, -1e3, 0.0]),
Some([0.0, 0.0, HALF_PI]),
long,
)],
),
(
"Z",
vec![h(
Geo::Line,
Some([0.0, 0.0, -1e3]),
Some([0.0, -HALF_PI, 0.0]),
long,
)],
),
]
}
fn helper_translate() -> GizmoMap {
let mut map: GizmoMap = vec![
("START", vec![h(Geo::Octahedron(0.01, 2), None, None, None)]),
("END", vec![h(Geo::Octahedron(0.01, 2), None, None, None)]),
("DELTA", vec![h(Geo::TranslateHelper, None, None, None)]),
];
map.extend(helper_axes());
map
}
fn gizmo_rotate() -> GizmoMap {
use Geo::*;
use Slot::*;
vec![
(
"XYZE",
vec![e(Circle(0.5, 1.0), Gray, None, Some([0.0, HALF_PI, 0.0]))],
),
("X", vec![e(Circle(0.5, 0.5), Red, None, None)]),
(
"Y",
vec![e(Circle(0.5, 0.5), Green, None, Some([0.0, 0.0, -HALF_PI]))],
),
(
"Z",
vec![e(Circle(0.5, 0.5), Blue, None, Some([0.0, HALF_PI, 0.0]))],
),
(
"E",
vec![e(
Circle(0.75, 1.0),
YellowTransparent,
None,
Some([0.0, HALF_PI, 0.0]),
)],
),
]
}
fn helper_rotate() -> GizmoMap {
vec![(
"AXIS",
vec![h(
Geo::Line,
Some([-1e3, 0.0, 0.0]),
None,
Some([1e6, 1.0, 1.0]),
)],
)]
}
fn picker_rotate() -> GizmoMap {
use Geo::*;
use Slot::*;
let ring = Torus(0.5, 0.1, 4, 24);
let origin = Some([0.0, 0.0, 0.0]);
vec![
("XYZE", vec![e(Sphere(0.25, 10, 8), Invisible, None, None)]),
(
"X",
vec![e(ring, Invisible, origin, Some([0.0, -HALF_PI, -HALF_PI]))],
),
(
"Y",
vec![e(ring, Invisible, origin, Some([HALF_PI, 0.0, 0.0]))],
),
(
"Z",
vec![e(ring, Invisible, origin, Some([0.0, 0.0, -HALF_PI]))],
),
("E", vec![e(Torus(0.75, 0.1, 2, 24), Invisible, None, None)]),
]
}
fn gizmo_scale() -> GizmoMap {
use Geo::*;
use Slot::*;
let origin = Some([0.0, 0.0, 0.0]);
vec![
(
"X",
vec![
e(
ScaleHandle,
Red,
Some([0.5, 0.0, 0.0]),
Some([0.0, 0.0, -HALF_PI]),
),
e(Line2, Red, origin, Some([0.0, 0.0, -HALF_PI])),
e(
ScaleHandle,
Red,
Some([-0.5, 0.0, 0.0]),
Some([0.0, 0.0, HALF_PI]),
),
],
),
(
"Y",
vec![
e(ScaleHandle, Green, Some([0.0, 0.5, 0.0]), None),
e(Line2, Green, None, None),
e(
ScaleHandle,
Green,
Some([0.0, -0.5, 0.0]),
Some([0.0, 0.0, PI]),
),
],
),
(
"Z",
vec![
e(
ScaleHandle,
Blue,
Some([0.0, 0.0, 0.5]),
Some([HALF_PI, 0.0, 0.0]),
),
e(Line2, Blue, origin, Some([HALF_PI, 0.0, 0.0])),
e(
ScaleHandle,
Blue,
Some([0.0, 0.0, -0.5]),
Some([-HALF_PI, 0.0, 0.0]),
),
],
),
(
"XY",
vec![e(
Box(0.15, 0.15, 0.01),
BlueTransparent,
Some([0.15, 0.15, 0.0]),
None,
)],
),
(
"YZ",
vec![e(
Box(0.15, 0.15, 0.01),
RedTransparent,
Some([0.0, 0.15, 0.15]),
Some([0.0, HALF_PI, 0.0]),
)],
),
(
"XZ",
vec![e(
Box(0.15, 0.15, 0.01),
GreenTransparent,
Some([0.15, 0.0, 0.15]),
Some([-HALF_PI, 0.0, 0.0]),
)],
),
(
"XYZ",
vec![e(Box(0.1, 0.1, 0.1), WhiteTransparent, None, None)],
),
]
}
fn picker_scale() -> GizmoMap {
let mut map = picker_arrows();
map.extend(picker_planes());
map.push((
"XYZ",
vec![e(
Geo::Box(0.2, 0.2, 0.2),
Slot::Invisible,
Some([0.0, 0.0, 0.0]),
None,
)],
));
map
}
fn material(slot: Slot, palette: &Palette) -> MeshBasicNodeMaterial {
let mut m = if slot == Slot::Helper {
MeshBasicNodeMaterial::line(palette.color(slot))
} else {
let mut m = MeshBasicNodeMaterial::new();
m.color = palette.color(slot);
m
};
m.depth_test = false;
m.depth_write = false;
m.fog = false;
m.transparent = true;
m.opacity = slot.opacity();
m
}
fn setup_gizmo(map: GizmoMap, palette: &Palette) -> Group {
let node = Object3D::new_node();
let mut handles = Vec::new();
for (name, entries) in map {
for entry in entries.iter().rev() {
let position = entry.position.unwrap_or([0.0; 3]);
let mut quaternion = Quaternion::default();
if let Some([x, y, z]) = entry.rotation {
quaternion.set_from_euler(&Euler::new(x, y, z));
}
let scale = entry.scale.unwrap_or([1.0; 3]);
let mut matrix = Matrix4::identity();
matrix.compose(
&Vector3::new(position[0], position[1], position[2]),
&quaternion,
&Vector3::new(scale[0], scale[1], scale[2]),
);
let mut geometry = entry.geo.build();
geometry.apply_matrix4(&matrix);
let geometry = Rc::new(geometry);
let material = material(entry.slot, palette);
let child = if entry.geo.is_line() {
Line::new(geometry, material)
} else {
Mesh::new(geometry, material)
};
{
let mut object = child.borrow_mut();
object.name = name.to_string();
object.render_order = f64::INFINITY;
}
node.add(&child);
handles.push(Handle {
node: child,
name,
helper: entry.helper,
slot: entry.slot,
});
}
}
Group { node, handles }
}
impl Gizmo {
fn new(palette: &Palette) -> Self {
let node = Object3D {
object_type: "TransformControlsGizmo",
..Default::default()
}
.into_node();
let gizmo = [
setup_gizmo(gizmo_translate(), palette),
setup_gizmo(gizmo_rotate(), palette),
setup_gizmo(gizmo_scale(), palette),
];
let picker = [
setup_gizmo(picker_translate(), palette),
setup_gizmo(picker_rotate(), palette),
setup_gizmo(picker_scale(), palette),
];
let helper = [
setup_gizmo(helper_translate(), palette),
setup_gizmo(helper_rotate(), palette),
setup_gizmo(helper_scale(), palette),
];
for group in gizmo.iter().chain(&picker).chain(&helper) {
node.add(&group.node);
}
for group in &picker {
group.node.borrow_mut().visible = false;
}
Self {
node,
gizmo,
picker,
helper,
}
}
}
fn helper_scale() -> GizmoMap {
helper_axes()
}
fn set_material(node: &ObjectRef, color: Color, opacity: Option<f64>) {
let mut object = node.borrow_mut();
let material = match &mut object.payload {
Payload::Mesh(mesh) => mesh.material.as_mut(),
Payload::Line(line) => line.material.as_mut(),
_ => None,
};
if let Some(material) = material {
material.color = color;
if let Some(opacity) = opacity {
material.opacity = opacity;
}
}
}
fn intersect_object_with_ray(
object: &ObjectRef,
raycaster: &Raycaster,
include_invisible: bool,
) -> Option<crate::core::Intersection> {
raycaster
.intersect_object(object, true)
.into_iter()
.find(|hit| include_invisible || hit.object.borrow().visible)
}
fn is_within(node: &ObjectRef, ancestor: &ObjectRef) -> bool {
let mut current = Some(node.clone());
while let Some(n) = current {
if ObjectRef::ptr_eq(&n, ancestor) {
return true;
}
current = n.parent();
}
false
}
fn set_property<T: PartialEq>(
slot: &mut T,
value: T,
name: &'static str,
events: &mut Vec<TransformControlsEvent>,
) {
if *slot != value {
*slot = value;
events.push(TransformControlsEvent::PropertyChanged(name));
events.push(TransformControlsEvent::Change);
}
}
#[derive(Debug)]
pub struct TransformControls {
pub enabled: bool,
pub show_x: bool,
pub show_y: bool,
pub show_z: bool,
pub show_xy: bool,
pub show_yz: bool,
pub show_xz: bool,
pub show_xyze: bool,
pub show_e: bool,
pub min_x: f64,
pub max_x: f64,
pub min_y: f64,
pub max_y: f64,
pub min_z: f64,
pub max_z: f64,
pub viewport: Option<Vector4>,
pub pointer_locked: bool,
object: Option<ObjectRef>,
axis: Option<Axis>,
mode: Mode,
translation_snap: Option<f64>,
rotation_snap: Option<f64>,
scale_snap: Option<f64>,
space: Space,
size: f64,
dragging: bool,
world_position: Vector3,
world_position_start: Vector3,
world_quaternion: Quaternion,
world_quaternion_start: Quaternion,
camera_position: Vector3,
camera_quaternion: Quaternion,
point_start: Vector3,
point_end: Vector3,
rotation_axis: Vector3,
rotation_angle: f64,
eye: Vector3,
offset: Vector3,
start_norm: Vector3,
end_norm: Vector3,
camera_scale: Vector3,
parent_position: Vector3,
parent_quaternion: Quaternion,
parent_quaternion_inv: Quaternion,
parent_scale: Vector3,
world_scale_start: Vector3,
world_quaternion_inv: Quaternion,
world_scale: Vector3,
position_start: Vector3,
quaternion_start: Quaternion,
scale_start: Vector3,
dir_vector: Vector3,
raycaster: Raycaster,
root: ObjectRef,
gizmo: Gizmo,
plane: ObjectRef,
palette: Palette,
element_width: f64,
element_height: f64,
moving: bool,
}
impl Default for TransformControls {
fn default() -> Self {
Self::new()
}
}
impl TransformControls {
pub fn new() -> Self {
let palette = Palette::default();
let root = Object3D {
visible: false,
..Default::default()
}
.into_node();
let gizmo = Gizmo::new(&palette);
root.add(&gizmo.node);
let mut plane_material = MeshBasicNodeMaterial::new();
plane_material.visible = false;
plane_material.wireframe = true;
plane_material.side = Side::Double;
plane_material.transparent = true;
plane_material.opacity = 0.1;
let plane = Mesh::new(
Rc::new(plane_geometry(100000.0, 100000.0, 2, 2)),
plane_material,
);
plane.borrow_mut().object_type = "TransformControlsPlane";
root.add(&plane);
Self {
enabled: true,
show_x: true,
show_y: true,
show_z: true,
show_xy: true,
show_yz: true,
show_xz: true,
show_xyze: true,
show_e: true,
min_x: f64::NEG_INFINITY,
max_x: f64::INFINITY,
min_y: f64::NEG_INFINITY,
max_y: f64::INFINITY,
min_z: f64::NEG_INFINITY,
max_z: f64::INFINITY,
viewport: None,
pointer_locked: false,
object: None,
axis: None,
mode: Mode::Translate,
translation_snap: None,
rotation_snap: None,
scale_snap: None,
space: Space::World,
size: 1.0,
dragging: false,
world_position: Vector3::ZERO,
world_position_start: Vector3::ZERO,
world_quaternion: Quaternion::default(),
world_quaternion_start: Quaternion::default(),
camera_position: Vector3::ZERO,
camera_quaternion: Quaternion::default(),
point_start: Vector3::ZERO,
point_end: Vector3::ZERO,
rotation_axis: Vector3::ZERO,
rotation_angle: 0.0,
eye: Vector3::ZERO,
offset: Vector3::ZERO,
start_norm: Vector3::ZERO,
end_norm: Vector3::ZERO,
camera_scale: Vector3::ZERO,
parent_position: Vector3::ZERO,
parent_quaternion: Quaternion::default(),
parent_quaternion_inv: Quaternion::default(),
parent_scale: Vector3::ZERO,
world_scale_start: Vector3::ZERO,
world_quaternion_inv: Quaternion::default(),
world_scale: Vector3::ZERO,
position_start: Vector3::ZERO,
quaternion_start: Quaternion::default(),
scale_start: Vector3::ZERO,
dir_vector: Vector3::ZERO,
raycaster: Raycaster::default(),
root,
gizmo,
plane,
palette,
element_width: 0.0,
element_height: 0.0,
moving: false,
}
}
pub fn set_element_size(&mut self, width: f64, height: f64) {
self.element_width = width;
self.element_height = height;
}
pub fn get_helper(&self) -> &ObjectRef {
&self.root
}
pub fn get_raycaster(&mut self) -> &mut Raycaster {
&mut self.raycaster
}
#[doc(hidden)]
pub fn handle_tag(&self, node: &ObjectRef) -> Option<Option<&'static str>> {
let gizmo = &self.gizmo;
gizmo
.gizmo
.iter()
.chain(&gizmo.picker)
.chain(&gizmo.helper)
.flat_map(|group| &group.handles)
.find(|handle| ObjectRef::ptr_eq(&handle.node, node))
.map(|handle| handle.helper.then_some("helper"))
}
pub fn object(&self) -> Option<&ObjectRef> {
self.object.as_ref()
}
pub fn axis(&self) -> Option<Axis> {
self.axis
}
pub fn get_mode(&self) -> Mode {
self.mode
}
pub fn space(&self) -> Space {
self.space
}
pub fn size(&self) -> f64 {
self.size
}
pub fn dragging(&self) -> bool {
self.dragging
}
pub fn translation_snap(&self) -> Option<f64> {
self.translation_snap
}
pub fn rotation_snap(&self) -> Option<f64> {
self.rotation_snap
}
pub fn scale_snap(&self) -> Option<f64> {
self.scale_snap
}
pub fn world_position(&self) -> Vector3 {
self.world_position
}
pub fn world_position_start(&self) -> Vector3 {
self.world_position_start
}
pub fn world_quaternion(&self) -> Quaternion {
self.world_quaternion
}
pub fn world_quaternion_start(&self) -> Quaternion {
self.world_quaternion_start
}
pub fn camera_position(&self) -> Vector3 {
self.camera_position
}
pub fn camera_quaternion(&self) -> Quaternion {
self.camera_quaternion
}
pub fn point_start(&self) -> Vector3 {
self.point_start
}
pub fn point_end(&self) -> Vector3 {
self.point_end
}
pub fn rotation_axis(&self) -> Vector3 {
self.rotation_axis
}
pub fn rotation_angle(&self) -> f64 {
self.rotation_angle
}
pub fn eye(&self) -> Vector3 {
self.eye
}
pub fn attach(&mut self, object: &ObjectRef) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
let same = self
.object
.as_ref()
.is_some_and(|o| ObjectRef::ptr_eq(o, object));
if !same {
self.object = Some(object.clone());
events.push(TransformControlsEvent::PropertyChanged("object"));
events.push(TransformControlsEvent::Change);
}
self.root.borrow_mut().visible = true;
events
}
pub fn detach(&mut self) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
if self.object.take().is_some() {
events.push(TransformControlsEvent::PropertyChanged("object"));
events.push(TransformControlsEvent::Change);
}
set_property(&mut self.axis, None, "axis", &mut events);
self.root.borrow_mut().visible = false;
events
}
pub fn reset(&mut self) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
if !self.enabled || !self.dragging {
return events;
}
let Some(object) = &self.object else {
return events;
};
{
let mut o = object.borrow_mut();
o.position = self.position_start;
o.quaternion = self.quaternion_start;
o.sync_rotation_from_quaternion();
o.scale = self.scale_start;
}
events.push(TransformControlsEvent::Change);
events.push(TransformControlsEvent::ObjectChange);
self.point_start = self.point_end;
events
}
pub fn set_mode(&mut self, mode: Mode) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
set_property(&mut self.mode, mode, "mode", &mut events);
events
}
pub fn set_translation_snap(&mut self, snap: Option<f64>) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
set_property(
&mut self.translation_snap,
snap,
"translationSnap",
&mut events,
);
events
}
pub fn set_rotation_snap(&mut self, snap: Option<f64>) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
set_property(&mut self.rotation_snap, snap, "rotationSnap", &mut events);
events
}
pub fn set_scale_snap(&mut self, snap: Option<f64>) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
set_property(&mut self.scale_snap, snap, "scaleSnap", &mut events);
events
}
pub fn set_size(&mut self, size: f64) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
set_property(&mut self.size, size, "size", &mut events);
events
}
pub fn set_space(&mut self, space: Space) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
set_property(&mut self.space, space, "space", &mut events);
events
}
pub fn set_colors(&mut self, x_axis: Color, y_axis: Color, z_axis: Color, active: Color) {
self.palette = Palette {
x_axis,
y_axis,
z_axis,
active,
};
let gizmo = &self.gizmo;
for group in gizmo.gizmo.iter().chain(&gizmo.picker).chain(&gizmo.helper) {
for handle in &group.handles {
if matches!(
handle.slot,
Slot::Red
| Slot::Green
| Slot::Blue
| Slot::RedTransparent
| Slot::GreenTransparent
| Slot::BlueTransparent
| Slot::YellowTransparent
) {
set_material(&handle.node, self.palette.color(handle.slot), None);
}
}
}
}
fn get_pointer(&self, event: &TransformPointerEvent) -> Pointer {
if self.pointer_locked {
return Pointer {
x: 0.0,
y: 0.0,
button: event.button,
};
}
let (origin_x, origin_y, region_width, region_height) = match self.viewport {
Some(viewport) => (
viewport.x,
self.element_height - viewport.y - viewport.w,
viewport.z,
viewport.w,
),
None => (0.0, 0.0, self.element_width, self.element_height),
};
Pointer {
x: (event.x - origin_x) / region_width * 2.0 - 1.0,
y: -(event.y - origin_y) / region_height * 2.0 + 1.0,
button: event.button,
}
}
pub fn on_pointer_down(
&mut self,
event: &TransformPointerEvent,
camera: &mut impl TransformCamera,
) -> Vec<TransformControlsEvent> {
if !self.enabled {
return Vec::new();
}
self.moving = true;
let pointer = self.get_pointer(event);
let mut events = self.pointer_hover(Some(&pointer), camera);
events.extend(self.pointer_down(Some(&pointer), camera));
events
}
pub fn on_pointer_move(
&mut self,
event: &TransformPointerEvent,
camera: &mut impl TransformCamera,
) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
if !self.enabled {
return events;
}
if matches!(event.pointer_type, PointerType::Mouse | PointerType::Pen) {
let pointer = self.get_pointer(event);
events.extend(self.pointer_hover(Some(&pointer), camera));
}
if self.moving && self.enabled {
let pointer = self.get_pointer(event);
events.extend(self.pointer_move(Some(&pointer), camera));
}
events
}
pub fn disconnect(&mut self) {
self.moving = false;
}
pub fn on_pointer_up(&mut self, event: &TransformPointerEvent) -> Vec<TransformControlsEvent> {
if !self.enabled {
return Vec::new();
}
self.moving = false;
let pointer = self.get_pointer(event);
self.pointer_up(Some(&pointer))
}
pub fn pointer_hover(
&mut self,
pointer: Option<&Pointer>,
camera: &impl TransformCamera,
) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
if self.object.is_none() || self.dragging {
return events;
}
if let Some(pointer) = pointer {
self.raycaster
.set_from_camera(&Vector2::new(pointer.x, pointer.y), camera);
}
let picker = &self.gizmo.picker[self.mode.index()].node;
let axis = intersect_object_with_ray(picker, &self.raycaster, false)
.and_then(|hit| Axis::from_name(&hit.object.borrow().name));
set_property(&mut self.axis, axis, "axis", &mut events);
events
}
pub fn pointer_down(
&mut self,
pointer: Option<&Pointer>,
camera: &mut impl TransformCamera,
) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
let Some(object) = self.object.clone() else {
return events;
};
if self.dragging || pointer.is_some_and(|p| p.button != 0) {
return events;
}
if self.axis.is_none() {
return events;
}
if let Some(pointer) = pointer {
self.raycaster
.set_from_camera(&Vector2::new(pointer.x, pointer.y), &*camera);
}
if let Some(hit) = intersect_object_with_ray(&self.plane, &self.raycaster, true) {
object.update_matrix_world(false);
if let Some(parent) = object.parent() {
parent.update_matrix_world(false);
if is_within(&self.root, &parent) {
self.update(camera);
}
}
{
let o = object.borrow();
self.position_start = o.position;
self.quaternion_start = o.quaternion;
self.scale_start = o.scale;
o.matrix_world.decompose(
&mut self.world_position_start,
&mut self.world_quaternion_start,
&mut self.world_scale_start,
);
}
self.point_start = hit.point;
self.point_start.sub(&self.world_position_start);
}
set_property(&mut self.dragging, true, "dragging", &mut events);
events.push(TransformControlsEvent::MouseDown(self.mode));
events
}
pub fn pointer_move(
&mut self,
pointer: Option<&Pointer>,
camera: &impl TransformCamera,
) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
let mode = self.mode;
let mut space = self.space;
if mode == Mode::Scale {
space = Space::Local;
} else if matches!(self.axis, Some(Axis::E | Axis::XYZE | Axis::XYZ)) {
space = Space::World;
}
let (Some(object), Some(axis)) = (self.object.clone(), self.axis) else {
return events;
};
if !self.dragging || pointer.is_some_and(|p| p.button != -1) {
return events;
}
if let Some(pointer) = pointer {
self.raycaster
.set_from_camera(&Vector2::new(pointer.x, pointer.y), camera);
}
let Some(hit) = intersect_object_with_ray(&self.plane, &self.raycaster, true) else {
return events;
};
self.point_end = hit.point;
self.point_end.sub(&self.world_position_start);
match mode {
Mode::Translate => self.translate(&object, axis, space),
Mode::Scale => self.scale(&object, axis),
Mode::Rotate => self.rotate(&object, axis, space, camera, &mut events),
}
events.push(TransformControlsEvent::Change);
events.push(TransformControlsEvent::ObjectChange);
events
}
fn translate(&mut self, object: &ObjectRef, axis: Axis, space: Space) {
self.offset = self.point_end;
self.offset.sub(&self.point_start);
if space == Space::Local && axis != Axis::XYZ {
self.offset.apply_quaternion(&self.world_quaternion_inv);
}
if !axis.has("X") {
self.offset.x = 0.0;
}
if !axis.has("Y") {
self.offset.y = 0.0;
}
if !axis.has("Z") {
self.offset.z = 0.0;
}
if space == Space::Local && axis != Axis::XYZ {
self.offset.apply_quaternion(&self.quaternion_start);
} else {
self.offset.apply_quaternion(&self.parent_quaternion_inv);
}
self.offset.divide(&self.parent_scale);
{
let mut o = object.borrow_mut();
o.position = self.offset;
o.position.add(&self.position_start);
}
if let Some(snap) = snap_on(self.translation_snap) {
if space == Space::Local {
let mut inverse = self.quaternion_start;
inverse.invert();
let mut o = object.borrow_mut();
o.position.apply_quaternion(&inverse);
if axis.has("X") {
o.position.x = js_round(o.position.x / snap) * snap;
}
if axis.has("Y") {
o.position.y = js_round(o.position.y / snap) * snap;
}
if axis.has("Z") {
o.position.z = js_round(o.position.z / snap) * snap;
}
o.position.apply_quaternion(&self.quaternion_start);
}
if space == Space::World {
let mut world = object.get_world_position();
if axis.has("X") {
world.x = js_round(world.x / snap) * snap;
}
if axis.has("Y") {
world.y = js_round(world.y / snap) * snap;
}
if axis.has("Z") {
world.z = js_round(world.z / snap) * snap;
}
if let Some(parent) = object.parent() {
parent.world_to_local(&mut world);
}
object.borrow_mut().position = world;
}
}
let mut o = object.borrow_mut();
o.position.x = js_max(self.min_x, js_min(self.max_x, o.position.x));
o.position.y = js_max(self.min_y, js_min(self.max_y, o.position.y));
o.position.z = js_max(self.min_z, js_min(self.max_z, o.position.z));
}
fn scale(&mut self, object: &ObjectRef, axis: Axis) {
let mut factor;
if axis.has("XYZ") {
let mut d = self.point_end.length() / self.point_start.length();
if self.point_end.dot(&self.point_start) < 0.0 {
d *= -1.0;
}
factor = Vector3::new(d, d, d);
} else {
let mut start = self.point_start;
factor = self.point_end;
start.apply_quaternion(&self.world_quaternion_inv);
factor.apply_quaternion(&self.world_quaternion_inv);
factor.divide(&start);
if !axis.has("X") {
factor.x = 1.0;
}
if !axis.has("Y") {
factor.y = 1.0;
}
if !axis.has("Z") {
factor.z = 1.0;
}
}
let mut o = object.borrow_mut();
o.scale = self.scale_start;
o.scale.multiply(&factor);
if let Some(snap) = snap_on(self.scale_snap) {
if axis.has("X") {
o.scale.x = or_number(js_round(o.scale.x / snap) * snap, snap);
}
if axis.has("Y") {
o.scale.y = or_number(js_round(o.scale.y / snap) * snap, snap);
}
if axis.has("Z") {
o.scale.z = or_number(js_round(o.scale.z / snap) * snap, snap);
}
}
}
fn rotate(
&mut self,
object: &ObjectRef,
axis: Axis,
space: Space,
camera: &impl TransformCamera,
events: &mut Vec<TransformControlsEvent>,
) {
self.offset = self.point_end;
self.offset.sub(&self.point_start);
let mut camera_position = Vector3::ZERO;
camera_position.set_from_matrix_position(&camera.matrix_world());
let rotation_speed = 20.0 / self.world_position.distance_to(&camera_position);
let mut in_plane_rotation = false;
if axis == Axis::XYZE {
self.rotation_axis = self.offset;
self.rotation_axis.cross(&self.eye).normalize();
let mut v = self.rotation_axis;
v.cross(&self.eye);
let angle = self.offset.dot(&v) * rotation_speed;
set_property(&mut self.rotation_angle, angle, "rotationAngle", events);
} else if matches!(axis, Axis::X | Axis::Y | Axis::Z) {
let unit = match axis {
Axis::X => UNIT_X,
Axis::Y => UNIT_Y,
_ => UNIT_Z,
};
self.rotation_axis = unit;
let mut v = unit;
if space == Space::Local {
v.apply_quaternion(&self.world_quaternion);
}
v.cross(&self.eye);
if v.length() == 0.0 {
in_plane_rotation = true;
} else {
v.normalize();
let angle = self.offset.dot(&v) * rotation_speed;
set_property(&mut self.rotation_angle, angle, "rotationAngle", events);
}
}
if axis == Axis::E || in_plane_rotation {
self.rotation_axis = self.eye;
let angle = self.point_end.angle_to(&self.point_start);
set_property(&mut self.rotation_angle, angle, "rotationAngle", events);
self.start_norm = self.point_start;
self.start_norm.normalize();
self.end_norm = self.point_end;
self.end_norm.normalize();
self.end_norm.cross(&self.start_norm);
let sign = if self.end_norm.dot(&self.eye) < 0.0 {
1.0
} else {
-1.0
};
let angle = self.rotation_angle * sign;
set_property(&mut self.rotation_angle, angle, "rotationAngle", events);
}
if let Some(snap) = snap_on(self.rotation_snap) {
let angle = js_round(self.rotation_angle / snap) * snap;
set_property(&mut self.rotation_angle, angle, "rotationAngle", events);
}
let mut q = Quaternion::default();
if space == Space::Local && axis != Axis::E && axis != Axis::XYZE {
q.set_from_axis_angle(&self.rotation_axis, self.rotation_angle);
let mut o = object.borrow_mut();
o.quaternion = self.quaternion_start;
o.quaternion.multiply(&q).normalize();
o.sync_rotation_from_quaternion();
} else {
self.rotation_axis
.apply_quaternion(&self.parent_quaternion_inv);
q.set_from_axis_angle(&self.rotation_axis, self.rotation_angle);
let mut o = object.borrow_mut();
o.quaternion = q;
o.quaternion.multiply(&self.quaternion_start).normalize();
o.sync_rotation_from_quaternion();
}
}
pub fn pointer_up(&mut self, pointer: Option<&Pointer>) -> Vec<TransformControlsEvent> {
let mut events = Vec::new();
if pointer.is_some_and(|p| p.button != 0) {
return events;
}
if self.dragging && self.axis.is_some() {
events.push(TransformControlsEvent::MouseUp(self.mode));
}
set_property(&mut self.dragging, false, "dragging", &mut events);
set_property(&mut self.axis, None, "axis", &mut events);
events
}
pub fn update(&mut self, camera: &mut impl TransformCamera) {
if let Some(object) = &self.object {
object.update_matrix_world(false);
match object.parent() {
None => eprintln!(
"TransformControls: The attached 3D object must be a part of the scene graph."
),
Some(parent) => parent.borrow().matrix_world.decompose(
&mut self.parent_position,
&mut self.parent_quaternion,
&mut self.parent_scale,
),
}
object.borrow().matrix_world.decompose(
&mut self.world_position,
&mut self.world_quaternion,
&mut self.world_scale,
);
self.parent_quaternion_inv = self.parent_quaternion;
self.parent_quaternion_inv.invert();
self.world_quaternion_inv = self.world_quaternion;
self.world_quaternion_inv.invert();
}
camera.update_matrix_world();
camera.matrix_world().decompose(
&mut self.camera_position,
&mut self.camera_quaternion,
&mut self.camera_scale,
);
if camera.is_orthographic_camera() {
let e = camera.matrix_world().elements;
self.eye = Vector3::new(-e[8], -e[9], -e[10]);
self.eye.normalize().negate();
} else {
self.eye = self.camera_position;
self.eye.sub(&self.world_position).normalize();
}
if let Some(parent) = self.root.parent() {
let mut m = parent.borrow().matrix_world;
m.invert();
let mut root = self.root.borrow_mut();
let root = &mut *root;
m.decompose(&mut root.position, &mut root.quaternion, &mut root.scale);
root.sync_rotation_from_quaternion();
}
let factor = camera.gizmo_factor(self.world_position.distance_to(&self.camera_position));
self.update_gizmo(factor);
self.update_plane();
self.root.update_matrix_world(false);
}
fn update_gizmo(&self, factor: f64) {
let mode = self.mode;
let space = if mode == Mode::Scale {
Space::Local
} else {
self.space
};
let quaternion = if space == Space::Local {
self.world_quaternion
} else {
Quaternion::default()
};
let gizmo = &self.gizmo;
for m in [Mode::Translate, Mode::Rotate, Mode::Scale] {
gizmo.gizmo[m.index()].node.borrow_mut().visible = mode == m;
gizmo.helper[m.index()].node.borrow_mut().visible = mode == m;
}
let i = mode.index();
let handles = gizmo.picker[i]
.handles
.iter()
.chain(&gizmo.gizmo[i].handles)
.chain(&gizmo.helper[i].handles);
let axis = self.axis.map(Axis::as_str);
let handle_scale = factor * self.size / 4.0;
for handle in handles {
let name = handle.name;
let mut h = handle.node.borrow_mut();
h.visible = true;
h.set_rotation(0.0, 0.0, 0.0);
h.position = self.world_position;
h.scale = Vector3::new(1.0, 1.0, 1.0);
h.scale.multiply_scalar(handle_scale);
if handle.helper {
h.visible = false;
if name == "AXIS" {
h.visible = axis.is_some();
let aligned = |unit: Vector3, euler: Euler, h: &mut Object3D| {
let mut q = Quaternion::default();
q.set_from_euler(&euler);
h.quaternion = quaternion;
h.quaternion.multiply(&q);
let mut align = unit;
align.apply_quaternion(&quaternion);
if align.dot(&self.eye).abs() > 0.9 {
h.visible = false;
}
};
match axis {
Some("X") => aligned(UNIT_X, Euler::new(0.0, 0.0, 0.0), &mut h),
Some("Y") => aligned(UNIT_Y, Euler::new(0.0, 0.0, HALF_PI), &mut h),
Some("Z") => aligned(UNIT_Z, Euler::new(0.0, HALF_PI, 0.0), &mut h),
Some("XYZE") => {
let mut q = Quaternion::default();
q.set_from_euler(&Euler::new(0.0, HALF_PI, 0.0));
let mut look = Matrix4::identity();
look.look_at(&Vector3::ZERO, &self.rotation_axis, &UNIT_Y);
h.quaternion.set_from_rotation_matrix(&look);
h.quaternion.multiply(&q);
h.visible = self.dragging;
}
Some("E") => h.visible = false,
_ => {}
}
} else if name == "START" {
h.position = self.world_position_start;
h.visible = self.dragging;
} else if name == "END" {
h.position = self.world_position;
h.visible = self.dragging;
} else if name == "DELTA" {
h.position = self.world_position_start;
h.quaternion = self.world_quaternion_start;
let mut v = Vector3::new(1e-10, 1e-10, 1e-10);
v.add(&self.world_position_start)
.sub(&self.world_position)
.multiply_scalar(-1.0);
let mut inverse = self.world_quaternion_start;
inverse.invert();
v.apply_quaternion(&inverse);
h.scale = v;
h.visible = self.dragging;
} else {
h.quaternion = quaternion;
h.position = if self.dragging {
self.world_position_start
} else {
self.world_position
};
if let Some(axis) = axis {
h.visible = axis.contains(name);
}
}
h.sync_rotation_from_quaternion();
continue;
}
h.quaternion = quaternion;
if mode == Mode::Translate || mode == Mode::Scale {
const AXIS_HIDE_THRESHOLD: f64 = 0.99;
const PLANE_HIDE_THRESHOLD: f64 = 0.2;
let facing = |unit: Vector3| {
let mut align = unit;
align.apply_quaternion(&quaternion);
align.dot(&self.eye).abs()
};
let hide = match name {
"X" => facing(UNIT_X) > AXIS_HIDE_THRESHOLD,
"Y" => facing(UNIT_Y) > AXIS_HIDE_THRESHOLD,
"Z" => facing(UNIT_Z) > AXIS_HIDE_THRESHOLD,
"XY" => facing(UNIT_Z) < PLANE_HIDE_THRESHOLD,
"YZ" => facing(UNIT_X) < PLANE_HIDE_THRESHOLD,
"XZ" => facing(UNIT_Y) < PLANE_HIDE_THRESHOLD,
_ => false,
};
if hide {
h.scale = Vector3::new(1e-10, 1e-10, 1e-10);
h.visible = false;
}
} else if mode == Mode::Rotate {
let mut inverse = quaternion;
inverse.invert();
let mut align = self.eye;
align.apply_quaternion(&inverse);
if name.contains('E') {
let mut look = Matrix4::identity();
look.look_at(&self.eye, &Vector3::ZERO, &UNIT_Y);
h.quaternion.set_from_rotation_matrix(&look);
}
let turn = match name {
"X" => Some((UNIT_X, (-align.y).atan2(align.z))),
"Y" => Some((UNIT_Y, align.x.atan2(align.z))),
"Z" => Some((UNIT_Z, align.y.atan2(align.x))),
_ => None,
};
if let Some((unit, angle)) = turn {
let mut q = Quaternion::default();
q.set_from_axis_angle(&unit, angle);
let mut turned = Quaternion::default();
turned.multiply_quaternions(&quaternion, &q);
h.quaternion = turned;
}
}
h.sync_rotation_from_quaternion();
let has = |s: &str| name.contains(s);
h.visible = h.visible && (!has("X") || self.show_x);
h.visible = h.visible && (!has("Y") || self.show_y);
h.visible = h.visible && (!has("Z") || self.show_z);
h.visible = h.visible && (!has("E") || (self.show_x && self.show_y && self.show_z));
h.visible = h.visible && (!has("XY") || self.show_xy);
h.visible = h.visible && (!has("YZ") || self.show_yz);
h.visible = h.visible && (!has("XZ") || self.show_xz);
h.visible = h.visible && (name != "E" || self.show_e);
h.visible = h.visible && (name != "XYZE" || self.show_xyze);
drop(h);
let mut color = self.palette.color(handle.slot);
let mut opacity = handle.slot.opacity();
if let (true, Some(axis)) = (self.enabled, axis) {
let selected =
name == axis || axis.chars().any(|a| name.len() == 1 && name.starts_with(a));
if selected {
color = self.palette.active;
opacity = 1.0;
}
}
set_material(&handle.node, color, Some(opacity));
}
}
fn update_plane(&mut self) {
let mut space = self.space;
if self.mode == Mode::Scale {
space = Space::Local;
}
let quaternion = if space == Space::Local {
self.world_quaternion
} else {
Quaternion::default()
};
let mut v1 = UNIT_X;
v1.apply_quaternion(&quaternion);
let mut v2 = UNIT_Y;
v2.apply_quaternion(&quaternion);
let mut v3 = UNIT_Z;
v3.apply_quaternion(&quaternion);
let mut align = v2;
match self.mode {
Mode::Translate | Mode::Scale => match self.axis {
Some(Axis::X) => {
align = self.eye;
align.cross(&v1);
self.dir_vector = v1;
self.dir_vector.cross(&align);
}
Some(Axis::Y) => {
align = self.eye;
align.cross(&v2);
self.dir_vector = v2;
self.dir_vector.cross(&align);
}
Some(Axis::Z) => {
align = self.eye;
align.cross(&v3);
self.dir_vector = v3;
self.dir_vector.cross(&align);
}
Some(Axis::XY) => self.dir_vector = v3,
Some(Axis::YZ) => self.dir_vector = v1,
Some(Axis::XZ) => {
align = v3;
self.dir_vector = v2;
}
Some(Axis::XYZ | Axis::E) => self.dir_vector = Vector3::ZERO,
Some(Axis::XYZE) | None => {}
},
Mode::Rotate => self.dir_vector = Vector3::ZERO,
}
let mut plane = self.plane.borrow_mut();
plane.position = self.world_position;
if self.dir_vector.length() == 0.0 {
plane.quaternion = self.camera_quaternion;
} else {
let mut m = Matrix4::identity();
m.look_at(&Vector3::ZERO, &self.dir_vector, &align);
plane.quaternion.set_from_rotation_matrix(&m);
}
plane.sync_rotation_from_quaternion();
}
}