diff --git a/Source/Engine/Core/Math/Quaternion.cpp b/Source/Engine/Core/Math/Quaternion.cpp
index ab92426d7..a8e276bf2 100644
--- a/Source/Engine/Core/Math/Quaternion.cpp
+++ b/Source/Engine/Core/Math/Quaternion.cpp
@@ -7,6 +7,7 @@
#include "Matrix3x3.h"
#include "Math.h"
#include "../Types/String.h"
+#include "Engine/Core/Math/Transform.h"
Quaternion Quaternion::Zero(0, 0, 0, 0);
Quaternion Quaternion::One(1, 1, 1, 1);
@@ -537,3 +538,14 @@ void Quaternion::RotationYawPitchRoll(float yaw, float pitch, float roll, Quater
result.Y = sinYawOver2 * cosPitchOver2 * cosRollOver2 - cosYawOver2 * sinPitchOver2 * sinRollOver2;
result.Z = cosYawOver2 * cosPitchOver2 * sinRollOver2 - sinYawOver2 * sinPitchOver2 * cosRollOver2;
}
+
+Quaternion Quaternion::GetRotationFromNormal(const Vector3& InNormal, const Transform& InReferenceTransform)
+{
+ Float3 up = InReferenceTransform.GetUp();
+ auto dot = Vector3::Dot(InNormal, up);
+ if (Math::NearEqual(Math::Abs(dot), 1))
+ {
+ up = InReferenceTransform.GetRight();
+ }
+ return Quaternion::LookRotation(InNormal, up);
+}
diff --git a/Source/Engine/Core/Math/Quaternion.cs b/Source/Engine/Core/Math/Quaternion.cs
index e50795221..ad2117be3 100644
--- a/Source/Engine/Core/Math/Quaternion.cs
+++ b/Source/Engine/Core/Math/Quaternion.cs
@@ -1483,6 +1483,47 @@ namespace FlaxEngine
return results;
}
+ ///
+ /// Gets rotation from a normal in relation to a transform.
+ /// This function is especially useful for axis aligned faces,
+ /// and with .
+ ///
+ /// Example code:
+ ///
+ /// GetRotationFromNormalExample :
+ /// 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);
+ /// SomeObject.Position = point;
+ /// SomeObject.Orientation = rot;
+ /// }
+ /// }
+ /// }
+ ///
+ ///
+ ///
+ /// The normal vector.
+ /// The reference transform.
+ /// The rotation from the normal vector.
+ public static Quaternion GetRotationFromNormal(Vector3 InNormal, Transform InReferenceTransform)
+ {
+ Float3 up = InReferenceTransform.Up;
+ var dot = Vector3.Dot(InNormal, up);
+ if (Mathf.NearEqual(Math.Abs(dot), 1))
+ {
+ up = InReferenceTransform.Right;
+ }
+ return LookRotation(InNormal, up);
+ }
+
///
/// Adds two quaternions.
///
diff --git a/Source/Engine/Core/Math/Quaternion.h b/Source/Engine/Core/Math/Quaternion.h
index 45605a674..25b90a1d4 100644
--- a/Source/Engine/Core/Math/Quaternion.h
+++ b/Source/Engine/Core/Math/Quaternion.h
@@ -660,6 +660,17 @@ public:
// @param roll The roll of rotation (in radians)
// @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 .
+ ///
+ /// The normal vector.
+ /// The reference transform.
+ /// The rotation from the normal vector.
+ static Quaternion GetRotationFromNormal(const Vector3& InNormal, const Transform& InReferenceTransform);
};
///
diff --git a/Source/Engine/Core/Math/Transform.cpp b/Source/Engine/Core/Math/Transform.cpp
index 6195dad04..234b78c04 100644
--- a/Source/Engine/Core/Math/Transform.cpp
+++ b/Source/Engine/Core/Math/Transform.cpp
@@ -252,3 +252,27 @@ void Transform::Lerp(const Transform& t1, const Transform& t2, float amount, Tra
Quaternion::Slerp(t1.Orientation, t2.Orientation, amount, result.Orientation);
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)
+{
+ 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);
+}
diff --git a/Source/Engine/Core/Math/Transform.cs b/Source/Engine/Core/Math/Transform.cs
index e00265f6d..ba86c1a6d 100644
--- a/Source/Engine/Core/Math/Transform.cs
+++ b/Source/Engine/Core/Math/Transform.cs
@@ -477,6 +477,185 @@ 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:
+ /// ,
+ /// .
+ /// 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,
+ /// 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, float InNormalOffset, Transform InRelativeTo, Float3 InReturnScale, Vector3 InGridSize)
+ {
+ 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);
+ }
+
+ ///
+ /// 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;
+ /// 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;
+ /// 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, Vector3 InNormalOffset, Transform InRelativeTo, Vector3 InGridSize)
+ {
+ Quaternion rot = Quaternion.GetRotationFromNormal(InNormal, InRelativeTo);
+ return new Transform(Vector3.SnapToRotatedGridWithOffset(InPoint, InRelativeTo.Translation, InNormalOffset, rot, InGridSize), rot, Float3.One);
+ }
///
/// Tests for equality between two objects.
diff --git a/Source/Engine/Core/Math/Transform.h b/Source/Engine/Core/Math/Transform.h
index 2c51bfa4a..f170ce7a9 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,6 +291,62 @@ 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 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);
+
+
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 3ffb2cdc9..30247d70b 100644
--- a/Source/Engine/Core/Math/Vector3.cpp
+++ b/Source/Engine/Core/Math/Vector3.cpp
@@ -324,6 +324,26 @@ float Float3::Angle(const Float3& from, const Float3& to)
return Math::Acos(dot);
}
+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);
+}
+
+template<>
+Float3 Float3::SnapToRotatedGridWithOffset(const Float3& InPoint, const Float3& InCenterPoint, const Float3& InOffset, const Quaternion& InOrientation, const Float3& InGridSize)
+{
+ 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;
+}
+
// Double
static_assert(sizeof(Double3) == 24, "Invalid Double3 type size.");
@@ -638,6 +658,26 @@ double Double3::Angle(const Double3& from, const Double3& to)
return Math::Acos(dot);
}
+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);
+}
+
+template<>
+Double3 Double3::SnapToRotatedGridWithOffset(const Double3& InPoint, const Double3& InCenterPoint, const Double3& InOffset, const Quaternion& InOrientation, const Double3& InGridSize)
+{
+ 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;
+}
+
// Int
static_assert(sizeof(Int3) == 12, "Invalid Int3 type size.");
@@ -852,3 +892,23 @@ int32 Int3::Angle(const Int3& from, const Int3& to)
{
return 0;
}
+
+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);
+}
+
+template<>
+Int3 Int3::SnapToRotatedGridWithOffset(const Int3& InPoint, const Int3& InCenterPoint, const Int3& InOffset, const Quaternion& InOrientation, const Int3& InGridSize)
+{
+ 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;
+}
diff --git a/Source/Engine/Core/Math/Vector3.cs b/Source/Engine/Core/Math/Vector3.cs
index 738a9bad8..dc2587934 100644
--- a/Source/Engine/Core/Math/Vector3.cs
+++ b/Source/Engine/Core/Math/Vector3.cs
@@ -1672,7 +1672,7 @@ namespace FlaxEngine
}
///
- /// Snaps the input position into the grid.
+ /// Snaps the input position onto the grid.
///
/// The position to snap.
/// The size of the grid.
@@ -1685,6 +1685,168 @@ namespace FlaxEngine
return pos;
}
+ ///
+ /// Snaps the onto the rotated grid.
+ /// For world aligned grid snapping use instead.
+ /// Example code:
+ ///
+ /// SnapToRotatedGridExample :
+ /// 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;
+ /// //Get rotation from normal relative to collider transform
+ /// rot = .GetRotacionFromNormal(normal,transform);
+ /// point = .SnapToRotatedGrid(point,position,rot,GridSize);
+ /// SomeObject.Position = point;
+ /// }
+ /// }
+ /// }
+ ///
+ ///
+ ///
+ /// The position to snap.
+ /// The center point.
+ /// The rotation of the grid.
+ /// The size of the grid.
+ /// The position snapped to the grid.
+ public static Vector3 SnapToRotatedGrid(Vector3 InPoint, Vector3 InCenterPoint, Quaternion InOrientation, Vector3 InGridSize)
+ {
+ 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;
+ }
+
///
/// Adds two vectors.
///
diff --git a/Source/Engine/Core/Math/Vector3.h b/Source/Engine/Core/Math/Vector3.h
index 619fcfc12..ec10879ae 100644
--- a/Source/Engine/Core/Math/Vector3.h
+++ b/Source/Engine/Core/Math/Vector3.h
@@ -927,6 +927,36 @@ public:
/// The second vector.
/// The angle (in radians).
static FLAXENGINE_API T Angle(const Vector3Base& from, const Vector3Base& to);
+
+ ///
+ /// Snaps the input position onto the grid.
+ ///
+ /// The position to snap.
+ /// The size of the grid.
+ /// The position snapped to the grid.
+ static FLAXENGINE_API Vector3Base SnapToGrid(const Vector3Base& pos, const Vector3Base& gridSize);
+
+ ///
+ /// 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 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);
};
template