diff --git a/Source/Engine/Core/Math/Quaternion.cpp b/Source/Engine/Core/Math/Quaternion.cpp
index a8e276bf2..46240d4b8 100644
--- a/Source/Engine/Core/Math/Quaternion.cpp
+++ b/Source/Engine/Core/Math/Quaternion.cpp
@@ -539,13 +539,13 @@ void Quaternion::RotationYawPitchRoll(float yaw, float pitch, float roll, Quater
result.Z = cosYawOver2 * cosPitchOver2 * sinRollOver2 - sinYawOver2 * sinPitchOver2 * cosRollOver2;
}
-Quaternion Quaternion::GetRotationFromNormal(const Vector3& InNormal, const Transform& InReferenceTransform)
+Quaternion Quaternion::GetRotationFromNormal(const Vector3& normal, const Transform& reference)
{
- Float3 up = InReferenceTransform.GetUp();
- auto dot = Vector3::Dot(InNormal, up);
+ Float3 up = reference.GetUp();
+ const float dot = Vector3::Dot(normal, up);
if (Math::NearEqual(Math::Abs(dot), 1))
{
- up = InReferenceTransform.GetRight();
+ up = reference.GetRight();
}
- return Quaternion::LookRotation(InNormal, up);
+ return Quaternion::LookRotation(normal, up);
}
diff --git a/Source/Engine/Core/Math/Quaternion.cs b/Source/Engine/Core/Math/Quaternion.cs
index ad2117be3..b6b9518c3 100644
--- a/Source/Engine/Core/Math/Quaternion.cs
+++ b/Source/Engine/Core/Math/Quaternion.cs
@@ -1491,16 +1491,16 @@ namespace FlaxEngine
/// Example code:
///
/// GetRotationFromNormalExample :
- /// RayOrgin;
+ /// RayOrigin;
/// SomeObject;
///
/// {
- /// (.RayCast(RayOrgin.Position, RayOrgin.Transform.Forward, out Hit)
+ /// (.RayCast(RayOrigin.Position, RayOrigin.Transform.Forward, out hit)
/// {
- /// position = Hit.Collider.Position;
- /// transform = Hit.Collider.Transform;
- /// point = Hit.Point;
- /// normal = Hit.Normal;
+ /// position = hit.Collider.Position;
+ /// transform = hit.Collider.Transform;
+ /// point = hit.Point;
+ /// normal = hit.Normal;
/// rot = .GetRotationFromNormal(normal,transform);
/// SomeObject.Position = point;
/// SomeObject.Orientation = rot;
@@ -1510,18 +1510,16 @@ namespace FlaxEngine
///
///
///
- /// The normal vector.
- /// The reference transform.
+ /// The normal vector.
+ /// The reference transform.
/// The rotation from the normal vector.
- public static Quaternion GetRotationFromNormal(Vector3 InNormal, Transform InReferenceTransform)
+ public static Quaternion GetRotationFromNormal(Vector3 normal, Transform reference)
{
- Float3 up = InReferenceTransform.Up;
- var dot = Vector3.Dot(InNormal, up);
+ Float3 up = reference.Up;
+ var dot = Vector3.Dot(normal, up);
if (Mathf.NearEqual(Math.Abs(dot), 1))
- {
- up = InReferenceTransform.Right;
- }
- return LookRotation(InNormal, up);
+ up = reference.Right;
+ return LookRotation(normal, up);
}
///
diff --git a/Source/Engine/Core/Math/Quaternion.h b/Source/Engine/Core/Math/Quaternion.h
index 25b90a1d4..b2b57886f 100644
--- a/Source/Engine/Core/Math/Quaternion.h
+++ b/Source/Engine/Core/Math/Quaternion.h
@@ -661,16 +661,13 @@ public:
// @param result When the method completes, contains the newly created quaternion
static void RotationYawPitchRoll(float yaw, float pitch, float roll, Quaternion& result);
-
///
- /// Gets rotation from a normal in relation to a transform.
- /// This function is especially useful for axis aligned faces,
- /// and with .
+ /// Gets rotation from a normal in relation to a transform. This function is especially useful for axis aligned faces, and with .
///
- /// The normal vector.
- /// The reference transform.
+ /// The normal vector.
+ /// The reference transform.
/// The rotation from the normal vector.
- static Quaternion GetRotationFromNormal(const Vector3& InNormal, const Transform& InReferenceTransform);
+ static Quaternion GetRotationFromNormal(const Vector3& normal, const Transform& reference);
};
///
diff --git a/Source/Engine/Core/Math/Transform.cpp b/Source/Engine/Core/Math/Transform.cpp
index 234b78c04..0106be2f9 100644
--- a/Source/Engine/Core/Math/Transform.cpp
+++ b/Source/Engine/Core/Math/Transform.cpp
@@ -253,26 +253,8 @@ void Transform::Lerp(const Transform& t1, const Transform& t2, float amount, Tra
Float3::Lerp(t1.Scale, t2.Scale, amount, result.Scale);
}
-inline Transform Transform::AlignRotationToNormalAndSnapToGrid(const Vector3& InPoint, const Vector3& InNormal, float InNormalOffset, const Transform& InRelativeTo, const Float3& InReturnScale, const Vector3& InGridSize)
+Transform Transform::AlignRotationToNormalAndSnapToGrid(const Vector3& point, const Vector3& normal, const Vector3& normalOffset, const Transform& relativeTo, const Vector3& gridSize, const Float3& scale)
{
- Quaternion rot = Quaternion::GetRotationFromNormal(InNormal, InRelativeTo);
- return Transform(Vector3::SnapToRotatedGridWithOffset(InPoint, InRelativeTo.Translation, Vector3(0, 0, InNormalOffset), rot, InGridSize), rot, InReturnScale);
-}
-
-inline Transform Transform::AlignRotationToNormalAndSnapToGrid(const Vector3& InPoint, const Vector3& InNormal, float InNormalOffset, const Transform& InRelativeTo, const Vector3& InGridSize)
-{
- Quaternion rot = Quaternion::GetRotationFromNormal(InNormal, InRelativeTo);
- return Transform(Vector3::SnapToRotatedGridWithOffset(InPoint, InRelativeTo.Translation, Vector3(0, 0, InNormalOffset), rot, InGridSize), rot, Float3::One);
-}
-
-inline Transform Transform::AlignRotationToNormalAndSnapToGrid(const Vector3& InPoint, const Vector3& InNormal, const Vector3& InNormalOffset, const Transform& InRelativeTo, const Float3& InReturnScale, const Vector3& InGridSize)
-{
- Quaternion rot = Quaternion::GetRotationFromNormal(InNormal, InRelativeTo);
- return Transform(Vector3::SnapToRotatedGridWithOffset(InPoint, InRelativeTo.Translation, InNormalOffset, rot, InGridSize), rot, InReturnScale);
-}
-
-inline Transform Transform::AlignRotationToNormalAndSnapToGrid(const Vector3& InPoint, const Vector3& InNormal, const Vector3& InNormalOffset, const Transform& InRelativeTo, const Vector3& InGridSize)
-{
- Quaternion rot = Quaternion::GetRotationFromNormal(InNormal, InRelativeTo);
- return Transform(Vector3::SnapToRotatedGridWithOffset(InPoint, InRelativeTo.Translation, InNormalOffset, rot, InGridSize), rot, Float3::One);
+ Quaternion rot = Quaternion::GetRotationFromNormal(normal, relativeTo);
+ return Transform(Vector3::SnapToGrid(point, gridSize, rot, relativeTo.Translation, normalOffset), rot, scale);
}
diff --git a/Source/Engine/Core/Math/Transform.cs b/Source/Engine/Core/Math/Transform.cs
index ba86c1a6d..7387bab83 100644
--- a/Source/Engine/Core/Math/Transform.cs
+++ b/Source/Engine/Core/Math/Transform.cs
@@ -477,24 +477,25 @@ namespace FlaxEngine
Quaternion.Slerp(ref start.Orientation, ref end.Orientation, amount, out result.Orientation);
Float3.Lerp(ref start.Scale, ref end.Scale, amount, out result.Scale);
}
+
///
- /// Combines the functions:
- /// ,
+ /// Combines the functions:
+ /// ,
/// .
/// Example code:
///
/// AlignRotationToObjectAndSnapToGridExample :
- /// Offset = 50.0f;
+ /// Offset = new Vector3(0, 0, 50f);
/// GridSize = * 20.0f;
- /// RayOrgin;
+ /// RayOrigin;
/// SomeObject;
///
/// {
- /// (.RayCast(RayOrgin.Position, RayOrgin.Transform.Forward, out Hit)
+ /// (.RayCast(RayOrigin.Position, RayOrigin.Transform.Forward, out hit)
/// {
- /// transform = Hit.Collider.Transform;
- /// point = Hit.Point;
- /// normal = Hit.Normal;
+ /// transform = hit.Collider.Transform;
+ /// point = hit.Point;
+ /// normal = hit.Normal;
/// SomeObject.Transform = .AlignRotationToNormalAndSnapToGrid
/// (
/// point,
@@ -502,7 +503,8 @@ namespace FlaxEngine
/// Offset,
/// transform,
/// SomeObject.Scale,
- /// GridSize
+ /// GridSize,
+ /// Float3.One
/// );
/// }
/// }
@@ -510,127 +512,37 @@ namespace FlaxEngine
///
///
///
- /// The position to snap.
- /// The size of the grid.
- /// The local Z grid offset to apply after snapping.
- /// The normal vector.
- /// The relative transform.
- /// The scale to apply to the transform.
+ /// The position to snap.
+ /// The size of the grid.
+ /// The local grid offset to apply after snapping.
+ /// The normal vector.
+ /// The relative transform.
+ /// The scale to apply to the transform.
/// The rotated and snapped transform.
- public static Transform AlignRotationToNormalAndSnapToGrid(Vector3 InPoint, Vector3 InNormal, float InNormalOffset, Transform InRelativeTo, Float3 InReturnScale, Vector3 InGridSize)
+ public static Transform AlignRotationToNormalAndSnapToGrid(Vector3 point, Vector3 normal, Vector3 normalOffset, Transform relativeTo, Vector3 gridSize, Float3 scale)
{
- Quaternion rot = Quaternion.GetRotationFromNormal(InNormal, InRelativeTo);
- return new Transform(Vector3.SnapToRotatedGridWithOffset(InPoint, InRelativeTo.Translation, new Vector3(0, 0, InNormalOffset), rot, InGridSize), rot, InReturnScale);
- }
-
- ///
- /// Combines the functions:
- /// ,
- /// .
- /// Example code:
- ///
- /// AlignRotationToObjectAndSnapToGridExample :
- /// Offset = 50.0f;
- /// GridSize = * 20.0f;
- /// RayOrgin;
- /// SomeObject;
- ///
- /// {
- /// (.RayCast(RayOrgin.Position, RayOrgin.Transform.Forward, out Hit)
- /// {
- /// transform = Hit.Collider.Transform;
- /// point = Hit.Point;
- /// normal = Hit.Normal;
- /// SomeObject.Transform = .AlignRotationToNormalAndSnapToGrid
- /// (
- /// point,
- /// normal,
- /// Offset,
- /// transform,
- /// GridSize
- /// );
- /// }
- /// }
- /// }
- ///
- ///
- ///
- /// The position to snap.
- /// The size of the grid.
- /// The local Z grid offset to apply after snapping.
- /// The normal vector.
- /// The relative transform.
- /// The rotated and snapped transform with scale .
- public static Transform AlignRotationToNormalAndSnapToGrid(Vector3 InPoint, Vector3 InNormal, float InNormalOffset, Transform InRelativeTo, Vector3 InGridSize)
- {
- Quaternion rot = Quaternion.GetRotationFromNormal(InNormal, InRelativeTo);
- return new Transform(Vector3.SnapToRotatedGridWithOffset(InPoint, InRelativeTo.Translation, new Vector3(0, 0, InNormalOffset), rot, InGridSize), rot, Float3.One);
+ Quaternion rot = Quaternion.GetRotationFromNormal(normal, relativeTo);
+ return new Transform(Vector3.SnapToGrid(point, gridSize, rot, relativeTo.Translation, normalOffset), rot, scale);
}
///
/// Combines the functions:
- /// ,
+ /// ,
/// .
/// Example code:
///
/// AlignRotationToObjectAndSnapToGridExample :
/// Offset = new Vector3(0, 0, 50f);
/// GridSize = * 20.0f;
- /// RayOrgin;
+ /// RayOrigin;
/// SomeObject;
///
/// {
- /// (.RayCast(RayOrgin.Position, RayOrgin.Transform.Forward, out Hit)
+ /// (.RayCast(RayOrigin.Position, RayOrigin.Transform.Forward, out hit)
/// {
- /// transform = Hit.Collider.Transform;
- /// point = Hit.Point;
- /// normal = Hit.Normal;
- /// SomeObject.Transform = .AlignRotationToNormalAndSnapToGrid
- /// (
- /// point,
- /// normal,
- /// Offset,
- /// transform,
- /// SomeObject.Scale,
- /// GridSize
- /// );
- /// }
- /// }
- /// }
- ///
- ///
- ///
- /// The position to snap.
- /// The size of the grid.
- /// The local Z grid offset to apply after snapping.
- /// The normal vector.
- /// The relative transform.
- /// The scale to apply to the transform.
- /// The rotated and snapped transform.
- public static Transform AlignRotationToNormalAndSnapToGrid(Vector3 InPoint, Vector3 InNormal, Vector3 InNormalOffset, Transform InRelativeTo, Float3 InReturnScale, Vector3 InGridSize)
- {
- Quaternion rot = Quaternion.GetRotationFromNormal(InNormal, InRelativeTo);
- return new Transform(Vector3.SnapToRotatedGridWithOffset(InPoint, InRelativeTo.Translation, InNormalOffset, rot, InGridSize), rot, InReturnScale);
- }
-
- ///
- /// Combines the functions:
- /// ,
- /// .
- /// Example code:
- ///
- /// AlignRotationToObjectAndSnapToGridExample :
- /// Offset = new Vector3(0, 0, 50f);
- /// GridSize = * 20.0f;
- /// RayOrgin;
- /// SomeObject;
- ///
- /// {
- /// (.RayCast(RayOrgin.Position, RayOrgin.Transform.Forward, out Hit)
- /// {
- /// transform = Hit.Collider.Transform;
- /// point = Hit.Point;
- /// normal = Hit.Normal;
+ /// transform = hit.Collider.Transform;
+ /// point = hit.Point;
+ /// normal = hit.Normal;
/// SomeObject.Transform = .AlignRotationToNormalAndSnapToGrid
/// (
/// point,
@@ -645,16 +557,15 @@ namespace FlaxEngine
///
///
///
- /// The position to snap.
- /// The size of the grid.
- /// The local Z grid offset to apply after snapping.
- /// The normal vector.
- /// The relative transform.
+ /// The position to snap.
+ /// The size of the grid.
+ /// The local grid offset to apply after snapping.
+ /// The normal vector.
+ /// The relative transform.
/// The rotated and snapped transform with scale .
- public static Transform AlignRotationToNormalAndSnapToGrid(Vector3 InPoint, Vector3 InNormal, Vector3 InNormalOffset, Transform InRelativeTo, Vector3 InGridSize)
+ public static Transform AlignRotationToNormalAndSnapToGrid(Vector3 point, Vector3 normal, Vector3 normalOffset, Transform relativeTo, Vector3 gridSize)
{
- Quaternion rot = Quaternion.GetRotationFromNormal(InNormal, InRelativeTo);
- return new Transform(Vector3.SnapToRotatedGridWithOffset(InPoint, InRelativeTo.Translation, InNormalOffset, rot, InGridSize), rot, Float3.One);
+ return AlignRotationToNormalAndSnapToGrid(point, normal, normalOffset, relativeTo, gridSize, Float3.One);
}
///
diff --git a/Source/Engine/Core/Math/Transform.h b/Source/Engine/Core/Math/Transform.h
index f170ce7a9..8e9e07e0a 100644
--- a/Source/Engine/Core/Math/Transform.h
+++ b/Source/Engine/Core/Math/Transform.h
@@ -18,20 +18,20 @@ API_STRUCT() struct FLAXENGINE_API Transform
///
/// The translation vector of the transform.
///
- API_FIELD(Attributes = "EditorOrder(10), EditorDisplay(null, \"Position\"), ValueCategory(Utils.ValueCategory.Distance)")
- Vector3 Translation;
+ API_FIELD(Attributes="EditorOrder(10), EditorDisplay(null, \"Position\"), ValueCategory(Utils.ValueCategory.Distance)")
+ Vector3 Translation;
///
/// The rotation of the transform.
///
- API_FIELD(Attributes = "EditorOrder(20), EditorDisplay(null, \"Rotation\"), ValueCategory(Utils.ValueCategory.Angle)")
- Quaternion Orientation;
+ API_FIELD(Attributes="EditorOrder(20), EditorDisplay(null, \"Rotation\"), ValueCategory(Utils.ValueCategory.Angle)")
+ Quaternion Orientation;
///
/// The scale vector of the transform.
///
- API_FIELD(Attributes = "EditorOrder(30), Limit(float.MinValue, float.MaxValue, 0.01f)")
- Float3 Scale;
+ API_FIELD(Attributes="EditorOrder(30), Limit(float.MinValue, float.MaxValue, 0.01f)")
+ Float3 Scale;
public:
///
@@ -291,61 +291,19 @@ public:
return result;
}
-
///
/// Combines the functions:
- /// ,
+ /// ,
/// .
///
- /// The position to snap.
- /// The size of the grid.
- /// The local Z grid offset to apply after snapping.
- /// The normal vector.
- /// The relative transform.
- /// The scale to apply to the transform.
+ /// The position to snap.
+ /// The size of the grid.
+ /// The local grid offset to apply after snapping.
+ /// The normal vector.
+ /// The relative transform.
+ /// The scale to apply to the transform.
/// The rotated and snapped transform.
- static Transform AlignRotationToNormalAndSnapToGrid(const Vector3& InPoint, const Vector3& InNormal, float InNormalOffset, const Transform& InRelativeTo, const Float3& InReturnScale, const Vector3& InGridSize);
-
- ///
- /// Combines the functions:
- /// ,
- /// .
- ///
- /// The position to snap.
- /// The size of the grid.
- /// The local Z grid offset to apply after snapping.
- /// The normal vector.
- /// The relative transform.
- /// The rotated and snapped transform with scale .
- static Transform AlignRotationToNormalAndSnapToGrid(const Vector3& InPoint, const Vector3& InNormal, float InNormalOffset, const Transform& InRelativeTo, const Vector3& InGridSize);
-
- ///
- /// Combines the functions:
- /// ,
- /// .
- ///
- /// The position to snap.
- /// The size of the grid.
- /// The local Z grid offset to apply after snapping.
- /// The normal vector.
- /// The relative transform.
- /// The scale to apply to the transform.
- /// The rotated and snapped transform.
- static Transform AlignRotationToNormalAndSnapToGrid(const Vector3& InPoint, const Vector3& InNormal, const Vector3& InNormalOffset, const Transform& InRelativeTo, const Float3& InReturnScale, const Vector3& InGridSize);
-
- ///
- /// Combines the functions:
- /// ,
- /// .
- ///
- /// The position to snap.
- /// The size of the grid.
- /// The local Z grid offset to apply after snapping.
- /// The normal vector.
- /// The relative transform.
- /// The rotated and snapped transform with scale .
- static Transform AlignRotationToNormalAndSnapToGrid(const Vector3& InPoint, const Vector3& InNormal, const Vector3& InNormalOffset, const Transform& InRelativeTo, const Vector3& InGridSize);
-
+ static Transform AlignRotationToNormalAndSnapToGrid(const Vector3& point, const Vector3& normal, const Vector3& normalOffset, const Transform& relativeTo, const Vector3& gridSize, const Float3& scale = Float3::One);
public:
FORCE_INLINE Transform operator*(const Transform& other) const
diff --git a/Source/Engine/Core/Math/Vector3.cpp b/Source/Engine/Core/Math/Vector3.cpp
index 30247d70b..5a26f2309 100644
--- a/Source/Engine/Core/Math/Vector3.cpp
+++ b/Source/Engine/Core/Math/Vector3.cpp
@@ -328,20 +328,14 @@ template<>
Float3 Float3::SnapToGrid(const Float3& pos, const Float3& gridSize)
{
return Float3(Math::Ceil((pos.X - (gridSize.X * 0.5f)) / gridSize.X) * gridSize.X,
- Math::Ceil((pos.Y - (gridSize.Y * 0.5f)) / gridSize.Y) * gridSize.Y,
- Math::Ceil((pos.Z - (gridSize.Z * 0.5f)) / gridSize.Z) * gridSize.Z);
+ Math::Ceil((pos.Y - (gridSize.Y * 0.5f)) / gridSize.Y) * gridSize.Y,
+ Math::Ceil((pos.Z - (gridSize.Z * 0.5f)) / gridSize.Z) * gridSize.Z);
}
template<>
-Float3 Float3::SnapToRotatedGridWithOffset(const Float3& InPoint, const Float3& InCenterPoint, const Float3& InOffset, const Quaternion& InOrientation, const Float3& InGridSize)
+Float3 Float3::SnapToGrid(const Float3& point, const Float3& gridSize, const Quaternion& gridOrientation, const Float3& gridOrigin, const Float3& offset)
{
- return (InOrientation * (InOrientation.Conjugated() * Float3::SnapToGrid((InPoint - InCenterPoint), InGridSize) + InOffset)) + InCenterPoint;
-}
-
-template<>
-Float3 Float3::SnapToRotatedGrid(const Float3& InPoint, const Float3& InCenterPoint, const Quaternion& InOrientation, const Float3& InGridSize)
-{
- return (InOrientation * InOrientation.Conjugated() * Float3::SnapToGrid((InPoint - InCenterPoint), InGridSize)) + InCenterPoint;
+ return (gridOrientation * (gridOrientation.Conjugated() * SnapToGrid(point - gridOrigin, gridSize) + offset)) + gridOrigin;
}
// Double
@@ -661,21 +655,15 @@ double Double3::Angle(const Double3& from, const Double3& to)
template<>
Double3 Double3::SnapToGrid(const Double3& pos, const Double3& gridSize)
{
- return Double3(Math::Ceil((pos.X - (gridSize.X * 0.5f)) / gridSize.X) * gridSize.X,
- Math::Ceil((pos.Y - (gridSize.Y * 0.5f)) / gridSize.Y) * gridSize.Y,
- Math::Ceil((pos.Z - (gridSize.Z * 0.5f)) / gridSize.Z) * gridSize.Z);
+ return Double3(Math::Ceil((pos.X - (gridSize.X * 0.5)) / gridSize.X) * gridSize.X,
+ Math::Ceil((pos.Y - (gridSize.Y * 0.5)) / gridSize.Y) * gridSize.Y,
+ Math::Ceil((pos.Z - (gridSize.Z * 0.5)) / gridSize.Z) * gridSize.Z);
}
template<>
-Double3 Double3::SnapToRotatedGridWithOffset(const Double3& InPoint, const Double3& InCenterPoint, const Double3& InOffset, const Quaternion& InOrientation, const Double3& InGridSize)
+Double3 Double3::SnapToGrid(const Double3& point, const Double3& gridSize, const Quaternion& gridOrientation, const Double3& gridOrigin, const Double3& offset)
{
- return (InOrientation * (InOrientation.Conjugated() * Float3::SnapToGrid((InPoint - InCenterPoint), InGridSize) + InOffset)) + InCenterPoint;
-}
-
-template<>
-Double3 Double3::SnapToRotatedGrid(const Double3& InPoint, const Double3& InCenterPoint, const Quaternion& InOrientation, const Double3& InGridSize)
-{
- return (InOrientation * InOrientation.Conjugated() * Float3::SnapToGrid((InPoint - InCenterPoint), InGridSize)) + InCenterPoint;
+ return (gridOrientation * (gridOrientation.Conjugated() * SnapToGrid(point - gridOrigin, gridSize) + offset)) + gridOrigin;
}
// Int
@@ -896,19 +884,13 @@ int32 Int3::Angle(const Int3& from, const Int3& to)
template<>
Int3 Int3::SnapToGrid(const Int3& pos, const Int3& gridSize)
{
- return Double3(Math::Ceil((pos.X - (gridSize.X * 0.5f)) / gridSize.X) * gridSize.X,
- Math::Ceil((pos.Y - (gridSize.Y * 0.5f)) / gridSize.Y) * gridSize.Y,
- Math::Ceil((pos.Z - (gridSize.Z * 0.5f)) / gridSize.Z) * gridSize.Z);
+ return Int3(((pos.X - (gridSize.X / 2)) / gridSize.X) * gridSize.X,
+ ((pos.Y - (gridSize.Y / 2)) / gridSize.Y) * gridSize.Y,
+ ((pos.Z - (gridSize.Z / 2)) / gridSize.Z) * gridSize.Z);
}
template<>
-Int3 Int3::SnapToRotatedGridWithOffset(const Int3& InPoint, const Int3& InCenterPoint, const Int3& InOffset, const Quaternion& InOrientation, const Int3& InGridSize)
+Int3 Int3::SnapToGrid(const Int3& point, const Int3& gridSize, const Quaternion& gridOrientation, const Int3& gridOrigin, const Int3& offset)
{
- return (InOrientation * (InOrientation.Conjugated() * Int3::SnapToGrid((InPoint - InCenterPoint), InGridSize) + InOffset)) + InCenterPoint;
-}
-
-template<>
-Int3 Int3::SnapToRotatedGrid(const Int3& InPoint, const Int3& InCenterPoint, const Quaternion& InOrientation, const Int3& InGridSize)
-{
- return (InOrientation * InOrientation.Conjugated() * Int3::SnapToGrid((InPoint - InCenterPoint), InGridSize)) + InCenterPoint;
+ return (gridOrientation * (gridOrientation.Conjugated() * SnapToGrid(point - gridOrigin, gridSize) + offset)) + gridOrigin;
}
diff --git a/Source/Engine/Core/Math/Vector3.cs b/Source/Engine/Core/Math/Vector3.cs
index dc2587934..5505c5053 100644
--- a/Source/Engine/Core/Math/Vector3.cs
+++ b/Source/Engine/Core/Math/Vector3.cs
@@ -1686,25 +1686,25 @@ namespace FlaxEngine
}
///
- /// Snaps the onto the rotated grid.
- /// For world aligned grid snapping use instead.
+ /// Snaps the onto the rotated grid.
+ /// For world aligned grid snapping use instead.
/// Example code:
///
- /// SnapToRotatedGridExample :
+ /// SnapToGridExample :
/// GridSize = * 20.0f;
- /// RayOrgin;
+ /// RayOrigin;
/// SomeObject;
///
/// {
- /// (.RayCast(RayOrgin.Position, RayOrgin.Transform.Forward, out Hit)
+ /// (.RayCast(RayOrigin.Position, RayOrigin.Transform.Forward, out hit)
/// {
- /// position = Hit.Collider.Position;
- /// transform = Hit.Collider.Transform;
- /// point = Hit.Point;
- /// normal = Hit.Normal;
+ /// position = hit.Collider.Position;
+ /// transform = hit.Collider.Transform;
+ /// point = hit.Point;
+ /// normal = hit.Normal;
/// //Get rotation from normal relative to collider transform
- /// rot = .GetRotacionFromNormal(normal,transform);
- /// point = .SnapToRotatedGrid(point,position,rot,GridSize);
+ /// rot = .GetRotationFromNormal(normal, transform);
+ /// point = .SnapToGrid(point, GridSize, rot, position);
/// SomeObject.Position = point;
/// }
/// }
@@ -1712,139 +1712,15 @@ namespace FlaxEngine
///
///
///
- /// The position to snap.
- /// The center point.
- /// The rotation of the grid.
- /// The size of the grid.
+ /// The position to snap.
+ /// The size of the grid.
+ /// The rotation of the grid.
+ /// The center point of the grid.
+ /// The local position offset applied to the snapped position before grid rotation.
/// The position snapped to the grid.
- public static Vector3 SnapToRotatedGrid(Vector3 InPoint, Vector3 InCenterPoint, Quaternion InOrientation, Vector3 InGridSize)
+ public static Vector3 SnapToGrid(Vector3 point, Vector3 gridSize, Quaternion gridOrientation, Vector3 gridOrigin, Vector3 offset)
{
- Vector3 p = (InPoint - InCenterPoint) * InOrientation.Conjugated();
- return (SnapToGrid(p, InGridSize) * InOrientation) + InCenterPoint;
- }
- ///
- /// The same as but with local offset applied after point is snapped.
- /// Example code:
- ///
- /// SnapToRotatedGridWithOffsetExample :
- /// Offset = new Vector3(0, 0, 50f);
- /// GridSize = * 20.0f;
- /// RayOrgin;
- /// SomeObject;
- ///
- /// {
- /// (.RayCast(RayOrgin.Position, RayOrgin.Transform.Forward, out Hit)
- /// {
- /// position = Hit.Collider.Position;
- /// transform = Hit.Collider.Transform;
- /// point = Hit.Point;
- /// normal = Hit.Normal;
- /// rot = .GetRotationFromNormal(normal,transform);
- /// point = .SnapToRotatedGridWithOffset(point,position,Offset,rot,GridSize);
- /// SomeObject.Position = point;
- /// }
- /// }
- /// }
- ///
- ///
- ///
- /// The position to snap.
- /// The center point.
- /// The rotation of the grid.
- /// The size of the grid.
- /// The local grid offset to apply after snapping.
- /// The position snapped to the grid, with offset applied.
- public static Vector3 SnapToRotatedGridWithOffset(Vector3 InPoint, Vector3 InCenterPoint, Vector3 InOffset, Quaternion InOrientation, Vector3 InGridSize)
- {
- return ((SnapToGrid((InPoint - InCenterPoint) * InOrientation.Conjugated(), InGridSize) + InOffset) * InOrientation) + InCenterPoint;
- }
-
- ///
- /// Gets the closest vector id to
- ///
- ///
- ///
- /// index or -1 if all vectors in array are outside of
- public int GetClosest(ref Vector3[] InArray, Real Tolerance)
- {
- Vector3 self = this;
- int FinalID = -1;
- for (int i = 0; i < InArray.Length; i++)
- {
- if (Distance(self, InArray[i]) <= Tolerance)
- {
- FinalID = i;
- self = InArray[i];
- }
- }
- return FinalID;
- }
-
- ///
- /// Gets the closest vector id to
- ///
- ///
- ///
- /// index or -1 if all vectors in array are outside of
- public int GetClosest(ref System.Collections.Generic.List InList, Real Tolerance)
- {
- Vector3 self = this;
- int FinalID = -1;
- for (int i = 0; i < InList.Count; i++)
- {
- if (Distance(self, InList[i]) <= Tolerance)
- {
- FinalID = i;
- self = InList[i];
- }
- }
- return FinalID;
- }
-
- ///
- /// Gets the closest vector to
- ///
- ///
- ///
- ///
- public void GetClosest(ref Vector3[] InArray, ref Vector3 OutVector, ref Real OutDistance)
- {
- Vector3 self = this;
- Real LastDistance = Real.MaxValue;
- for (int i = 0; i < InArray.Length; i++)
- {
- var d = Distance(self, InArray[i]);
- if (d <= LastDistance)
- {
- self = InArray[i];
- LastDistance = d;
- }
- }
- OutDistance = LastDistance;
- OutVector = self;
- }
-
- ///
- /// Gets the closest vector to
- ///
- ///
- ///
- ///
- public void GetClosest(ref System.Collections.Generic.List InList, ref Vector3 OutVector, ref Real OutDistance)
- {
- Vector3 self = this;
- Real LastDistance = Real.MaxValue;
- for (int i = 0; i < InList.Count; i++)
- {
- var d = Distance(self, InList[i]);
- if (d <= LastDistance)
- {
- self = InList[i];
- LastDistance = d;
- }
- }
- OutDistance = LastDistance;
- OutVector = self;
+ return ((SnapToGrid(point - gridOrigin, gridSize) * gridOrientation.Conjugated() + offset) * gridOrientation) + gridOrigin;
}
///
diff --git a/Source/Engine/Core/Math/Vector3.h b/Source/Engine/Core/Math/Vector3.h
index ec10879ae..2e5d3d478 100644
--- a/Source/Engine/Core/Math/Vector3.h
+++ b/Source/Engine/Core/Math/Vector3.h
@@ -937,26 +937,15 @@ public:
static FLAXENGINE_API Vector3Base SnapToGrid(const Vector3Base& pos, const Vector3Base& gridSize);
///
- /// Snaps the onto the rotated grid.
- /// For world aligned grid snapping use instead.
+ /// Snaps the onto the rotated grid. For world aligned grid snapping use instead.
///
- /// The position to snap.
- /// The center point.
- /// The rotation of the grid.
- /// The size of the grid.
+ /// The position to snap.
+ /// The size of the grid.
+ /// The center point of the grid.
+ /// The rotation of the grid.
+ /// The local position offset applied to the snapped position before grid rotation.
/// The position snapped to the grid.
- static FLAXENGINE_API Vector3Base SnapToRotatedGrid(const Vector3Base& InPoint, const Vector3Base& InCenterPoint, const Quaternion& InOrientation, const Vector3Base& InGridSize);
-
- ///
- /// The same as but with local offset applied after point is snapped.
- ///
- /// The position to snap.
- /// The center point.
- /// The rotation of the grid.
- /// The size of the grid.
- /// The local grid offset to apply after snapping.
- /// The position snapped to the grid, with offset applied.
- static FLAXENGINE_API Vector3Base SnapToRotatedGridWithOffset(const Vector3Base& InPoint, const Vector3Base& InCenterPoint, const Vector3Base& InOffset, const Quaternion& InOrientation, const Vector3Base& InGridSize);
+ static FLAXENGINE_API Vector3Base SnapToGrid(const Vector3Base& point, const Vector3Base& gridSize, const Quaternion& gridOrientation, const Vector3Base& gridOrigin = Zero, const Vector3Base& offset = Zero);
};
template