├── BlueprintRotationLibrary.cpp ├── BlueprintRotationLibrary.h ├── LICENSE.txt ├── Nodes.png └── README.md /BlueprintRotationLibrary.cpp: -------------------------------------------------------------------------------- 1 | #include "BlueprintRotationLibrary.h" 2 | 3 | FQuat UBlueprintRotationLibrary::Lerp(const FQuat& A, const FQuat& B, const float& Alpha) 4 | { 5 | return FMath::Lerp(A, B, Alpha); 6 | } 7 | 8 | FQuat UBlueprintRotationLibrary::FastLerp(const FQuat& A, const FQuat& B, const float& Alpha) 9 | { 10 | return FQuat::FastLerp(A, B, Alpha); 11 | } 12 | 13 | FQuat UBlueprintRotationLibrary::BiLerp(const FQuat& P00, const FQuat& P10, const FQuat& P01, const FQuat& P11, const float & FracX, const float & FracY) 14 | { 15 | return FMath::BiLerp(P00, P10, P01, P11, FracX, FracY); 16 | } 17 | 18 | FQuat UBlueprintRotationLibrary::FastBiLerp(const FQuat& P00, const FQuat& P10, const FQuat& P01, const FQuat& P11, const float & FracX, const float & FracY) 19 | { 20 | return FQuat::FastBilerp(P00, P10, P01, P11, FracX, FracY); 21 | } 22 | 23 | FQuat UBlueprintRotationLibrary::Slerp(const FQuat& A, const FQuat& B, const float & Slerp) 24 | { 25 | return FQuat::Slerp(A, B, Slerp); 26 | } 27 | 28 | FQuat UBlueprintRotationLibrary::Slerp_NotNormalized(const FQuat& A, const FQuat& B, const float & Slerp) 29 | { 30 | return FQuat::Slerp_NotNormalized(A, B, Slerp); 31 | } 32 | 33 | float UBlueprintRotationLibrary::Dot(const FQuat& A, const FQuat& B) 34 | { 35 | return A | B; 36 | } 37 | 38 | FQuat UBlueprintRotationLibrary::VectorToOrientationQuat(const FVector Vector) 39 | { 40 | return Vector.ToOrientationQuat(); 41 | } 42 | 43 | FRotator UBlueprintRotationLibrary::VectorToOrientationRotator(const FVector Vector) 44 | { 45 | return Vector.ToOrientationRotator(); 46 | } 47 | 48 | FQuat UBlueprintRotationLibrary::RotatorToQuat(const FRotator Rotator) 49 | { 50 | return Rotator.Quaternion(); 51 | } 52 | 53 | FRotator UBlueprintRotationLibrary::QuatToRotator(const FQuat& Quat) 54 | { 55 | return FRotator(Quat); 56 | } 57 | 58 | float UBlueprintRotationLibrary::AngleBetweenDirectionVectorsRad(FVector A, FVector B) 59 | { 60 | A.Normalize(1.0f); 61 | B.Normalize(1.0f); 62 | 63 | return FGenericPlatformMath::Acos(FVector::DotProduct(A, B)); 64 | } 65 | 66 | float UBlueprintRotationLibrary::AngleBetweenDirectionVectorsDeg(FVector A, FVector B) 67 | { 68 | A.Normalize(1.0f); 69 | B.Normalize(1.0f); 70 | 71 | return FMath::RadiansToDegrees(FGenericPlatformMath::Acos(FVector::DotProduct(A, B))); 72 | } 73 | 74 | float UBlueprintRotationLibrary::AngleBetweenQuatsRad(FQuat A, FQuat B) 75 | { 76 | return A.AngularDistance(B); 77 | } 78 | 79 | float UBlueprintRotationLibrary::AngleBetweenQuatsDeg(FQuat A, FQuat B) 80 | { 81 | return FMath::RadiansToDegrees(A.AngularDistance(B)); 82 | } 83 | 84 | FQuat UBlueprintRotationLibrary::EulerDegToQuat(const FVector Euler) 85 | { 86 | return FQuat::MakeFromEuler(Euler); 87 | } 88 | 89 | FVector UBlueprintRotationLibrary::QuatToEulerDeg(const FQuat& Quat) 90 | { 91 | return Quat.Euler(); 92 | } 93 | 94 | FQuat UBlueprintRotationLibrary::QuatPlusQuat(const FQuat& A, const FQuat& B) 95 | { 96 | return A + B; 97 | } 98 | 99 | FQuat UBlueprintRotationLibrary::QuatMinusQuat(const FQuat& A, const FQuat& B) 100 | { 101 | return A - B; 102 | } 103 | 104 | FQuat UBlueprintRotationLibrary::QuatMultiplyQuat(const FQuat& A, const FQuat& B) 105 | { 106 | return A * B; 107 | } 108 | 109 | FQuat UBlueprintRotationLibrary::QuatMultiplyFloatScale(const FQuat& A, const float B) 110 | { 111 | return A * B; 112 | } 113 | 114 | FQuat UBlueprintRotationLibrary::QuatDivFloatScale(const FQuat& A, const float B) 115 | { 116 | return A / B; 117 | } 118 | 119 | bool UBlueprintRotationLibrary::AreQuatsEqual(const FQuat& A, const FQuat& B) 120 | { 121 | return A == B; 122 | } 123 | 124 | FString UBlueprintRotationLibrary::QuatToString(const FQuat& Quat) 125 | { 126 | return FString::Printf(TEXT("X=%f,Y=%f,Z=%f,W=%f"), Quat.X, Quat.Y, Quat.Z, Quat.W); 127 | } 128 | 129 | void UBlueprintRotationLibrary::AddActorLocalRotation(AActor* Actor, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport) 130 | { 131 | ETeleportType Teleport; 132 | 133 | if (bTeleport) 134 | { 135 | Teleport = ETeleportType::TeleportPhysics; 136 | } 137 | else 138 | { 139 | Teleport = ETeleportType::None; 140 | } 141 | 142 | Actor->AddActorLocalRotation(Quat, bSweep, &OutSweepHitResult, Teleport); 143 | } 144 | 145 | void UBlueprintRotationLibrary::AddActorWorldRotation(AActor* Actor, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport) 146 | { 147 | ETeleportType Teleport; 148 | 149 | if (bTeleport) 150 | { 151 | Teleport = ETeleportType::TeleportPhysics; 152 | } 153 | else 154 | { 155 | Teleport = ETeleportType::None; 156 | } 157 | 158 | Actor->AddActorWorldRotation(Quat, bSweep, &OutSweepHitResult, Teleport); 159 | } 160 | 161 | void UBlueprintRotationLibrary::AddComponentLocalRotation(USceneComponent* Component, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport) 162 | { 163 | ETeleportType Teleport; 164 | 165 | if (bTeleport) 166 | { 167 | Teleport = ETeleportType::TeleportPhysics; 168 | } 169 | else 170 | { 171 | Teleport = ETeleportType::None; 172 | } 173 | 174 | Component->AddLocalRotation(Quat, bSweep, &OutSweepHitResult, Teleport); 175 | } 176 | 177 | void UBlueprintRotationLibrary::AddComponentRelativeRotation(USceneComponent* Component, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport) 178 | { 179 | ETeleportType Teleport; 180 | 181 | if (bTeleport) 182 | { 183 | Teleport = ETeleportType::TeleportPhysics; 184 | } 185 | else 186 | { 187 | Teleport = ETeleportType::None; 188 | } 189 | 190 | Component->AddRelativeRotation(Quat, bSweep, &OutSweepHitResult, Teleport); 191 | } 192 | 193 | void UBlueprintRotationLibrary::AddComponentWorldRotation(USceneComponent* Component, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport) 194 | { 195 | ETeleportType Teleport; 196 | 197 | if (bTeleport) 198 | { 199 | Teleport = ETeleportType::TeleportPhysics; 200 | } 201 | else 202 | { 203 | Teleport = ETeleportType::None; 204 | } 205 | 206 | Component->AddWorldRotation(Quat, bSweep, &OutSweepHitResult, Teleport); 207 | } 208 | 209 | void UBlueprintRotationLibrary::SetActorRelativeRotation(AActor* Actor, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport) 210 | { 211 | ETeleportType Teleport; 212 | 213 | if (bTeleport) 214 | { 215 | Teleport = ETeleportType::TeleportPhysics; 216 | } 217 | else 218 | { 219 | Teleport = ETeleportType::None; 220 | } 221 | 222 | Actor->SetActorRelativeRotation(Quat, bSweep, &OutSweepHitResult, Teleport); 223 | } 224 | 225 | void UBlueprintRotationLibrary::SetActorRotation(AActor* Actor, const FQuat& Quat, bool bTeleport) 226 | { 227 | ETeleportType Teleport; 228 | 229 | if (bTeleport) 230 | { 231 | Teleport = ETeleportType::TeleportPhysics; 232 | } 233 | else 234 | { 235 | Teleport = ETeleportType::None; 236 | } 237 | 238 | Actor->SetActorRotation(Quat, Teleport); 239 | } 240 | 241 | void UBlueprintRotationLibrary::SetComponentRelativeRotation(USceneComponent* Component, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport) 242 | { 243 | ETeleportType Teleport; 244 | 245 | if (bTeleport) 246 | { 247 | Teleport = ETeleportType::TeleportPhysics; 248 | } 249 | else 250 | { 251 | Teleport = ETeleportType::None; 252 | } 253 | 254 | Component->SetRelativeRotation(Quat, bSweep, &OutSweepHitResult, Teleport); 255 | } 256 | 257 | void UBlueprintRotationLibrary::SetComponentWorldRotation(USceneComponent* Component, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport) 258 | { 259 | ETeleportType Teleport; 260 | 261 | if (bTeleport) 262 | { 263 | Teleport = ETeleportType::TeleportPhysics; 264 | } 265 | else 266 | { 267 | Teleport = ETeleportType::None; 268 | } 269 | 270 | Component->SetWorldRotation(Quat, bSweep, &OutSweepHitResult, Teleport); 271 | } 272 | 273 | FQuat UBlueprintRotationLibrary::GetTransformQuat(const FTransform Transform) 274 | { 275 | return Transform.GetRotation(); 276 | } 277 | 278 | void UBlueprintRotationLibrary::BreakTransformQuat(const FTransform Transform, FVector& Location, FQuat& RotationQuat, FVector& Scale) 279 | { 280 | Location = Transform.GetLocation(); 281 | RotationQuat = Transform.GetRotation(); 282 | Scale = Transform.GetScale3D(); 283 | } 284 | 285 | void UBlueprintRotationLibrary::QuatAxisAngleRad(const FQuat& Quat, float& OutAngleRad, FVector& OutAxis) 286 | { 287 | OutAngleRad = Quat.GetAngle(); 288 | OutAxis = Quat.GetRotationAxis(); 289 | } 290 | 291 | void UBlueprintRotationLibrary::QuatAxisAngleDeg(const FQuat& Quat, float& OutAngleDeg, FVector& OutAxis) 292 | { 293 | OutAngleDeg = FMath::RadiansToDegrees(Quat.GetAngle()); 294 | OutAxis = Quat.GetRotationAxis(); 295 | } 296 | 297 | FQuat UBlueprintRotationLibrary::FindBetweenNormals(const FVector& Normal1, const FVector& Normal2) 298 | { 299 | return FQuat::FindBetweenNormals(Normal1, Normal2); 300 | } 301 | 302 | FVector UBlueprintRotationLibrary::GetForwardVector(const FQuat& Quat) 303 | { 304 | return Quat.GetForwardVector(); 305 | } 306 | 307 | FVector UBlueprintRotationLibrary::GetRightVector(const FQuat& Quat) 308 | { 309 | return Quat.GetRightVector(); 310 | } 311 | 312 | FVector UBlueprintRotationLibrary::GetUpVector(const FQuat& Quat) 313 | { 314 | return Quat.GetUpVector(); 315 | } 316 | 317 | FQuat UBlueprintRotationLibrary::Inverse(const FQuat& Quat) 318 | { 319 | return Quat.Inverse(); 320 | } 321 | 322 | FVector UBlueprintRotationLibrary::QuatToVector(const FQuat& Quat) 323 | { 324 | return Quat.Vector(); 325 | } 326 | -------------------------------------------------------------------------------- /BlueprintRotationLibrary.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "CoreMinimal.h" 4 | #include "UObject/NoExportTypes.h" 5 | #include "BlueprintRotationLibrary.generated.h" 6 | 7 | UCLASS() 8 | class PROJECTNAME_API UBlueprintRotationLibrary : public UObject 9 | { 10 | GENERATED_BODY() 11 | 12 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Lerp (Quat)")) 13 | static FQuat Lerp(const FQuat& A, const FQuat& B, const float& Alpha); 14 | 15 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Fast Lerp (Quat)")) 16 | static FQuat FastLerp(const FQuat& A, const FQuat& B, const float& Alpha); 17 | 18 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="BiLerp (Quat)")) 19 | static FQuat BiLerp( 20 | const FQuat& P00, 21 | const FQuat& P10, 22 | const FQuat& P01, 23 | const FQuat& P11, 24 | const float& FracX, 25 | const float& FracY 26 | ); 27 | 28 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Fast BiLerp (Quat)")) 29 | static FQuat FastBiLerp( 30 | const FQuat& P00, 31 | const FQuat& P10, 32 | const FQuat& P01, 33 | const FQuat& P11, 34 | const float& FracX, 35 | const float& FracY 36 | ); 37 | 38 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Slerp (Quat)")) 39 | static FQuat Slerp(const FQuat& A, const FQuat& B, const float& Slerp); 40 | 41 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Slerp (Not Normalized) (Quat)")) 42 | static FQuat Slerp_NotNormalized(const FQuat& A, const FQuat& B, const float& Slerp); 43 | 44 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Dot (Quat)", CompactNodeTitle="dot")) 45 | static float Dot(const FQuat& A, const FQuat& B); 46 | 47 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 48 | static FQuat VectorToOrientationQuat(const FVector Vector); 49 | 50 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(BlueprintAutocast)) 51 | static FRotator VectorToOrientationRotator(const FVector Vector); 52 | 53 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 54 | static FQuat RotatorToQuat(const FRotator Rotator); 55 | 56 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(BlueprintAutocast)) 57 | static FRotator QuatToRotator(const FQuat& Quat); 58 | 59 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 60 | static float AngleBetweenDirectionVectorsRad(FVector A, FVector B); 61 | 62 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 63 | static float AngleBetweenDirectionVectorsDeg(FVector A, FVector B); 64 | 65 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 66 | static float AngleBetweenQuatsRad(FQuat A, FQuat B); 67 | 68 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 69 | static float AngleBetweenQuatsDeg(FQuat A, FQuat B); 70 | 71 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 72 | static FQuat EulerDegToQuat(const FVector Euler); 73 | 74 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 75 | static FVector QuatToEulerDeg(const FQuat& Quat); 76 | 77 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Quat + Quat", CompactNodeTitle="+")) 78 | static FQuat QuatPlusQuat(const FQuat& A, const FQuat& B); 79 | 80 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Quat - Quat", CompactNodeTitle="-")) 81 | static FQuat QuatMinusQuat(const FQuat& A, const FQuat& B); 82 | 83 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Quat * Quat", CompactNodeTitle="*")) 84 | static FQuat QuatMultiplyQuat(const FQuat& A, const FQuat& B); 85 | 86 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Quat * Float (Scale)", CompactNodeTitle="* (Scale)")) 87 | static FQuat QuatMultiplyFloatScale(const FQuat& A, const float B); 88 | 89 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Quat / Float (Scale)", CompactNodeTitle="/ (Scale)")) 90 | static FQuat QuatDivFloatScale(const FQuat& A, const float B); 91 | 92 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(DisplayName="Quat == Quat", CompactNodeTitle="==")) 93 | static bool AreQuatsEqual(const FQuat& A, const FQuat& B); 94 | 95 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary", meta=(BlueprintAutocast)) 96 | static FString QuatToString(const FQuat& Quat); 97 | 98 | UFUNCTION(BlueprintCallable, Category="BlueprintRotationLibrary") 99 | static void AddActorLocalRotation(AActor* Actor, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport); 100 | 101 | UFUNCTION(BlueprintCallable, Category="BlueprintRotationLibrary") 102 | static void AddActorWorldRotation(AActor* Actor, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport); 103 | 104 | UFUNCTION(BlueprintCallable, Category="BlueprintRotationLibrary") 105 | static void AddComponentLocalRotation(USceneComponent* Component, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport); 106 | 107 | UFUNCTION(BlueprintCallable, Category="BlueprintRotationLibrary") 108 | static void AddComponentRelativeRotation(USceneComponent* Component, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport); 109 | 110 | UFUNCTION(BlueprintCallable, Category="BlueprintRotationLibrary") 111 | static void AddComponentWorldRotation(USceneComponent* Component, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport); 112 | 113 | UFUNCTION(BlueprintCallable, Category="BlueprintRotationLibrary") 114 | static void SetActorRelativeRotation(AActor* Actor, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport); 115 | 116 | UFUNCTION(BlueprintCallable, Category="BlueprintRotationLibrary") 117 | static void SetActorRotation(AActor* Actor, const FQuat& Quat, bool bTeleport); 118 | 119 | UFUNCTION(BlueprintCallable, Category="BlueprintRotationLibrary") 120 | static void SetComponentRelativeRotation(USceneComponent* Component, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport); 121 | 122 | UFUNCTION(BlueprintCallable, Category="BlueprintRotationLibrary") 123 | static void SetComponentWorldRotation(USceneComponent* Component, const FQuat& Quat, bool bSweep, FHitResult& OutSweepHitResult, bool bTeleport); 124 | 125 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 126 | static FQuat GetTransformQuat(const FTransform Transform); 127 | 128 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 129 | static void BreakTransformQuat(const FTransform Transform, FVector& Location, FQuat& RotationQuat, FVector& Scale); 130 | 131 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 132 | static void QuatAxisAngleRad(const FQuat& Quat, float& OutAngleRad, FVector& OutAxis); 133 | 134 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 135 | static void QuatAxisAngleDeg(const FQuat& Quat, float& OutAngleDeg, FVector& OutAxis); 136 | 137 | /** 138 | * @brief Generates the 'smallest' (geodesic) rotation between two normals (assumed to be unit length). 139 | * 140 | * Copied from C++ docs 141 | */ 142 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 143 | static FQuat FindBetweenNormals(const FVector& Normal1, const FVector& Normal2); 144 | 145 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 146 | static FVector GetForwardVector(const FQuat& Quat); 147 | 148 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 149 | static FVector GetRightVector(const FQuat& Quat); 150 | 151 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 152 | static FVector GetUpVector(const FQuat& Quat); 153 | 154 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 155 | static FQuat Inverse(const FQuat& Quat); 156 | 157 | /** 158 | * @brief Convert a rotation into a unit vector facing in its direction. 159 | * 160 | * Copied from C++ docs 161 | */ 162 | UFUNCTION(BlueprintPure, Category="BlueprintRotationLibrary") 163 | static FVector QuatToVector(const FQuat& Quat); 164 | }; 165 | -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | This is free and unencumbered software released into the public domain. 2 | 3 | Anyone is free to copy, modify, publish, use, compile, sell, or 4 | distribute this software, either in source code form or as a compiled 5 | binary, for any purpose, commercial or non-commercial, and by any 6 | means. 7 | 8 | In jurisdictions that recognize copyright laws, the author or authors 9 | of this software dedicate any and all copyright interest in the 10 | software to the public domain. We make this dedication for the benefit 11 | of the public at large and to the detriment of our heirs and 12 | successors. We intend this dedication to be an overt act of 13 | relinquishment in perpetuity of all present and future rights to this 14 | software under copyright law. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 | OTHER DEALINGS IN THE SOFTWARE. 23 | 24 | For more information, please refer to 25 | -------------------------------------------------------------------------------- /Nodes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CraftedCart/BlueprintRotationLibrary/8be77038d5d298465e7773b5932ba25050558a30/Nodes.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | BlueprintRotationLibrary 2 | ======================== 3 | 4 | A collection of blueprint nodes to work with Quaternions within Unreal Engine's Blueprint scripting 5 | 6 | ![Blueprint nodes](Nodes.png) 7 | 8 | Just copy-n-paste the .cpp and .h files somewhere into your project's source, **and be sure to replace `PROJECTNAME_API` 9 | with your own `_API` macro** in BlueprintRotationLibrary.h, line 8. 10 | 11 | I don't care what you do with this, I put this into the public domain. It's mostly just wrappers around FQuat functions 12 | anyway. <3 13 | 14 | This project lives on GitLab (https://gitlab.com/CraftedCart/BlueprintRotationLibrary), however changes are synced over 15 | to GitHub (https://github.com/CraftedCart/BlueprintRotationLibrary) 16 | --------------------------------------------------------------------------------