From 653aaecaec9be4e0ca576bd97f061c6daf77b2ef Mon Sep 17 00:00:00 2001 From: Wojtek Figat Date: Fri, 30 Aug 2024 14:48:06 +0200 Subject: [PATCH] Postmerge cleanup #2391 --- Source/Engine/Core/Math/Quaternion.cpp | 10 +- Source/Engine/Core/Math/Quaternion.cs | 28 ++--- Source/Engine/Core/Math/Quaternion.h | 11 +- Source/Engine/Core/Math/Transform.cpp | 24 +--- Source/Engine/Core/Math/Transform.cs | 155 +++++------------------- Source/Engine/Core/Math/Transform.h | 70 +++-------- Source/Engine/Core/Math/Vector3.cpp | 46 +++---- Source/Engine/Core/Math/Vector3.cs | 160 +++---------------------- Source/Engine/Core/Math/Vector3.h | 25 ++-- 9 files changed, 111 insertions(+), 418 deletions(-) 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