DomainRotatePlane Node

Author: Auburn

include/FastNoise/Generators/Modifiers.h

@@ -495,5 +495,46 @@ namespace FastNoise
         }
     };
 #endif
+
+    enum class PlaneRotationType
+    {
+        ImproveXYPlanes,
+        ImproveXZPlanes
+    };
+
+    class DomainRotatePlane : public virtual Generator
+    {
+    public:
+        const Metadata& GetMetadata() const override;
+
+        void SetSource( SmartNodeArg<> gen ) { this->SetSourceMemberVariable( mSource, gen ); }
+        void SetRotationType( PlaneRotationType type ) { mRotationType = type; }
+
+    protected:
+        GeneratorSource mSource;
+        PlaneRotationType mRotationType = PlaneRotationType::ImproveXYPlanes;
+    };
+
+#ifdef FASTNOISE_METADATA
+    template<>
+    struct MetadataT<DomainRotatePlane> : MetadataT<Generator>
+    {
+        SmartNode<> CreateNode( FastSIMD::FeatureSet ) const override;
+
+        MetadataT()
+        {
+            groups.push_back( "Domain Modifiers" );
+            this->AddGeneratorSource( "Source", &DomainRotatePlane::SetSource );
+            
+            this->AddVariableEnum( "Rotation Type", PlaneRotationType::ImproveXYPlanes, &DomainRotatePlane::SetRotationType, "Improve XY Planes", "Improve XZ Planes" );
+
+            description =
+                "Applies preset rotation to improve noise in specific 3D planes. Faster than DomainRotate.\n"
+                "This helps reduce axis aligned artifacts in 3D noise for the specified plane.\n"
+                "For 2D input coordinates a 3rd dimension is added and the noise is optimized for the XY plane\n"
+                "For 4D input coordinates only the first 3 dimensions are rotated, the 4th dimension is passed through unchanged";
+        }
+    };
+#endif
 
 }

include/FastNoise/Generators/Modifiers.inl

@@ -299,3 +299,63 @@ class FastSIMD::DispatchClass<FastNoise::Abs, SIMD> final : public virtual FastN
         return FS::Abs( value );
     }
 };
+
+template<FastSIMD::FeatureSet SIMD>
+class FastSIMD::DispatchClass<FastNoise::DomainRotatePlane, SIMD> final : public virtual FastNoise::DomainRotatePlane, public FastSIMD::DispatchClass<FastNoise::Generator, SIMD>
+{
+    FS_FORCEINLINE void FS_VECTORCALL RotateCoords( PlaneRotationType rotationType, float32v& x, float32v& y, float32v& z ) const
+    {
+        float32v newX = x;
+        float32v newY = y;
+        float32v newZ = z;
+
+        switch( rotationType )
+        {
+        case PlaneRotationType::ImproveXYPlanes:
+        {
+            float32v xy = x + y;
+            float32v s2 = xy * float32v( -0.211324865405187f );
+            newZ = z * float32v( 0.577350269189626f );
+            newX = x + s2 - newZ;
+            newY = y + s2 - newZ;
+            newZ = newZ + xy * float32v( 0.577350269189626f );
+        }
+            break;
+
+        case PlaneRotationType::ImproveXZPlanes:
+        {
+            float32v xz = x + z;
+            float32v s2 = xz * float32v( -0.211324865405187f );
+            newY = y * float32v( 0.577350269189626f );
+            newX = x + s2 - newY;
+            newZ = z + s2 - newY;
+            newY = newY + xz * float32v( 0.577350269189626f );
+
+        }
+            break;
+        }
+        x = newX;
+        y = newY;
+        z = newZ;
+    }
+
+    float32v FS_VECTORCALL Gen( int32v seed, float32v x, float32v y ) const
+    {
+        float32v z = 0;
+        RotateCoords( PlaneRotationType::ImproveXYPlanes, x, y, z );
+
+        return this->GetSourceValue( mSource, seed, x, y, z );
+    }
+
+    float32v FS_VECTORCALL Gen( int32v seed, float32v x, float32v y, float32v z ) const
+    {
+        RotateCoords( mRotationType, x, y, z );
+        return this->GetSourceValue( mSource, seed, x, y, z );
+    }
+
+    float32v FS_VECTORCALL Gen( int32v seed, float32v x, float32v y, float32v z, float32v w ) const
+    {
+        RotateCoords( mRotationType, x, y, z );
+        return this->GetSourceValue( mSource, seed, x, y, z, w );
+    }
+};

src/FastNoise/FastSIMD_Build.inl

@@ -140,3 +140,4 @@ FASTNOISE_REGISTER_NODE( AddDimension );
 FASTNOISE_REGISTER_NODE( RemoveDimension );
 
 FASTNOISE_REGISTER_NODE( Modulus );
+FASTNOISE_REGISTER_NODE( DomainRotatePlane );

src/FastNoise/Metadata.cpp

@@ -21,15 +21,15 @@ constexpr static std::nullptr_t gMetadataVectorSize = nullptr; // Invalid
 // Setting these values avoids needless vector resizing and oversizing on startup
 // Sadly there is no way to automate this as they fill up as part of static init
 template<>
-constexpr size_t gMetadataVectorSize<const Metadata*> = 45;
+constexpr size_t gMetadataVectorSize<const Metadata*> = 47;
 template<>
-constexpr size_t gMetadataVectorSize<const char*> = 87;
+constexpr size_t gMetadataVectorSize<const char*> = 91;
 template<>
-constexpr size_t gMetadataVectorSize<Metadata::MemberVariable> = 70;
+constexpr size_t gMetadataVectorSize<Metadata::MemberVariable> = 72;
 template<>
-constexpr size_t gMetadataVectorSize<Metadata::MemberNodeLookup> = 30;
+constexpr size_t gMetadataVectorSize<Metadata::MemberNodeLookup> = 32;
 template<>
-constexpr size_t gMetadataVectorSize<Metadata::MemberHybrid> = 56;
+constexpr size_t gMetadataVectorSize<Metadata::MemberHybrid> = 57;
 
 template<typename T>
 static std::vector<T>& GetVectorStorage()