2021-06-18 15:45:37 +08:00
|
|
|
|
// The macros break if the references are taken out, for some reason.
|
|
|
|
|
#![allow(clippy::op_ref)]
|
|
|
|
|
|
2020-03-21 19:16:46 +08:00
|
|
|
|
use num::{One, Zero};
|
2018-02-02 19:26:35 +08:00
|
|
|
|
use std::ops::{Div, DivAssign, Mul, MulAssign};
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
2020-03-22 06:22:55 +08:00
|
|
|
|
use simba::scalar::{ClosedAdd, ClosedMul};
|
|
|
|
|
use simba::simd::SimdRealField;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
2021-04-12 16:32:17 +08:00
|
|
|
|
use crate::base::{SVector, Scalar};
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
2020-03-21 19:16:46 +08:00
|
|
|
|
use crate::geometry::{
|
2020-03-25 02:06:28 +08:00
|
|
|
|
AbstractRotation, Isometry, Point, Rotation, Similarity, Translation, UnitComplex,
|
|
|
|
|
UnitQuaternion,
|
2020-03-21 19:16:46 +08:00
|
|
|
|
};
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
2020-11-15 23:57:49 +08:00
|
|
|
|
// TODO: there are several cloning of rotations that we could probably get rid of (but we didn't
|
2016-12-05 05:44:42 +08:00
|
|
|
|
// yet because that would require to add a bound like `where for<'a, 'b> &'a R: Mul<&'b R, Output = R>`
|
|
|
|
|
// which is quite ugly.
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
*
|
|
|
|
|
* In this file, we provide:
|
|
|
|
|
* =========================
|
|
|
|
|
*
|
|
|
|
|
*
|
|
|
|
|
* (Operators)
|
|
|
|
|
*
|
2017-08-03 01:37:44 +08:00
|
|
|
|
* Similarity × Similarity
|
|
|
|
|
* Similarity × R
|
|
|
|
|
* Similarity × Isometry
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
2017-08-03 01:37:44 +08:00
|
|
|
|
* Isometry × Similarity
|
|
|
|
|
* Isometry ÷ Similarity
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
|
|
|
|
*
|
2017-08-03 01:37:44 +08:00
|
|
|
|
* Similarity ÷ Similarity
|
|
|
|
|
* Similarity ÷ R
|
|
|
|
|
* Similarity ÷ Isometry
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
2017-08-03 01:37:44 +08:00
|
|
|
|
* Similarity × Point
|
|
|
|
|
* Similarity × Vector
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
|
|
|
|
*
|
2017-08-03 01:37:44 +08:00
|
|
|
|
* Similarity × Translation
|
|
|
|
|
* Translation × Similarity
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
2017-08-03 01:37:44 +08:00
|
|
|
|
* NOTE: The following are provided explicitly because we can't have R × Similarity.
|
|
|
|
|
* Rotation × Similarity<Rotation>
|
|
|
|
|
* UnitQuaternion × Similarity<UnitQuaternion>
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
2017-08-03 01:37:44 +08:00
|
|
|
|
* Rotation ÷ Similarity<Rotation>
|
|
|
|
|
* UnitQuaternion ÷ Similarity<UnitQuaternion>
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
|
|
|
|
* (Assignment Operators)
|
|
|
|
|
*
|
2017-08-03 01:37:44 +08:00
|
|
|
|
* Similarity ×= Translation
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
2017-08-03 01:37:44 +08:00
|
|
|
|
* Similarity ×= Similarity
|
|
|
|
|
* Similarity ×= Isometry
|
|
|
|
|
* Similarity ×= R
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
2017-08-03 01:37:44 +08:00
|
|
|
|
* Similarity ÷= Similarity
|
|
|
|
|
* Similarity ÷= Isometry
|
|
|
|
|
* Similarity ÷= R
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
// XXX: code duplication: those macros are the same as for the isometry.
|
|
|
|
|
macro_rules! similarity_binop_impl(
|
|
|
|
|
($Op: ident, $op: ident;
|
|
|
|
|
$lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
|
|
|
|
|
$action: expr; $($lives: tt),*) => {
|
2021-04-11 17:00:38 +08:00
|
|
|
|
impl<$($lives ,)* T: SimdRealField, R, const D: usize> $Op<$Rhs> for $Lhs
|
|
|
|
|
where T::Element: SimdRealField,
|
|
|
|
|
R: AbstractRotation<T, D> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
type Output = $Output;
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
fn $op($lhs, $rhs: $Rhs) -> Self::Output {
|
|
|
|
|
$action
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
macro_rules! similarity_binop_impl_all(
|
|
|
|
|
($Op: ident, $op: ident;
|
|
|
|
|
$lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
|
|
|
|
|
[val val] => $action_val_val: expr;
|
|
|
|
|
[ref val] => $action_ref_val: expr;
|
|
|
|
|
[val ref] => $action_val_ref: expr;
|
|
|
|
|
[ref ref] => $action_ref_ref: expr;) => {
|
|
|
|
|
similarity_binop_impl!(
|
|
|
|
|
$Op, $op;
|
|
|
|
|
$lhs: $Lhs, $rhs: $Rhs, Output = $Output;
|
|
|
|
|
$action_val_val; );
|
|
|
|
|
|
|
|
|
|
similarity_binop_impl!(
|
|
|
|
|
$Op, $op;
|
|
|
|
|
$lhs: &'a $Lhs, $rhs: $Rhs, Output = $Output;
|
|
|
|
|
$action_ref_val; 'a);
|
|
|
|
|
|
|
|
|
|
similarity_binop_impl!(
|
|
|
|
|
$Op, $op;
|
|
|
|
|
$lhs: $Lhs, $rhs: &'b $Rhs, Output = $Output;
|
|
|
|
|
$action_val_ref; 'b);
|
|
|
|
|
|
|
|
|
|
similarity_binop_impl!(
|
|
|
|
|
$Op, $op;
|
|
|
|
|
$lhs: &'a $Lhs, $rhs: &'b $Rhs, Output = $Output;
|
|
|
|
|
$action_ref_ref; 'a, 'b);
|
|
|
|
|
}
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
macro_rules! similarity_binop_assign_impl_all(
|
|
|
|
|
($OpAssign: ident, $op_assign: ident;
|
|
|
|
|
$lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty;
|
|
|
|
|
[val] => $action_val: expr;
|
|
|
|
|
[ref] => $action_ref: expr;) => {
|
2021-04-11 17:00:38 +08:00
|
|
|
|
impl<T: SimdRealField, R, const D: usize> $OpAssign<$Rhs> for $Lhs
|
|
|
|
|
where T::Element: SimdRealField,
|
|
|
|
|
R: AbstractRotation<T, D>{
|
2016-12-05 05:44:42 +08:00
|
|
|
|
#[inline]
|
|
|
|
|
fn $op_assign(&mut $lhs, $rhs: $Rhs) {
|
|
|
|
|
$action_val
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
|
impl<'b, T: SimdRealField, R, const D: usize> $OpAssign<&'b $Rhs> for $Lhs
|
|
|
|
|
where T::Element: SimdRealField,
|
|
|
|
|
R: AbstractRotation<T, D> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
#[inline]
|
|
|
|
|
fn $op_assign(&mut $lhs, $rhs: &'b $Rhs) {
|
|
|
|
|
$action_ref
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Similarity × Similarity
|
|
|
|
|
// Similarity ÷ Similarity
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_binop_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, rhs: Similarity<T, R, D>, Output = Similarity<T, R, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val val] => &self * &rhs;
|
|
|
|
|
[ref val] => self * &rhs;
|
|
|
|
|
[val ref] => &self * rhs;
|
|
|
|
|
[ref ref] => {
|
|
|
|
|
let mut res = self * &rhs.isometry;
|
|
|
|
|
res.prepend_scaling_mut(rhs.scaling());
|
|
|
|
|
res
|
|
|
|
|
};
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
similarity_binop_impl_all!(
|
|
|
|
|
Div, div;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, rhs: Similarity<T, R, D>, Output = Similarity<T, R, D>;
|
2020-10-26 01:23:24 +08:00
|
|
|
|
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
|
|
|
|
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
|
|
|
|
[val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
|
|
|
|
[ref ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Similarity ×= Translation
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_binop_assign_impl_all!(
|
|
|
|
|
MulAssign, mul_assign;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, rhs: Translation<T, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val] => *self *= &rhs;
|
|
|
|
|
[ref] => {
|
|
|
|
|
let shift = self.isometry.rotation.transform_vector(&rhs.vector) * self.scaling();
|
|
|
|
|
self.isometry.translation.vector += shift;
|
|
|
|
|
};
|
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Similarity ×= Similarity
|
|
|
|
|
// Similarity ÷= Similarity
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_binop_assign_impl_all!(
|
|
|
|
|
MulAssign, mul_assign;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, rhs: Similarity<T, R, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val] => *self *= &rhs;
|
|
|
|
|
[ref] => {
|
|
|
|
|
*self *= &rhs.isometry;
|
|
|
|
|
self.prepend_scaling_mut(rhs.scaling());
|
|
|
|
|
};
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
similarity_binop_assign_impl_all!(
|
|
|
|
|
DivAssign, div_assign;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, rhs: Similarity<T, R, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val] => *self /= &rhs;
|
2020-11-15 23:57:49 +08:00
|
|
|
|
// TODO: don't invert explicitly.
|
2020-10-26 19:44:53 +08:00
|
|
|
|
[ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Similarity ×= Isometry
|
|
|
|
|
// Similarity ÷= Isometry
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_binop_assign_impl_all!(
|
|
|
|
|
MulAssign, mul_assign;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, rhs: Isometry<T, R, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val] => *self *= &rhs;
|
|
|
|
|
[ref] => {
|
|
|
|
|
let shift = self.isometry.rotation.transform_vector(&rhs.translation.vector) * self.scaling();
|
|
|
|
|
self.isometry.translation.vector += shift;
|
|
|
|
|
self.isometry.rotation *= rhs.rotation.clone();
|
|
|
|
|
};
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
similarity_binop_assign_impl_all!(
|
|
|
|
|
DivAssign, div_assign;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, rhs: Isometry<T, R, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val] => *self /= &rhs;
|
2020-11-15 23:57:49 +08:00
|
|
|
|
// TODO: don't invert explicitly.
|
2020-10-26 19:44:53 +08:00
|
|
|
|
[ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Similarity ×= R
|
|
|
|
|
// Similarity ÷= R
|
2020-03-21 19:16:46 +08:00
|
|
|
|
md_assign_impl_all!(
|
2021-04-11 17:00:38 +08:00
|
|
|
|
MulAssign, mul_assign where T: SimdRealField for T::Element: SimdRealField;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
(Const<D>, U1), (Const<D>, Const<D>)
|
|
|
|
|
const D; for; where;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, Rotation<T, D>, D>, rhs: Rotation<T, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val] => self.isometry.rotation *= rhs;
|
2021-08-04 23:34:25 +08:00
|
|
|
|
[ref] => self.isometry.rotation *= rhs.clone();
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2020-03-21 19:16:46 +08:00
|
|
|
|
md_assign_impl_all!(
|
2021-04-11 17:00:38 +08:00
|
|
|
|
DivAssign, div_assign where T: SimdRealField for T::Element: SimdRealField;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
(Const<D>, U1), (Const<D>, Const<D>)
|
|
|
|
|
const D; for; where;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, Rotation<T, D>, D>, rhs: Rotation<T, D>;
|
2020-11-15 23:57:49 +08:00
|
|
|
|
// TODO: don't invert explicitly?
|
2020-10-26 19:44:53 +08:00
|
|
|
|
[val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
|
|
|
|
|
[ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2020-03-21 19:16:46 +08:00
|
|
|
|
md_assign_impl_all!(
|
2021-04-11 17:00:38 +08:00
|
|
|
|
MulAssign, mul_assign where T: SimdRealField for T::Element: SimdRealField;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
(U3, U3), (U3, U3)
|
|
|
|
|
const; for; where;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>;
|
2020-03-21 19:16:46 +08:00
|
|
|
|
[val] => self.isometry.rotation *= rhs;
|
2021-08-04 23:34:25 +08:00
|
|
|
|
[ref] => self.isometry.rotation *= rhs.clone();
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2020-03-21 19:16:46 +08:00
|
|
|
|
md_assign_impl_all!(
|
2021-04-11 17:00:38 +08:00
|
|
|
|
DivAssign, div_assign where T: SimdRealField for T::Element: SimdRealField;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
(U3, U3), (U3, U3)
|
|
|
|
|
const; for; where;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>;
|
2020-11-15 23:57:49 +08:00
|
|
|
|
// TODO: don't invert explicitly?
|
2020-10-26 19:44:53 +08:00
|
|
|
|
[val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
|
|
|
|
|
[ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2020-03-25 02:06:28 +08:00
|
|
|
|
md_assign_impl_all!(
|
2021-04-11 17:00:38 +08:00
|
|
|
|
MulAssign, mul_assign where T: SimdRealField for T::Element: SimdRealField;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
(U2, U2), (U2, U2)
|
|
|
|
|
const; for; where;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>;
|
2020-03-25 02:06:28 +08:00
|
|
|
|
[val] => self.isometry.rotation *= rhs;
|
2021-08-04 23:34:25 +08:00
|
|
|
|
[ref] => self.isometry.rotation *= rhs.clone();
|
2020-03-25 02:06:28 +08:00
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
md_assign_impl_all!(
|
2021-04-11 17:00:38 +08:00
|
|
|
|
DivAssign, div_assign where T: SimdRealField for T::Element: SimdRealField;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
(U2, U2), (U2, U2)
|
|
|
|
|
const; for; where;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>;
|
2020-11-15 23:57:49 +08:00
|
|
|
|
// TODO: don't invert explicitly?
|
2020-10-26 19:44:53 +08:00
|
|
|
|
[val] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
|
|
|
|
|
[ref] => #[allow(clippy::suspicious_op_assign_impl)] { *self *= rhs.inverse() };
|
2020-03-25 02:06:28 +08:00
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Similarity × Isometry
|
|
|
|
|
// Similarity ÷ Isometry
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_binop_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, rhs: Isometry<T, R, D>, Output = Similarity<T, R, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val val] => &self * &rhs;
|
|
|
|
|
[ref val] => self * &rhs;
|
|
|
|
|
[val ref] => &self * rhs;
|
|
|
|
|
[ref ref] => {
|
|
|
|
|
let shift = self.isometry.rotation.transform_vector(&rhs.translation.vector) * self.scaling();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
Similarity::from_parts(
|
2020-10-26 01:23:24 +08:00
|
|
|
|
#[allow(clippy::suspicious_arithmetic_impl)]
|
2018-10-28 14:33:39 +08:00
|
|
|
|
Translation::from(&self.isometry.translation.vector + shift),
|
2016-12-05 05:44:42 +08:00
|
|
|
|
self.isometry.rotation.clone() * rhs.rotation.clone(),
|
|
|
|
|
self.scaling())
|
|
|
|
|
};
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
similarity_binop_impl_all!(
|
|
|
|
|
Div, div;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, rhs: Isometry<T, R, D>, Output = Similarity<T, R, D>;
|
2020-10-26 01:23:24 +08:00
|
|
|
|
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
|
|
|
|
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
|
|
|
|
[val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
|
|
|
|
[ref ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Isometry × Similarity
|
|
|
|
|
// Isometry ÷ Similarity
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_binop_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Isometry<T, R, D>, rhs: Similarity<T, R, D>, Output = Similarity<T, R, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val val] => {
|
|
|
|
|
let scaling = rhs.scaling();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
Similarity::from_isometry(self * rhs.isometry, scaling)
|
2016-12-05 05:44:42 +08:00
|
|
|
|
};
|
|
|
|
|
[ref val] => {
|
|
|
|
|
let scaling = rhs.scaling();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
Similarity::from_isometry(self * rhs.isometry, scaling)
|
2016-12-05 05:44:42 +08:00
|
|
|
|
};
|
|
|
|
|
[val ref] => {
|
|
|
|
|
let scaling = rhs.scaling();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
Similarity::from_isometry(self * &rhs.isometry, scaling)
|
2016-12-05 05:44:42 +08:00
|
|
|
|
};
|
|
|
|
|
[ref ref] => {
|
|
|
|
|
let scaling = rhs.scaling();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
Similarity::from_isometry(self * &rhs.isometry, scaling)
|
2016-12-05 05:44:42 +08:00
|
|
|
|
};
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
similarity_binop_impl_all!(
|
|
|
|
|
Div, div;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Isometry<T, R, D>, rhs: Similarity<T, R, D>, Output = Similarity<T, R, D>;
|
2020-10-26 01:23:24 +08:00
|
|
|
|
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
|
|
|
|
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
|
|
|
|
[val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
|
|
|
|
[ref ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * rhs.inverse() };
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Similarity × Point
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_binop_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, right: Point<T, D>, Output = Point<T, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val val] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
self.isometry.translation * (self.isometry.rotation.transform_point(&right) * scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref val] => &self.isometry.translation * (self.isometry.rotation.transform_point(&right) * self.scaling());
|
|
|
|
|
[val ref] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
self.isometry.translation * (self.isometry.rotation.transform_point(right) * scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref ref] => &self.isometry.translation * (self.isometry.rotation.transform_point(right) * self.scaling());
|
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Similarity × Vector
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_binop_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, right: SVector<T, D>, Output = SVector<T, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val val] => self.isometry.rotation.transform_vector(&right) * self.scaling();
|
|
|
|
|
[ref val] => self.isometry.rotation.transform_vector(&right) * self.scaling();
|
|
|
|
|
[val ref] => self.isometry.rotation.transform_vector(right) * self.scaling();
|
|
|
|
|
[ref ref] => self.isometry.rotation.transform_vector(right) * self.scaling();
|
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Similarity × Translation
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_binop_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, R, D>, right: Translation<T, D>, Output = Similarity<T, R, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val val] => &self * &right;
|
|
|
|
|
[ref val] => self * &right;
|
|
|
|
|
[val ref] => &self * right;
|
|
|
|
|
[ref ref] => {
|
|
|
|
|
let shift = self.isometry.rotation.transform_vector(&right.vector) * self.scaling();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
Similarity::from_parts(
|
2020-10-26 01:23:24 +08:00
|
|
|
|
#[allow(clippy::suspicious_arithmetic_impl)]
|
2018-10-28 14:33:39 +08:00
|
|
|
|
Translation::from(&self.isometry.translation.vector + shift),
|
2016-12-05 05:44:42 +08:00
|
|
|
|
self.isometry.rotation.clone(),
|
|
|
|
|
self.scaling())
|
|
|
|
|
};
|
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Translation × Similarity
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_binop_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Translation<T, D>, right: Similarity<T, R, D>, Output = Similarity<T, R, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val val] => {
|
|
|
|
|
let scaling = right.scaling();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
Similarity::from_isometry(self * right.isometry, scaling)
|
2016-12-05 05:44:42 +08:00
|
|
|
|
};
|
|
|
|
|
[ref val] => {
|
|
|
|
|
let scaling = right.scaling();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
Similarity::from_isometry(self * right.isometry, scaling)
|
2016-12-05 05:44:42 +08:00
|
|
|
|
};
|
2017-08-03 01:37:44 +08:00
|
|
|
|
[val ref] => Similarity::from_isometry(self * &right.isometry, right.scaling());
|
|
|
|
|
[ref ref] => Similarity::from_isometry(self * &right.isometry, right.scaling());
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
macro_rules! similarity_from_composition_impl(
|
|
|
|
|
($Op: ident, $op: ident;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
$($Dims: ident),*;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
$lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
|
|
|
|
|
$action: expr; $($lives: tt),*) => {
|
2021-04-11 17:00:38 +08:00
|
|
|
|
impl<$($lives ,)* T: SimdRealField $(, const $Dims: usize)*> $Op<$Rhs> for $Lhs
|
|
|
|
|
where T::Element: SimdRealField {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
type Output = $Output;
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
fn $op($lhs, $rhs: $Rhs) -> Self::Output {
|
|
|
|
|
$action
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
macro_rules! similarity_from_composition_impl_all(
|
|
|
|
|
($Op: ident, $op: ident;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
$($Dims: ident),*;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
$lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
|
|
|
|
|
[val val] => $action_val_val: expr;
|
|
|
|
|
[ref val] => $action_ref_val: expr;
|
|
|
|
|
[val ref] => $action_val_ref: expr;
|
|
|
|
|
[ref ref] => $action_ref_ref: expr;) => {
|
|
|
|
|
|
|
|
|
|
similarity_from_composition_impl!(
|
|
|
|
|
$Op, $op;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
$($Dims),*;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
$lhs: $Lhs, $rhs: $Rhs, Output = $Output;
|
|
|
|
|
$action_val_val; );
|
|
|
|
|
|
|
|
|
|
similarity_from_composition_impl!(
|
|
|
|
|
$Op, $op;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
$($Dims),*;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
$lhs: &'a $Lhs, $rhs: $Rhs, Output = $Output;
|
|
|
|
|
$action_ref_val; 'a);
|
|
|
|
|
|
|
|
|
|
similarity_from_composition_impl!(
|
|
|
|
|
$Op, $op;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
$($Dims),*;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
$lhs: $Lhs, $rhs: &'b $Rhs, Output = $Output;
|
|
|
|
|
$action_val_ref; 'b);
|
|
|
|
|
|
|
|
|
|
similarity_from_composition_impl!(
|
|
|
|
|
$Op, $op;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
$($Dims),*;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
$lhs: &'a $Lhs, $rhs: &'b $Rhs, Output = $Output;
|
|
|
|
|
$action_ref_ref; 'a, 'b);
|
|
|
|
|
}
|
|
|
|
|
);
|
|
|
|
|
|
2020-03-21 19:16:46 +08:00
|
|
|
|
// Similarity × Rotation
|
|
|
|
|
similarity_from_composition_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
D;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, Rotation<T, D>, D>, rhs: Rotation<T, D>,
|
|
|
|
|
Output = Similarity<T, Rotation<T, D>, D>;
|
2020-03-21 19:16:46 +08:00
|
|
|
|
[val val] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry * rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref val] => Similarity::from_isometry(&self.isometry * rhs, self.scaling());
|
|
|
|
|
[val ref] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry * rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref ref] => Similarity::from_isometry(&self.isometry * rhs, self.scaling());
|
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Rotation × Similarity
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_from_composition_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
D;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Rotation<T, D>, right: Similarity<T, Rotation<T, D>, D>,
|
|
|
|
|
Output = Similarity<T, Rotation<T, D>, D>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val val] => &self * &right;
|
|
|
|
|
[ref val] => self * &right;
|
|
|
|
|
[val ref] => &self * right;
|
2017-08-03 01:37:44 +08:00
|
|
|
|
[ref ref] => Similarity::from_isometry(self * &right.isometry, right.scaling());
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2020-03-21 19:16:46 +08:00
|
|
|
|
// Similarity ÷ Rotation
|
|
|
|
|
similarity_from_composition_impl_all!(
|
|
|
|
|
Div, div;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
D;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, Rotation<T, D>, D>, rhs: Rotation<T, D>,
|
|
|
|
|
Output = Similarity<T, Rotation<T, D>, D>;
|
2020-03-21 19:16:46 +08:00
|
|
|
|
[val val] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry / rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref val] => Similarity::from_isometry(&self.isometry / rhs, self.scaling());
|
|
|
|
|
[val ref] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry / rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref ref] => Similarity::from_isometry(&self.isometry / rhs, self.scaling());
|
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// Rotation ÷ Similarity
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_from_composition_impl_all!(
|
|
|
|
|
Div, div;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
D;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Rotation<T, D>, right: Similarity<T, Rotation<T, D>, D>,
|
|
|
|
|
Output = Similarity<T, Rotation<T, D>, D>;
|
2020-11-15 23:57:49 +08:00
|
|
|
|
// TODO: don't call inverse explicitly?
|
2020-10-26 01:23:24 +08:00
|
|
|
|
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
|
|
|
|
|
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
|
|
|
|
|
[val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
|
|
|
|
|
[ref ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2020-03-21 19:16:46 +08:00
|
|
|
|
// Similarity × UnitQuaternion
|
|
|
|
|
similarity_from_composition_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>,
|
|
|
|
|
Output = Similarity<T, UnitQuaternion<T>, 3>;
|
2020-03-21 19:16:46 +08:00
|
|
|
|
[val val] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry * rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref val] => Similarity::from_isometry(&self.isometry * rhs, self.scaling());
|
|
|
|
|
[val ref] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry * rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref ref] => Similarity::from_isometry(&self.isometry * rhs, self.scaling());
|
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// UnitQuaternion × Similarity
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_from_composition_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: UnitQuaternion<T>, right: Similarity<T, UnitQuaternion<T>, 3>,
|
|
|
|
|
Output = Similarity<T, UnitQuaternion<T>, 3>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
[val val] => &self * &right;
|
|
|
|
|
[ref val] => self * &right;
|
|
|
|
|
[val ref] => &self * right;
|
2017-08-03 01:37:44 +08:00
|
|
|
|
[ref ref] => Similarity::from_isometry(self * &right.isometry, right.scaling());
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
|
|
|
|
|
2020-03-25 02:06:28 +08:00
|
|
|
|
// Similarity ÷ UnitQuaternion
|
2020-03-21 19:16:46 +08:00
|
|
|
|
similarity_from_composition_impl_all!(
|
|
|
|
|
Div, div;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>,
|
|
|
|
|
Output = Similarity<T, UnitQuaternion<T>, 3>;
|
2020-03-21 19:16:46 +08:00
|
|
|
|
[val val] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry / rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref val] => Similarity::from_isometry(&self.isometry / rhs, self.scaling());
|
|
|
|
|
[val ref] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry / rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref ref] => Similarity::from_isometry(&self.isometry / rhs, self.scaling());
|
|
|
|
|
);
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
// UnitQuaternion ÷ Similarity
|
2016-12-05 05:44:42 +08:00
|
|
|
|
similarity_from_composition_impl_all!(
|
|
|
|
|
Div, div;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: UnitQuaternion<T>, right: Similarity<T, UnitQuaternion<T>, 3>,
|
|
|
|
|
Output = Similarity<T, UnitQuaternion<T>, 3>;
|
2020-11-15 23:57:49 +08:00
|
|
|
|
// TODO: don't call inverse explicitly?
|
2020-10-26 01:23:24 +08:00
|
|
|
|
[val val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
|
|
|
|
|
[ref val] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
|
|
|
|
|
[val ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
|
|
|
|
|
[ref ref] => #[allow(clippy::suspicious_arithmetic_impl)] { self * right.inverse() };
|
2016-12-05 05:44:42 +08:00
|
|
|
|
);
|
2020-03-25 02:06:28 +08:00
|
|
|
|
|
|
|
|
|
// Similarity × UnitComplex
|
|
|
|
|
similarity_from_composition_impl_all!(
|
|
|
|
|
Mul, mul;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>,
|
|
|
|
|
Output = Similarity<T, UnitComplex<T>, 2>;
|
2020-03-25 02:06:28 +08:00
|
|
|
|
[val val] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry * rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref val] => Similarity::from_isometry(&self.isometry * rhs, self.scaling());
|
|
|
|
|
[val ref] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry * rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref ref] => Similarity::from_isometry(&self.isometry * rhs, self.scaling());
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
// Similarity ÷ UnitComplex
|
|
|
|
|
similarity_from_composition_impl_all!(
|
|
|
|
|
Div, div;
|
2021-04-08 17:53:01 +08:00
|
|
|
|
;
|
2021-04-11 17:00:38 +08:00
|
|
|
|
self: Similarity<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>,
|
|
|
|
|
Output = Similarity<T, UnitComplex<T>, 2>;
|
2020-03-25 02:06:28 +08:00
|
|
|
|
[val val] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry / rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref val] => Similarity::from_isometry(&self.isometry / rhs, self.scaling());
|
|
|
|
|
[val ref] => {
|
|
|
|
|
let scaling = self.scaling();
|
|
|
|
|
Similarity::from_isometry(self.isometry / rhs, scaling)
|
|
|
|
|
};
|
|
|
|
|
[ref ref] => Similarity::from_isometry(&self.isometry / rhs, self.scaling());
|
|
|
|
|
);
|