fix clippy warnings

jgcodes2020 · jgcodes2020 · commit 06538f9f8496 · 2025-01-22T23:19:57.000-05:00
diff --git a/graphene/src/matrix.rs b/graphene/src/matrix.rs
@@ -234,7 +234,7 @@ impl ops::Mul<Matrix> for Matrix {
     type Output = Matrix;
 
     fn mul(self, rhs: Matrix) -> Self::Output {
-        (&self).multiply(&rhs)
+        Matrix::multiply(&self, &rhs)
     }
 }
 impl ops::MulAssign<Matrix> for Matrix {
@@ -246,32 +246,38 @@ impl ops::MulAssign<Matrix> for Matrix {
 impl ops::Mul<Vec4> for Matrix {
     type Output = Vec4;
 
+    /// Transforms this `Vec4` using the provided matrix.
+    /// See [Matrix::transform_vec4].
     fn mul(self, rhs: Vec4) -> Self::Output {
-        (&self).transform_vec4(&rhs)
+        Matrix::transform_vec4(&self, &rhs)
     }
 }
 
 impl ops::Mul<Vec3> for Matrix {
     type Output = Vec3;
 
+    /// Transforms this `Vec3` using the provided matrix.
+    /// See [Matrix::transform_vec3].
     fn mul(self, rhs: Vec3) -> Self::Output {
-        (&self).transform_vec3(&rhs)
+        Matrix::transform_vec3(&self, &rhs)
     }
 }
 
 impl ops::Mul<Point> for Matrix {
     type Output = Point;
 
     fn mul(self, rhs: Point) -> Self::Output {
-        (&self).transform_point(&rhs)
+        Matrix::transform_point(&self, &rhs)
     }
 }
 
 impl ops::Mul<Point3D> for Matrix {
     type Output = Point3D;
 
+    /// Transforms this point using the provided matrix.
+    /// See [Matrix::transform_point3d].
     fn mul(self, rhs: Point3D) -> Self::Output {
-        (&self).transform_point3d(&rhs)
+        Matrix::transform_point3d(&self, &rhs)
     }
 }
 
diff --git a/graphene/src/quaternion.rs b/graphene/src/quaternion.rs
@@ -150,7 +150,7 @@ impl ops::Add<Quaternion> for Quaternion {
     type Output = Quaternion;
 
     fn add(self, rhs: Quaternion) -> Self::Output {
-        (&self).add(&rhs)
+        Quaternion::add(&self, &rhs)
     }
 }
 
@@ -164,7 +164,7 @@ impl ops::Mul<Quaternion> for Quaternion {
     type Output = Quaternion;
 
     fn mul(self, rhs: Quaternion) -> Self::Output {
-        (&self).multiply(&rhs)
+        Quaternion::multiply(&self, &rhs)
     }
 }
 
diff --git a/graphene/src/vec2.rs b/graphene/src/vec2.rs
@@ -58,7 +58,7 @@ impl ops::Add<Vec2> for Vec2 {
     type Output = Vec2;
 
     fn add(self, rhs: Vec2) -> Self::Output {
-        (&self).add(&rhs)
+        Vec2::add(&self, &rhs)
     }
 }
 impl ops::AddAssign<Vec2> for Vec2 {
@@ -70,7 +70,7 @@ impl ops::Sub<Vec2> for Vec2 {
     type Output = Vec2;
 
     fn sub(self, rhs: Vec2) -> Self::Output {
-        (&self).subtract(&rhs)
+        Vec2::subtract(&self, &rhs)
     }
 }
 impl ops::SubAssign<Vec2> for Vec2 {
@@ -82,7 +82,7 @@ impl ops::Neg for Vec2 {
     type Output = Vec2;
 
     fn neg(self) -> Self::Output {
-        (&self).negate()
+        Vec2::negate(&self)
     }
 }
 
@@ -91,7 +91,7 @@ impl ops::Mul<f32> for Vec2 {
     type Output = Vec2;
 
     fn mul(self, rhs: f32) -> Self::Output {
-        (&self).scale(rhs)
+        Vec2::scale(&self, rhs)
     }
 }
 impl ops::MulAssign<f32> for Vec2 {
@@ -112,7 +112,7 @@ impl ops::Mul<Vec2> for Vec2 {
     type Output = Vec2;
 
     fn mul(self, rhs: Vec2) -> Self::Output {
-        (&self).multiply(&rhs)
+        Vec2::multiply(&self, &rhs)
     }
 }
 impl ops::MulAssign<Vec2> for Vec2 {
@@ -124,7 +124,7 @@ impl ops::Div<Vec2> for Vec2 {
     type Output = Vec2;
 
     fn div(self, rhs: Vec2) -> Self::Output {
-        (&self).divide(&rhs)
+        Vec2::divide(&self, &rhs)
     }
 }
 impl ops::DivAssign<Vec2> for Vec2 {
diff --git a/graphene/src/vec3.rs b/graphene/src/vec3.rs
@@ -59,7 +59,7 @@ impl ops::Add<Vec3> for Vec3 {
     type Output = Vec3;
 
     fn add(self, rhs: Vec3) -> Self::Output {
-        (&self).add(&rhs)
+        Vec3::add(&self, &rhs)
     }
 }
 impl ops::AddAssign<Vec3> for Vec3 {
@@ -71,7 +71,7 @@ impl ops::Sub<Vec3> for Vec3 {
     type Output = Vec3;
 
     fn sub(self, rhs: Vec3) -> Self::Output {
-        (&self).subtract(&rhs)
+        Vec3::subtract(&self, &rhs)
     }
 }
 impl ops::SubAssign<Vec3> for Vec3 {
@@ -83,7 +83,7 @@ impl ops::Neg for Vec3 {
     type Output = Vec3;
 
     fn neg(self) -> Self::Output {
-        (&self).negate()
+        Vec3::negate(&self)
     }
 }
 
@@ -92,7 +92,7 @@ impl ops::Mul<f32> for Vec3 {
     type Output = Vec3;
 
     fn mul(self, rhs: f32) -> Self::Output {
-        (&self).scale(rhs)
+        Vec3::scale(&self, rhs)
     }
 }
 impl ops::MulAssign<f32> for Vec3 {
@@ -113,7 +113,7 @@ impl ops::Mul<Vec3> for Vec3 {
     type Output = Vec3;
 
     fn mul(self, rhs: Vec3) -> Self::Output {
-        (&self).multiply(&rhs)
+        Vec3::multiply(&self, &rhs)
     }
 }
 impl ops::MulAssign<Vec3> for Vec3 {
@@ -125,7 +125,7 @@ impl ops::Div<Vec3> for Vec3 {
     type Output = Vec3;
 
     fn div(self, rhs: Vec3) -> Self::Output {
-        (&self).divide(&rhs)
+        Vec3::divide(&self, &rhs)
     }
 }
 impl ops::DivAssign<Vec3> for Vec3 {
diff --git a/graphene/src/vec4.rs b/graphene/src/vec4.rs
@@ -82,7 +82,7 @@ impl ops::Add<Vec4> for Vec4 {
     type Output = Vec4;
 
     fn add(self, rhs: Vec4) -> Self::Output {
-        (&self).add(&rhs)
+        Vec4::add(&self, &rhs)
     }
 }
 impl ops::AddAssign<Vec4> for Vec4 {
@@ -94,7 +94,7 @@ impl ops::Sub<Vec4> for Vec4 {
     type Output = Vec4;
 
     fn sub(self, rhs: Vec4) -> Self::Output {
-        (&self).subtract(&rhs)
+        Vec4::subtract(&self, &rhs)
     }
 }
 impl ops::SubAssign<Vec4> for Vec4 {
@@ -106,7 +106,7 @@ impl ops::Neg for Vec4 {
     type Output = Vec4;
 
     fn neg(self) -> Self::Output {
-        (&self).negate()
+        Vec4::negate(&self)
     }
 }
 
@@ -115,7 +115,7 @@ impl ops::Mul<f32> for Vec4 {
     type Output = Vec4;
 
     fn mul(self, rhs: f32) -> Self::Output {
-        (&self).scale(rhs)
+        Vec4::scale(&self, rhs)
     }
 }
 impl ops::MulAssign<f32> for Vec4 {
@@ -136,7 +136,7 @@ impl ops::Mul<Vec4> for Vec4 {
     type Output = Vec4;
 
     fn mul(self, rhs: Vec4) -> Self::Output {
-        (&self).multiply(&rhs)
+        Vec4::multiply(&self, &rhs)
     }
 }
 impl ops::MulAssign<Vec4> for Vec4 {
@@ -148,7 +148,7 @@ impl ops::Div<Vec4> for Vec4 {
     type Output = Vec4;
 
     fn div(self, rhs: Vec4) -> Self::Output {
-        (&self).divide(&rhs)
+        Vec4::divide(&self, &rhs)
     }
 }
 impl ops::DivAssign<Vec4> for Vec4 {

Original file line number	Diff line number	Diff line change
`@@ -234,7 +234,7 @@ impl ops::Mul<Matrix> for Matrix {`
`234`	`234`	`type Output = Matrix;`
`235`	`235`
`236`	`236`	`fn mul(self, rhs: Matrix) -> Self::Output {`
`237`		`- (&self).multiply(&rhs)`
	`237`	`+ Matrix::multiply(&self, &rhs)`
`238`	`238`	`}`
`239`	`239`	`}`
`240`	`240`	`impl ops::MulAssign<Matrix> for Matrix {`
`@@ -246,32 +246,38 @@ impl ops::MulAssign<Matrix> for Matrix {`
`246`	`246`	`impl ops::Mul<Vec4> for Matrix {`
`247`	`247`	`type Output = Vec4;`
`248`	`248`
	`249`	+ /// Transforms this `Vec4` using the provided matrix.
	`250`	`+ /// See [Matrix::transform_vec4].`
`249`	`251`	`fn mul(self, rhs: Vec4) -> Self::Output {`
`250`		`- (&self).transform_vec4(&rhs)`
	`252`	`+ Matrix::transform_vec4(&self, &rhs)`
`251`	`253`	`}`
`252`	`254`	`}`
`253`	`255`
`254`	`256`	`impl ops::Mul<Vec3> for Matrix {`
`255`	`257`	`type Output = Vec3;`
`256`	`258`
	`259`	+ /// Transforms this `Vec3` using the provided matrix.
	`260`	`+ /// See [Matrix::transform_vec3].`
`257`	`261`	`fn mul(self, rhs: Vec3) -> Self::Output {`
`258`		`- (&self).transform_vec3(&rhs)`
	`262`	`+ Matrix::transform_vec3(&self, &rhs)`
`259`	`263`	`}`
`260`	`264`	`}`
`261`	`265`
`262`	`266`	`impl ops::Mul<Point> for Matrix {`
`263`	`267`	`type Output = Point;`
`264`	`268`
`265`	`269`	`fn mul(self, rhs: Point) -> Self::Output {`
`266`		`- (&self).transform_point(&rhs)`
	`270`	`+ Matrix::transform_point(&self, &rhs)`
`267`	`271`	`}`
`268`	`272`	`}`
`269`	`273`
`270`	`274`	`impl ops::Mul<Point3D> for Matrix {`
`271`	`275`	`type Output = Point3D;`
`272`	`276`
	`277`	`+ /// Transforms this point using the provided matrix.`
	`278`	`+ /// See [Matrix::transform_point3d].`
`273`	`279`	`fn mul(self, rhs: Point3D) -> Self::Output {`
`274`		`- (&self).transform_point3d(&rhs)`
	`280`	`+ Matrix::transform_point3d(&self, &rhs)`
`275`	`281`	`}`
`276`	`282`	`}`
`277`	`283`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ impl ops::Add<Quaternion> for Quaternion {`
`150`	`150`	`type Output = Quaternion;`
`151`	`151`
`152`	`152`	`fn add(self, rhs: Quaternion) -> Self::Output {`
`153`		`- (&self).add(&rhs)`
	`153`	`+ Quaternion::add(&self, &rhs)`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`
`@@ -164,7 +164,7 @@ impl ops::Mul<Quaternion> for Quaternion {`
`164`	`164`	`type Output = Quaternion;`
`165`	`165`
`166`	`166`	`fn mul(self, rhs: Quaternion) -> Self::Output {`
`167`		`- (&self).multiply(&rhs)`
	`167`	`+ Quaternion::multiply(&self, &rhs)`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ impl ops::Add<Vec2> for Vec2 {`
`58`	`58`	`type Output = Vec2;`
`59`	`59`
`60`	`60`	`fn add(self, rhs: Vec2) -> Self::Output {`
`61`		`- (&self).add(&rhs)`
	`61`	`+ Vec2::add(&self, &rhs)`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`	`impl ops::AddAssign<Vec2> for Vec2 {`
`@@ -70,7 +70,7 @@ impl ops::Sub<Vec2> for Vec2 {`
`70`	`70`	`type Output = Vec2;`
`71`	`71`
`72`	`72`	`fn sub(self, rhs: Vec2) -> Self::Output {`
`73`		`- (&self).subtract(&rhs)`
	`73`	`+ Vec2::subtract(&self, &rhs)`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`	`impl ops::SubAssign<Vec2> for Vec2 {`
`@@ -82,7 +82,7 @@ impl ops::Neg for Vec2 {`
`82`	`82`	`type Output = Vec2;`
`83`	`83`
`84`	`84`	`fn neg(self) -> Self::Output {`
`85`		`- (&self).negate()`
	`85`	`+ Vec2::negate(&self)`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`@@ -91,7 +91,7 @@ impl ops::Mul<f32> for Vec2 {`
`91`	`91`	`type Output = Vec2;`
`92`	`92`
`93`	`93`	`fn mul(self, rhs: f32) -> Self::Output {`
`94`		`- (&self).scale(rhs)`
	`94`	`+ Vec2::scale(&self, rhs)`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`	`impl ops::MulAssign<f32> for Vec2 {`
`@@ -112,7 +112,7 @@ impl ops::Mul<Vec2> for Vec2 {`
`112`	`112`	`type Output = Vec2;`
`113`	`113`
`114`	`114`	`fn mul(self, rhs: Vec2) -> Self::Output {`
`115`		`- (&self).multiply(&rhs)`
	`115`	`+ Vec2::multiply(&self, &rhs)`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`	`impl ops::MulAssign<Vec2> for Vec2 {`
`@@ -124,7 +124,7 @@ impl ops::Div<Vec2> for Vec2 {`
`124`	`124`	`type Output = Vec2;`
`125`	`125`
`126`	`126`	`fn div(self, rhs: Vec2) -> Self::Output {`
`127`		`- (&self).divide(&rhs)`
	`127`	`+ Vec2::divide(&self, &rhs)`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`	`impl ops::DivAssign<Vec2> for Vec2 {`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ impl ops::Add<Vec3> for Vec3 {`
`59`	`59`	`type Output = Vec3;`
`60`	`60`
`61`	`61`	`fn add(self, rhs: Vec3) -> Self::Output {`
`62`		`- (&self).add(&rhs)`
	`62`	`+ Vec3::add(&self, &rhs)`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`	`impl ops::AddAssign<Vec3> for Vec3 {`
`@@ -71,7 +71,7 @@ impl ops::Sub<Vec3> for Vec3 {`
`71`	`71`	`type Output = Vec3;`
`72`	`72`
`73`	`73`	`fn sub(self, rhs: Vec3) -> Self::Output {`
`74`		`- (&self).subtract(&rhs)`
	`74`	`+ Vec3::subtract(&self, &rhs)`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`	`impl ops::SubAssign<Vec3> for Vec3 {`
`@@ -83,7 +83,7 @@ impl ops::Neg for Vec3 {`
`83`	`83`	`type Output = Vec3;`
`84`	`84`
`85`	`85`	`fn neg(self) -> Self::Output {`
`86`		`- (&self).negate()`
	`86`	`+ Vec3::negate(&self)`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`@@ -92,7 +92,7 @@ impl ops::Mul<f32> for Vec3 {`
`92`	`92`	`type Output = Vec3;`
`93`	`93`
`94`	`94`	`fn mul(self, rhs: f32) -> Self::Output {`
`95`		`- (&self).scale(rhs)`
	`95`	`+ Vec3::scale(&self, rhs)`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`	`impl ops::MulAssign<f32> for Vec3 {`
`@@ -113,7 +113,7 @@ impl ops::Mul<Vec3> for Vec3 {`
`113`	`113`	`type Output = Vec3;`
`114`	`114`
`115`	`115`	`fn mul(self, rhs: Vec3) -> Self::Output {`
`116`		`- (&self).multiply(&rhs)`
	`116`	`+ Vec3::multiply(&self, &rhs)`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`	`impl ops::MulAssign<Vec3> for Vec3 {`
`@@ -125,7 +125,7 @@ impl ops::Div<Vec3> for Vec3 {`
`125`	`125`	`type Output = Vec3;`
`126`	`126`
`127`	`127`	`fn div(self, rhs: Vec3) -> Self::Output {`
`128`		`- (&self).divide(&rhs)`
	`128`	`+ Vec3::divide(&self, &rhs)`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`	`impl ops::DivAssign<Vec3> for Vec3 {`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ impl ops::Add<Vec4> for Vec4 {`
`82`	`82`	`type Output = Vec4;`
`83`	`83`
`84`	`84`	`fn add(self, rhs: Vec4) -> Self::Output {`
`85`		`- (&self).add(&rhs)`
	`85`	`+ Vec4::add(&self, &rhs)`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`	`impl ops::AddAssign<Vec4> for Vec4 {`
`@@ -94,7 +94,7 @@ impl ops::Sub<Vec4> for Vec4 {`
`94`	`94`	`type Output = Vec4;`
`95`	`95`
`96`	`96`	`fn sub(self, rhs: Vec4) -> Self::Output {`
`97`		`- (&self).subtract(&rhs)`
	`97`	`+ Vec4::subtract(&self, &rhs)`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`	`impl ops::SubAssign<Vec4> for Vec4 {`
`@@ -106,7 +106,7 @@ impl ops::Neg for Vec4 {`
`106`	`106`	`type Output = Vec4;`
`107`	`107`
`108`	`108`	`fn neg(self) -> Self::Output {`
`109`		`- (&self).negate()`
	`109`	`+ Vec4::negate(&self)`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`@@ -115,7 +115,7 @@ impl ops::Mul<f32> for Vec4 {`
`115`	`115`	`type Output = Vec4;`
`116`	`116`
`117`	`117`	`fn mul(self, rhs: f32) -> Self::Output {`
`118`		`- (&self).scale(rhs)`
	`118`	`+ Vec4::scale(&self, rhs)`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`	`impl ops::MulAssign<f32> for Vec4 {`
`@@ -136,7 +136,7 @@ impl ops::Mul<Vec4> for Vec4 {`
`136`	`136`	`type Output = Vec4;`
`137`	`137`
`138`	`138`	`fn mul(self, rhs: Vec4) -> Self::Output {`
`139`		`- (&self).multiply(&rhs)`
	`139`	`+ Vec4::multiply(&self, &rhs)`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`	`impl ops::MulAssign<Vec4> for Vec4 {`
`@@ -148,7 +148,7 @@ impl ops::Div<Vec4> for Vec4 {`
`148`	`148`	`type Output = Vec4;`
`149`	`149`
`150`	`150`	`fn div(self, rhs: Vec4) -> Self::Output {`
`151`		`- (&self).divide(&rhs)`
	`151`	`+ Vec4::divide(&self, &rhs)`
`152`	`152`	`}`
`153`	`153`	`}`
`154`	`154`	`impl ops::DivAssign<Vec4> for Vec4 {`