Add FastNoiseLite / general noise overhaul

- replace OpenSimplexNoise

Co-authored-by: Cory Petkovsek <tinmanjuggernaut@users.noreply.github.com>

26 files changed, 4084 insertions, 2991 deletions

diff --git a/COPYRIGHT.txt b/COPYRIGHT.txt
index cfb4778d6b..8b49cbfd2a 100644
--- a/COPYRIGHT.txt
+++ b/COPYRIGHT.txt
@@ -305,11 +305,10 @@ Comment: Tangent Space Normal Maps implementation
 Copyright: 2011, Morten S. Mikkelsen
 License: Zlib
 
-Files: ./thirdparty/misc/open-simplex-noise.c
- ./thirdparty/misc/open-simplex-noise.h
-Comment: OpenSimplex Noise
-Copyright: 2014, Stephen M. Cameron
-License: public-domain or Unlicense
+Files: ./thirdparty/noise/FastNoiseLite.h
+Comment: FastNoise Lite
+Copyright: 2020, Jordan Peck and contributors
+License: MIT
 
 Files: ./thirdparty/misc/pcg.cpp
  ./thirdparty/misc/pcg.h
diff --git a/modules/opensimplex/SCsub b/modules/noise/SCsub
index 86d77c3dfb..3e8395b9b1 100644
--- a/modules/opensimplex/SCsub
+++ b/modules/noise/SCsub
@@ -3,21 +3,21 @@
 Import("env")
 Import("env_modules")
 
-env_opensimplex = env_modules.Clone()
+env_noise = env_modules.Clone()
 
 # Thirdparty source files
 
 thirdparty_obj = []
 
-thirdparty_dir = "#thirdparty/misc/"
+thirdparty_dir = "#thirdparty/noise/"
 thirdparty_sources = [
-    "open-simplex-noise.c",
+    # Add C++ source files for noise modules here
 ]
 thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
-env_opensimplex.Prepend(CPPPATH=[thirdparty_dir])
+env_noise.Prepend(CPPPATH=[thirdparty_dir])
 
-env_thirdparty = env_opensimplex.Clone()
+env_thirdparty = env_noise.Clone()
 env_thirdparty.disable_warnings()
 env_thirdparty.add_source_files(thirdparty_obj, thirdparty_sources)
 env.modules_sources += thirdparty_obj
@@ -26,7 +26,7 @@ env.modules_sources += thirdparty_obj
 
 module_obj = []
 
-env_opensimplex.add_source_files(module_obj, "*.cpp")
+env_noise.add_source_files(module_obj, "*.cpp")
 env.modules_sources += module_obj
 
 # Needed to force rebuilding the module files when the thirdparty library is updated.
diff --git a/modules/opensimplex/config.py b/modules/noise/config.py
index 90b85dbd70..74db20f2a4 100644
--- a/modules/opensimplex/config.py
+++ b/modules/noise/config.py
@@ -8,8 +8,9 @@ def configure(env):
 
 def get_doc_classes():
     return [
+        "FastNoiseLite",
+        "Noise",
         "NoiseTexture",
-        "OpenSimplexNoise",
     ]
 
 
diff --git a/modules/noise/doc_classes/FastNoiseLite.xml b/modules/noise/doc_classes/FastNoiseLite.xml
new file mode 100644
index 0000000000..b6d91850c4
--- /dev/null
+++ b/modules/noise/doc_classes/FastNoiseLite.xml
@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="FastNoiseLite" inherits="Noise" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
+	<brief_description>
+		Generates noise using the FastNoiseLite library.
+	</brief_description>
+	<description>
+		This class generates noise using the FastNoiseLite library, which is a collection of several noise algorithms including Cellular, Perlin, Value, and more.
+		Most generated noise values are in the range of [code][-1,1][/code], however not always. Some of the cellular noise algorithms return results above [code]1[/code].
+	</description>
+	<tutorials>
+	</tutorials>
+	<members>
+		<member name="cellular_distance_function" type="int" setter="set_cellular_distance_function" getter="get_cellular_distance_function" enum="FastNoiseLite.CellularDistanceFunction" default="0">
+			Determines how the distance to the nearest/second-nearest point is computed. See [enum CellularDistanceFunction] for options.
+		</member>
+		<member name="cellular_jitter" type="float" setter="set_cellular_jitter" getter="get_cellular_jitter" default="0.45">
+			Maximum distance a point can move off of its grid position. Set to [code]0[/code] for an even grid.
+		</member>
+		<member name="cellular_return_type" type="int" setter="set_cellular_return_type" getter="get_cellular_return_type" enum="FastNoiseLite.CellularReturnType" default="0">
+			Return type from cellular noise calculations. See [enum CellularReturnType].
+		</member>
+		<member name="color_ramp" type="Gradient" setter="set_color_ramp" getter="get_color_ramp">
+			A [Gradient] which is used to map the luminance of each pixel to a color value.
+		</member>
+		<member name="domain_warp_amplitude" type="float" setter="set_domain_warp_amplitude" getter="get_domain_warp_amplitude" default="30.0">
+			Sets the maximum warp distance from the origin.
+		</member>
+		<member name="domain_warp_enabled" type="bool" setter="set_domain_warp_enabled" getter="is_domain_warp_enabled" default="false">
+			If enabled, another FastNoiseLite instance is used to warp the space, resulting in a distortion of the noise.
+		</member>
+		<member name="domain_warp_fractal_gain" type="float" setter="set_domain_warp_fractal_gain" getter="get_domain_warp_fractal_gain" default="0.5">
+			Determines the strength of each subsequent layer of the noise which is used to warp the space.
+			A low value places more emphasis on the lower frequency base layers, while a high value puts more emphasis on the higher frequency layers.
+		</member>
+		<member name="domain_warp_fractal_lacunarity" type="float" setter="set_domain_warp_fractal_lacunarity" getter="get_domain_warp_fractal_lacunarity" default="6.0">
+			Octave lacunarity of the fractal noise which warps the space. Increasing this value results in higher octaves producing noise with finer details and a rougher appearance.
+		</member>
+		<member name="domain_warp_fractal_octaves" type="int" setter="set_domain_warp_fractal_octaves" getter="get_domain_warp_fractal_octaves" default="5">
+			The number of noise layers that are sampled to get the final value for the fractal noise which warps the space.
+		</member>
+		<member name="domain_warp_fractal_type" type="int" setter="set_domain_warp_fractal_type" getter="get_domain_warp_fractal_type" enum="FastNoiseLite.DomainWarpFractalType" default="1">
+			The method for combining octaves into a fractal which is used to warp the space. See [enum DomainWarpFractalType].
+		</member>
+		<member name="domain_warp_frequency" type="float" setter="set_domain_warp_frequency" getter="get_domain_warp_frequency" default="0.05">
+			Frequency of the noise which warps the space. Low frequency results in smooth noise while high frequency results in rougher, more granular noise.
+		</member>
+		<member name="domain_warp_type" type="int" setter="set_domain_warp_type" getter="get_domain_warp_type" enum="FastNoiseLite.DomainWarpType" default="0">
+			Sets the warp algorithm. See [enum DomainWarpType].
+		</member>
+		<member name="fractal_gain" type="float" setter="set_fractal_gain" getter="get_fractal_gain" default="0.5">
+			Determines the strength of each subsequent layer of noise in fractal noise.
+			A low value places more emphasis on the lower frequency base layers, while a high value puts more emphasis on the higher frequency layers.
+		</member>
+		<member name="fractal_lacunarity" type="float" setter="set_fractal_lacunarity" getter="get_fractal_lacunarity" default="2.0">
+			Frequency multiplier between subsequent octaves. Increasing this value results in higher octaves producing noise with finer details and a rougher appearance.
+		</member>
+		<member name="fractal_octaves" type="int" setter="set_fractal_octaves" getter="get_fractal_octaves" default="5">
+			The number of noise layers that are sampled to get the final value for fractal noise types.
+		</member>
+		<member name="fractal_ping_pong_strength" type="float" setter="set_fractal_ping_pong_strength" getter="get_fractal_ping_pong_strength" default="2.0">
+			Sets the strength of the fractal ping pong type.
+		</member>
+		<member name="fractal_type" type="int" setter="set_fractal_type" getter="get_fractal_type" enum="FastNoiseLite.FractalType" default="1">
+			The method for combining octaves into a fractal. See [enum FractalType].
+		</member>
+		<member name="fractal_weighted_strength" type="float" setter="set_fractal_weighted_strength" getter="get_fractal_weighted_strength" default="0.0">
+			Higher weighting means higher octaves have less impact if lower octaves have a large impact.
+		</member>
+		<member name="frequency" type="float" setter="set_frequency" getter="get_frequency" default="0.01">
+			The frequency for all noise types. Low frequency results in smooth noise while high frequency results in rougher, more granular noise.
+		</member>
+		<member name="in_3d_space" type="bool" setter="set_in_3d_space" getter="is_in_3d_space" default="false">
+			Determines whether the noise image returned by [method Noise.get_image] is calculated in 3d space. May result in reduced contrast.
+		</member>
+		<member name="noise_type" type="int" setter="set_noise_type" getter="get_noise_type" enum="FastNoiseLite.NoiseType" default="1">
+			The noise algorithm used. See [enum NoiseType].
+		</member>
+		<member name="offset" type="Vector3" setter="set_offset" getter="get_offset" default="Vector3(0, 0, 0)">
+			Translate the noise input coordinates by the given [Vector3].
+		</member>
+		<member name="seed" type="int" setter="set_seed" getter="get_seed" default="0">
+			The random number seed for all noise types.
+		</member>
+	</members>
+	<constants>
+		<constant name="TYPE_VALUE" value="5" enum="NoiseType">
+			A lattice of points are assigned random values then interpolated based on neighboring values.
+		</constant>
+		<constant name="TYPE_VALUE_CUBIC" value="4" enum="NoiseType">
+			Similar to Value noise, but slower. Has more variance in peaks and valleys.
+			Cubic noise can be used to avoid certain artifacts when using value noise to create a bumpmap. In general, you should always use this mode if the value noise is being used for a heightmap or bumpmap.
+		</constant>
+		<constant name="TYPE_PERLIN" value="3" enum="NoiseType">
+			A lattice of random gradients. Their dot products are interpolated to obtain values in between the lattices.
+		</constant>
+		<constant name="TYPE_CELLULAR" value="2" enum="NoiseType">
+			Cellular includes both Worley noise and Voronoi diagrams which creates various regions of the same value.
+		</constant>
+		<constant name="TYPE_SIMPLEX" value="0" enum="NoiseType">
+			As opposed to [constant TYPE_PERLIN], gradients exist in a simplex lattice rather than a grid lattice, avoiding directional artifacts.
+		</constant>
+		<constant name="TYPE_SIMPLEX_SMOOTH" value="1" enum="NoiseType">
+			Modified, higher quality version of [constant TYPE_SIMPLEX], but slower.
+		</constant>
+		<constant name="FRACTAL_NONE" value="0" enum="FractalType">
+			No fractal noise.
+		</constant>
+		<constant name="FRACTAL_FBM" value="1" enum="FractalType">
+			Method using Fractional Brownian Motion to combine octaves into a fractal.
+		</constant>
+		<constant name="FRACTAL_RIDGED" value="2" enum="FractalType">
+			Method of combining octaves into a fractal resulting in a "ridged" look.
+		</constant>
+		<constant name="FRACTAL_PING_PONG" value="3" enum="FractalType">
+			Method of combining octaves into a fractal with a ping pong effect.
+		</constant>
+		<constant name="DISTANCE_EUCLIDEAN" value="0" enum="CellularDistanceFunction">
+			Euclidean distance to the nearest point.
+		</constant>
+		<constant name="DISTANCE_EUCLIDEAN_SQUARED" value="1" enum="CellularDistanceFunction">
+			Squared Euclidean distance to the nearest point.
+		</constant>
+		<constant name="DISTANCE_MANHATTAN" value="2" enum="CellularDistanceFunction">
+			Manhattan distance (taxicab metric) to the nearest point.
+		</constant>
+		<constant name="DISTANCE_HYBRID" value="3" enum="CellularDistanceFunction">
+			Blend of [constant DISTANCE_EUCLIDEAN] and [constant DISTANCE_MANHATTAN] to give curved cell boundaries
+		</constant>
+		<constant name="RETURN_CELL_VALUE" value="0" enum="CellularReturnType">
+			The cellular distance function will return the same value for all points within a cell.
+		</constant>
+		<constant name="RETURN_DISTANCE" value="1" enum="CellularReturnType">
+			The cellular distance function will return a value determined by the distance to the nearest point.
+		</constant>
+		<constant name="RETURN_DISTANCE2" value="2" enum="CellularReturnType">
+			The cellular distance function returns the distance to the second-nearest point.
+		</constant>
+		<constant name="RETURN_DISTANCE2_ADD" value="3" enum="CellularReturnType">
+			The distance to the nearest point is added to the distance to the second-nearest point.
+		</constant>
+		<constant name="RETURN_DISTANCE2_SUB" value="4" enum="CellularReturnType">
+			The distance to the nearest point is subtracted from the distance to the second-nearest point.
+		</constant>
+		<constant name="RETURN_DISTANCE2_MUL" value="5" enum="CellularReturnType">
+			The distance to the nearest point is multiplied with the distance to the second-nearest point.
+		</constant>
+		<constant name="RETURN_DISTANCE2_DIV" value="6" enum="CellularReturnType">
+			The distance to the nearest point is divided by the distance to the second-nearest point.
+		</constant>
+		<constant name="DOMAIN_WARP_SIMPLEX" value="0" enum="DomainWarpType">
+			The domain is warped using the simplex noise algorithm.
+		</constant>
+		<constant name="DOMAIN_WARP_SIMPLEX_REDUCED" value="1" enum="DomainWarpType">
+			The domain is warped using a simplified version of the simplex noise algorithm.
+		</constant>
+		<constant name="DOMAIN_WARP_BASIC_GRID" value="2" enum="DomainWarpType">
+			The domain is warped using a simple noise grid (not as smooth as the other methods, but more performant).
+		</constant>
+		<constant name="DOMAIN_WARP_FRACTAL_NONE" value="0" enum="DomainWarpFractalType">
+			No fractal noise for warping the space.
+		</constant>
+		<constant name="DOMAIN_WARP_FRACTAL_PROGRESSIVE" value="1" enum="DomainWarpFractalType">
+			Warping the space progressively, octave for octave, resulting in a more "liquified" distortion.
+		</constant>
+		<constant name="DOMAIN_WARP_FRACTAL_INDEPENDENT" value="2" enum="DomainWarpFractalType">
+			Warping the space independently for each octave, resulting in a more chaotic distortion.
+		</constant>
+	</constants>
+</class>
diff --git a/modules/noise/doc_classes/Noise.xml b/modules/noise/doc_classes/Noise.xml
new file mode 100644
index 0000000000..db0dec18d2
--- /dev/null
+++ b/modules/noise/doc_classes/Noise.xml
@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="Noise" inherits="Resource" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
+	<brief_description>
+		Abstract base class for noise generators.
+	</brief_description>
+	<description>
+		This class defines the interface for noise generation libraries to inherit from.
+		A default get_seamless_noise() implementation is provided for libraries that do not provide seamless noise. This function requests a larger image from get_image(), reverses the quadrants of the image, then uses the strips of extra width to blend over the seams.
+		Inheriting noise classes can optionally override this function to provide a more optimal algorithm.
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+		<method name="get_image">
+			<return type="Image" />
+			<argument index="0" name="width" type="int" />
+			<argument index="1" name="height" type="int" />
+			<argument index="2" name="invert" type="bool" default="false" />
+			<description>
+				Returns a 2D [Image] noise image.
+			</description>
+		</method>
+		<method name="get_noise_1d">
+			<return type="float" />
+			<argument index="0" name="x" type="float" />
+			<description>
+				Returns the 1D noise value at the given (x) coordinate.
+			</description>
+		</method>
+		<method name="get_noise_2d">
+			<return type="float" />
+			<argument index="0" name="x" type="float" />
+			<argument index="1" name="y" type="float" />
+			<description>
+				Returns the 2D noise value at the given position.
+			</description>
+		</method>
+		<method name="get_noise_2dv">
+			<return type="float" />
+			<argument index="0" name="v" type="Vector2" />
+			<description>
+				Returns the 2D noise value at the given position.
+			</description>
+		</method>
+		<method name="get_noise_3d">
+			<return type="float" />
+			<argument index="0" name="x" type="float" />
+			<argument index="1" name="y" type="float" />
+			<argument index="2" name="z" type="float" />
+			<description>
+				Returns the 3D noise value at the given position.
+			</description>
+		</method>
+		<method name="get_noise_3dv">
+			<return type="float" />
+			<argument index="0" name="v" type="Vector3" />
+			<description>
+				Returns the 3D noise value at the given position.
+			</description>
+		</method>
+		<method name="get_seamless_image">
+			<return type="Image" />
+			<argument index="0" name="width" type="int" />
+			<argument index="1" name="height" type="int" />
+			<argument index="2" name="invert" type="bool" default="false" />
+			<argument index="3" name="skirt" type="float" default="0.1" />
+			<description>
+				Returns a seamless 2D [Image] noise image.
+			</description>
+		</method>
+	</methods>
+</class>
diff --git a/modules/opensimplex/doc_classes/NoiseTexture.xml b/modules/noise/doc_classes/NoiseTexture.xml
index 497735ccf3..63630eccde 100644
--- a/modules/opensimplex/doc_classes/NoiseTexture.xml
+++ b/modules/noise/doc_classes/NoiseTexture.xml
@@ -1,15 +1,15 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <class name="NoiseTexture" inherits="Texture2D" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
 	<brief_description>
-		[OpenSimplexNoise] filled texture.
+		A texture filled with noise generated by a [Noise] object.
 	</brief_description>
 	<description>
-		Uses an [OpenSimplexNoise] to fill the texture data. You can specify the texture size but keep in mind that larger textures will take longer to generate and seamless noise only works with square sized textures.
-		NoiseTexture can also generate normal map textures.
+		Uses [FastNoiseLite] or other libraries to fill the texture data of your desired size.
+		NoiseTexture can also generate normalmap textures.
 		The class uses [Thread]s to generate the texture data internally, so [method Texture2D.get_image] may return [code]null[/code] if the generation process has not completed yet. In that case, you need to wait for the texture to be generated before accessing the image and the generated byte data:
 		[codeblock]
 		var texture = NoiseTexture.new()
-		texture.noise = OpenSimplexNoise.new()
+		texture.noise = FastNoiseLite.new()
 		await texture.changed
 		var image = texture.get_image()
 		var data = image.get_data()
@@ -27,15 +27,18 @@
 		<member name="height" type="int" setter="set_height" getter="get_height" default="512">
 			Height of the generated texture.
 		</member>
-		<member name="noise" type="OpenSimplexNoise" setter="set_noise" getter="get_noise">
-			The [OpenSimplexNoise] instance used to generate the noise.
+		<member name="invert" type="bool" setter="set_invert" getter="get_invert" default="false">
+			If [code]true[/code], inverts the noise texture. White becomes black, black becomes white.
 		</member>
-		<member name="noise_offset" type="Vector2" setter="set_noise_offset" getter="get_noise_offset" default="Vector2(0, 0)">
-			An offset used to specify the noise space coordinate of the top left corner of the generated noise. This value is ignored if [member seamless] is enabled.
+		<member name="noise" type="Noise" setter="set_noise" getter="get_noise">
+			The instance of the [Noise] object.
 		</member>
 		<member name="seamless" type="bool" setter="set_seamless" getter="get_seamless" default="false">
-			Whether the texture can be tiled without visible seams or not. Seamless textures take longer to generate.
-			[b]Note:[/b] Seamless noise has a lower contrast compared to non-seamless noise. This is due to the way noise uses higher dimensions for generating seamless noise.
+			If [code]true[/code], a seamless texture is requested from the [Noise] resource.
+			[b]Note:[/b] Seamless noise textures may take longer to generate and/or can have a lower contrast compared to non-seamless noise depending on the used [Noise] resource. This is because some implementations use higher dimensions for generating seamless noise.
+		</member>
+		<member name="seamless_blend_skirt" type="float" setter="set_seamless_blend_skirt" getter="get_seamless_blend_skirt" default="0.1">
+			Used for the default/fallback implementation of the seamless texture generation. It determines the distance over which the seams are blended. High values may result in less details and contrast. See [Noise] for further details.
 		</member>
 		<member name="width" type="int" setter="set_width" getter="get_width" default="512">
 			Width of the generated texture.
diff --git a/modules/noise/fastnoise_lite.cpp b/modules/noise/fastnoise_lite.cpp
new file mode 100644
index 0000000000..98a4f817e3
--- /dev/null
+++ b/modules/noise/fastnoise_lite.cpp
@@ -0,0 +1,577 @@
+/*************************************************************************/
+/*  fastnoise_lite.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "fastnoise_lite.h"
+
+FastNoiseLite::FastNoiseLite() {
+	// Most defaults copied from the library.
+	set_noise_type(TYPE_SIMPLEX_SMOOTH);
+	set_seed(0);
+	set_frequency(0.01);
+	set_in_3d_space(false);
+
+	set_fractal_type(FRACTAL_FBM);
+	set_fractal_octaves(5);
+	set_fractal_lacunarity(2.0);
+	set_fractal_gain(0.5);
+	set_fractal_weighted_strength(0.0);
+	set_fractal_ping_pong_strength(2.0);
+
+	set_cellular_distance_function(DISTANCE_EUCLIDEAN);
+	set_cellular_return_type(RETURN_CELL_VALUE);
+	set_cellular_jitter(0.45);
+
+	set_domain_warp_enabled(false);
+	set_domain_warp_type(DOMAIN_WARP_SIMPLEX);
+	set_domain_warp_amplitude(30.0);
+	set_domain_warp_frequency(0.05);
+	set_domain_warp_fractal_type(DOMAIN_WARP_FRACTAL_PROGRESSIVE);
+	set_domain_warp_fractal_octaves(5);
+	set_domain_warp_fractal_lacunarity(6);
+	set_domain_warp_fractal_gain(0.5);
+}
+
+FastNoiseLite::~FastNoiseLite() {
+}
+
+// General settings.
+
+void FastNoiseLite::set_noise_type(NoiseType p_noise_type) {
+	noise_type = p_noise_type;
+	_noise.SetNoiseType((_FastNoiseLite::NoiseType)p_noise_type);
+	emit_changed();
+	notify_property_list_changed();
+}
+
+FastNoiseLite::NoiseType FastNoiseLite::get_noise_type() const {
+	return noise_type;
+}
+
+void FastNoiseLite::set_seed(int p_seed) {
+	seed = p_seed;
+	_noise.SetSeed(p_seed);
+	emit_changed();
+}
+
+int FastNoiseLite::get_seed() const {
+	return seed;
+}
+
+void FastNoiseLite::set_frequency(real_t p_freq) {
+	frequency = p_freq;
+	_noise.SetFrequency(p_freq);
+	emit_changed();
+}
+
+real_t FastNoiseLite::get_frequency() const {
+	return frequency;
+}
+
+void FastNoiseLite::set_in_3d_space(bool p_enable) {
+	in_3d_space = p_enable;
+	emit_changed();
+}
+bool FastNoiseLite::is_in_3d_space() const {
+	return in_3d_space;
+}
+
+void FastNoiseLite::set_offset(Vector3 p_offset) {
+	offset = p_offset;
+	emit_changed();
+}
+
+Vector3 FastNoiseLite::get_offset() const {
+	return offset;
+}
+
+void FastNoiseLite::set_color_ramp(const Ref<Gradient> &p_gradient) {
+	color_ramp = p_gradient;
+	if (color_ramp.is_valid()) {
+		color_ramp->connect(SNAME("changed"), callable_mp(this, &FastNoiseLite::_changed));
+		emit_changed();
+	}
+}
+
+Ref<Gradient> FastNoiseLite::get_color_ramp() const {
+	return color_ramp;
+}
+
+// Noise functions.
+
+real_t FastNoiseLite::get_noise_1d(real_t p_x) {
+	return get_noise_2d(p_x, 0.0);
+}
+
+real_t FastNoiseLite::get_noise_2dv(Vector2 p_v) {
+	return get_noise_2d(p_v.x, p_v.y);
+}
+
+real_t FastNoiseLite::get_noise_2d(real_t p_x, real_t p_y) {
+	if (domain_warp_enabled) {
+		_domain_warp_noise.DomainWarp(p_x, p_y);
+	}
+	return _noise.GetNoise(p_x + offset.x, p_y + offset.y);
+}
+
+real_t FastNoiseLite::get_noise_3dv(Vector3 p_v) {
+	return get_noise_3d(p_v.x, p_v.y, p_v.z);
+}
+
+real_t FastNoiseLite::get_noise_3d(real_t p_x, real_t p_y, real_t p_z) {
+	if (domain_warp_enabled) {
+		_domain_warp_noise.DomainWarp(p_x, p_y, p_z);
+	}
+	return _noise.GetNoise(p_x + offset.x, p_y + offset.y, p_z + offset.z);
+}
+
+// Fractal.
+
+void FastNoiseLite::set_fractal_type(FractalType p_type) {
+	fractal_type = p_type;
+	_noise.SetFractalType((_FastNoiseLite::FractalType)p_type);
+	emit_changed();
+	notify_property_list_changed();
+}
+
+FastNoiseLite::FractalType FastNoiseLite::get_fractal_type() const {
+	return fractal_type;
+}
+
+void FastNoiseLite::set_fractal_octaves(int p_octaves) {
+	fractal_octaves = p_octaves;
+	_noise.SetFractalOctaves(p_octaves);
+	emit_changed();
+}
+
+int FastNoiseLite::get_fractal_octaves() const {
+	return fractal_octaves;
+}
+
+void FastNoiseLite::set_fractal_lacunarity(real_t p_lacunarity) {
+	fractal_lacunarity = p_lacunarity;
+	_noise.SetFractalLacunarity(p_lacunarity);
+	emit_changed();
+}
+
+real_t FastNoiseLite::get_fractal_lacunarity() const {
+	return fractal_lacunarity;
+}
+
+void FastNoiseLite::set_fractal_gain(real_t p_gain) {
+	fractal_gain = p_gain;
+	_noise.SetFractalGain(p_gain);
+	emit_changed();
+}
+
+real_t FastNoiseLite::get_fractal_gain() const {
+	return fractal_gain;
+}
+
+void FastNoiseLite::set_fractal_weighted_strength(real_t p_weighted_strength) {
+	fractal_weighted_strength = p_weighted_strength;
+	_noise.SetFractalWeightedStrength(p_weighted_strength);
+	emit_changed();
+}
+real_t FastNoiseLite::get_fractal_weighted_strength() const {
+	return fractal_weighted_strength;
+}
+
+void FastNoiseLite::set_fractal_ping_pong_strength(real_t p_ping_pong_strength) {
+	fractal_pinp_pong_strength = p_ping_pong_strength;
+	_noise.SetFractalPingPongStrength(p_ping_pong_strength);
+	emit_changed();
+}
+real_t FastNoiseLite::get_fractal_ping_pong_strength() const {
+	return fractal_pinp_pong_strength;
+}
+
+// Cellular.
+
+void FastNoiseLite::set_cellular_distance_function(CellularDistanceFunction p_func) {
+	cellular_distance_function = p_func;
+	_noise.SetCellularDistanceFunction((_FastNoiseLite::CellularDistanceFunction)p_func);
+	emit_changed();
+}
+
+FastNoiseLite::CellularDistanceFunction FastNoiseLite::get_cellular_distance_function() const {
+	return cellular_distance_function;
+}
+
+void FastNoiseLite::set_cellular_jitter(real_t p_jitter) {
+	cellular_jitter = p_jitter;
+	_noise.SetCellularJitter(p_jitter);
+	emit_changed();
+}
+
+real_t FastNoiseLite::get_cellular_jitter() const {
+	return cellular_jitter;
+}
+
+void FastNoiseLite::set_cellular_return_type(CellularReturnType p_ret) {
+	cellular_return_type = p_ret;
+	_noise.SetCellularReturnType((_FastNoiseLite::CellularReturnType)p_ret);
+
+	emit_changed();
+}
+
+FastNoiseLite::CellularReturnType FastNoiseLite::get_cellular_return_type() const {
+	return cellular_return_type;
+}
+
+// Domain warp specific.
+
+void FastNoiseLite::set_domain_warp_enabled(bool p_enabled) {
+	if (domain_warp_enabled != p_enabled) {
+		domain_warp_enabled = p_enabled;
+		emit_changed();
+		notify_property_list_changed();
+	}
+}
+
+bool FastNoiseLite::is_domain_warp_enabled() const {
+	return domain_warp_enabled;
+}
+
+void FastNoiseLite::set_domain_warp_type(DomainWarpType p_domain_warp_type) {
+	domain_warp_type = p_domain_warp_type;
+	_domain_warp_noise.SetDomainWarpType((_FastNoiseLite::DomainWarpType)p_domain_warp_type);
+	emit_changed();
+}
+
+FastNoiseLite::DomainWarpType FastNoiseLite::get_domain_warp_type() const {
+	return domain_warp_type;
+}
+
+void FastNoiseLite::set_domain_warp_amplitude(real_t p_amplitude) {
+	domain_warp_amplitude = p_amplitude;
+	_domain_warp_noise.SetDomainWarpAmp(p_amplitude);
+	emit_changed();
+}
+real_t FastNoiseLite::get_domain_warp_amplitude() const {
+	return domain_warp_amplitude;
+}
+
+void FastNoiseLite::set_domain_warp_frequency(real_t p_frequency) {
+	domain_warp_frequency = p_frequency;
+	_domain_warp_noise.SetFrequency(p_frequency);
+	emit_changed();
+}
+
+real_t FastNoiseLite::get_domain_warp_frequency() const {
+	return domain_warp_frequency;
+}
+
+void FastNoiseLite::set_domain_warp_fractal_type(DomainWarpFractalType p_domain_warp_fractal_type) {
+	domain_warp_fractal_type = p_domain_warp_fractal_type;
+
+	// This needs manual conversion because Godots Inspector property API does not support discontiguous enum indices.
+	_FastNoiseLite::FractalType type;
+	switch (p_domain_warp_fractal_type) {
+		case DOMAIN_WARP_FRACTAL_NONE:
+			type = _FastNoiseLite::FractalType_None;
+			break;
+		case DOMAIN_WARP_FRACTAL_PROGRESSIVE:
+			type = _FastNoiseLite::FractalType_DomainWarpProgressive;
+			break;
+		case DOMAIN_WARP_FRACTAL_INDEPENDENT:
+			type = _FastNoiseLite::FractalType_DomainWarpIndependent;
+			break;
+		default:
+			type = _FastNoiseLite::FractalType_None;
+	}
+
+	_domain_warp_noise.SetFractalType(type);
+	emit_changed();
+}
+
+FastNoiseLite::DomainWarpFractalType FastNoiseLite::get_domain_warp_fractal_type() const {
+	return domain_warp_fractal_type;
+}
+
+void FastNoiseLite::set_domain_warp_fractal_octaves(int p_octaves) {
+	domain_warp_fractal_octaves = p_octaves;
+	_domain_warp_noise.SetFractalOctaves(p_octaves);
+	emit_changed();
+}
+
+int FastNoiseLite::get_domain_warp_fractal_octaves() const {
+	return domain_warp_fractal_octaves;
+}
+
+void FastNoiseLite::set_domain_warp_fractal_lacunarity(real_t p_lacunarity) {
+	domain_warp_fractal_lacunarity = p_lacunarity;
+	_domain_warp_noise.SetFractalLacunarity(p_lacunarity);
+	emit_changed();
+}
+
+real_t FastNoiseLite::get_domain_warp_fractal_lacunarity() const {
+	return domain_warp_fractal_lacunarity;
+}
+
+void FastNoiseLite::set_domain_warp_fractal_gain(real_t p_gain) {
+	domain_warp_fractal_gain = p_gain;
+	_domain_warp_noise.SetFractalGain(p_gain);
+	emit_changed();
+}
+
+real_t FastNoiseLite::get_domain_warp_fractal_gain() const {
+	return domain_warp_fractal_gain;
+}
+
+// Textures.
+
+Ref<Image> FastNoiseLite::get_image(int p_width, int p_height, bool p_invert) {
+	bool grayscale = color_ramp.is_null();
+
+	Vector<uint8_t> data;
+	data.resize(p_width * p_height * (grayscale ? 1 : 4));
+
+	uint8_t *wd8 = data.ptrw();
+
+	// Get all values and identify min/max values.
+	Vector<real_t> values;
+	values.resize(p_width * p_height);
+	real_t min_val = 100;
+	real_t max_val = -100;
+
+	for (int y = 0, i = 0; y < p_height; y++) {
+		for (int x = 0; x < p_width; x++, i++) {
+			values.set(i, is_in_3d_space() ? get_noise_3d(x, y, 0.0) : get_noise_2d(x, y));
+			if (values[i] > max_val) {
+				max_val = values[i];
+			}
+			if (values[i] < min_val) {
+				min_val = values[i];
+			}
+		}
+	}
+
+	// Normalize values and write to texture.
+	uint8_t value;
+	for (int i = 0, x = 0; i < p_height; i++) {
+		for (int j = 0; j < p_width; j++, x++) {
+			if (max_val == min_val) {
+				value = 0;
+			} else {
+				value = uint8_t(CLAMP((values[x] - min_val) / (max_val - min_val) * 255.f, 0, 255));
+			}
+			if (p_invert) {
+				value = 255 - value;
+			}
+			if (grayscale) {
+				wd8[x] = value;
+			} else {
+				float luminance = value / 255.0;
+				Color ramp_color = color_ramp->get_color_at_offset(luminance);
+				wd8[x * 4 + 0] = uint8_t(CLAMP(ramp_color.r * 255, 0, 255));
+				wd8[x * 4 + 1] = uint8_t(CLAMP(ramp_color.g * 255, 0, 255));
+				wd8[x * 4 + 2] = uint8_t(CLAMP(ramp_color.b * 255, 0, 255));
+				wd8[x * 4 + 3] = uint8_t(CLAMP(ramp_color.a * 255, 0, 255));
+			}
+		}
+	}
+	if (grayscale) {
+		return memnew(Image(p_width, p_height, false, Image::FORMAT_L8, data));
+	} else {
+		return memnew(Image(p_width, p_height, false, Image::FORMAT_RGBA8, data));
+	}
+}
+
+Ref<Image> FastNoiseLite::get_seamless_image(int p_width, int p_height, bool p_invert, real_t p_blend_skirt) {
+	// Just return parent function. This is here only so Godot will properly document this function.
+	return Noise::get_seamless_image(p_width, p_height, p_invert, p_blend_skirt);
+}
+
+void FastNoiseLite::_changed() {
+	emit_changed();
+}
+
+void FastNoiseLite::_bind_methods() {
+	// General settings.
+
+	ClassDB::bind_method(D_METHOD("set_noise_type", "type"), &FastNoiseLite::set_noise_type);
+	ClassDB::bind_method(D_METHOD("get_noise_type"), &FastNoiseLite::get_noise_type);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "noise_type", PROPERTY_HINT_ENUM, "Simplex,Simplex Smooth,Cellular,Perlin,Value Cubic,Value"), "set_noise_type", "get_noise_type");
+
+	ClassDB::bind_method(D_METHOD("set_seed", "seed"), &FastNoiseLite::set_seed);
+	ClassDB::bind_method(D_METHOD("get_seed"), &FastNoiseLite::get_seed);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "seed"), "set_seed", "get_seed");
+
+	ClassDB::bind_method(D_METHOD("set_frequency", "freq"), &FastNoiseLite::set_frequency);
+	ClassDB::bind_method(D_METHOD("get_frequency"), &FastNoiseLite::get_frequency);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "frequency", PROPERTY_HINT_RANGE, ".001,1"), "set_frequency", "get_frequency");
+
+	ClassDB::bind_method(D_METHOD("set_in_3d_space", "enable"), &FastNoiseLite::set_in_3d_space);
+	ClassDB::bind_method(D_METHOD("is_in_3d_space"), &FastNoiseLite::is_in_3d_space);
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "in_3d_space"), "set_in_3d_space", "is_in_3d_space");
+
+	ClassDB::bind_method(D_METHOD("set_offset", "offset"), &FastNoiseLite::set_offset);
+	ClassDB::bind_method(D_METHOD("get_offset"), &FastNoiseLite::get_offset);
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "offset", PROPERTY_HINT_RANGE, "-999999999,999999999,1"), "set_offset", "get_offset");
+
+	ClassDB::bind_method(D_METHOD("set_color_ramp", "gradient"), &FastNoiseLite::set_color_ramp);
+	ClassDB::bind_method(D_METHOD("get_color_ramp"), &FastNoiseLite::get_color_ramp);
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "color_ramp", PROPERTY_HINT_RESOURCE_TYPE, "Gradient"), "set_color_ramp", "get_color_ramp");
+
+	// Fractal.
+
+	ADD_GROUP("Fractal", "fractal_");
+	ClassDB::bind_method(D_METHOD("set_fractal_type", "type"), &FastNoiseLite::set_fractal_type);
+	ClassDB::bind_method(D_METHOD("get_fractal_type"), &FastNoiseLite::get_fractal_type);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "fractal_type", PROPERTY_HINT_ENUM, "None,FBM,Ridged,PingPong"), "set_fractal_type", "get_fractal_type");
+
+	ClassDB::bind_method(D_METHOD("set_fractal_octaves", "octave_count"), &FastNoiseLite::set_fractal_octaves);
+	ClassDB::bind_method(D_METHOD("get_fractal_octaves"), &FastNoiseLite::get_fractal_octaves);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "fractal_octaves", PROPERTY_HINT_RANGE, "1,10,1"), "set_fractal_octaves", "get_fractal_octaves");
+
+	ClassDB::bind_method(D_METHOD("set_fractal_lacunarity", "lacunarity"), &FastNoiseLite::set_fractal_lacunarity);
+	ClassDB::bind_method(D_METHOD("get_fractal_lacunarity"), &FastNoiseLite::get_fractal_lacunarity);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fractal_lacunarity"), "set_fractal_lacunarity", "get_fractal_lacunarity");
+
+	ClassDB::bind_method(D_METHOD("set_fractal_gain", "gain"), &FastNoiseLite::set_fractal_gain);
+	ClassDB::bind_method(D_METHOD("get_fractal_gain"), &FastNoiseLite::get_fractal_gain);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fractal_gain"), "set_fractal_gain", "get_fractal_gain");
+
+	ClassDB::bind_method(D_METHOD("set_fractal_weighted_strength", "weighted_strength"), &FastNoiseLite::set_fractal_weighted_strength);
+	ClassDB::bind_method(D_METHOD("get_fractal_weighted_strength"), &FastNoiseLite::get_fractal_weighted_strength);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fractal_weighted_strength", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_fractal_weighted_strength", "get_fractal_weighted_strength");
+
+	ClassDB::bind_method(D_METHOD("set_fractal_ping_pong_strength", "ping_pong_strength"), &FastNoiseLite::set_fractal_ping_pong_strength);
+	ClassDB::bind_method(D_METHOD("get_fractal_ping_pong_strength"), &FastNoiseLite::get_fractal_ping_pong_strength);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fractal_ping_pong_strength"), "set_fractal_ping_pong_strength", "get_fractal_ping_pong_strength");
+
+	// Cellular.
+
+	ADD_GROUP("Cellular", "cellular_");
+	ClassDB::bind_method(D_METHOD("set_cellular_distance_function", "func"), &FastNoiseLite::set_cellular_distance_function);
+	ClassDB::bind_method(D_METHOD("get_cellular_distance_function"), &FastNoiseLite::get_cellular_distance_function);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "cellular_distance_function", PROPERTY_HINT_ENUM, "Euclidean,EuclideanSquared,Manhattan,Hybrid"), "set_cellular_distance_function", "get_cellular_distance_function");
+
+	ClassDB::bind_method(D_METHOD("set_cellular_jitter", "jitter"), &FastNoiseLite::set_cellular_jitter);
+	ClassDB::bind_method(D_METHOD("get_cellular_jitter"), &FastNoiseLite::get_cellular_jitter);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "cellular_jitter"), "set_cellular_jitter", "get_cellular_jitter");
+
+	ClassDB::bind_method(D_METHOD("set_cellular_return_type", "ret"), &FastNoiseLite::set_cellular_return_type);
+	ClassDB::bind_method(D_METHOD("get_cellular_return_type"), &FastNoiseLite::get_cellular_return_type);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "cellular_return_type", PROPERTY_HINT_ENUM, "CellValue,Distance,Distance2,Distance2Add,Distance2Sub,Distance2Mul,Distance2Div"), "set_cellular_return_type", "get_cellular_return_type");
+
+	// Domain warp.
+
+	ADD_GROUP("Domain warp", "domain_warp_");
+
+	ClassDB::bind_method(D_METHOD("set_domain_warp_enabled", "domain_warp_enabled"), &FastNoiseLite::set_domain_warp_enabled);
+	ClassDB::bind_method(D_METHOD("is_domain_warp_enabled"), &FastNoiseLite::is_domain_warp_enabled);
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "domain_warp_enabled"), "set_domain_warp_enabled", "is_domain_warp_enabled");
+
+	ClassDB::bind_method(D_METHOD("set_domain_warp_type", "domain_warp_type"), &FastNoiseLite::set_domain_warp_type);
+	ClassDB::bind_method(D_METHOD("get_domain_warp_type"), &FastNoiseLite::get_domain_warp_type);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "domain_warp_type", PROPERTY_HINT_ENUM, "Simplex,SimplexReduced,BasicGrid"), "set_domain_warp_type", "get_domain_warp_type");
+
+	ClassDB::bind_method(D_METHOD("set_domain_warp_amplitude", "domain_warp_amplitude"), &FastNoiseLite::set_domain_warp_amplitude);
+	ClassDB::bind_method(D_METHOD("get_domain_warp_amplitude"), &FastNoiseLite::get_domain_warp_amplitude);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "domain_warp_amplitude"), "set_domain_warp_amplitude", "get_domain_warp_amplitude");
+
+	ClassDB::bind_method(D_METHOD("set_domain_warp_frequency", "domain_warp_frequency"), &FastNoiseLite::set_domain_warp_frequency);
+	ClassDB::bind_method(D_METHOD("get_domain_warp_frequency"), &FastNoiseLite::get_domain_warp_frequency);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "domain_warp_frequency"), "set_domain_warp_frequency", "get_domain_warp_frequency");
+
+	ClassDB::bind_method(D_METHOD("set_domain_warp_fractal_type", "domain_warp_fractal_type"), &FastNoiseLite::set_domain_warp_fractal_type);
+	ClassDB::bind_method(D_METHOD("get_domain_warp_fractal_type"), &FastNoiseLite::get_domain_warp_fractal_type);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "domain_warp_fractal_type", PROPERTY_HINT_ENUM, "None,Progressive,Independent"), "set_domain_warp_fractal_type", "get_domain_warp_fractal_type");
+
+	ClassDB::bind_method(D_METHOD("set_domain_warp_fractal_octaves", "domain_warp_octave_count"), &FastNoiseLite::set_domain_warp_fractal_octaves);
+	ClassDB::bind_method(D_METHOD("get_domain_warp_fractal_octaves"), &FastNoiseLite::get_domain_warp_fractal_octaves);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "domain_warp_fractal_octaves", PROPERTY_HINT_RANGE, "1,10,1"), "set_domain_warp_fractal_octaves", "get_domain_warp_fractal_octaves");
+
+	ClassDB::bind_method(D_METHOD("set_domain_warp_fractal_lacunarity", "domain_warp_lacunarity"), &FastNoiseLite::set_domain_warp_fractal_lacunarity);
+	ClassDB::bind_method(D_METHOD("get_domain_warp_fractal_lacunarity"), &FastNoiseLite::get_domain_warp_fractal_lacunarity);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "domain_warp_fractal_lacunarity"), "set_domain_warp_fractal_lacunarity", "get_domain_warp_fractal_lacunarity");
+
+	ClassDB::bind_method(D_METHOD("set_domain_warp_fractal_gain", "domain_warp_gain"), &FastNoiseLite::set_domain_warp_fractal_gain);
+	ClassDB::bind_method(D_METHOD("get_domain_warp_fractal_gain"), &FastNoiseLite::get_domain_warp_fractal_gain);
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "domain_warp_fractal_gain"), "set_domain_warp_fractal_gain", "get_domain_warp_fractal_gain");
+
+	ClassDB::bind_method(D_METHOD("_changed"), &FastNoiseLite::_changed);
+
+	BIND_ENUM_CONSTANT(TYPE_VALUE);
+	BIND_ENUM_CONSTANT(TYPE_VALUE_CUBIC);
+	BIND_ENUM_CONSTANT(TYPE_PERLIN);
+	BIND_ENUM_CONSTANT(TYPE_CELLULAR);
+	BIND_ENUM_CONSTANT(TYPE_SIMPLEX);
+	BIND_ENUM_CONSTANT(TYPE_SIMPLEX_SMOOTH);
+
+	BIND_ENUM_CONSTANT(FRACTAL_NONE);
+	BIND_ENUM_CONSTANT(FRACTAL_FBM);
+	BIND_ENUM_CONSTANT(FRACTAL_RIDGED);
+	BIND_ENUM_CONSTANT(FRACTAL_PING_PONG);
+
+	BIND_ENUM_CONSTANT(DISTANCE_EUCLIDEAN);
+	BIND_ENUM_CONSTANT(DISTANCE_EUCLIDEAN_SQUARED);
+	BIND_ENUM_CONSTANT(DISTANCE_MANHATTAN);
+	BIND_ENUM_CONSTANT(DISTANCE_HYBRID);
+
+	BIND_ENUM_CONSTANT(RETURN_CELL_VALUE);
+	BIND_ENUM_CONSTANT(RETURN_DISTANCE);
+	BIND_ENUM_CONSTANT(RETURN_DISTANCE2);
+	BIND_ENUM_CONSTANT(RETURN_DISTANCE2_ADD);
+	BIND_ENUM_CONSTANT(RETURN_DISTANCE2_SUB);
+	BIND_ENUM_CONSTANT(RETURN_DISTANCE2_MUL);
+	BIND_ENUM_CONSTANT(RETURN_DISTANCE2_DIV);
+
+	BIND_ENUM_CONSTANT(DOMAIN_WARP_SIMPLEX);
+	BIND_ENUM_CONSTANT(DOMAIN_WARP_SIMPLEX_REDUCED);
+	BIND_ENUM_CONSTANT(DOMAIN_WARP_BASIC_GRID);
+
+	BIND_ENUM_CONSTANT(DOMAIN_WARP_FRACTAL_NONE);
+	BIND_ENUM_CONSTANT(DOMAIN_WARP_FRACTAL_PROGRESSIVE);
+	BIND_ENUM_CONSTANT(DOMAIN_WARP_FRACTAL_INDEPENDENT);
+}
+
+void FastNoiseLite::_validate_property(PropertyInfo &property) const {
+	if (property.name.begins_with("cellular") && get_noise_type() != TYPE_CELLULAR) {
+		property.usage = PROPERTY_USAGE_NO_EDITOR;
+		return;
+	}
+
+	if (property.name != "fractal_type" && property.name.begins_with("fractal") && get_fractal_type() == FRACTAL_NONE) {
+		property.usage = PROPERTY_USAGE_NO_EDITOR;
+		return;
+	}
+
+	if (property.name == "fractal_ping_pong_strength" && get_fractal_type() != FRACTAL_PING_PONG) {
+		property.usage = PROPERTY_USAGE_NO_EDITOR;
+		return;
+	}
+
+	if (property.name != "domain_warp_enabled" && property.name.begins_with("domain_warp") && !domain_warp_enabled) {
+		property.usage = PROPERTY_USAGE_NO_EDITOR;
+		return;
+	}
+}
diff --git a/modules/noise/fastnoise_lite.h b/modules/noise/fastnoise_lite.h
new file mode 100644
index 0000000000..4635e26d28
--- /dev/null
+++ b/modules/noise/fastnoise_lite.h
@@ -0,0 +1,237 @@
+/*************************************************************************/
+/*  fastnoise_lite.h                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef FASTNOISE_LITE_H
+#define FASTNOISE_LITE_H
+
+#include "core/io/image.h"
+#include "core/object/ref_counted.h"
+#include "noise.h"
+#include "scene/resources/gradient.h"
+
+#include <thirdparty/noise/FastNoiseLite.h>
+
+typedef fastnoiselite::FastNoiseLite _FastNoiseLite;
+
+class FastNoiseLite : public Noise {
+	GDCLASS(FastNoiseLite, Noise);
+	OBJ_SAVE_TYPE(FastNoiseLite);
+
+public:
+	enum NoiseType {
+		TYPE_SIMPLEX = _FastNoiseLite::NoiseType_OpenSimplex2,
+		TYPE_SIMPLEX_SMOOTH = _FastNoiseLite::NoiseType_OpenSimplex2S,
+		TYPE_CELLULAR = _FastNoiseLite::NoiseType_Cellular,
+		TYPE_PERLIN = _FastNoiseLite::NoiseType_Perlin,
+		TYPE_VALUE_CUBIC = _FastNoiseLite::NoiseType_ValueCubic,
+		TYPE_VALUE = _FastNoiseLite::NoiseType_Value,
+	};
+
+	enum FractalType {
+		FRACTAL_NONE = _FastNoiseLite::FractalType_None,
+		FRACTAL_FBM = _FastNoiseLite::FractalType_FBm,
+		FRACTAL_RIDGED = _FastNoiseLite::FractalType_Ridged,
+		FRACTAL_PING_PONG = _FastNoiseLite::FractalType_PingPong,
+	};
+
+	enum CellularDistanceFunction {
+		DISTANCE_EUCLIDEAN = _FastNoiseLite::CellularDistanceFunction_Euclidean,
+		DISTANCE_EUCLIDEAN_SQUARED = _FastNoiseLite::CellularDistanceFunction_EuclideanSq,
+		DISTANCE_MANHATTAN = _FastNoiseLite::CellularDistanceFunction_Manhattan,
+		DISTANCE_HYBRID = _FastNoiseLite::CellularDistanceFunction_Hybrid
+	};
+
+	enum CellularReturnType {
+		RETURN_CELL_VALUE = _FastNoiseLite::CellularReturnType_CellValue,
+		RETURN_DISTANCE = _FastNoiseLite::CellularReturnType_Distance,
+		RETURN_DISTANCE2 = _FastNoiseLite::CellularReturnType_Distance2,
+		RETURN_DISTANCE2_ADD = _FastNoiseLite::CellularReturnType_Distance2Add,
+		RETURN_DISTANCE2_SUB = _FastNoiseLite::CellularReturnType_Distance2Sub,
+		RETURN_DISTANCE2_MUL = _FastNoiseLite::CellularReturnType_Distance2Mul,
+		RETURN_DISTANCE2_DIV = _FastNoiseLite::CellularReturnType_Distance2Div
+	};
+
+	enum DomainWarpType {
+		DOMAIN_WARP_SIMPLEX = _FastNoiseLite::DomainWarpType_OpenSimplex2,
+		DOMAIN_WARP_SIMPLEX_REDUCED = _FastNoiseLite::DomainWarpType_OpenSimplex2Reduced,
+		DOMAIN_WARP_BASIC_GRID = _FastNoiseLite::DomainWarpType_BasicGrid
+	};
+
+	enum DomainWarpFractalType {
+		DOMAIN_WARP_FRACTAL_NONE,
+		DOMAIN_WARP_FRACTAL_PROGRESSIVE,
+		DOMAIN_WARP_FRACTAL_INDEPENDENT
+	};
+
+protected:
+	static void _bind_methods();
+	virtual void _validate_property(PropertyInfo &property) const override;
+
+private:
+	_FastNoiseLite _noise;
+	_FastNoiseLite _domain_warp_noise;
+
+	Vector3 offset;
+	NoiseType noise_type;
+	Ref<Gradient> color_ramp;
+
+	int seed;
+	real_t frequency;
+	bool in_3d_space;
+
+	// Fractal specific.
+	FractalType fractal_type;
+	int fractal_octaves;
+	real_t fractal_lacunarity;
+	real_t fractal_gain;
+	real_t fractal_weighted_strength;
+	real_t fractal_pinp_pong_strength;
+
+	// Cellular specific.
+	CellularDistanceFunction cellular_distance_function;
+	CellularReturnType cellular_return_type;
+	real_t cellular_jitter;
+
+	// Domain warp specific.
+	bool domain_warp_enabled;
+	DomainWarpType domain_warp_type;
+	real_t domain_warp_frequency;
+	real_t domain_warp_amplitude;
+
+	DomainWarpFractalType domain_warp_fractal_type;
+	int domain_warp_fractal_octaves;
+	real_t domain_warp_fractal_lacunarity;
+	real_t domain_warp_fractal_gain;
+
+public:
+	FastNoiseLite();
+	~FastNoiseLite();
+
+	// General noise settings.
+
+	void set_noise_type(NoiseType p_noise_type);
+	NoiseType get_noise_type() const;
+
+	void set_seed(int p_seed);
+	int get_seed() const;
+
+	void set_frequency(real_t p_freq);
+	real_t get_frequency() const;
+
+	void set_in_3d_space(bool p_enable);
+	bool is_in_3d_space() const;
+
+	void set_offset(Vector3 p_offset);
+	Vector3 get_offset() const;
+
+	void set_color_ramp(const Ref<Gradient> &p_gradient);
+	Ref<Gradient> get_color_ramp() const;
+
+	// Fractal specific.
+
+	void set_fractal_type(FractalType p_type);
+	FractalType get_fractal_type() const;
+
+	void set_fractal_octaves(int p_octaves);
+	int get_fractal_octaves() const;
+
+	void set_fractal_lacunarity(real_t p_lacunarity);
+	real_t get_fractal_lacunarity() const;
+
+	void set_fractal_gain(real_t p_gain);
+	real_t get_fractal_gain() const;
+
+	void set_fractal_weighted_strength(real_t p_weighted_strength);
+	real_t get_fractal_weighted_strength() const;
+
+	void set_fractal_ping_pong_strength(real_t p_ping_pong_strength);
+	real_t get_fractal_ping_pong_strength() const;
+
+	// Cellular specific.
+
+	void set_cellular_distance_function(CellularDistanceFunction p_func);
+	CellularDistanceFunction get_cellular_distance_function() const;
+
+	void set_cellular_return_type(CellularReturnType p_ret);
+	CellularReturnType get_cellular_return_type() const;
+
+	void set_cellular_jitter(real_t p_jitter);
+	real_t get_cellular_jitter() const;
+
+	// Domain warp specific.
+
+	void set_domain_warp_enabled(bool p_enabled);
+	bool is_domain_warp_enabled() const;
+
+	void set_domain_warp_type(DomainWarpType p_domain_warp_type);
+	DomainWarpType get_domain_warp_type() const;
+
+	void set_domain_warp_amplitude(real_t p_amplitude);
+	real_t get_domain_warp_amplitude() const;
+
+	void set_domain_warp_frequency(real_t p_frequency);
+	real_t get_domain_warp_frequency() const;
+
+	void set_domain_warp_fractal_type(DomainWarpFractalType p_domain_warp_fractal_type);
+	DomainWarpFractalType get_domain_warp_fractal_type() const;
+
+	void set_domain_warp_fractal_octaves(int p_octaves);
+	int get_domain_warp_fractal_octaves() const;
+
+	void set_domain_warp_fractal_lacunarity(real_t p_lacunarity);
+	real_t get_domain_warp_fractal_lacunarity() const;
+
+	void set_domain_warp_fractal_gain(real_t p_gain);
+	real_t get_domain_warp_fractal_gain() const;
+
+	// Interface methods.
+
+	Ref<Image> get_image(int p_width, int p_height, bool p_invert = false) override;
+	Ref<Image> get_seamless_image(int p_width, int p_height, bool p_invert = false, real_t p_blend_skirt = 0.1) override;
+
+	real_t get_noise_1d(real_t p_x) override;
+
+	real_t get_noise_2dv(Vector2 p_v) override;
+	real_t get_noise_2d(real_t p_x, real_t p_y) override;
+
+	real_t get_noise_3dv(Vector3 p_v) override;
+	real_t get_noise_3d(real_t p_x, real_t p_y, real_t p_z) override;
+
+	void _changed();
+};
+
+VARIANT_ENUM_CAST(FastNoiseLite::NoiseType);
+VARIANT_ENUM_CAST(FastNoiseLite::FractalType);
+VARIANT_ENUM_CAST(FastNoiseLite::CellularDistanceFunction);
+VARIANT_ENUM_CAST(FastNoiseLite::CellularReturnType);
+VARIANT_ENUM_CAST(FastNoiseLite::DomainWarpType);
+VARIANT_ENUM_CAST(FastNoiseLite::DomainWarpFractalType);
+
+#endif // FASTNOISE_LITE_H
diff --git a/modules/opensimplex/icons/NoiseTexture.svg b/modules/noise/icons/NoiseTexture.svg
index 479684cde2..479684cde2 100644
--- a/modules/opensimplex/icons/NoiseTexture.svg
+++ b/modules/noise/icons/NoiseTexture.svg
diff --git a/modules/noise/noise.cpp b/modules/noise/noise.cpp
new file mode 100644
index 0000000000..430e8c87cf
--- /dev/null
+++ b/modules/noise/noise.cpp
@@ -0,0 +1,68 @@
+/*************************************************************************/
+/*  noise.cpp                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "noise.h"
+
+Ref<Image> Noise::get_seamless_image(int p_width, int p_height, bool p_invert, real_t p_blend_skirt) {
+	int skirt_width = p_width * p_blend_skirt;
+	int skirt_height = p_height * p_blend_skirt;
+	int src_width = p_width + skirt_width;
+	int src_height = p_height + skirt_height;
+
+	Ref<Image> src = get_image(src_width, src_height, p_invert);
+	bool grayscale = (src->get_format() == Image::FORMAT_L8);
+	if (grayscale) {
+		return _generate_seamless_image<uint8_t>(src, p_width, p_height, p_invert, p_blend_skirt);
+	} else {
+		return _generate_seamless_image<uint32_t>(src, p_width, p_height, p_invert, p_blend_skirt);
+	}
+}
+
+// Template specialization for faster grayscale blending.
+template <>
+uint8_t Noise::_alpha_blend<uint8_t>(uint8_t p_bg, uint8_t p_fg, int p_alpha) const {
+	uint16_t alpha = p_alpha + 1;
+	uint16_t inv_alpha = 256 - p_alpha;
+
+	return (uint8_t)((alpha * p_fg + inv_alpha * p_bg) >> 8);
+}
+
+void Noise::_bind_methods() {
+	// Noise functions.
+	ClassDB::bind_method(D_METHOD("get_noise_1d", "x"), &Noise::get_noise_1d);
+	ClassDB::bind_method(D_METHOD("get_noise_2d", "x", "y"), &Noise::get_noise_2d);
+	ClassDB::bind_method(D_METHOD("get_noise_2dv", "v"), &Noise::get_noise_2dv);
+	ClassDB::bind_method(D_METHOD("get_noise_3d", "x", "y", "z"), &Noise::get_noise_3d);
+	ClassDB::bind_method(D_METHOD("get_noise_3dv", "v"), &Noise::get_noise_3dv);
+
+	// Textures.
+	ClassDB::bind_method(D_METHOD("get_image", "width", "height", "invert"), &Noise::get_image, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("get_seamless_image", "width", "height", "invert", "skirt"), &Noise::get_seamless_image, DEFVAL(false), DEFVAL(0.1));
+}
diff --git a/modules/noise/noise.h b/modules/noise/noise.h
new file mode 100644
index 0000000000..c05bc057da
--- /dev/null
+++ b/modules/noise/noise.h
@@ -0,0 +1,239 @@
+/*************************************************************************/
+/*  noise.h                                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef NOISE_H
+#define NOISE_H
+
+#include "core/io/image.h"
+
+class Noise : public Resource {
+	GDCLASS(Noise, Resource);
+
+	// Helper struct for get_seamless_image(). See comments in .cpp for usage.
+	template <typename T>
+	struct img_buff {
+		T *img;
+		int width; // Array dimensions & default modulo for image.
+		int height;
+		int offset_x; // Offset index location on image (wrapped by specified modulo).
+		int offset_y;
+		int alt_width; // Alternate module for image.
+		int alt_height;
+
+		enum ALT_MODULO {
+			DEFAULT = 0,
+			ALT_X,
+			ALT_Y,
+			ALT_XY
+		};
+
+		// Multi-dimensional array indexer (e.g. img[x][y]) that supports multiple modulos.
+		T &operator()(int x, int y, ALT_MODULO mode = DEFAULT) {
+			switch (mode) {
+				case ALT_XY:
+					return img[(x + offset_x) % alt_width + ((y + offset_y) % alt_height) * width];
+				case ALT_X:
+					return img[(x + offset_x) % alt_width + ((y + offset_y) % height) * width];
+				case ALT_Y:
+					return img[(x + offset_x) % width + ((y + offset_y) % alt_height) * width];
+				default:
+					return img[(x + offset_x) % width + ((y + offset_y) % height) * width];
+			}
+		}
+	};
+
+	union l2c {
+		uint32_t l;
+		uint8_t c[4];
+		struct {
+			uint8_t r;
+			uint8_t g;
+			uint8_t b;
+			uint8_t a;
+		};
+	};
+
+	template <typename T>
+	Ref<Image> _generate_seamless_image(Ref<Image> p_src, int p_width, int p_height, bool p_invert, real_t p_blend_skirt) {
+		/*
+		To make a seamless image, we swap the quadrants so the edges are perfect matches.
+		We initially get a 10% larger image so we have an overlap we can use to blend over the seams.
+
+		Noise::img_buff::operator() acts as a multi-dimensional array indexer.
+		It does the array math, translates between the flipped and non-flipped quadrants, and manages offsets and modulos.
+
+		Here is how the larger source image and final output image map to each other:
+
+		Output size = p_width*p_height	Source w/ extra 10% skirt `s` size = src_width*src_height
+		Q1   Q2							Q4	Q3 s1
+		Q3   Q4							Q2	Q1 s2
+										s5	s4 s3
+
+		All of the loops use output coordinates, so Output:Q1 == Source:Q1
+		Ex: Output(half_width, half_height) [the midpoint, corner of Q1/Q4] =>
+		on Source it's translated to
+		corner of Q1/s3 unless the ALT_XY modulo moves it to Q4
+		*/
+
+		int skirt_width = MAX(1, p_width * p_blend_skirt);
+		int skirt_height = MAX(1, p_height * p_blend_skirt);
+		int src_width = p_width + skirt_width;
+		int src_height = p_height + skirt_height;
+		int half_width = p_width * .5;
+		int half_height = p_height * .5;
+		int skirt_edge_x = half_width + skirt_width;
+		int skirt_edge_y = half_height + skirt_height;
+
+		Vector<uint8_t> dest;
+		dest.resize(p_width * p_height * Image::get_format_pixel_size(p_src->get_format()));
+
+		img_buff<T> rd_src = {
+			(T *)p_src->get_data().ptr(),
+			src_width, src_height,
+			half_width, half_height,
+			p_width, p_height
+		};
+
+		// `wr` is setup for straight x/y coordinate array access.
+		img_buff<T> wr = {
+			(T *)dest.ptrw(),
+			p_width, p_height,
+			0, 0, 0, 0
+		};
+		// `rd_dest` is a readable pointer to `wr`, i.e. what has already been written to the output buffer.
+		img_buff<T> rd_dest = {
+			(T *)dest.ptr(),
+			p_width, p_height,
+			0, 0, 0, 0
+		};
+
+		// Swap the quadrants to make edges seamless.
+		for (int y = 0; y < p_height; y++) {
+			for (int x = 0; x < p_width; x++) {
+				// rd_src has a half offset and the shorter modulo ignores the skirt.
+				// It reads and writes in Q1-4 order (see map above), skipping the skirt.
+				wr(x, y) = rd_src(x, y, img_buff<T>::ALT_XY);
+			}
+		}
+
+		// Blend the vertical skirt over the middle seam.
+		for (int x = half_width; x < skirt_edge_x; x++) {
+			int alpha = 255 * (1 - Math::smoothstep(.1f, .9f, float(x - half_width) / float(skirt_width)));
+			for (int y = 0; y < p_height; y++) {
+				// Skip the center square
+				if (y == half_height) {
+					y = skirt_edge_y - 1;
+				} else {
+					// Starts reading at s2, ALT_Y skips s3, and continues with s1.
+					wr(x, y) = _alpha_blend<T>(rd_dest(x, y), rd_src(x, y, img_buff<T>::ALT_Y), alpha);
+				}
+			}
+		}
+
+		// Blend the horizontal skirt over the middle seam.
+		for (int y = half_height; y < skirt_edge_y; y++) {
+			int alpha = 255 * (1 - Math::smoothstep(.1f, .9f, float(y - half_height) / float(skirt_height)));
+			for (int x = 0; x < p_width; x++) {
+				// Skip the center square
+				if (x == half_width) {
+					x = skirt_edge_x - 1;
+				} else {
+					// Starts reading at s4, skips s3, continues with s5.
+					wr(x, y) = _alpha_blend<T>(rd_dest(x, y), rd_src(x, y, img_buff<T>::ALT_X), alpha);
+				}
+			}
+		}
+
+		// Fill in the center square. Wr starts at the top left of Q4, which is the equivalent of the top left of s3, unless a modulo is used.
+		for (int y = half_height; y < skirt_edge_y; y++) {
+			for (int x = half_width; x < skirt_edge_x; x++) {
+				int xpos = 255 * (1 - Math::smoothstep(.1f, .9f, float(x - half_width) / float(skirt_width)));
+				int ypos = 255 * (1 - Math::smoothstep(.1f, .9f, float(y - half_height) / float(skirt_height)));
+
+				// Blend s3(Q1) onto s5(Q2) for the top half.
+				T top_blend = _alpha_blend<T>(rd_src(x, y, img_buff<T>::ALT_X), rd_src(x, y, img_buff<T>::DEFAULT), xpos);
+				// Blend s1(Q3) onto Q4 for the bottom half.
+				T bottom_blend = _alpha_blend<T>(rd_src(x, y, img_buff<T>::ALT_XY), rd_src(x, y, img_buff<T>::ALT_Y), xpos);
+				// Blend the top half onto the bottom half.
+				wr(x, y) = _alpha_blend<T>(bottom_blend, top_blend, ypos);
+			}
+		}
+		Ref<Image> image = memnew(Image(p_width, p_height, false, p_src->get_format(), dest));
+		p_src.unref();
+		return image;
+	}
+
+	template <typename T>
+	T _alpha_blend(T p_bg, T p_fg, int p_alpha) const {
+		l2c fg, bg, out;
+
+		fg.l = p_fg;
+		bg.l = p_bg;
+
+		uint16_t alpha;
+		uint16_t inv_alpha;
+
+		// If no alpha argument specified, use the alpha channel in the color
+		if (p_alpha == -1) {
+			alpha = fg.c[3] + 1;
+			inv_alpha = 256 - fg.c[3];
+		} else {
+			alpha = p_alpha + 1;
+			inv_alpha = 256 - p_alpha;
+		}
+
+		out.c[0] = (uint8_t)((alpha * fg.c[0] + inv_alpha * bg.c[0]) >> 8);
+		out.c[1] = (uint8_t)((alpha * fg.c[1] + inv_alpha * bg.c[1]) >> 8);
+		out.c[2] = (uint8_t)((alpha * fg.c[2] + inv_alpha * bg.c[2]) >> 8);
+		out.c[3] = 0xFF;
+
+		return out.l;
+	}
+
+protected:
+	static void _bind_methods();
+
+public:
+	// Virtual destructor so we can delete any Noise derived object when referenced as a Noise*.
+	virtual ~Noise() {}
+
+	virtual real_t get_noise_1d(real_t p_x) = 0;
+
+	virtual real_t get_noise_2dv(Vector2 p_v) = 0;
+	virtual real_t get_noise_2d(real_t p_x, real_t p_y) = 0;
+
+	virtual real_t get_noise_3dv(Vector3 p_v) = 0;
+	virtual real_t get_noise_3d(real_t p_x, real_t p_y, real_t p_z) = 0;
+
+	virtual Ref<Image> get_image(int p_width, int p_height, bool p_invert = false) = 0;
+	virtual Ref<Image> get_seamless_image(int p_width, int p_height, bool p_invert = false, real_t p_blend_skirt = 0.1);
+};
+
+#endif // NOISE_H
diff --git a/modules/opensimplex/noise_texture.cpp b/modules/noise/noise_texture.cpp
index f3342dfd84..3721043a09 100644
--- a/modules/opensimplex/noise_texture.cpp
+++ b/modules/noise/noise_texture.cpp
@@ -31,9 +31,10 @@
 #include "noise_texture.h"
 
 #include "core/core_string_names.h"
+#include "noise.h"
 
 NoiseTexture::NoiseTexture() {
-	noise = Ref<OpenSimplexNoise>();
+	noise = Ref<Noise>();
 
 	_queue_update();
 }
@@ -52,12 +53,15 @@ void NoiseTexture::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_noise", "noise"), &NoiseTexture::set_noise);
 	ClassDB::bind_method(D_METHOD("get_noise"), &NoiseTexture::get_noise);
 
-	ClassDB::bind_method(D_METHOD("set_noise_offset", "noise_offset"), &NoiseTexture::set_noise_offset);
-	ClassDB::bind_method(D_METHOD("get_noise_offset"), &NoiseTexture::get_noise_offset);
+	ClassDB::bind_method(D_METHOD("set_invert", "invert"), &NoiseTexture::set_invert);
+	ClassDB::bind_method(D_METHOD("get_invert"), &NoiseTexture::get_invert);
 
 	ClassDB::bind_method(D_METHOD("set_seamless", "seamless"), &NoiseTexture::set_seamless);
 	ClassDB::bind_method(D_METHOD("get_seamless"), &NoiseTexture::get_seamless);
 
+	ClassDB::bind_method(D_METHOD("set_seamless_blend_skirt", "seamless_blend_skirt"), &NoiseTexture::set_seamless_blend_skirt);
+	ClassDB::bind_method(D_METHOD("get_seamless_blend_skirt"), &NoiseTexture::get_seamless_blend_skirt);
+
 	ClassDB::bind_method(D_METHOD("set_as_normal_map", "as_normal_map"), &NoiseTexture::set_as_normal_map);
 	ClassDB::bind_method(D_METHOD("is_normal_map"), &NoiseTexture::is_normal_map);
 
@@ -70,11 +74,12 @@ void NoiseTexture::_bind_methods() {
 
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "width", PROPERTY_HINT_RANGE, "1,2048,1,or_greater"), "set_width", "get_width");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "height", PROPERTY_HINT_RANGE, "1,2048,1,or_greater"), "set_height", "get_height");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "invert"), "set_invert", "get_invert");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "seamless"), "set_seamless", "get_seamless");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "seamless_blend_skirt", PROPERTY_HINT_RANGE, "0.05,1,0.001"), "set_seamless_blend_skirt", "get_seamless_blend_skirt");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "as_normal_map"), "set_as_normal_map", "is_normal_map");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "bump_strength", PROPERTY_HINT_RANGE, "0,32,0.1,or_greater"), "set_bump_strength", "get_bump_strength");
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "noise", PROPERTY_HINT_RESOURCE_TYPE, "OpenSimplexNoise"), "set_noise", "get_noise");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "noise_offset"), "set_noise_offset", "get_noise_offset");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "noise", PROPERTY_HINT_RESOURCE_TYPE, "Noise"), "set_noise", "get_noise");
 }
 
 void NoiseTexture::_validate_property(PropertyInfo &property) const {
@@ -83,6 +88,12 @@ void NoiseTexture::_validate_property(PropertyInfo &property) const {
 			property.usage = PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL;
 		}
 	}
+
+	if (property.name == "seamless_blend_skirt") {
+		if (!seamless) {
+			property.usage = PROPERTY_USAGE_NO_EDITOR;
+		}
+	}
 }
 
 void NoiseTexture::_set_texture_image(const Ref<Image> &p_image) {
@@ -123,7 +134,7 @@ void NoiseTexture::_queue_update() {
 
 Ref<Image> NoiseTexture::_generate_texture() {
 	// Prevent memdelete due to unref() on other thread.
-	Ref<OpenSimplexNoise> ref_noise = noise;
+	Ref<Noise> ref_noise = noise;
 
 	if (ref_noise.is_null()) {
 		return Ref<Image>();
@@ -132,9 +143,9 @@ Ref<Image> NoiseTexture::_generate_texture() {
 	Ref<Image> image;
 
 	if (seamless) {
-		image = ref_noise->get_seamless_image(size.x);
+		image = ref_noise->get_seamless_image(size.x, size.y, invert, seamless_blend_skirt);
 	} else {
-		image = ref_noise->get_image(size.x, size.y, noise_offset);
+		image = ref_noise->get_image(size.x, size.y, invert);
 	}
 
 	if (as_normal_map) {
@@ -168,7 +179,7 @@ void NoiseTexture::_update_texture() {
 	update_queued = false;
 }
 
-void NoiseTexture::set_noise(Ref<OpenSimplexNoise> p_noise) {
+void NoiseTexture::set_noise(Ref<Noise> p_noise) {
 	if (p_noise == noise) {
 		return;
 	}
@@ -182,7 +193,7 @@ void NoiseTexture::set_noise(Ref<OpenSimplexNoise> p_noise) {
 	_queue_update();
 }
 
-Ref<OpenSimplexNoise> NoiseTexture::get_noise() {
+Ref<Noise> NoiseTexture::get_noise() {
 	return noise;
 }
 
@@ -204,26 +215,42 @@ void NoiseTexture::set_height(int p_height) {
 	_queue_update();
 }
 
-void NoiseTexture::set_noise_offset(Vector2 p_noise_offset) {
-	if (noise_offset == p_noise_offset) {
+void NoiseTexture::set_invert(bool p_invert) {
+	if (p_invert == invert) {
 		return;
 	}
-	noise_offset = p_noise_offset;
+	invert = p_invert;
 	_queue_update();
 }
 
+bool NoiseTexture::get_invert() const {
+	return invert;
+}
+
 void NoiseTexture::set_seamless(bool p_seamless) {
 	if (p_seamless == seamless) {
 		return;
 	}
 	seamless = p_seamless;
 	_queue_update();
+	notify_property_list_changed();
 }
 
 bool NoiseTexture::get_seamless() {
 	return seamless;
 }
 
+void NoiseTexture::set_seamless_blend_skirt(real_t p_blend_skirt) {
+	if (p_blend_skirt == seamless_blend_skirt) {
+		return;
+	}
+	seamless_blend_skirt = p_blend_skirt;
+	_queue_update();
+}
+real_t NoiseTexture::get_seamless_blend_skirt() {
+	return seamless_blend_skirt;
+}
+
 void NoiseTexture::set_as_normal_map(bool p_as_normal_map) {
 	if (p_as_normal_map == as_normal_map) {
 		return;
@@ -259,10 +286,6 @@ int NoiseTexture::get_height() const {
 	return size.y;
 }
 
-Vector2 NoiseTexture::get_noise_offset() const {
-	return noise_offset;
-}
-
 RID NoiseTexture::get_rid() const {
 	if (!texture.is_valid()) {
 		texture = RS::get_singleton()->texture_2d_placeholder_create();
diff --git a/modules/opensimplex/noise_texture.h b/modules/noise/noise_texture.h
index ee8f88aaca..2a94df39d4 100644
--- a/modules/opensimplex/noise_texture.h
+++ b/modules/noise/noise_texture.h
@@ -31,10 +31,10 @@
 #ifndef NOISE_TEXTURE_H
 #define NOISE_TEXTURE_H
 
-#include "open_simplex_noise.h"
+#include "noise.h"
 
-#include "core/io/image.h"
 #include "core/object/ref_counted.h"
+#include "scene/resources/texture.h"
 
 class NoiseTexture : public Texture2D {
 	GDCLASS(NoiseTexture, Texture2D);
@@ -51,10 +51,12 @@ private:
 	mutable RID texture;
 	uint32_t flags = 0;
 
-	Ref<OpenSimplexNoise> noise;
+	Ref<Noise> noise;
+	bool invert = false;
 	Vector2i size = Vector2i(512, 512);
 	Vector2 noise_offset;
 	bool seamless = false;
+	real_t seamless_blend_skirt = 0.1;
 	bool as_normal_map = false;
 	float bump_strength = 8.0;
 
@@ -71,18 +73,21 @@ protected:
 	virtual void _validate_property(PropertyInfo &property) const override;
 
 public:
-	void set_noise(Ref<OpenSimplexNoise> p_noise);
-	Ref<OpenSimplexNoise> get_noise();
+	void set_noise(Ref<Noise> p_noise);
+	Ref<Noise> get_noise();
 
 	void set_width(int p_width);
 	void set_height(int p_height);
 
-	void set_noise_offset(Vector2 p_noise_offset);
-	Vector2 get_noise_offset() const;
+	void set_invert(bool p_invert);
+	bool get_invert() const;
 
 	void set_seamless(bool p_seamless);
 	bool get_seamless();
 
+	void set_seamless_blend_skirt(real_t p_blend_skirt);
+	real_t get_seamless_blend_skirt();
+
 	void set_as_normal_map(bool p_as_normal_map);
 	bool is_normal_map();
 
diff --git a/modules/opensimplex/register_types.cpp b/modules/noise/register_types.cpp
index 30dfdc3764..81bb0317c1 100644
--- a/modules/opensimplex/register_types.cpp
+++ b/modules/noise/register_types.cpp
@@ -29,13 +29,16 @@
 /*************************************************************************/
 
 #include "register_types.h"
+
+#include "fastnoise_lite.h"
+#include "noise.h"
 #include "noise_texture.h"
-#include "open_simplex_noise.h"
 
-void register_opensimplex_types() {
-	GDREGISTER_CLASS(OpenSimplexNoise);
+void register_noise_types() {
 	GDREGISTER_CLASS(NoiseTexture);
+	GDREGISTER_ABSTRACT_CLASS(Noise);
+	GDREGISTER_CLASS(FastNoiseLite);
 }
 
-void unregister_opensimplex_types() {
+void unregister_noise_types() {
 }
diff --git a/modules/opensimplex/register_types.h b/modules/noise/register_types.h
index 2262ab2f5e..e441a48518 100644
--- a/modules/opensimplex/register_types.h
+++ b/modules/noise/register_types.h
@@ -28,10 +28,10 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef OPENSIMPLEX_REGISTER_TYPES_H
-#define OPENSIMPLEX_REGISTER_TYPES_H
+#ifndef NOISE_REGISTER_TYPES_H
+#define NOISE_REGISTER_TYPES_H
 
-void register_opensimplex_types();
-void unregister_opensimplex_types();
+void register_noise_types();
+void unregister_noise_types();
 
-#endif // OPENSIMPLEX_REGISTER_TYPES_H
+#endif // NOISE_REGISTER_TYPES_H
diff --git a/modules/opensimplex/doc_classes/OpenSimplexNoise.xml b/modules/opensimplex/doc_classes/OpenSimplexNoise.xml
deleted file mode 100644
index 51dd83efc3..0000000000
--- a/modules/opensimplex/doc_classes/OpenSimplexNoise.xml
+++ /dev/null
@@ -1,112 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<class name="OpenSimplexNoise" inherits="Resource" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
-	<brief_description>
-		Noise generator based on Open Simplex.
-	</brief_description>
-	<description>
-		This resource allows you to configure and sample a fractal noise space. Here is a brief usage example that configures an OpenSimplexNoise and gets samples at various positions and dimensions:
-		[codeblock]
-		var noise = OpenSimplexNoise.new()
-
-		# Configure
-		noise.seed = randi()
-		noise.octaves = 4
-		noise.period = 20.0
-		noise.persistence = 0.8
-
-		# Sample
-		print("Values:")
-		print(noise.get_noise_2d(1.0, 1.0))
-		print(noise.get_noise_3d(0.5, 3.0, 15.0))
-		print(noise.get_noise_4d(0.5, 1.9, 4.7, 0.0))
-		[/codeblock]
-	</description>
-	<tutorials>
-	</tutorials>
-	<methods>
-		<method name="get_image" qualifiers="const">
-			<return type="Image" />
-			<argument index="0" name="width" type="int" />
-			<argument index="1" name="height" type="int" />
-			<argument index="2" name="noise_offset" type="Vector2" default="Vector2(0, 0)" />
-			<description>
-				Generate a noise image in [constant Image.FORMAT_L8] format with the requested [code]width[/code] and [code]height[/code], based on the current noise parameters. If [code]noise_offset[/code] is specified, then the offset value is used as the coordinates of the top-left corner of the generated noise.
-			</description>
-		</method>
-		<method name="get_noise_1d" qualifiers="const">
-			<return type="float" />
-			<argument index="0" name="x" type="float" />
-			<description>
-				Returns the 1D noise value [code][-1,1][/code] at the given x-coordinate.
-				[b]Note:[/b] This method actually returns the 2D noise value [code][-1,1][/code] with fixed y-coordinate value 0.0.
-			</description>
-		</method>
-		<method name="get_noise_2d" qualifiers="const">
-			<return type="float" />
-			<argument index="0" name="x" type="float" />
-			<argument index="1" name="y" type="float" />
-			<description>
-				Returns the 2D noise value [code][-1,1][/code] at the given position.
-			</description>
-		</method>
-		<method name="get_noise_2dv" qualifiers="const">
-			<return type="float" />
-			<argument index="0" name="pos" type="Vector2" />
-			<description>
-				Returns the 2D noise value [code][-1,1][/code] at the given position.
-			</description>
-		</method>
-		<method name="get_noise_3d" qualifiers="const">
-			<return type="float" />
-			<argument index="0" name="x" type="float" />
-			<argument index="1" name="y" type="float" />
-			<argument index="2" name="z" type="float" />
-			<description>
-				Returns the 3D noise value [code][-1,1][/code] at the given position.
-			</description>
-		</method>
-		<method name="get_noise_3dv" qualifiers="const">
-			<return type="float" />
-			<argument index="0" name="pos" type="Vector3" />
-			<description>
-				Returns the 3D noise value [code][-1,1][/code] at the given position.
-			</description>
-		</method>
-		<method name="get_noise_4d" qualifiers="const">
-			<return type="float" />
-			<argument index="0" name="x" type="float" />
-			<argument index="1" name="y" type="float" />
-			<argument index="2" name="z" type="float" />
-			<argument index="3" name="w" type="float" />
-			<description>
-				Returns the 4D noise value [code][-1,1][/code] at the given position.
-			</description>
-		</method>
-		<method name="get_seamless_image" qualifiers="const">
-			<return type="Image" />
-			<argument index="0" name="size" type="int" />
-			<description>
-				Generate a tileable noise image in [constant Image.FORMAT_L8] format, based on the current noise parameters. Generated seamless images are always square ([code]size[/code] × [code]size[/code]).
-				[b]Note:[/b] Seamless noise has a lower contrast compared to non-seamless noise. This is due to the way noise uses higher dimensions for generating seamless noise.
-			</description>
-		</method>
-	</methods>
-	<members>
-		<member name="lacunarity" type="float" setter="set_lacunarity" getter="get_lacunarity" default="2.0">
-			Difference in period between [member octaves].
-		</member>
-		<member name="octaves" type="int" setter="set_octaves" getter="get_octaves" default="3">
-			Number of OpenSimplex noise layers that are sampled to get the fractal noise. Higher values result in more detailed noise but take more time to generate.
-			[b]Note:[/b] The maximum allowed value is 9.
-		</member>
-		<member name="period" type="float" setter="set_period" getter="get_period" default="64.0">
-			Period of the base octave. A lower period results in a higher-frequency noise (more value changes across the same distance).
-		</member>
-		<member name="persistence" type="float" setter="set_persistence" getter="get_persistence" default="0.5">
-			Contribution factor of the different octaves. A [code]persistence[/code] value of 1 means all the octaves have the same contribution, a value of 0.5 means each octave contributes half as much as the previous one.
-		</member>
-		<member name="seed" type="int" setter="set_seed" getter="get_seed" default="0">
-			Seed used to generate random values, different seeds will generate different noise maps.
-		</member>
-	</members>
-</class>
diff --git a/modules/opensimplex/open_simplex_noise.cpp b/modules/opensimplex/open_simplex_noise.cpp
deleted file mode 100644
index b7c901fd06..0000000000
--- a/modules/opensimplex/open_simplex_noise.cpp
+++ /dev/null
@@ -1,250 +0,0 @@
-/*************************************************************************/
-/*  open_simplex_noise.cpp                                               */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#include "open_simplex_noise.h"
-
-#include "core/core_string_names.h"
-
-OpenSimplexNoise::OpenSimplexNoise() {
-	_init_seeds();
-}
-
-OpenSimplexNoise::~OpenSimplexNoise() {
-}
-
-void OpenSimplexNoise::_init_seeds() {
-	for (int i = 0; i < MAX_OCTAVES; ++i) {
-		open_simplex_noise(seed + i * 2, &(contexts[i]));
-	}
-}
-
-void OpenSimplexNoise::set_seed(int p_seed) {
-	if (seed == p_seed) {
-		return;
-	}
-
-	seed = p_seed;
-
-	_init_seeds();
-
-	emit_changed();
-}
-
-int OpenSimplexNoise::get_seed() const {
-	return seed;
-}
-
-void OpenSimplexNoise::set_octaves(int p_octaves) {
-	if (p_octaves == octaves) {
-		return;
-	}
-
-	ERR_FAIL_COND_MSG(p_octaves > MAX_OCTAVES, vformat("The number of OpenSimplexNoise octaves is limited to %d; ignoring the new value.", MAX_OCTAVES));
-
-	octaves = CLAMP(p_octaves, 1, MAX_OCTAVES);
-	emit_changed();
-}
-
-void OpenSimplexNoise::set_period(float p_period) {
-	if (p_period == period) {
-		return;
-	}
-	period = p_period;
-	emit_changed();
-}
-
-void OpenSimplexNoise::set_persistence(float p_persistence) {
-	if (p_persistence == persistence) {
-		return;
-	}
-	persistence = p_persistence;
-	emit_changed();
-}
-
-void OpenSimplexNoise::set_lacunarity(float p_lacunarity) {
-	if (p_lacunarity == lacunarity) {
-		return;
-	}
-	lacunarity = p_lacunarity;
-	emit_changed();
-}
-
-Ref<Image> OpenSimplexNoise::get_image(int p_width, int p_height, const Vector2 &p_noise_offset) const {
-	Vector<uint8_t> data;
-	data.resize(p_width * p_height);
-
-	uint8_t *wd8 = data.ptrw();
-
-	for (int i = 0; i < p_height; i++) {
-		for (int j = 0; j < p_width; j++) {
-			float v = get_noise_2d(float(j) + p_noise_offset.x, float(i) + p_noise_offset.y);
-			v = v * 0.5 + 0.5; // Normalize [0..1]
-			wd8[(i * p_width + j)] = uint8_t(CLAMP(v * 255.0, 0, 255));
-		}
-	}
-
-	Ref<Image> image = memnew(Image(p_width, p_height, false, Image::FORMAT_L8, data));
-	return image;
-}
-
-Ref<Image> OpenSimplexNoise::get_seamless_image(int p_size) const {
-	Vector<uint8_t> data;
-	data.resize(p_size * p_size);
-
-	uint8_t *wd8 = data.ptrw();
-
-	for (int i = 0; i < p_size; i++) {
-		for (int j = 0; j < p_size; j++) {
-			float ii = (float)i / (float)p_size;
-			float jj = (float)j / (float)p_size;
-
-			ii *= Math_TAU;
-			jj *= Math_TAU;
-
-			float radius = p_size / Math_TAU;
-
-			float x = radius * Math::sin(jj);
-			float y = radius * Math::cos(jj);
-			float z = radius * Math::sin(ii);
-			float w = radius * Math::cos(ii);
-			float v = get_noise_4d(x, y, z, w);
-
-			v = v * 0.5 + 0.5; // Normalize [0..1]
-			wd8[(i * p_size + j)] = uint8_t(CLAMP(v * 255.0, 0, 255));
-		}
-	}
-
-	Ref<Image> image = memnew(Image(p_size, p_size, false, Image::FORMAT_L8, data));
-	return image;
-}
-
-void OpenSimplexNoise::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("get_seed"), &OpenSimplexNoise::get_seed);
-	ClassDB::bind_method(D_METHOD("set_seed", "seed"), &OpenSimplexNoise::set_seed);
-
-	ClassDB::bind_method(D_METHOD("set_octaves", "octave_count"), &OpenSimplexNoise::set_octaves);
-	ClassDB::bind_method(D_METHOD("get_octaves"), &OpenSimplexNoise::get_octaves);
-
-	ClassDB::bind_method(D_METHOD("set_period", "period"), &OpenSimplexNoise::set_period);
-	ClassDB::bind_method(D_METHOD("get_period"), &OpenSimplexNoise::get_period);
-
-	ClassDB::bind_method(D_METHOD("set_persistence", "persistence"), &OpenSimplexNoise::set_persistence);
-	ClassDB::bind_method(D_METHOD("get_persistence"), &OpenSimplexNoise::get_persistence);
-
-	ClassDB::bind_method(D_METHOD("set_lacunarity", "lacunarity"), &OpenSimplexNoise::set_lacunarity);
-	ClassDB::bind_method(D_METHOD("get_lacunarity"), &OpenSimplexNoise::get_lacunarity);
-
-	ClassDB::bind_method(D_METHOD("get_image", "width", "height", "noise_offset"), &OpenSimplexNoise::get_image, DEFVAL(Vector2()));
-	ClassDB::bind_method(D_METHOD("get_seamless_image", "size"), &OpenSimplexNoise::get_seamless_image);
-
-	ClassDB::bind_method(D_METHOD("get_noise_1d", "x"), &OpenSimplexNoise::get_noise_1d);
-	ClassDB::bind_method(D_METHOD("get_noise_2d", "x", "y"), &OpenSimplexNoise::get_noise_2d);
-	ClassDB::bind_method(D_METHOD("get_noise_3d", "x", "y", "z"), &OpenSimplexNoise::get_noise_3d);
-	ClassDB::bind_method(D_METHOD("get_noise_4d", "x", "y", "z", "w"), &OpenSimplexNoise::get_noise_4d);
-
-	ClassDB::bind_method(D_METHOD("get_noise_2dv", "pos"), &OpenSimplexNoise::get_noise_2dv);
-	ClassDB::bind_method(D_METHOD("get_noise_3dv", "pos"), &OpenSimplexNoise::get_noise_3dv);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "seed"), "set_seed", "get_seed");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "octaves", PROPERTY_HINT_RANGE, vformat("1,%d,1", MAX_OCTAVES)), "set_octaves", "get_octaves");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "period", PROPERTY_HINT_RANGE, "0.1,256.0,0.1"), "set_period", "get_period");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "persistence", PROPERTY_HINT_RANGE, "0.0,1.0,0.001"), "set_persistence", "get_persistence");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "lacunarity", PROPERTY_HINT_RANGE, "0.1,4.0,0.01"), "set_lacunarity", "get_lacunarity");
-}
-
-float OpenSimplexNoise::get_noise_1d(float x) const {
-	return get_noise_2d(x, 1.0);
-}
-
-float OpenSimplexNoise::get_noise_2d(float x, float y) const {
-	x /= period;
-	y /= period;
-
-	float amp = 1.0;
-	float max = 1.0;
-	float sum = _get_octave_noise_2d(0, x, y);
-
-	int i = 0;
-	while (++i < octaves) {
-		x *= lacunarity;
-		y *= lacunarity;
-		amp *= persistence;
-		max += amp;
-		sum += _get_octave_noise_2d(i, x, y) * amp;
-	}
-
-	return sum / max;
-}
-
-float OpenSimplexNoise::get_noise_3d(float x, float y, float z) const {
-	x /= period;
-	y /= period;
-	z /= period;
-
-	float amp = 1.0;
-	float max = 1.0;
-	float sum = _get_octave_noise_3d(0, x, y, z);
-
-	int i = 0;
-	while (++i < octaves) {
-		x *= lacunarity;
-		y *= lacunarity;
-		z *= lacunarity;
-		amp *= persistence;
-		max += amp;
-		sum += _get_octave_noise_3d(i, x, y, z) * amp;
-	}
-
-	return sum / max;
-}
-
-float OpenSimplexNoise::get_noise_4d(float x, float y, float z, float w) const {
-	x /= period;
-	y /= period;
-	z /= period;
-	w /= period;
-
-	float amp = 1.0;
-	float max = 1.0;
-	float sum = _get_octave_noise_4d(0, x, y, z, w);
-
-	int i = 0;
-	while (++i < octaves) {
-		x *= lacunarity;
-		y *= lacunarity;
-		z *= lacunarity;
-		w *= lacunarity;
-		amp *= persistence;
-		max += amp;
-		sum += _get_octave_noise_4d(i, x, y, z, w) * amp;
-	}
-
-	return sum / max;
-}
diff --git a/modules/opensimplex/open_simplex_noise.h b/modules/opensimplex/open_simplex_noise.h
deleted file mode 100644
index c34f998b78..0000000000
--- a/modules/opensimplex/open_simplex_noise.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*************************************************************************/
-/*  open_simplex_noise.h                                                 */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
-
-#ifndef OPEN_SIMPLEX_NOISE_H
-#define OPEN_SIMPLEX_NOISE_H
-
-#include "core/io/image.h"
-#include "core/object/ref_counted.h"
-#include "scene/resources/texture.h"
-
-#include "thirdparty/misc/open-simplex-noise.h"
-
-class OpenSimplexNoise : public Resource {
-	GDCLASS(OpenSimplexNoise, Resource);
-	OBJ_SAVE_TYPE(OpenSimplexNoise);
-
-	// The maximum number of octaves allowed. Note that these are statically allocated.
-	// Higher values become exponentially slower, so this shouldn't be set too high
-	// to avoid freezing the editor for long periods of time.
-	static const int MAX_OCTAVES = 9;
-
-	osn_context contexts[MAX_OCTAVES];
-
-	int seed = 0;
-	float persistence = 0.5; // Controls details, value in [0,1]. Higher increases grain, lower increases smoothness.
-	int octaves = 3; // Number of noise layers
-	float period = 64.0; // Distance above which we start to see similarities. The higher, the longer "hills" will be on a terrain.
-	float lacunarity = 2.0; // Controls period change across octaves. 2 is usually a good value to address all detail levels.
-
-public:
-	OpenSimplexNoise();
-	~OpenSimplexNoise();
-
-	void _init_seeds();
-
-	void set_seed(int seed);
-	int get_seed() const;
-
-	void set_octaves(int p_octaves);
-	int get_octaves() const { return octaves; }
-
-	void set_period(float p_period);
-	float get_period() const { return period; }
-
-	void set_persistence(float p_persistence);
-	float get_persistence() const { return persistence; }
-
-	void set_lacunarity(float p_lacunarity);
-	float get_lacunarity() const { return lacunarity; }
-
-	Ref<Image> get_image(int p_width, int p_height, const Vector2 &p_noise_offset = Vector2()) const;
-	Ref<Image> get_seamless_image(int p_size) const;
-
-	float get_noise_1d(float x) const;
-	float get_noise_2d(float x, float y) const;
-	float get_noise_3d(float x, float y, float z) const;
-	float get_noise_4d(float x, float y, float z, float w) const;
-
-	_FORCE_INLINE_ float _get_octave_noise_2d(int octave, float x, float y) const { return open_simplex_noise2(&(contexts[octave]), x, y); }
-	_FORCE_INLINE_ float _get_octave_noise_3d(int octave, float x, float y, float z) const { return open_simplex_noise3(&(contexts[octave]), x, y, z); }
-	_FORCE_INLINE_ float _get_octave_noise_4d(int octave, float x, float y, float z, float w) const { return open_simplex_noise4(&(contexts[octave]), x, y, z, w); }
-
-	// Convenience
-
-	_FORCE_INLINE_ float get_noise_2dv(const Vector2 &v) const { return get_noise_2d(v.x, v.y); }
-	_FORCE_INLINE_ float get_noise_3dv(const Vector3 &v) const { return get_noise_3d(v.x, v.y, v.z); }
-
-protected:
-	static void _bind_methods();
-};
-
-#endif // OPEN_SIMPLEX_NOISE_H
diff --git a/thirdparty/README.md b/thirdparty/README.md
index 547dfad964..86dadfae09 100644
--- a/thirdparty/README.md
+++ b/thirdparty/README.md
@@ -412,10 +412,10 @@ Collection of single-file libraries used in Godot components.
   * Upstream: https://archive.blender.org/wiki/index.php/Dev:Shading/Tangent_Space_Normal_Maps/
   * Version: 1.0 (2011)
   * License: zlib
-- `open-simplex-noise.{c,h}`
-  * Upstream: https://github.com/smcameron/open-simplex-noise-in-c
-  * Version: git (826f1dd1724e6fb3ff45f58e48c0fbae864c3403, 2020) + custom changes
-  * License: Public Domain or Unlicense
+- `FastNoiseLite.h}`
+  * Upstream: https://github.com/Auburn/FastNoiseLite
+  * Version: git (6be3d6bf7fb408de341285f9ee8a29b67fd953f1, 2022) + custom changes
+  * License: MIT
 - `pcg.{cpp,h}`
   * Upstream: http://www.pcg-random.org
   * Version: minimal C implementation, http://www.pcg-random.org/download.html
diff --git a/thirdparty/misc/open-simplex-noise-LICENSE b/thirdparty/misc/open-simplex-noise-LICENSE
deleted file mode 100644
index a84c395662..0000000000
--- a/thirdparty/misc/open-simplex-noise-LICENSE
+++ /dev/null
@@ -1,25 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <http://unlicense.org>
-
diff --git a/thirdparty/misc/open-simplex-noise-no-allocate.patch b/thirdparty/misc/open-simplex-noise-no-allocate.patch
deleted file mode 100644
index fc3abe7d00..0000000000
--- a/thirdparty/misc/open-simplex-noise-no-allocate.patch
+++ /dev/null
@@ -1,133 +0,0 @@
-diff -u orig/open-simplex-noise.c misc/open-simplex-noise.c
---- orig/open-simplex-noise.c	2018-09-14 11:11:40.049810000 +0200
-+++ misc/open-simplex-noise.c	2018-09-14 11:09:39.726457000 +0200
-@@ -13,6 +13,11 @@
-  *   of any particular randomization library, so results
-  *   will be the same when ported to other languages.
-  */
-+
-+// -- GODOT start --
-+// Modified to work without allocating memory, also removed some unused function. 
-+// -- GODOT end --
-+
- #include <math.h>
- #include <stdlib.h>
- #include <stdint.h>
-@@ -34,11 +39,12 @@
- 	
- #define DEFAULT_SEED (0LL)
- 
--struct osn_context {
-+// -- GODOT start --
-+/*struct osn_context {
- 	int16_t *perm;
- 	int16_t *permGradIndex3D;
--};
--
-+};*/
-+// -- GODOT end --
- #define ARRAYSIZE(x) (sizeof((x)) / sizeof((x)[0]))
- 
- /* 
-@@ -126,7 +132,9 @@
- 	int xi = (int) x;
- 	return x < xi ? xi - 1 : xi;
- }
--	
-+
-+// -- GODOT start --
-+/*
- static int allocate_perm(struct osn_context *ctx, int nperm, int ngrad)
- {
- 	if (ctx->perm)
-@@ -154,18 +162,21 @@
- 	memcpy(ctx->perm, p, sizeof(*ctx->perm) * nelements);
- 		
- 	for (i = 0; i < 256; i++) {
--		/* Since 3D has 24 gradients, simple bitmask won't work, so precompute modulo array. */
-+		// Since 3D has 24 gradients, simple bitmask won't work, so precompute modulo array.
- 		ctx->permGradIndex3D[i] = (int16_t)((ctx->perm[i] % (ARRAYSIZE(gradients3D) / 3)) * 3);
- 	}
- 	return 0;
- }
-+*/
-+// -- GODOT end --
- 
- /*	
-  * Initializes using a permutation array generated from a 64-bit seed.
-  * Generates a proper permutation (i.e. doesn't merely perform N successive pair
-  * swaps on a base array).  Uses a simple 64-bit LCG.
-  */
--int open_simplex_noise(int64_t seed, struct osn_context **ctx)
-+// -- GODOT start --
-+int open_simplex_noise(int64_t seed, struct osn_context *ctx)
- {
- 	int rc;
- 	int16_t source[256];
-@@ -174,20 +185,9 @@
- 	int16_t *permGradIndex3D;
- 	int r;
- 
--	*ctx = (struct osn_context *) malloc(sizeof(**ctx));
--	if (!(*ctx))
--		return -ENOMEM;
--	(*ctx)->perm = NULL;
--	(*ctx)->permGradIndex3D = NULL;
--
--	rc = allocate_perm(*ctx, 256, 256);
--	if (rc) {
--		free(*ctx);
--		return rc;
--	}
--
--	perm = (*ctx)->perm;
--	permGradIndex3D = (*ctx)->permGradIndex3D;
-+	perm = ctx->perm;
-+	permGradIndex3D = ctx->permGradIndex3D;
-+// -- GODOT end --
- 
- 	for (i = 0; i < 256; i++)
- 		source[i] = (int16_t) i;
-@@ -206,6 +206,8 @@
- 	return 0;
- }
- 
-+// -- GODOT start --
-+/*
- void open_simplex_noise_free(struct osn_context *ctx)
- {
- 	if (!ctx)
-@@ -220,6 +222,8 @@
- 	}
- 	free(ctx);
- }
-+*/
-+// -- GODOT end --
- 	
- /* 2D OpenSimplex (Simplectic) Noise. */
- double open_simplex_noise2(struct osn_context *ctx, double x, double y) 
-diff -u orig/open-simplex-noise.h misc/open-simplex-noise.h
---- orig/open-simplex-noise.h	2018-09-14 11:11:19.659807000 +0200
-+++ misc/open-simplex-noise.h	2018-09-14 11:10:05.006460000 +0200
-@@ -35,11 +35,18 @@
- 	extern "C" {
- #endif
- 
--struct osn_context;
-+// -- GODOT start --
-+// Modified to work without allocating memory, also removed some unused function. 
- 
--int open_simplex_noise(int64_t seed, struct osn_context **ctx);
-+struct osn_context {
-+	int16_t perm[256];
-+	int16_t permGradIndex3D[256];
-+};
-+
-+int open_simplex_noise(int64_t seed, struct osn_context *ctx);
-+//int open_simplex_noise_init_perm(struct osn_context *ctx, int16_t p[], int nelements);
-+// -- GODOT end --
- void open_simplex_noise_free(struct osn_context *ctx);
--int open_simplex_noise_init_perm(struct osn_context *ctx, int16_t p[], int nelements);
- double open_simplex_noise2(struct osn_context *ctx, double x, double y);
- double open_simplex_noise3(struct osn_context *ctx, double x, double y, double z);
- double open_simplex_noise4(struct osn_context *ctx, double x, double y, double z, double w);
diff --git a/thirdparty/misc/open-simplex-noise.c b/thirdparty/misc/open-simplex-noise.c
deleted file mode 100644
index 44a072cad1..0000000000
--- a/thirdparty/misc/open-simplex-noise.c
+++ /dev/null
@@ -1,2255 +0,0 @@
-/*
- * OpenSimplex (Simplectic) Noise in C.
- * Ported by Stephen M. Cameron from Kurt Spencer's java implementation
- * 
- * v1.1 (October 5, 2014)
- * - Added 2D and 4D implementations.
- * - Proper gradient sets for all dimensions, from a
- *   dimensionally-generalizable scheme with an actual
- *   rhyme and reason behind it.
- * - Removed default permutation array in favor of
- *   default seed.
- * - Changed seed-based constructor to be independent
- *   of any particular randomization library, so results
- *   will be the same when ported to other languages.
- */
-
-// -- GODOT start --
-// Modified to work without allocating memory, also removed some unused function. 
-// -- GODOT end --
-
-#include <math.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include <errno.h>
-
-#include "open-simplex-noise.h"
-
-#define STRETCH_CONSTANT_2D (-0.211324865405187)    /* (1 / sqrt(2 + 1) - 1 ) / 2; */
-#define SQUISH_CONSTANT_2D  (0.366025403784439)     /* (sqrt(2 + 1) -1) / 2; */
-#define STRETCH_CONSTANT_3D (-1.0 / 6.0)            /* (1 / sqrt(3 + 1) - 1) / 3; */
-#define SQUISH_CONSTANT_3D  (1.0 / 3.0)             /* (sqrt(3+1)-1)/3; */
-#define STRETCH_CONSTANT_4D (-0.138196601125011)    /* (1 / sqrt(4 + 1) - 1) / 4; */
-#define SQUISH_CONSTANT_4D  (0.309016994374947)     /* (sqrt(4 + 1) - 1) / 4; */
-	
-#define NORM_CONSTANT_2D (47.0)
-#define NORM_CONSTANT_3D (103.0)
-#define NORM_CONSTANT_4D (30.0)
-	
-#define DEFAULT_SEED (0LL)
-
-// -- GODOT start --
-/*struct osn_context {
-	int16_t *perm;
-	int16_t *permGradIndex3D;
-};*/
-// -- GODOT end --
-#define ARRAYSIZE(x) (sizeof((x)) / sizeof((x)[0]))
-
-/* 
- * Gradients for 2D. They approximate the directions to the
- * vertices of an octagon from the center.
- */
-static const int8_t gradients2D[] = {
-	 5,  2,    2,  5,
-	-5,  2,   -2,  5,
-	 5, -2,    2, -5,
-	-5, -2,   -2, -5,
-};
-
-/*	
- * Gradients for 3D. They approximate the directions to the
- * vertices of a rhombicuboctahedron from the center, skewed so
- * that the triangular and square facets can be inscribed inside
- * circles of the same radius.
- */
-static const signed char gradients3D[] = {
-	-11,  4,  4,     -4,  11,  4,    -4,  4,  11,
-	 11,  4,  4,      4,  11,  4,     4,  4,  11,
-	-11, -4,  4,     -4, -11,  4,    -4, -4,  11,
-	 11, -4,  4,      4, -11,  4,     4, -4,  11,
-	-11,  4, -4,     -4,  11, -4,    -4,  4, -11,
-	 11,  4, -4,      4,  11, -4,     4,  4, -11,
-	-11, -4, -4,     -4, -11, -4,    -4, -4, -11,
-	 11, -4, -4,      4, -11, -4,     4, -4, -11,
-};
-
-/*	
- * Gradients for 4D. They approximate the directions to the
- * vertices of a disprismatotesseractihexadecachoron from the center,
- * skewed so that the tetrahedral and cubic facets can be inscribed inside
- * spheres of the same radius.
- */
-static const signed char gradients4D[] = {
-	 3,  1,  1,  1,      1,  3,  1,  1,      1,  1,  3,  1,      1,  1,  1,  3,
-	-3,  1,  1,  1,     -1,  3,  1,  1,     -1,  1,  3,  1,     -1,  1,  1,  3,
-	 3, -1,  1,  1,      1, -3,  1,  1,      1, -1,  3,  1,      1, -1,  1,  3,
-	-3, -1,  1,  1,     -1, -3,  1,  1,     -1, -1,  3,  1,     -1, -1,  1,  3,
-	 3,  1, -1,  1,      1,  3, -1,  1,      1,  1, -3,  1,      1,  1, -1,  3,
-	-3,  1, -1,  1,     -1,  3, -1,  1,     -1,  1, -3,  1,     -1,  1, -1,  3,
-	 3, -1, -1,  1,      1, -3, -1,  1,      1, -1, -3,  1,      1, -1, -1,  3,
-	-3, -1, -1,  1,     -1, -3, -1,  1,     -1, -1, -3,  1,     -1, -1, -1,  3,
-	 3,  1,  1, -1,      1,  3,  1, -1,      1,  1,  3, -1,      1,  1,  1, -3,
-	-3,  1,  1, -1,     -1,  3,  1, -1,     -1,  1,  3, -1,     -1,  1,  1, -3,
-	 3, -1,  1, -1,      1, -3,  1, -1,      1, -1,  3, -1,      1, -1,  1, -3,
-	-3, -1,  1, -1,     -1, -3,  1, -1,     -1, -1,  3, -1,     -1, -1,  1, -3,
-	 3,  1, -1, -1,      1,  3, -1, -1,      1,  1, -3, -1,      1,  1, -1, -3,
-	-3,  1, -1, -1,     -1,  3, -1, -1,     -1,  1, -3, -1,     -1,  1, -1, -3,
-	 3, -1, -1, -1,      1, -3, -1, -1,      1, -1, -3, -1,      1, -1, -1, -3,
-	-3, -1, -1, -1,     -1, -3, -1, -1,     -1, -1, -3, -1,     -1, -1, -1, -3,
-};
-
-static double extrapolate2(const struct osn_context *ctx, int xsb, int ysb, double dx, double dy)
-{
-	const int16_t *perm = ctx->perm;
-	int index = perm[(perm[xsb & 0xFF] + ysb) & 0xFF] & 0x0E;
-	return gradients2D[index] * dx
-		+ gradients2D[index + 1] * dy;
-}
-	
-static double extrapolate3(const struct osn_context *ctx, int xsb, int ysb, int zsb, double dx, double dy, double dz)
-{
-	const int16_t *perm = ctx->perm;
-	const int16_t *permGradIndex3D = ctx->permGradIndex3D;
-	int index = permGradIndex3D[(perm[(perm[xsb & 0xFF] + ysb) & 0xFF] + zsb) & 0xFF];
-	return gradients3D[index] * dx
-		+ gradients3D[index + 1] * dy
-		+ gradients3D[index + 2] * dz;
-}
-	
-static double extrapolate4(const struct osn_context *ctx, int xsb, int ysb, int zsb, int wsb, double dx, double dy, double dz, double dw)
-{
-	const int16_t *perm = ctx->perm;
-	int index = perm[(perm[(perm[(perm[xsb & 0xFF] + ysb) & 0xFF] + zsb) & 0xFF] + wsb) & 0xFF] & 0xFC;
-	return gradients4D[index] * dx
-		+ gradients4D[index + 1] * dy
-		+ gradients4D[index + 2] * dz
-		+ gradients4D[index + 3] * dw;
-}
-	
-static INLINE int fastFloor(double x) {
-	int xi = (int) x;
-	return x < xi ? xi - 1 : xi;
-}
-
-// -- GODOT start --
-/*
-static int allocate_perm(struct osn_context *ctx, int nperm, int ngrad)
-{
-	if (ctx->perm)
-		free(ctx->perm);
-	if (ctx->permGradIndex3D)
-		free(ctx->permGradIndex3D);
-	ctx->perm = (int16_t *) malloc(sizeof(*ctx->perm) * nperm); 
-	if (!ctx->perm)
-		return -ENOMEM;
-	ctx->permGradIndex3D = (int16_t *) malloc(sizeof(*ctx->permGradIndex3D) * ngrad);
-	if (!ctx->permGradIndex3D) {
-		free(ctx->perm);
-		return -ENOMEM;
-	}
-	return 0;
-}
-	
-int open_simplex_noise_init_perm(struct osn_context *ctx, int16_t p[], int nelements)
-{
-	int i, rc;
-
-	rc = allocate_perm(ctx, nelements, 256);
-	if (rc)
-		return rc;
-	memcpy(ctx->perm, p, sizeof(*ctx->perm) * nelements);
-		
-	for (i = 0; i < 256; i++) {
-		// Since 3D has 24 gradients, simple bitmask won't work, so precompute modulo array.
-		ctx->permGradIndex3D[i] = (int16_t)((ctx->perm[i] % (ARRAYSIZE(gradients3D) / 3)) * 3);
-	}
-	return 0;
-}
-*/
-// -- GODOT end --
-
-/*	
- * Initializes using a permutation array generated from a 64-bit seed.
- * Generates a proper permutation (i.e. doesn't merely perform N successive pair
- * swaps on a base array).  Uses a simple 64-bit LCG.
- */
-// -- GODOT start --
-int open_simplex_noise(int64_t seed, struct osn_context *ctx)
-{
-	int rc;
-	int16_t source[256];
-	int i;
-	int16_t *perm;
-	int16_t *permGradIndex3D;
-	int r;
-
-	perm = ctx->perm;
-	permGradIndex3D = ctx->permGradIndex3D;
-// -- GODOT end --
-
-	uint64_t seedU = seed;
-	for (i = 0; i < 256; i++)
-		source[i] = (int16_t) i;
-	seedU = seedU * 6364136223846793005ULL + 1442695040888963407ULL;
-	seedU = seedU * 6364136223846793005ULL + 1442695040888963407ULL;
-	seedU = seedU * 6364136223846793005ULL + 1442695040888963407ULL;
-	for (i = 255; i >= 0; i--) {
-		seedU = seedU * 6364136223846793005ULL + 1442695040888963407ULL;
-		r = (int)((seedU + 31) % (i + 1));
-		if (r < 0)
-			r += (i + 1);
-		perm[i] = source[r];
-		permGradIndex3D[i] = (short)((perm[i] % (ARRAYSIZE(gradients3D) / 3)) * 3);
-		source[r] = source[i];
-	}
-	return 0;
-}
-
-// -- GODOT start --
-/*
-void open_simplex_noise_free(struct osn_context *ctx)
-{
-	if (!ctx)
-		return;
-	if (ctx->perm) {
-		free(ctx->perm);
-		ctx->perm = NULL;	
-	}
-	if (ctx->permGradIndex3D) {
-		free(ctx->permGradIndex3D);
-		ctx->permGradIndex3D = NULL;
-	}
-	free(ctx);
-}
-*/
-// -- GODOT end --
-	
-/* 2D OpenSimplex (Simplectic) Noise. */
-double open_simplex_noise2(const struct osn_context *ctx, double x, double y)
-{
-	
-	/* Place input coordinates onto grid. */
-	double stretchOffset = (x + y) * STRETCH_CONSTANT_2D;
-	double xs = x + stretchOffset;
-	double ys = y + stretchOffset;
-		
-	/* Floor to get grid coordinates of rhombus (stretched square) super-cell origin. */
-	int xsb = fastFloor(xs);
-	int ysb = fastFloor(ys);
-		
-	/* Skew out to get actual coordinates of rhombus origin. We'll need these later. */
-	double squishOffset = (xsb + ysb) * SQUISH_CONSTANT_2D;
-	double xb = xsb + squishOffset;
-	double yb = ysb + squishOffset;
-		
-	/* Compute grid coordinates relative to rhombus origin. */
-	double xins = xs - xsb;
-	double yins = ys - ysb;
-		
-	/* Sum those together to get a value that determines which region we're in. */
-	double inSum = xins + yins;
-
-	/* Positions relative to origin point. */
-	double dx0 = x - xb;
-	double dy0 = y - yb;
-		
-	/* We'll be defining these inside the next block and using them afterwards. */
-	double dx_ext, dy_ext;
-	int xsv_ext, ysv_ext;
-
-	double dx1;
-	double dy1;
-	double attn1;
-	double dx2;
-	double dy2;
-	double attn2;
-	double zins;
-	double attn0;
-	double attn_ext;
-
-	double value = 0;
-
-	/* Contribution (1,0) */
-	dx1 = dx0 - 1 - SQUISH_CONSTANT_2D;
-	dy1 = dy0 - 0 - SQUISH_CONSTANT_2D;
-	attn1 = 2 - dx1 * dx1 - dy1 * dy1;
-	if (attn1 > 0) {
-		attn1 *= attn1;
-		value += attn1 * attn1 * extrapolate2(ctx, xsb + 1, ysb + 0, dx1, dy1);
-	}
-
-	/* Contribution (0,1) */
-	dx2 = dx0 - 0 - SQUISH_CONSTANT_2D;
-	dy2 = dy0 - 1 - SQUISH_CONSTANT_2D;
-	attn2 = 2 - dx2 * dx2 - dy2 * dy2;
-	if (attn2 > 0) {
-		attn2 *= attn2;
-		value += attn2 * attn2 * extrapolate2(ctx, xsb + 0, ysb + 1, dx2, dy2);
-	}
-		
-	if (inSum <= 1) { /* We're inside the triangle (2-Simplex) at (0,0) */
-		zins = 1 - inSum;
-		if (zins > xins || zins > yins) { /* (0,0) is one of the closest two triangular vertices */
-			if (xins > yins) {
-				xsv_ext = xsb + 1;
-				ysv_ext = ysb - 1;
-				dx_ext = dx0 - 1;
-				dy_ext = dy0 + 1;
-			} else {
-				xsv_ext = xsb - 1;
-				ysv_ext = ysb + 1;
-				dx_ext = dx0 + 1;
-				dy_ext = dy0 - 1;
-			}
-		} else { /* (1,0) and (0,1) are the closest two vertices. */
-			xsv_ext = xsb + 1;
-			ysv_ext = ysb + 1;
-			dx_ext = dx0 - 1 - 2 * SQUISH_CONSTANT_2D;
-			dy_ext = dy0 - 1 - 2 * SQUISH_CONSTANT_2D;
-		}
-	} else { /* We're inside the triangle (2-Simplex) at (1,1) */
-		zins = 2 - inSum;
-		if (zins < xins || zins < yins) { /* (0,0) is one of the closest two triangular vertices */
-			if (xins > yins) {
-				xsv_ext = xsb + 2;
-				ysv_ext = ysb + 0;
-				dx_ext = dx0 - 2 - 2 * SQUISH_CONSTANT_2D;
-				dy_ext = dy0 + 0 - 2 * SQUISH_CONSTANT_2D;
-			} else {
-				xsv_ext = xsb + 0;
-				ysv_ext = ysb + 2;
-				dx_ext = dx0 + 0 - 2 * SQUISH_CONSTANT_2D;
-				dy_ext = dy0 - 2 - 2 * SQUISH_CONSTANT_2D;
-			}
-		} else { /* (1,0) and (0,1) are the closest two vertices. */
-			dx_ext = dx0;
-			dy_ext = dy0;
-			xsv_ext = xsb;
-			ysv_ext = ysb;
-		}
-		xsb += 1;
-		ysb += 1;
-		dx0 = dx0 - 1 - 2 * SQUISH_CONSTANT_2D;
-		dy0 = dy0 - 1 - 2 * SQUISH_CONSTANT_2D;
-	}
-		
-	/* Contribution (0,0) or (1,1) */
-	attn0 = 2 - dx0 * dx0 - dy0 * dy0;
-	if (attn0 > 0) {
-		attn0 *= attn0;
-		value += attn0 * attn0 * extrapolate2(ctx, xsb, ysb, dx0, dy0);
-	}
-	
-	/* Extra Vertex */
-	attn_ext = 2 - dx_ext * dx_ext - dy_ext * dy_ext;
-	if (attn_ext > 0) {
-		attn_ext *= attn_ext;
-		value += attn_ext * attn_ext * extrapolate2(ctx, xsv_ext, ysv_ext, dx_ext, dy_ext);
-	}
-	
-	return value / NORM_CONSTANT_2D;
-}
-	
-/*
- * 3D OpenSimplex (Simplectic) Noise
- */
-double open_simplex_noise3(const struct osn_context *ctx, double x, double y, double z)
-{
-
-	/* Place input coordinates on simplectic honeycomb. */
-	double stretchOffset = (x + y + z) * STRETCH_CONSTANT_3D;
-	double xs = x + stretchOffset;
-	double ys = y + stretchOffset;
-	double zs = z + stretchOffset;
-	
-	/* Floor to get simplectic honeycomb coordinates of rhombohedron (stretched cube) super-cell origin. */
-	int xsb = fastFloor(xs);
-	int ysb = fastFloor(ys);
-	int zsb = fastFloor(zs);
-	
-	/* Skew out to get actual coordinates of rhombohedron origin. We'll need these later. */
-	double squishOffset = (xsb + ysb + zsb) * SQUISH_CONSTANT_3D;
-	double xb = xsb + squishOffset;
-	double yb = ysb + squishOffset;
-	double zb = zsb + squishOffset;
-	
-	/* Compute simplectic honeycomb coordinates relative to rhombohedral origin. */
-	double xins = xs - xsb;
-	double yins = ys - ysb;
-	double zins = zs - zsb;
-	
-	/* Sum those together to get a value that determines which region we're in. */
-	double inSum = xins + yins + zins;
-
-	/* Positions relative to origin point. */
-	double dx0 = x - xb;
-	double dy0 = y - yb;
-	double dz0 = z - zb;
-	
-	/* We'll be defining these inside the next block and using them afterwards. */
-	double dx_ext0, dy_ext0, dz_ext0;
-	double dx_ext1, dy_ext1, dz_ext1;
-	int xsv_ext0, ysv_ext0, zsv_ext0;
-	int xsv_ext1, ysv_ext1, zsv_ext1;
-
-	double wins;
-	int8_t c, c1, c2;
-	int8_t aPoint, bPoint;
-	double aScore, bScore;
-	int aIsFurtherSide;
-	int bIsFurtherSide;
-	double p1, p2, p3;
-	double score;
-	double attn0, attn1, attn2, attn3, attn4, attn5, attn6;
-	double dx1, dy1, dz1;
-	double dx2, dy2, dz2;
-	double dx3, dy3, dz3;
-	double dx4, dy4, dz4;
-	double dx5, dy5, dz5;
-	double dx6, dy6, dz6;
-	double attn_ext0, attn_ext1;
-	
-	double value = 0;
-	if (inSum <= 1) { /* We're inside the tetrahedron (3-Simplex) at (0,0,0) */
-		
-		/* Determine which two of (0,0,1), (0,1,0), (1,0,0) are closest. */
-		aPoint = 0x01;
-		aScore = xins;
-		bPoint = 0x02;
-		bScore = yins;
-		if (aScore >= bScore && zins > bScore) {
-			bScore = zins;
-			bPoint = 0x04;
-		} else if (aScore < bScore && zins > aScore) {
-			aScore = zins;
-			aPoint = 0x04;
-		}
-		
-		/* Now we determine the two lattice points not part of the tetrahedron that may contribute.
-		   This depends on the closest two tetrahedral vertices, including (0,0,0) */
-		wins = 1 - inSum;
-		if (wins > aScore || wins > bScore) { /* (0,0,0) is one of the closest two tetrahedral vertices. */
-			c = (bScore > aScore ? bPoint : aPoint); /* Our other closest vertex is the closest out of a and b. */
-			
-			if ((c & 0x01) == 0) {
-				xsv_ext0 = xsb - 1;
-				xsv_ext1 = xsb;
-				dx_ext0 = dx0 + 1;
-				dx_ext1 = dx0;
-			} else {
-				xsv_ext0 = xsv_ext1 = xsb + 1;
-				dx_ext0 = dx_ext1 = dx0 - 1;
-			}
-
-			if ((c & 0x02) == 0) {
-				ysv_ext0 = ysv_ext1 = ysb;
-				dy_ext0 = dy_ext1 = dy0;
-				if ((c & 0x01) == 0) {
-					ysv_ext1 -= 1;
-					dy_ext1 += 1;
-				} else {
-					ysv_ext0 -= 1;
-					dy_ext0 += 1;
-				}
-			} else {
-				ysv_ext0 = ysv_ext1 = ysb + 1;
-				dy_ext0 = dy_ext1 = dy0 - 1;
-			}
-
-			if ((c & 0x04) == 0) {
-				zsv_ext0 = zsb;
-				zsv_ext1 = zsb - 1;
-				dz_ext0 = dz0;
-				dz_ext1 = dz0 + 1;
-			} else {
-				zsv_ext0 = zsv_ext1 = zsb + 1;
-				dz_ext0 = dz_ext1 = dz0 - 1;
-			}
-		} else { /* (0,0,0) is not one of the closest two tetrahedral vertices. */
-			c = (int8_t)(aPoint | bPoint); /* Our two extra vertices are determined by the closest two. */
-			
-			if ((c & 0x01) == 0) {
-				xsv_ext0 = xsb;
-				xsv_ext1 = xsb - 1;
-				dx_ext0 = dx0 - 2 * SQUISH_CONSTANT_3D;
-				dx_ext1 = dx0 + 1 - SQUISH_CONSTANT_3D;
-			} else {
-				xsv_ext0 = xsv_ext1 = xsb + 1;
-				dx_ext0 = dx0 - 1 - 2 * SQUISH_CONSTANT_3D;
-				dx_ext1 = dx0 - 1 - SQUISH_CONSTANT_3D;
-			}
-
-			if ((c & 0x02) == 0) {
-				ysv_ext0 = ysb;
-				ysv_ext1 = ysb - 1;
-				dy_ext0 = dy0 - 2 * SQUISH_CONSTANT_3D;
-				dy_ext1 = dy0 + 1 - SQUISH_CONSTANT_3D;
-			} else {
-				ysv_ext0 = ysv_ext1 = ysb + 1;
-				dy_ext0 = dy0 - 1 - 2 * SQUISH_CONSTANT_3D;
-				dy_ext1 = dy0 - 1 - SQUISH_CONSTANT_3D;
-			}
-
-			if ((c & 0x04) == 0) {
-				zsv_ext0 = zsb;
-				zsv_ext1 = zsb - 1;
-				dz_ext0 = dz0 - 2 * SQUISH_CONSTANT_3D;
-				dz_ext1 = dz0 + 1 - SQUISH_CONSTANT_3D;
-			} else {
-				zsv_ext0 = zsv_ext1 = zsb + 1;
-				dz_ext0 = dz0 - 1 - 2 * SQUISH_CONSTANT_3D;
-				dz_ext1 = dz0 - 1 - SQUISH_CONSTANT_3D;
-			}
-		}
-
-		/* Contribution (0,0,0) */
-		attn0 = 2 - dx0 * dx0 - dy0 * dy0 - dz0 * dz0;
-		if (attn0 > 0) {
-			attn0 *= attn0;
-			value += attn0 * attn0 * extrapolate3(ctx, xsb + 0, ysb + 0, zsb + 0, dx0, dy0, dz0);
-		}
-
-		/* Contribution (1,0,0) */
-		dx1 = dx0 - 1 - SQUISH_CONSTANT_3D;
-		dy1 = dy0 - 0 - SQUISH_CONSTANT_3D;
-		dz1 = dz0 - 0 - SQUISH_CONSTANT_3D;
-		attn1 = 2 - dx1 * dx1 - dy1 * dy1 - dz1 * dz1;
-		if (attn1 > 0) {
-			attn1 *= attn1;
-			value += attn1 * attn1 * extrapolate3(ctx, xsb + 1, ysb + 0, zsb + 0, dx1, dy1, dz1);
-		}
-
-		/* Contribution (0,1,0) */
-		dx2 = dx0 - 0 - SQUISH_CONSTANT_3D;
-		dy2 = dy0 - 1 - SQUISH_CONSTANT_3D;
-		dz2 = dz1;
-		attn2 = 2 - dx2 * dx2 - dy2 * dy2 - dz2 * dz2;
-		if (attn2 > 0) {
-			attn2 *= attn2;
-			value += attn2 * attn2 * extrapolate3(ctx, xsb + 0, ysb + 1, zsb + 0, dx2, dy2, dz2);
-		}
-
-		/* Contribution (0,0,1) */
-		dx3 = dx2;
-		dy3 = dy1;
-		dz3 = dz0 - 1 - SQUISH_CONSTANT_3D;
-		attn3 = 2 - dx3 * dx3 - dy3 * dy3 - dz3 * dz3;
-		if (attn3 > 0) {
-			attn3 *= attn3;
-			value += attn3 * attn3 * extrapolate3(ctx, xsb + 0, ysb + 0, zsb + 1, dx3, dy3, dz3);
-		}
-	} else if (inSum >= 2) { /* We're inside the tetrahedron (3-Simplex) at (1,1,1) */
-	
-		/* Determine which two tetrahedral vertices are the closest, out of (1,1,0), (1,0,1), (0,1,1) but not (1,1,1). */
-		aPoint = 0x06;
-		aScore = xins;
-		bPoint = 0x05;
-		bScore = yins;
-		if (aScore <= bScore && zins < bScore) {
-			bScore = zins;
-			bPoint = 0x03;
-		} else if (aScore > bScore && zins < aScore) {
-			aScore = zins;
-			aPoint = 0x03;
-		}
-		
-		/* Now we determine the two lattice points not part of the tetrahedron that may contribute.
-		   This depends on the closest two tetrahedral vertices, including (1,1,1) */
-		wins = 3 - inSum;
-		if (wins < aScore || wins < bScore) { /* (1,1,1) is one of the closest two tetrahedral vertices. */
-			c = (bScore < aScore ? bPoint : aPoint); /* Our other closest vertex is the closest out of a and b. */
-			
-			if ((c & 0x01) != 0) {
-				xsv_ext0 = xsb + 2;
-				xsv_ext1 = xsb + 1;
-				dx_ext0 = dx0 - 2 - 3 * SQUISH_CONSTANT_3D;
-				dx_ext1 = dx0 - 1 - 3 * SQUISH_CONSTANT_3D;
-			} else {
-				xsv_ext0 = xsv_ext1 = xsb;
-				dx_ext0 = dx_ext1 = dx0 - 3 * SQUISH_CONSTANT_3D;
-			}
-
-			if ((c & 0x02) != 0) {
-				ysv_ext0 = ysv_ext1 = ysb + 1;
-				dy_ext0 = dy_ext1 = dy0 - 1 - 3 * SQUISH_CONSTANT_3D;
-				if ((c & 0x01) != 0) {
-					ysv_ext1 += 1;
-					dy_ext1 -= 1;
-				} else {
-					ysv_ext0 += 1;
-					dy_ext0 -= 1;
-				}
-			} else {
-				ysv_ext0 = ysv_ext1 = ysb;
-				dy_ext0 = dy_ext1 = dy0 - 3 * SQUISH_CONSTANT_3D;
-			}
-
-			if ((c & 0x04) != 0) {
-				zsv_ext0 = zsb + 1;
-				zsv_ext1 = zsb + 2;
-				dz_ext0 = dz0 - 1 - 3 * SQUISH_CONSTANT_3D;
-				dz_ext1 = dz0 - 2 - 3 * SQUISH_CONSTANT_3D;
-			} else {
-				zsv_ext0 = zsv_ext1 = zsb;
-				dz_ext0 = dz_ext1 = dz0 - 3 * SQUISH_CONSTANT_3D;
-			}
-		} else { /* (1,1,1) is not one of the closest two tetrahedral vertices. */
-			c = (int8_t)(aPoint & bPoint); /* Our two extra vertices are determined by the closest two. */
-			
-			if ((c & 0x01) != 0) {
-				xsv_ext0 = xsb + 1;
-				xsv_ext1 = xsb + 2;
-				dx_ext0 = dx0 - 1 - SQUISH_CONSTANT_3D;
-				dx_ext1 = dx0 - 2 - 2 * SQUISH_CONSTANT_3D;
-			} else {
-				xsv_ext0 = xsv_ext1 = xsb;
-				dx_ext0 = dx0 - SQUISH_CONSTANT_3D;
-				dx_ext1 = dx0 - 2 * SQUISH_CONSTANT_3D;
-			}
-
-			if ((c & 0x02) != 0) {
-				ysv_ext0 = ysb + 1;
-				ysv_ext1 = ysb + 2;
-				dy_ext0 = dy0 - 1 - SQUISH_CONSTANT_3D;
-				dy_ext1 = dy0 - 2 - 2 * SQUISH_CONSTANT_3D;
-			} else {
-				ysv_ext0 = ysv_ext1 = ysb;
-				dy_ext0 = dy0 - SQUISH_CONSTANT_3D;
-				dy_ext1 = dy0 - 2 * SQUISH_CONSTANT_3D;
-			}
-
-			if ((c & 0x04) != 0) {
-				zsv_ext0 = zsb + 1;
-				zsv_ext1 = zsb + 2;
-				dz_ext0 = dz0 - 1 - SQUISH_CONSTANT_3D;
-				dz_ext1 = dz0 - 2 - 2 * SQUISH_CONSTANT_3D;
-			} else {
-				zsv_ext0 = zsv_ext1 = zsb;
-				dz_ext0 = dz0 - SQUISH_CONSTANT_3D;
-				dz_ext1 = dz0 - 2 * SQUISH_CONSTANT_3D;
-			}
-		}
-		
-		/* Contribution (1,1,0) */
-		dx3 = dx0 - 1 - 2 * SQUISH_CONSTANT_3D;
-		dy3 = dy0 - 1 - 2 * SQUISH_CONSTANT_3D;
-		dz3 = dz0 - 0 - 2 * SQUISH_CONSTANT_3D;
-		attn3 = 2 - dx3 * dx3 - dy3 * dy3 - dz3 * dz3;
-		if (attn3 > 0) {
-			attn3 *= attn3;
-			value += attn3 * attn3 * extrapolate3(ctx, xsb + 1, ysb + 1, zsb + 0, dx3, dy3, dz3);
-		}
-
-		/* Contribution (1,0,1) */
-		dx2 = dx3;
-		dy2 = dy0 - 0 - 2 * SQUISH_CONSTANT_3D;
-		dz2 = dz0 - 1 - 2 * SQUISH_CONSTANT_3D;
-		attn2 = 2 - dx2 * dx2 - dy2 * dy2 - dz2 * dz2;
-		if (attn2 > 0) {
-			attn2 *= attn2;
-			value += attn2 * attn2 * extrapolate3(ctx, xsb + 1, ysb + 0, zsb + 1, dx2, dy2, dz2);
-		}
-
-		/* Contribution (0,1,1) */
-		dx1 = dx0 - 0 - 2 * SQUISH_CONSTANT_3D;
-		dy1 = dy3;
-		dz1 = dz2;
-		attn1 = 2 - dx1 * dx1 - dy1 * dy1 - dz1 * dz1;
-		if (attn1 > 0) {
-			attn1 *= attn1;
-			value += attn1 * attn1 * extrapolate3(ctx, xsb + 0, ysb + 1, zsb + 1, dx1, dy1, dz1);
-		}
-
-		/* Contribution (1,1,1) */
-		dx0 = dx0 - 1 - 3 * SQUISH_CONSTANT_3D;
-		dy0 = dy0 - 1 - 3 * SQUISH_CONSTANT_3D;
-		dz0 = dz0 - 1 - 3 * SQUISH_CONSTANT_3D;
-		attn0 = 2 - dx0 * dx0 - dy0 * dy0 - dz0 * dz0;
-		if (attn0 > 0) {
-			attn0 *= attn0;
-			value += attn0 * attn0 * extrapolate3(ctx, xsb + 1, ysb + 1, zsb + 1, dx0, dy0, dz0);
-		}
-	} else { /* We're inside the octahedron (Rectified 3-Simplex) in between.
-		        Decide between point (0,0,1) and (1,1,0) as closest */
-		p1 = xins + yins;
-		if (p1 > 1) {
-			aScore = p1 - 1;
-			aPoint = 0x03;
-			aIsFurtherSide = 1;
-		} else {
-			aScore = 1 - p1;
-			aPoint = 0x04;
-			aIsFurtherSide = 0;
-		}
-
-		/* Decide between point (0,1,0) and (1,0,1) as closest */
-		p2 = xins + zins;
-		if (p2 > 1) {
-			bScore = p2 - 1;
-			bPoint = 0x05;
-			bIsFurtherSide = 1;
-		} else {
-			bScore = 1 - p2;
-			bPoint = 0x02;
-			bIsFurtherSide = 0;
-		}
-		
-		/* The closest out of the two (1,0,0) and (0,1,1) will replace the furthest out of the two decided above, if closer. */
-		p3 = yins + zins;
-		if (p3 > 1) {
-			score = p3 - 1;
-			if (aScore <= bScore && aScore < score) {
-				aScore = score;
-				aPoint = 0x06;
-				aIsFurtherSide = 1;
-			} else if (aScore > bScore && bScore < score) {
-				bScore = score;
-				bPoint = 0x06;
-				bIsFurtherSide = 1;
-			}
-		} else {
-			score = 1 - p3;
-			if (aScore <= bScore && aScore < score) {
-				aScore = score;
-				aPoint = 0x01;
-				aIsFurtherSide = 0;
-			} else if (aScore > bScore && bScore < score) {
-				bScore = score;
-				bPoint = 0x01;
-				bIsFurtherSide = 0;
-			}
-		}
-		
-		/* Where each of the two closest points are determines how the extra two vertices are calculated. */
-		if (aIsFurtherSide == bIsFurtherSide) {
-			if (aIsFurtherSide) { /* Both closest points on (1,1,1) side */
-
-				/* One of the two extra points is (1,1,1) */
-				dx_ext0 = dx0 - 1 - 3 * SQUISH_CONSTANT_3D;
-				dy_ext0 = dy0 - 1 - 3 * SQUISH_CONSTANT_3D;
-				dz_ext0 = dz0 - 1 - 3 * SQUISH_CONSTANT_3D;
-				xsv_ext0 = xsb + 1;
-				ysv_ext0 = ysb + 1;
-				zsv_ext0 = zsb + 1;
-
-				/* Other extra point is based on the shared axis. */
-				c = (int8_t)(aPoint & bPoint);
-				if ((c & 0x01) != 0) {
-					dx_ext1 = dx0 - 2 - 2 * SQUISH_CONSTANT_3D;
-					dy_ext1 = dy0 - 2 * SQUISH_CONSTANT_3D;
-					dz_ext1 = dz0 - 2 * SQUISH_CONSTANT_3D;
-					xsv_ext1 = xsb + 2;
-					ysv_ext1 = ysb;
-					zsv_ext1 = zsb;
-				} else if ((c & 0x02) != 0) {
-					dx_ext1 = dx0 - 2 * SQUISH_CONSTANT_3D;
-					dy_ext1 = dy0 - 2 - 2 * SQUISH_CONSTANT_3D;
-					dz_ext1 = dz0 - 2 * SQUISH_CONSTANT_3D;
-					xsv_ext1 = xsb;
-					ysv_ext1 = ysb + 2;
-					zsv_ext1 = zsb;
-				} else {
-					dx_ext1 = dx0 - 2 * SQUISH_CONSTANT_3D;
-					dy_ext1 = dy0 - 2 * SQUISH_CONSTANT_3D;
-					dz_ext1 = dz0 - 2 - 2 * SQUISH_CONSTANT_3D;
-					xsv_ext1 = xsb;
-					ysv_ext1 = ysb;
-					zsv_ext1 = zsb + 2;
-				}
-			} else { /* Both closest points on (0,0,0) side */
-
-				/* One of the two extra points is (0,0,0) */
-				dx_ext0 = dx0;
-				dy_ext0 = dy0;
-				dz_ext0 = dz0;
-				xsv_ext0 = xsb;
-				ysv_ext0 = ysb;
-				zsv_ext0 = zsb;
-
-				/* Other extra point is based on the omitted axis. */
-				c = (int8_t)(aPoint | bPoint);
-				if ((c & 0x01) == 0) {
-					dx_ext1 = dx0 + 1 - SQUISH_CONSTANT_3D;
-					dy_ext1 = dy0 - 1 - SQUISH_CONSTANT_3D;
-					dz_ext1 = dz0 - 1 - SQUISH_CONSTANT_3D;
-					xsv_ext1 = xsb - 1;
-					ysv_ext1 = ysb + 1;
-					zsv_ext1 = zsb + 1;
-				} else if ((c & 0x02) == 0) {
-					dx_ext1 = dx0 - 1 - SQUISH_CONSTANT_3D;
-					dy_ext1 = dy0 + 1 - SQUISH_CONSTANT_3D;
-					dz_ext1 = dz0 - 1 - SQUISH_CONSTANT_3D;
-					xsv_ext1 = xsb + 1;
-					ysv_ext1 = ysb - 1;
-					zsv_ext1 = zsb + 1;
-				} else {
-					dx_ext1 = dx0 - 1 - SQUISH_CONSTANT_3D;
-					dy_ext1 = dy0 - 1 - SQUISH_CONSTANT_3D;
-					dz_ext1 = dz0 + 1 - SQUISH_CONSTANT_3D;
-					xsv_ext1 = xsb + 1;
-					ysv_ext1 = ysb + 1;
-					zsv_ext1 = zsb - 1;
-				}
-			}
-		} else { /* One point on (0,0,0) side, one point on (1,1,1) side */
-			if (aIsFurtherSide) {
-				c1 = aPoint;
-				c2 = bPoint;
-			} else {
-				c1 = bPoint;
-				c2 = aPoint;
-			}
-
-			/* One contribution is a permutation of (1,1,-1) */
-			if ((c1 & 0x01) == 0) {
-				dx_ext0 = dx0 + 1 - SQUISH_CONSTANT_3D;
-				dy_ext0 = dy0 - 1 - SQUISH_CONSTANT_3D;
-				dz_ext0 = dz0 - 1 - SQUISH_CONSTANT_3D;
-				xsv_ext0 = xsb - 1;
-				ysv_ext0 = ysb + 1;
-				zsv_ext0 = zsb + 1;
-			} else if ((c1 & 0x02) == 0) {
-				dx_ext0 = dx0 - 1 - SQUISH_CONSTANT_3D;
-				dy_ext0 = dy0 + 1 - SQUISH_CONSTANT_3D;
-				dz_ext0 = dz0 - 1 - SQUISH_CONSTANT_3D;
-				xsv_ext0 = xsb + 1;
-				ysv_ext0 = ysb - 1;
-				zsv_ext0 = zsb + 1;
-			} else {
-				dx_ext0 = dx0 - 1 - SQUISH_CONSTANT_3D;
-				dy_ext0 = dy0 - 1 - SQUISH_CONSTANT_3D;
-				dz_ext0 = dz0 + 1 - SQUISH_CONSTANT_3D;
-				xsv_ext0 = xsb + 1;
-				ysv_ext0 = ysb + 1;
-				zsv_ext0 = zsb - 1;
-			}
-
-			/* One contribution is a permutation of (0,0,2) */
-			dx_ext1 = dx0 - 2 * SQUISH_CONSTANT_3D;
-			dy_ext1 = dy0 - 2 * SQUISH_CONSTANT_3D;
-			dz_ext1 = dz0 - 2 * SQUISH_CONSTANT_3D;
-			xsv_ext1 = xsb;
-			ysv_ext1 = ysb;
-			zsv_ext1 = zsb;
-			if ((c2 & 0x01) != 0) {
-				dx_ext1 -= 2;
-				xsv_ext1 += 2;
-			} else if ((c2 & 0x02) != 0) {
-				dy_ext1 -= 2;
-				ysv_ext1 += 2;
-			} else {
-				dz_ext1 -= 2;
-				zsv_ext1 += 2;
-			}
-		}
-
-		/* Contribution (1,0,0) */
-		dx1 = dx0 - 1 - SQUISH_CONSTANT_3D;
-		dy1 = dy0 - 0 - SQUISH_CONSTANT_3D;
-		dz1 = dz0 - 0 - SQUISH_CONSTANT_3D;
-		attn1 = 2 - dx1 * dx1 - dy1 * dy1 - dz1 * dz1;
-		if (attn1 > 0) {
-			attn1 *= attn1;
-			value += attn1 * attn1 * extrapolate3(ctx, xsb + 1, ysb + 0, zsb + 0, dx1, dy1, dz1);
-		}
-
-		/* Contribution (0,1,0) */
-		dx2 = dx0 - 0 - SQUISH_CONSTANT_3D;
-		dy2 = dy0 - 1 - SQUISH_CONSTANT_3D;
-		dz2 = dz1;
-		attn2 = 2 - dx2 * dx2 - dy2 * dy2 - dz2 * dz2;
-		if (attn2 > 0) {
-			attn2 *= attn2;
-			value += attn2 * attn2 * extrapolate3(ctx, xsb + 0, ysb + 1, zsb + 0, dx2, dy2, dz2);
-		}
-
-		/* Contribution (0,0,1) */
-		dx3 = dx2;
-		dy3 = dy1;
-		dz3 = dz0 - 1 - SQUISH_CONSTANT_3D;
-		attn3 = 2 - dx3 * dx3 - dy3 * dy3 - dz3 * dz3;
-		if (attn3 > 0) {
-			attn3 *= attn3;
-			value += attn3 * attn3 * extrapolate3(ctx, xsb + 0, ysb + 0, zsb + 1, dx3, dy3, dz3);
-		}
-
-		/* Contribution (1,1,0) */
-		dx4 = dx0 - 1 - 2 * SQUISH_CONSTANT_3D;
-		dy4 = dy0 - 1 - 2 * SQUISH_CONSTANT_3D;
-		dz4 = dz0 - 0 - 2 * SQUISH_CONSTANT_3D;
-		attn4 = 2 - dx4 * dx4 - dy4 * dy4 - dz4 * dz4;
-		if (attn4 > 0) {
-			attn4 *= attn4;
-			value += attn4 * attn4 * extrapolate3(ctx, xsb + 1, ysb + 1, zsb + 0, dx4, dy4, dz4);
-		}
-
-		/* Contribution (1,0,1) */
-		dx5 = dx4;
-		dy5 = dy0 - 0 - 2 * SQUISH_CONSTANT_3D;
-		dz5 = dz0 - 1 - 2 * SQUISH_CONSTANT_3D;
-		attn5 = 2 - dx5 * dx5 - dy5 * dy5 - dz5 * dz5;
-		if (attn5 > 0) {
-			attn5 *= attn5;
-			value += attn5 * attn5 * extrapolate3(ctx, xsb + 1, ysb + 0, zsb + 1, dx5, dy5, dz5);
-		}
-
-		/* Contribution (0,1,1) */
-		dx6 = dx0 - 0 - 2 * SQUISH_CONSTANT_3D;
-		dy6 = dy4;
-		dz6 = dz5;
-		attn6 = 2 - dx6 * dx6 - dy6 * dy6 - dz6 * dz6;
-		if (attn6 > 0) {
-			attn6 *= attn6;
-			value += attn6 * attn6 * extrapolate3(ctx, xsb + 0, ysb + 1, zsb + 1, dx6, dy6, dz6);
-		}
-	}
-
-	/* First extra vertex */
-	attn_ext0 = 2 - dx_ext0 * dx_ext0 - dy_ext0 * dy_ext0 - dz_ext0 * dz_ext0;
-	if (attn_ext0 > 0)
-	{
-		attn_ext0 *= attn_ext0;
-		value += attn_ext0 * attn_ext0 * extrapolate3(ctx, xsv_ext0, ysv_ext0, zsv_ext0, dx_ext0, dy_ext0, dz_ext0);
-	}
-
-	/* Second extra vertex */
-	attn_ext1 = 2 - dx_ext1 * dx_ext1 - dy_ext1 * dy_ext1 - dz_ext1 * dz_ext1;
-	if (attn_ext1 > 0)
-	{
-		attn_ext1 *= attn_ext1;
-		value += attn_ext1 * attn_ext1 * extrapolate3(ctx, xsv_ext1, ysv_ext1, zsv_ext1, dx_ext1, dy_ext1, dz_ext1);
-	}
-	
-	return value / NORM_CONSTANT_3D;
-}
-	
-/* 
- * 4D OpenSimplex (Simplectic) Noise.
- */
-double open_simplex_noise4(const struct osn_context *ctx, double x, double y, double z, double w)
-{
-	double uins;
-	double dx1, dy1, dz1, dw1;
-	double dx2, dy2, dz2, dw2;
-	double dx3, dy3, dz3, dw3;
-	double dx4, dy4, dz4, dw4;
-	double dx5, dy5, dz5, dw5;
-	double dx6, dy6, dz6, dw6;
-	double dx7, dy7, dz7, dw7;
-	double dx8, dy8, dz8, dw8;
-	double dx9, dy9, dz9, dw9;
-	double dx10, dy10, dz10, dw10;
-	double attn0, attn1, attn2, attn3, attn4;
-	double attn5, attn6, attn7, attn8, attn9, attn10;
-	double attn_ext0, attn_ext1, attn_ext2;
-	int8_t c, c1, c2;
-	int8_t aPoint, bPoint;
-	double aScore, bScore;
-	int aIsBiggerSide;
-	int bIsBiggerSide;
-	double p1, p2, p3, p4;
-	double score;
-
-	/* Place input coordinates on simplectic honeycomb. */
-	double stretchOffset = (x + y + z + w) * STRETCH_CONSTANT_4D;
-	double xs = x + stretchOffset;
-	double ys = y + stretchOffset;
-	double zs = z + stretchOffset;
-	double ws = w + stretchOffset;
-	
-	/* Floor to get simplectic honeycomb coordinates of rhombo-hypercube super-cell origin. */
-	int xsb = fastFloor(xs);
-	int ysb = fastFloor(ys);
-	int zsb = fastFloor(zs);
-	int wsb = fastFloor(ws);
-	
-	/* Skew out to get actual coordinates of stretched rhombo-hypercube origin. We'll need these later. */
-	double squishOffset = (xsb + ysb + zsb + wsb) * SQUISH_CONSTANT_4D;
-	double xb = xsb + squishOffset;
-	double yb = ysb + squishOffset;
-	double zb = zsb + squishOffset;
-	double wb = wsb + squishOffset;
-	
-	/* Compute simplectic honeycomb coordinates relative to rhombo-hypercube origin. */
-	double xins = xs - xsb;
-	double yins = ys - ysb;
-	double zins = zs - zsb;
-	double wins = ws - wsb;
-	
-	/* Sum those together to get a value that determines which region we're in. */
-	double inSum = xins + yins + zins + wins;
-
-	/* Positions relative to origin point. */
-	double dx0 = x - xb;
-	double dy0 = y - yb;
-	double dz0 = z - zb;
-	double dw0 = w - wb;
-	
-	/* We'll be defining these inside the next block and using them afterwards. */
-	double dx_ext0, dy_ext0, dz_ext0, dw_ext0;
-	double dx_ext1, dy_ext1, dz_ext1, dw_ext1;
-	double dx_ext2, dy_ext2, dz_ext2, dw_ext2;
-	int xsv_ext0, ysv_ext0, zsv_ext0, wsv_ext0;
-	int xsv_ext1, ysv_ext1, zsv_ext1, wsv_ext1;
-	int xsv_ext2, ysv_ext2, zsv_ext2, wsv_ext2;
-	
-	double value = 0;
-	if (inSum <= 1) { /* We're inside the pentachoron (4-Simplex) at (0,0,0,0) */
-
-		/* Determine which two of (0,0,0,1), (0,0,1,0), (0,1,0,0), (1,0,0,0) are closest. */
-		aPoint = 0x01;
-		aScore = xins;
-		bPoint = 0x02;
-		bScore = yins;
-		if (aScore >= bScore && zins > bScore) {
-			bScore = zins;
-			bPoint = 0x04;
-		} else if (aScore < bScore && zins > aScore) {
-			aScore = zins;
-			aPoint = 0x04;
-		}
-		if (aScore >= bScore && wins > bScore) {
-			bScore = wins;
-			bPoint = 0x08;
-		} else if (aScore < bScore && wins > aScore) {
-			aScore = wins;
-			aPoint = 0x08;
-		}
-		
-		/* Now we determine the three lattice points not part of the pentachoron that may contribute.
-		   This depends on the closest two pentachoron vertices, including (0,0,0,0) */
-		uins = 1 - inSum;
-		if (uins > aScore || uins > bScore) { /* (0,0,0,0) is one of the closest two pentachoron vertices. */
-			c = (bScore > aScore ? bPoint : aPoint); /* Our other closest vertex is the closest out of a and b. */
-			if ((c & 0x01) == 0) {
-				xsv_ext0 = xsb - 1;
-				xsv_ext1 = xsv_ext2 = xsb;
-				dx_ext0 = dx0 + 1;
-				dx_ext1 = dx_ext2 = dx0;
-			} else {
-				xsv_ext0 = xsv_ext1 = xsv_ext2 = xsb + 1;
-				dx_ext0 = dx_ext1 = dx_ext2 = dx0 - 1;
-			}
-
-			if ((c & 0x02) == 0) {
-				ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb;
-				dy_ext0 = dy_ext1 = dy_ext2 = dy0;
-				if ((c & 0x01) == 0x01) {
-					ysv_ext0 -= 1;
-					dy_ext0 += 1;
-				} else {
-					ysv_ext1 -= 1;
-					dy_ext1 += 1;
-				}
-			} else {
-				ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb + 1;
-				dy_ext0 = dy_ext1 = dy_ext2 = dy0 - 1;
-			}
-			
-			if ((c & 0x04) == 0) {
-				zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb;
-				dz_ext0 = dz_ext1 = dz_ext2 = dz0;
-				if ((c & 0x03) != 0) {
-					if ((c & 0x03) == 0x03) {
-						zsv_ext0 -= 1;
-						dz_ext0 += 1;
-					} else {
-						zsv_ext1 -= 1;
-						dz_ext1 += 1;
-					}
-				} else {
-					zsv_ext2 -= 1;
-					dz_ext2 += 1;
-				}
-			} else {
-				zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb + 1;
-				dz_ext0 = dz_ext1 = dz_ext2 = dz0 - 1;
-			}
-			
-			if ((c & 0x08) == 0) {
-				wsv_ext0 = wsv_ext1 = wsb;
-				wsv_ext2 = wsb - 1;
-				dw_ext0 = dw_ext1 = dw0;
-				dw_ext2 = dw0 + 1;
-			} else {
-				wsv_ext0 = wsv_ext1 = wsv_ext2 = wsb + 1;
-				dw_ext0 = dw_ext1 = dw_ext2 = dw0 - 1;
-			}
-		} else { /* (0,0,0,0) is not one of the closest two pentachoron vertices. */
-			c = (int8_t)(aPoint | bPoint); /* Our three extra vertices are determined by the closest two. */
-			
-			if ((c & 0x01) == 0) {
-				xsv_ext0 = xsv_ext2 = xsb;
-				xsv_ext1 = xsb - 1;
-				dx_ext0 = dx0 - 2 * SQUISH_CONSTANT_4D;
-				dx_ext1 = dx0 + 1 - SQUISH_CONSTANT_4D;
-				dx_ext2 = dx0 - SQUISH_CONSTANT_4D;
-			} else {
-				xsv_ext0 = xsv_ext1 = xsv_ext2 = xsb + 1;
-				dx_ext0 = dx0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				dx_ext1 = dx_ext2 = dx0 - 1 - SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c & 0x02) == 0) {
-				ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb;
-				dy_ext0 = dy0 - 2 * SQUISH_CONSTANT_4D;
-				dy_ext1 = dy_ext2 = dy0 - SQUISH_CONSTANT_4D;
-				if ((c & 0x01) == 0x01) {
-					ysv_ext1 -= 1;
-					dy_ext1 += 1;
-				} else {
-					ysv_ext2 -= 1;
-					dy_ext2 += 1;
-				}
-			} else {
-				ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb + 1;
-				dy_ext0 = dy0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				dy_ext1 = dy_ext2 = dy0 - 1 - SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c & 0x04) == 0) {
-				zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb;
-				dz_ext0 = dz0 - 2 * SQUISH_CONSTANT_4D;
-				dz_ext1 = dz_ext2 = dz0 - SQUISH_CONSTANT_4D;
-				if ((c & 0x03) == 0x03) {
-					zsv_ext1 -= 1;
-					dz_ext1 += 1;
-				} else {
-					zsv_ext2 -= 1;
-					dz_ext2 += 1;
-				}
-			} else {
-				zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb + 1;
-				dz_ext0 = dz0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				dz_ext1 = dz_ext2 = dz0 - 1 - SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c & 0x08) == 0) {
-				wsv_ext0 = wsv_ext1 = wsb;
-				wsv_ext2 = wsb - 1;
-				dw_ext0 = dw0 - 2 * SQUISH_CONSTANT_4D;
-				dw_ext1 = dw0 - SQUISH_CONSTANT_4D;
-				dw_ext2 = dw0 + 1 - SQUISH_CONSTANT_4D;
-			} else {
-				wsv_ext0 = wsv_ext1 = wsv_ext2 = wsb + 1;
-				dw_ext0 = dw0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				dw_ext1 = dw_ext2 = dw0 - 1 - SQUISH_CONSTANT_4D;
-			}
-		}
-
-		/* Contribution (0,0,0,0) */
-		attn0 = 2 - dx0 * dx0 - dy0 * dy0 - dz0 * dz0 - dw0 * dw0;
-		if (attn0 > 0) {
-			attn0 *= attn0;
-			value += attn0 * attn0 * extrapolate4(ctx, xsb + 0, ysb + 0, zsb + 0, wsb + 0, dx0, dy0, dz0, dw0);
-		}
-
-		/* Contribution (1,0,0,0) */
-		dx1 = dx0 - 1 - SQUISH_CONSTANT_4D;
-		dy1 = dy0 - 0 - SQUISH_CONSTANT_4D;
-		dz1 = dz0 - 0 - SQUISH_CONSTANT_4D;
-		dw1 = dw0 - 0 - SQUISH_CONSTANT_4D;
-		attn1 = 2 - dx1 * dx1 - dy1 * dy1 - dz1 * dz1 - dw1 * dw1;
-		if (attn1 > 0) {
-			attn1 *= attn1;
-			value += attn1 * attn1 * extrapolate4(ctx, xsb + 1, ysb + 0, zsb + 0, wsb + 0, dx1, dy1, dz1, dw1);
-		}
-
-		/* Contribution (0,1,0,0) */
-		dx2 = dx0 - 0 - SQUISH_CONSTANT_4D;
-		dy2 = dy0 - 1 - SQUISH_CONSTANT_4D;
-		dz2 = dz1;
-		dw2 = dw1;
-		attn2 = 2 - dx2 * dx2 - dy2 * dy2 - dz2 * dz2 - dw2 * dw2;
-		if (attn2 > 0) {
-			attn2 *= attn2;
-			value += attn2 * attn2 * extrapolate4(ctx, xsb + 0, ysb + 1, zsb + 0, wsb + 0, dx2, dy2, dz2, dw2);
-		}
-
-		/* Contribution (0,0,1,0) */
-		dx3 = dx2;
-		dy3 = dy1;
-		dz3 = dz0 - 1 - SQUISH_CONSTANT_4D;
-		dw3 = dw1;
-		attn3 = 2 - dx3 * dx3 - dy3 * dy3 - dz3 * dz3 - dw3 * dw3;
-		if (attn3 > 0) {
-			attn3 *= attn3;
-			value += attn3 * attn3 * extrapolate4(ctx, xsb + 0, ysb + 0, zsb + 1, wsb + 0, dx3, dy3, dz3, dw3);
-		}
-
-		/* Contribution (0,0,0,1) */
-		dx4 = dx2;
-		dy4 = dy1;
-		dz4 = dz1;
-		dw4 = dw0 - 1 - SQUISH_CONSTANT_4D;
-		attn4 = 2 - dx4 * dx4 - dy4 * dy4 - dz4 * dz4 - dw4 * dw4;
-		if (attn4 > 0) {
-			attn4 *= attn4;
-			value += attn4 * attn4 * extrapolate4(ctx, xsb + 0, ysb + 0, zsb + 0, wsb + 1, dx4, dy4, dz4, dw4);
-		}
-	} else if (inSum >= 3) { /* We're inside the pentachoron (4-Simplex) at (1,1,1,1)
-		Determine which two of (1,1,1,0), (1,1,0,1), (1,0,1,1), (0,1,1,1) are closest. */
-		aPoint = 0x0E;
-		aScore = xins;
-		bPoint = 0x0D;
-		bScore = yins;
-		if (aScore <= bScore && zins < bScore) {
-			bScore = zins;
-			bPoint = 0x0B;
-		} else if (aScore > bScore && zins < aScore) {
-			aScore = zins;
-			aPoint = 0x0B;
-		}
-		if (aScore <= bScore && wins < bScore) {
-			bScore = wins;
-			bPoint = 0x07;
-		} else if (aScore > bScore && wins < aScore) {
-			aScore = wins;
-			aPoint = 0x07;
-		}
-		
-		/* Now we determine the three lattice points not part of the pentachoron that may contribute.
-		   This depends on the closest two pentachoron vertices, including (0,0,0,0) */
-		uins = 4 - inSum;
-		if (uins < aScore || uins < bScore) { /* (1,1,1,1) is one of the closest two pentachoron vertices. */
-			c = (bScore < aScore ? bPoint : aPoint); /* Our other closest vertex is the closest out of a and b. */
-			
-			if ((c & 0x01) != 0) {
-				xsv_ext0 = xsb + 2;
-				xsv_ext1 = xsv_ext2 = xsb + 1;
-				dx_ext0 = dx0 - 2 - 4 * SQUISH_CONSTANT_4D;
-				dx_ext1 = dx_ext2 = dx0 - 1 - 4 * SQUISH_CONSTANT_4D;
-			} else {
-				xsv_ext0 = xsv_ext1 = xsv_ext2 = xsb;
-				dx_ext0 = dx_ext1 = dx_ext2 = dx0 - 4 * SQUISH_CONSTANT_4D;
-			}
-
-			if ((c & 0x02) != 0) {
-				ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb + 1;
-				dy_ext0 = dy_ext1 = dy_ext2 = dy0 - 1 - 4 * SQUISH_CONSTANT_4D;
-				if ((c & 0x01) != 0) {
-					ysv_ext1 += 1;
-					dy_ext1 -= 1;
-				} else {
-					ysv_ext0 += 1;
-					dy_ext0 -= 1;
-				}
-			} else {
-				ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb;
-				dy_ext0 = dy_ext1 = dy_ext2 = dy0 - 4 * SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c & 0x04) != 0) {
-				zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb + 1;
-				dz_ext0 = dz_ext1 = dz_ext2 = dz0 - 1 - 4 * SQUISH_CONSTANT_4D;
-				if ((c & 0x03) != 0x03) {
-					if ((c & 0x03) == 0) {
-						zsv_ext0 += 1;
-						dz_ext0 -= 1;
-					} else {
-						zsv_ext1 += 1;
-						dz_ext1 -= 1;
-					}
-				} else {
-					zsv_ext2 += 1;
-					dz_ext2 -= 1;
-				}
-			} else {
-				zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb;
-				dz_ext0 = dz_ext1 = dz_ext2 = dz0 - 4 * SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c & 0x08) != 0) {
-				wsv_ext0 = wsv_ext1 = wsb + 1;
-				wsv_ext2 = wsb + 2;
-				dw_ext0 = dw_ext1 = dw0 - 1 - 4 * SQUISH_CONSTANT_4D;
-				dw_ext2 = dw0 - 2 - 4 * SQUISH_CONSTANT_4D;
-			} else {
-				wsv_ext0 = wsv_ext1 = wsv_ext2 = wsb;
-				dw_ext0 = dw_ext1 = dw_ext2 = dw0 - 4 * SQUISH_CONSTANT_4D;
-			}
-		} else { /* (1,1,1,1) is not one of the closest two pentachoron vertices. */
-			c = (int8_t)(aPoint & bPoint); /* Our three extra vertices are determined by the closest two. */
-			
-			if ((c & 0x01) != 0) {
-				xsv_ext0 = xsv_ext2 = xsb + 1;
-				xsv_ext1 = xsb + 2;
-				dx_ext0 = dx0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				dx_ext1 = dx0 - 2 - 3 * SQUISH_CONSTANT_4D;
-				dx_ext2 = dx0 - 1 - 3 * SQUISH_CONSTANT_4D;
-			} else {
-				xsv_ext0 = xsv_ext1 = xsv_ext2 = xsb;
-				dx_ext0 = dx0 - 2 * SQUISH_CONSTANT_4D;
-				dx_ext1 = dx_ext2 = dx0 - 3 * SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c & 0x02) != 0) {
-				ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb + 1;
-				dy_ext0 = dy0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				dy_ext1 = dy_ext2 = dy0 - 1 - 3 * SQUISH_CONSTANT_4D;
-				if ((c & 0x01) != 0) {
-					ysv_ext2 += 1;
-					dy_ext2 -= 1;
-				} else {
-					ysv_ext1 += 1;
-					dy_ext1 -= 1;
-				}
-			} else {
-				ysv_ext0 = ysv_ext1 = ysv_ext2 = ysb;
-				dy_ext0 = dy0 - 2 * SQUISH_CONSTANT_4D;
-				dy_ext1 = dy_ext2 = dy0 - 3 * SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c & 0x04) != 0) {
-				zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb + 1;
-				dz_ext0 = dz0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				dz_ext1 = dz_ext2 = dz0 - 1 - 3 * SQUISH_CONSTANT_4D;
-				if ((c & 0x03) != 0) {
-					zsv_ext2 += 1;
-					dz_ext2 -= 1;
-				} else {
-					zsv_ext1 += 1;
-					dz_ext1 -= 1;
-				}
-			} else {
-				zsv_ext0 = zsv_ext1 = zsv_ext2 = zsb;
-				dz_ext0 = dz0 - 2 * SQUISH_CONSTANT_4D;
-				dz_ext1 = dz_ext2 = dz0 - 3 * SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c & 0x08) != 0) {
-				wsv_ext0 = wsv_ext1 = wsb + 1;
-				wsv_ext2 = wsb + 2;
-				dw_ext0 = dw0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				dw_ext1 = dw0 - 1 - 3 * SQUISH_CONSTANT_4D;
-				dw_ext2 = dw0 - 2 - 3 * SQUISH_CONSTANT_4D;
-			} else {
-				wsv_ext0 = wsv_ext1 = wsv_ext2 = wsb;
-				dw_ext0 = dw0 - 2 * SQUISH_CONSTANT_4D;
-				dw_ext1 = dw_ext2 = dw0 - 3 * SQUISH_CONSTANT_4D;
-			}
-		}
-
-		/* Contribution (1,1,1,0) */
-		dx4 = dx0 - 1 - 3 * SQUISH_CONSTANT_4D;
-		dy4 = dy0 - 1 - 3 * SQUISH_CONSTANT_4D;
-		dz4 = dz0 - 1 - 3 * SQUISH_CONSTANT_4D;
-		dw4 = dw0 - 3 * SQUISH_CONSTANT_4D;
-		attn4 = 2 - dx4 * dx4 - dy4 * dy4 - dz4 * dz4 - dw4 * dw4;
-		if (attn4 > 0) {
-			attn4 *= attn4;
-			value += attn4 * attn4 * extrapolate4(ctx, xsb + 1, ysb + 1, zsb + 1, wsb + 0, dx4, dy4, dz4, dw4);
-		}
-
-		/* Contribution (1,1,0,1) */
-		dx3 = dx4;
-		dy3 = dy4;
-		dz3 = dz0 - 3 * SQUISH_CONSTANT_4D;
-		dw3 = dw0 - 1 - 3 * SQUISH_CONSTANT_4D;
-		attn3 = 2 - dx3 * dx3 - dy3 * dy3 - dz3 * dz3 - dw3 * dw3;
-		if (attn3 > 0) {
-			attn3 *= attn3;
-			value += attn3 * attn3 * extrapolate4(ctx, xsb + 1, ysb + 1, zsb + 0, wsb + 1, dx3, dy3, dz3, dw3);
-		}
-
-		/* Contribution (1,0,1,1) */
-		dx2 = dx4;
-		dy2 = dy0 - 3 * SQUISH_CONSTANT_4D;
-		dz2 = dz4;
-		dw2 = dw3;
-		attn2 = 2 - dx2 * dx2 - dy2 * dy2 - dz2 * dz2 - dw2 * dw2;
-		if (attn2 > 0) {
-			attn2 *= attn2;
-			value += attn2 * attn2 * extrapolate4(ctx, xsb + 1, ysb + 0, zsb + 1, wsb + 1, dx2, dy2, dz2, dw2);
-		}
-
-		/* Contribution (0,1,1,1) */
-		dx1 = dx0 - 3 * SQUISH_CONSTANT_4D;
-		dz1 = dz4;
-		dy1 = dy4;
-		dw1 = dw3;
-		attn1 = 2 - dx1 * dx1 - dy1 * dy1 - dz1 * dz1 - dw1 * dw1;
-		if (attn1 > 0) {
-			attn1 *= attn1;
-			value += attn1 * attn1 * extrapolate4(ctx, xsb + 0, ysb + 1, zsb + 1, wsb + 1, dx1, dy1, dz1, dw1);
-		}
-
-		/* Contribution (1,1,1,1) */
-		dx0 = dx0 - 1 - 4 * SQUISH_CONSTANT_4D;
-		dy0 = dy0 - 1 - 4 * SQUISH_CONSTANT_4D;
-		dz0 = dz0 - 1 - 4 * SQUISH_CONSTANT_4D;
-		dw0 = dw0 - 1 - 4 * SQUISH_CONSTANT_4D;
-		attn0 = 2 - dx0 * dx0 - dy0 * dy0 - dz0 * dz0 - dw0 * dw0;
-		if (attn0 > 0) {
-			attn0 *= attn0;
-			value += attn0 * attn0 * extrapolate4(ctx, xsb + 1, ysb + 1, zsb + 1, wsb + 1, dx0, dy0, dz0, dw0);
-		}
-	} else if (inSum <= 2) { /* We're inside the first dispentachoron (Rectified 4-Simplex) */
-		aIsBiggerSide = 1;
-		bIsBiggerSide = 1;
-		
-		/* Decide between (1,1,0,0) and (0,0,1,1) */
-		if (xins + yins > zins + wins) {
-			aScore = xins + yins;
-			aPoint = 0x03;
-		} else {
-			aScore = zins + wins;
-			aPoint = 0x0C;
-		}
-		
-		/* Decide between (1,0,1,0) and (0,1,0,1) */
-		if (xins + zins > yins + wins) {
-			bScore = xins + zins;
-			bPoint = 0x05;
-		} else {
-			bScore = yins + wins;
-			bPoint = 0x0A;
-		}
-		
-		/* Closer between (1,0,0,1) and (0,1,1,0) will replace the further of a and b, if closer. */
-		if (xins + wins > yins + zins) {
-			score = xins + wins;
-			if (aScore >= bScore && score > bScore) {
-				bScore = score;
-				bPoint = 0x09;
-			} else if (aScore < bScore && score > aScore) {
-				aScore = score;
-				aPoint = 0x09;
-			}
-		} else {
-			score = yins + zins;
-			if (aScore >= bScore && score > bScore) {
-				bScore = score;
-				bPoint = 0x06;
-			} else if (aScore < bScore && score > aScore) {
-				aScore = score;
-				aPoint = 0x06;
-			}
-		}
-		
-		/* Decide if (1,0,0,0) is closer. */
-		p1 = 2 - inSum + xins;
-		if (aScore >= bScore && p1 > bScore) {
-			bScore = p1;
-			bPoint = 0x01;
-			bIsBiggerSide = 0;
-		} else if (aScore < bScore && p1 > aScore) {
-			aScore = p1;
-			aPoint = 0x01;
-			aIsBiggerSide = 0;
-		}
-		
-		/* Decide if (0,1,0,0) is closer. */
-		p2 = 2 - inSum + yins;
-		if (aScore >= bScore && p2 > bScore) {
-			bScore = p2;
-			bPoint = 0x02;
-			bIsBiggerSide = 0;
-		} else if (aScore < bScore && p2 > aScore) {
-			aScore = p2;
-			aPoint = 0x02;
-			aIsBiggerSide = 0;
-		}
-		
-		/* Decide if (0,0,1,0) is closer. */
-		p3 = 2 - inSum + zins;
-		if (aScore >= bScore && p3 > bScore) {
-			bScore = p3;
-			bPoint = 0x04;
-			bIsBiggerSide = 0;
-		} else if (aScore < bScore && p3 > aScore) {
-			aScore = p3;
-			aPoint = 0x04;
-			aIsBiggerSide = 0;
-		}
-		
-		/* Decide if (0,0,0,1) is closer. */
-		p4 = 2 - inSum + wins;
-		if (aScore >= bScore && p4 > bScore) {
-			bScore = p4;
-			bPoint = 0x08;
-			bIsBiggerSide = 0;
-		} else if (aScore < bScore && p4 > aScore) {
-			aScore = p4;
-			aPoint = 0x08;
-			aIsBiggerSide = 0;
-		}
-		
-		/* Where each of the two closest points are determines how the extra three vertices are calculated. */
-		if (aIsBiggerSide == bIsBiggerSide) {
-			if (aIsBiggerSide) { /* Both closest points on the bigger side */
-				c1 = (int8_t)(aPoint | bPoint);
-				c2 = (int8_t)(aPoint & bPoint);
-				if ((c1 & 0x01) == 0) {
-					xsv_ext0 = xsb;
-					xsv_ext1 = xsb - 1;
-					dx_ext0 = dx0 - 3 * SQUISH_CONSTANT_4D;
-					dx_ext1 = dx0 + 1 - 2 * SQUISH_CONSTANT_4D;
-				} else {
-					xsv_ext0 = xsv_ext1 = xsb + 1;
-					dx_ext0 = dx0 - 1 - 3 * SQUISH_CONSTANT_4D;
-					dx_ext1 = dx0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				}
-				
-				if ((c1 & 0x02) == 0) {
-					ysv_ext0 = ysb;
-					ysv_ext1 = ysb - 1;
-					dy_ext0 = dy0 - 3 * SQUISH_CONSTANT_4D;
-					dy_ext1 = dy0 + 1 - 2 * SQUISH_CONSTANT_4D;
-				} else {
-					ysv_ext0 = ysv_ext1 = ysb + 1;
-					dy_ext0 = dy0 - 1 - 3 * SQUISH_CONSTANT_4D;
-					dy_ext1 = dy0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				}
-				
-				if ((c1 & 0x04) == 0) {
-					zsv_ext0 = zsb;
-					zsv_ext1 = zsb - 1;
-					dz_ext0 = dz0 - 3 * SQUISH_CONSTANT_4D;
-					dz_ext1 = dz0 + 1 - 2 * SQUISH_CONSTANT_4D;
-				} else {
-					zsv_ext0 = zsv_ext1 = zsb + 1;
-					dz_ext0 = dz0 - 1 - 3 * SQUISH_CONSTANT_4D;
-					dz_ext1 = dz0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				}
-				
-				if ((c1 & 0x08) == 0) {
-					wsv_ext0 = wsb;
-					wsv_ext1 = wsb - 1;
-					dw_ext0 = dw0 - 3 * SQUISH_CONSTANT_4D;
-					dw_ext1 = dw0 + 1 - 2 * SQUISH_CONSTANT_4D;
-				} else {
-					wsv_ext0 = wsv_ext1 = wsb + 1;
-					dw_ext0 = dw0 - 1 - 3 * SQUISH_CONSTANT_4D;
-					dw_ext1 = dw0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				}
-				
-				/* One combination is a permutation of (0,0,0,2) based on c2 */
-				xsv_ext2 = xsb;
-				ysv_ext2 = ysb;
-				zsv_ext2 = zsb;
-				wsv_ext2 = wsb;
-				dx_ext2 = dx0 - 2 * SQUISH_CONSTANT_4D;
-				dy_ext2 = dy0 - 2 * SQUISH_CONSTANT_4D;
-				dz_ext2 = dz0 - 2 * SQUISH_CONSTANT_4D;
-				dw_ext2 = dw0 - 2 * SQUISH_CONSTANT_4D;
-				if ((c2 & 0x01) != 0) {
-					xsv_ext2 += 2;
-					dx_ext2 -= 2;
-				} else if ((c2 & 0x02) != 0) {
-					ysv_ext2 += 2;
-					dy_ext2 -= 2;
-				} else if ((c2 & 0x04) != 0) {
-					zsv_ext2 += 2;
-					dz_ext2 -= 2;
-				} else {
-					wsv_ext2 += 2;
-					dw_ext2 -= 2;
-				}
-				
-			} else { /* Both closest points on the smaller side */
-				/* One of the two extra points is (0,0,0,0) */
-				xsv_ext2 = xsb;
-				ysv_ext2 = ysb;
-				zsv_ext2 = zsb;
-				wsv_ext2 = wsb;
-				dx_ext2 = dx0;
-				dy_ext2 = dy0;
-				dz_ext2 = dz0;
-				dw_ext2 = dw0;
-				
-				/* Other two points are based on the omitted axes. */
-				c = (int8_t)(aPoint | bPoint);
-				
-				if ((c & 0x01) == 0) {
-					xsv_ext0 = xsb - 1;
-					xsv_ext1 = xsb;
-					dx_ext0 = dx0 + 1 - SQUISH_CONSTANT_4D;
-					dx_ext1 = dx0 - SQUISH_CONSTANT_4D;
-				} else {
-					xsv_ext0 = xsv_ext1 = xsb + 1;
-					dx_ext0 = dx_ext1 = dx0 - 1 - SQUISH_CONSTANT_4D;
-				}
-				
-				if ((c & 0x02) == 0) {
-					ysv_ext0 = ysv_ext1 = ysb;
-					dy_ext0 = dy_ext1 = dy0 - SQUISH_CONSTANT_4D;
-					if ((c & 0x01) == 0x01)
-					{
-						ysv_ext0 -= 1;
-						dy_ext0 += 1;
-					} else {
-						ysv_ext1 -= 1;
-						dy_ext1 += 1;
-					}
-				} else {
-					ysv_ext0 = ysv_ext1 = ysb + 1;
-					dy_ext0 = dy_ext1 = dy0 - 1 - SQUISH_CONSTANT_4D;
-				}
-				
-				if ((c & 0x04) == 0) {
-					zsv_ext0 = zsv_ext1 = zsb;
-					dz_ext0 = dz_ext1 = dz0 - SQUISH_CONSTANT_4D;
-					if ((c & 0x03) == 0x03)
-					{
-						zsv_ext0 -= 1;
-						dz_ext0 += 1;
-					} else {
-						zsv_ext1 -= 1;
-						dz_ext1 += 1;
-					}
-				} else {
-					zsv_ext0 = zsv_ext1 = zsb + 1;
-					dz_ext0 = dz_ext1 = dz0 - 1 - SQUISH_CONSTANT_4D;
-				}
-				
-				if ((c & 0x08) == 0)
-				{
-					wsv_ext0 = wsb;
-					wsv_ext1 = wsb - 1;
-					dw_ext0 = dw0 - SQUISH_CONSTANT_4D;
-					dw_ext1 = dw0 + 1 - SQUISH_CONSTANT_4D;
-				} else {
-					wsv_ext0 = wsv_ext1 = wsb + 1;
-					dw_ext0 = dw_ext1 = dw0 - 1 - SQUISH_CONSTANT_4D;
-				}
-				
-			}
-		} else { /* One point on each "side" */
-			if (aIsBiggerSide) {
-				c1 = aPoint;
-				c2 = bPoint;
-			} else {
-				c1 = bPoint;
-				c2 = aPoint;
-			}
-			
-			/* Two contributions are the bigger-sided point with each 0 replaced with -1. */
-			if ((c1 & 0x01) == 0) {
-				xsv_ext0 = xsb - 1;
-				xsv_ext1 = xsb;
-				dx_ext0 = dx0 + 1 - SQUISH_CONSTANT_4D;
-				dx_ext1 = dx0 - SQUISH_CONSTANT_4D;
-			} else {
-				xsv_ext0 = xsv_ext1 = xsb + 1;
-				dx_ext0 = dx_ext1 = dx0 - 1 - SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c1 & 0x02) == 0) {
-				ysv_ext0 = ysv_ext1 = ysb;
-				dy_ext0 = dy_ext1 = dy0 - SQUISH_CONSTANT_4D;
-				if ((c1 & 0x01) == 0x01) {
-					ysv_ext0 -= 1;
-					dy_ext0 += 1;
-				} else {
-					ysv_ext1 -= 1;
-					dy_ext1 += 1;
-				}
-			} else {
-				ysv_ext0 = ysv_ext1 = ysb + 1;
-				dy_ext0 = dy_ext1 = dy0 - 1 - SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c1 & 0x04) == 0) {
-				zsv_ext0 = zsv_ext1 = zsb;
-				dz_ext0 = dz_ext1 = dz0 - SQUISH_CONSTANT_4D;
-				if ((c1 & 0x03) == 0x03) {
-					zsv_ext0 -= 1;
-					dz_ext0 += 1;
-				} else {
-					zsv_ext1 -= 1;
-					dz_ext1 += 1;
-				}
-			} else {
-				zsv_ext0 = zsv_ext1 = zsb + 1;
-				dz_ext0 = dz_ext1 = dz0 - 1 - SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c1 & 0x08) == 0) {
-				wsv_ext0 = wsb;
-				wsv_ext1 = wsb - 1;
-				dw_ext0 = dw0 - SQUISH_CONSTANT_4D;
-				dw_ext1 = dw0 + 1 - SQUISH_CONSTANT_4D;
-			} else {
-				wsv_ext0 = wsv_ext1 = wsb + 1;
-				dw_ext0 = dw_ext1 = dw0 - 1 - SQUISH_CONSTANT_4D;
-			}
-
-			/* One contribution is a permutation of (0,0,0,2) based on the smaller-sided point */
-			xsv_ext2 = xsb;
-			ysv_ext2 = ysb;
-			zsv_ext2 = zsb;
-			wsv_ext2 = wsb;
-			dx_ext2 = dx0 - 2 * SQUISH_CONSTANT_4D;
-			dy_ext2 = dy0 - 2 * SQUISH_CONSTANT_4D;
-			dz_ext2 = dz0 - 2 * SQUISH_CONSTANT_4D;
-			dw_ext2 = dw0 - 2 * SQUISH_CONSTANT_4D;
-			if ((c2 & 0x01) != 0) {
-				xsv_ext2 += 2;
-				dx_ext2 -= 2;
-			} else if ((c2 & 0x02) != 0) {
-				ysv_ext2 += 2;
-				dy_ext2 -= 2;
-			} else if ((c2 & 0x04) != 0) {
-				zsv_ext2 += 2;
-				dz_ext2 -= 2;
-			} else {
-				wsv_ext2 += 2;
-				dw_ext2 -= 2;
-			}
-		}
-		
-		/* Contribution (1,0,0,0) */
-		dx1 = dx0 - 1 - SQUISH_CONSTANT_4D;
-		dy1 = dy0 - 0 - SQUISH_CONSTANT_4D;
-		dz1 = dz0 - 0 - SQUISH_CONSTANT_4D;
-		dw1 = dw0 - 0 - SQUISH_CONSTANT_4D;
-		attn1 = 2 - dx1 * dx1 - dy1 * dy1 - dz1 * dz1 - dw1 * dw1;
-		if (attn1 > 0) {
-			attn1 *= attn1;
-			value += attn1 * attn1 * extrapolate4(ctx, xsb + 1, ysb + 0, zsb + 0, wsb + 0, dx1, dy1, dz1, dw1);
-		}
-
-		/* Contribution (0,1,0,0) */
-		dx2 = dx0 - 0 - SQUISH_CONSTANT_4D;
-		dy2 = dy0 - 1 - SQUISH_CONSTANT_4D;
-		dz2 = dz1;
-		dw2 = dw1;
-		attn2 = 2 - dx2 * dx2 - dy2 * dy2 - dz2 * dz2 - dw2 * dw2;
-		if (attn2 > 0) {
-			attn2 *= attn2;
-			value += attn2 * attn2 * extrapolate4(ctx, xsb + 0, ysb + 1, zsb + 0, wsb + 0, dx2, dy2, dz2, dw2);
-		}
-
-		/* Contribution (0,0,1,0) */
-		dx3 = dx2;
-		dy3 = dy1;
-		dz3 = dz0 - 1 - SQUISH_CONSTANT_4D;
-		dw3 = dw1;
-		attn3 = 2 - dx3 * dx3 - dy3 * dy3 - dz3 * dz3 - dw3 * dw3;
-		if (attn3 > 0) {
-			attn3 *= attn3;
-			value += attn3 * attn3 * extrapolate4(ctx, xsb + 0, ysb + 0, zsb + 1, wsb + 0, dx3, dy3, dz3, dw3);
-		}
-
-		/* Contribution (0,0,0,1) */
-		dx4 = dx2;
-		dy4 = dy1;
-		dz4 = dz1;
-		dw4 = dw0 - 1 - SQUISH_CONSTANT_4D;
-		attn4 = 2 - dx4 * dx4 - dy4 * dy4 - dz4 * dz4 - dw4 * dw4;
-		if (attn4 > 0) {
-			attn4 *= attn4;
-			value += attn4 * attn4 * extrapolate4(ctx, xsb + 0, ysb + 0, zsb + 0, wsb + 1, dx4, dy4, dz4, dw4);
-		}
-		
-		/* Contribution (1,1,0,0) */
-		dx5 = dx0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dy5 = dy0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dz5 = dz0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dw5 = dw0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		attn5 = 2 - dx5 * dx5 - dy5 * dy5 - dz5 * dz5 - dw5 * dw5;
-		if (attn5 > 0) {
-			attn5 *= attn5;
-			value += attn5 * attn5 * extrapolate4(ctx, xsb + 1, ysb + 1, zsb + 0, wsb + 0, dx5, dy5, dz5, dw5);
-		}
-		
-		/* Contribution (1,0,1,0) */
-		dx6 = dx0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dy6 = dy0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dz6 = dz0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dw6 = dw0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		attn6 = 2 - dx6 * dx6 - dy6 * dy6 - dz6 * dz6 - dw6 * dw6;
-		if (attn6 > 0) {
-			attn6 *= attn6;
-			value += attn6 * attn6 * extrapolate4(ctx, xsb + 1, ysb + 0, zsb + 1, wsb + 0, dx6, dy6, dz6, dw6);
-		}
-
-		/* Contribution (1,0,0,1) */
-		dx7 = dx0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dy7 = dy0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dz7 = dz0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dw7 = dw0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		attn7 = 2 - dx7 * dx7 - dy7 * dy7 - dz7 * dz7 - dw7 * dw7;
-		if (attn7 > 0) {
-			attn7 *= attn7;
-			value += attn7 * attn7 * extrapolate4(ctx, xsb + 1, ysb + 0, zsb + 0, wsb + 1, dx7, dy7, dz7, dw7);
-		}
-		
-		/* Contribution (0,1,1,0) */
-		dx8 = dx0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dy8 = dy0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dz8 = dz0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dw8 = dw0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		attn8 = 2 - dx8 * dx8 - dy8 * dy8 - dz8 * dz8 - dw8 * dw8;
-		if (attn8 > 0) {
-			attn8 *= attn8;
-			value += attn8 * attn8 * extrapolate4(ctx, xsb + 0, ysb + 1, zsb + 1, wsb + 0, dx8, dy8, dz8, dw8);
-		}
-		
-		/* Contribution (0,1,0,1) */
-		dx9 = dx0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dy9 = dy0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dz9 = dz0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dw9 = dw0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		attn9 = 2 - dx9 * dx9 - dy9 * dy9 - dz9 * dz9 - dw9 * dw9;
-		if (attn9 > 0) {
-			attn9 *= attn9;
-			value += attn9 * attn9 * extrapolate4(ctx, xsb + 0, ysb + 1, zsb + 0, wsb + 1, dx9, dy9, dz9, dw9);
-		}
-		
-		/* Contribution (0,0,1,1) */
-		dx10 = dx0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dy10 = dy0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dz10 = dz0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dw10 = dw0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		attn10 = 2 - dx10 * dx10 - dy10 * dy10 - dz10 * dz10 - dw10 * dw10;
-		if (attn10 > 0) {
-			attn10 *= attn10;
-			value += attn10 * attn10 * extrapolate4(ctx, xsb + 0, ysb + 0, zsb + 1, wsb + 1, dx10, dy10, dz10, dw10);
-		}
-	} else { /* We're inside the second dispentachoron (Rectified 4-Simplex) */
-		aIsBiggerSide = 1;
-		bIsBiggerSide = 1;
-		
-		/* Decide between (0,0,1,1) and (1,1,0,0) */
-		if (xins + yins < zins + wins) {
-			aScore = xins + yins;
-			aPoint = 0x0C;
-		} else {
-			aScore = zins + wins;
-			aPoint = 0x03;
-		}
-		
-		/* Decide between (0,1,0,1) and (1,0,1,0) */
-		if (xins + zins < yins + wins) {
-			bScore = xins + zins;
-			bPoint = 0x0A;
-		} else {
-			bScore = yins + wins;
-			bPoint = 0x05;
-		}
-		
-		/* Closer between (0,1,1,0) and (1,0,0,1) will replace the further of a and b, if closer. */
-		if (xins + wins < yins + zins) {
-			score = xins + wins;
-			if (aScore <= bScore && score < bScore) {
-				bScore = score;
-				bPoint = 0x06;
-			} else if (aScore > bScore && score < aScore) {
-				aScore = score;
-				aPoint = 0x06;
-			}
-		} else {
-			score = yins + zins;
-			if (aScore <= bScore && score < bScore) {
-				bScore = score;
-				bPoint = 0x09;
-			} else if (aScore > bScore && score < aScore) {
-				aScore = score;
-				aPoint = 0x09;
-			}
-		}
-		
-		/* Decide if (0,1,1,1) is closer. */
-		p1 = 3 - inSum + xins;
-		if (aScore <= bScore && p1 < bScore) {
-			bScore = p1;
-			bPoint = 0x0E;
-			bIsBiggerSide = 0;
-		} else if (aScore > bScore && p1 < aScore) {
-			aScore = p1;
-			aPoint = 0x0E;
-			aIsBiggerSide = 0;
-		}
-		
-		/* Decide if (1,0,1,1) is closer. */
-		p2 = 3 - inSum + yins;
-		if (aScore <= bScore && p2 < bScore) {
-			bScore = p2;
-			bPoint = 0x0D;
-			bIsBiggerSide = 0;
-		} else if (aScore > bScore && p2 < aScore) {
-			aScore = p2;
-			aPoint = 0x0D;
-			aIsBiggerSide = 0;
-		}
-		
-		/* Decide if (1,1,0,1) is closer. */
-		p3 = 3 - inSum + zins;
-		if (aScore <= bScore && p3 < bScore) {
-			bScore = p3;
-			bPoint = 0x0B;
-			bIsBiggerSide = 0;
-		} else if (aScore > bScore && p3 < aScore) {
-			aScore = p3;
-			aPoint = 0x0B;
-			aIsBiggerSide = 0;
-		}
-		
-		/* Decide if (1,1,1,0) is closer. */
-		p4 = 3 - inSum + wins;
-		if (aScore <= bScore && p4 < bScore) {
-			bScore = p4;
-			bPoint = 0x07;
-			bIsBiggerSide = 0;
-		} else if (aScore > bScore && p4 < aScore) {
-			aScore = p4;
-			aPoint = 0x07;
-			aIsBiggerSide = 0;
-		}
-		
-		/* Where each of the two closest points are determines how the extra three vertices are calculated. */
-		if (aIsBiggerSide == bIsBiggerSide) {
-			if (aIsBiggerSide) { /* Both closest points on the bigger side */
-				c1 = (int8_t)(aPoint & bPoint);
-				c2 = (int8_t)(aPoint | bPoint);
-				
-				/* Two contributions are permutations of (0,0,0,1) and (0,0,0,2) based on c1 */
-				xsv_ext0 = xsv_ext1 = xsb;
-				ysv_ext0 = ysv_ext1 = ysb;
-				zsv_ext0 = zsv_ext1 = zsb;
-				wsv_ext0 = wsv_ext1 = wsb;
-				dx_ext0 = dx0 - SQUISH_CONSTANT_4D;
-				dy_ext0 = dy0 - SQUISH_CONSTANT_4D;
-				dz_ext0 = dz0 - SQUISH_CONSTANT_4D;
-				dw_ext0 = dw0 - SQUISH_CONSTANT_4D;
-				dx_ext1 = dx0 - 2 * SQUISH_CONSTANT_4D;
-				dy_ext1 = dy0 - 2 * SQUISH_CONSTANT_4D;
-				dz_ext1 = dz0 - 2 * SQUISH_CONSTANT_4D;
-				dw_ext1 = dw0 - 2 * SQUISH_CONSTANT_4D;
-				if ((c1 & 0x01) != 0) {
-					xsv_ext0 += 1;
-					dx_ext0 -= 1;
-					xsv_ext1 += 2;
-					dx_ext1 -= 2;
-				} else if ((c1 & 0x02) != 0) {
-					ysv_ext0 += 1;
-					dy_ext0 -= 1;
-					ysv_ext1 += 2;
-					dy_ext1 -= 2;
-				} else if ((c1 & 0x04) != 0) {
-					zsv_ext0 += 1;
-					dz_ext0 -= 1;
-					zsv_ext1 += 2;
-					dz_ext1 -= 2;
-				} else {
-					wsv_ext0 += 1;
-					dw_ext0 -= 1;
-					wsv_ext1 += 2;
-					dw_ext1 -= 2;
-				}
-				
-				/* One contribution is a permutation of (1,1,1,-1) based on c2 */
-				xsv_ext2 = xsb + 1;
-				ysv_ext2 = ysb + 1;
-				zsv_ext2 = zsb + 1;
-				wsv_ext2 = wsb + 1;
-				dx_ext2 = dx0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				dy_ext2 = dy0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				dz_ext2 = dz0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				dw_ext2 = dw0 - 1 - 2 * SQUISH_CONSTANT_4D;
-				if ((c2 & 0x01) == 0) {
-					xsv_ext2 -= 2;
-					dx_ext2 += 2;
-				} else if ((c2 & 0x02) == 0) {
-					ysv_ext2 -= 2;
-					dy_ext2 += 2;
-				} else if ((c2 & 0x04) == 0) {
-					zsv_ext2 -= 2;
-					dz_ext2 += 2;
-				} else {
-					wsv_ext2 -= 2;
-					dw_ext2 += 2;
-				}
-			} else { /* Both closest points on the smaller side */
-				/* One of the two extra points is (1,1,1,1) */
-				xsv_ext2 = xsb + 1;
-				ysv_ext2 = ysb + 1;
-				zsv_ext2 = zsb + 1;
-				wsv_ext2 = wsb + 1;
-				dx_ext2 = dx0 - 1 - 4 * SQUISH_CONSTANT_4D;
-				dy_ext2 = dy0 - 1 - 4 * SQUISH_CONSTANT_4D;
-				dz_ext2 = dz0 - 1 - 4 * SQUISH_CONSTANT_4D;
-				dw_ext2 = dw0 - 1 - 4 * SQUISH_CONSTANT_4D;
-				
-				/* Other two points are based on the shared axes. */
-				c = (int8_t)(aPoint & bPoint);
-				
-				if ((c & 0x01) != 0) {
-					xsv_ext0 = xsb + 2;
-					xsv_ext1 = xsb + 1;
-					dx_ext0 = dx0 - 2 - 3 * SQUISH_CONSTANT_4D;
-					dx_ext1 = dx0 - 1 - 3 * SQUISH_CONSTANT_4D;
-				} else {
-					xsv_ext0 = xsv_ext1 = xsb;
-					dx_ext0 = dx_ext1 = dx0 - 3 * SQUISH_CONSTANT_4D;
-				}
-				
-				if ((c & 0x02) != 0) {
-					ysv_ext0 = ysv_ext1 = ysb + 1;
-					dy_ext0 = dy_ext1 = dy0 - 1 - 3 * SQUISH_CONSTANT_4D;
-					if ((c & 0x01) == 0)
-					{
-						ysv_ext0 += 1;
-						dy_ext0 -= 1;
-					} else {
-						ysv_ext1 += 1;
-						dy_ext1 -= 1;
-					}
-				} else {
-					ysv_ext0 = ysv_ext1 = ysb;
-					dy_ext0 = dy_ext1 = dy0 - 3 * SQUISH_CONSTANT_4D;
-				}
-				
-				if ((c & 0x04) != 0) {
-					zsv_ext0 = zsv_ext1 = zsb + 1;
-					dz_ext0 = dz_ext1 = dz0 - 1 - 3 * SQUISH_CONSTANT_4D;
-					if ((c & 0x03) == 0)
-					{
-						zsv_ext0 += 1;
-						dz_ext0 -= 1;
-					} else {
-						zsv_ext1 += 1;
-						dz_ext1 -= 1;
-					}
-				} else {
-					zsv_ext0 = zsv_ext1 = zsb;
-					dz_ext0 = dz_ext1 = dz0 - 3 * SQUISH_CONSTANT_4D;
-				}
-				
-				if ((c & 0x08) != 0)
-				{
-					wsv_ext0 = wsb + 1;
-					wsv_ext1 = wsb + 2;
-					dw_ext0 = dw0 - 1 - 3 * SQUISH_CONSTANT_4D;
-					dw_ext1 = dw0 - 2 - 3 * SQUISH_CONSTANT_4D;
-				} else {
-					wsv_ext0 = wsv_ext1 = wsb;
-					dw_ext0 = dw_ext1 = dw0 - 3 * SQUISH_CONSTANT_4D;
-				}
-			}
-		} else { /* One point on each "side" */
-			if (aIsBiggerSide) {
-				c1 = aPoint;
-				c2 = bPoint;
-			} else {
-				c1 = bPoint;
-				c2 = aPoint;
-			}
-			
-			/* Two contributions are the bigger-sided point with each 1 replaced with 2. */
-			if ((c1 & 0x01) != 0) {
-				xsv_ext0 = xsb + 2;
-				xsv_ext1 = xsb + 1;
-				dx_ext0 = dx0 - 2 - 3 * SQUISH_CONSTANT_4D;
-				dx_ext1 = dx0 - 1 - 3 * SQUISH_CONSTANT_4D;
-			} else {
-				xsv_ext0 = xsv_ext1 = xsb;
-				dx_ext0 = dx_ext1 = dx0 - 3 * SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c1 & 0x02) != 0) {
-				ysv_ext0 = ysv_ext1 = ysb + 1;
-				dy_ext0 = dy_ext1 = dy0 - 1 - 3 * SQUISH_CONSTANT_4D;
-				if ((c1 & 0x01) == 0) {
-					ysv_ext0 += 1;
-					dy_ext0 -= 1;
-				} else {
-					ysv_ext1 += 1;
-					dy_ext1 -= 1;
-				}
-			} else {
-				ysv_ext0 = ysv_ext1 = ysb;
-				dy_ext0 = dy_ext1 = dy0 - 3 * SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c1 & 0x04) != 0) {
-				zsv_ext0 = zsv_ext1 = zsb + 1;
-				dz_ext0 = dz_ext1 = dz0 - 1 - 3 * SQUISH_CONSTANT_4D;
-				if ((c1 & 0x03) == 0) {
-					zsv_ext0 += 1;
-					dz_ext0 -= 1;
-				} else {
-					zsv_ext1 += 1;
-					dz_ext1 -= 1;
-				}
-			} else {
-				zsv_ext0 = zsv_ext1 = zsb;
-				dz_ext0 = dz_ext1 = dz0 - 3 * SQUISH_CONSTANT_4D;
-			}
-			
-			if ((c1 & 0x08) != 0) {
-				wsv_ext0 = wsb + 1;
-				wsv_ext1 = wsb + 2;
-				dw_ext0 = dw0 - 1 - 3 * SQUISH_CONSTANT_4D;
-				dw_ext1 = dw0 - 2 - 3 * SQUISH_CONSTANT_4D;
-			} else {
-				wsv_ext0 = wsv_ext1 = wsb;
-				dw_ext0 = dw_ext1 = dw0 - 3 * SQUISH_CONSTANT_4D;
-			}
-
-			/* One contribution is a permutation of (1,1,1,-1) based on the smaller-sided point */
-			xsv_ext2 = xsb + 1;
-			ysv_ext2 = ysb + 1;
-			zsv_ext2 = zsb + 1;
-			wsv_ext2 = wsb + 1;
-			dx_ext2 = dx0 - 1 - 2 * SQUISH_CONSTANT_4D;
-			dy_ext2 = dy0 - 1 - 2 * SQUISH_CONSTANT_4D;
-			dz_ext2 = dz0 - 1 - 2 * SQUISH_CONSTANT_4D;
-			dw_ext2 = dw0 - 1 - 2 * SQUISH_CONSTANT_4D;
-			if ((c2 & 0x01) == 0) {
-				xsv_ext2 -= 2;
-				dx_ext2 += 2;
-			} else if ((c2 & 0x02) == 0) {
-				ysv_ext2 -= 2;
-				dy_ext2 += 2;
-			} else if ((c2 & 0x04) == 0) {
-				zsv_ext2 -= 2;
-				dz_ext2 += 2;
-			} else {
-				wsv_ext2 -= 2;
-				dw_ext2 += 2;
-			}
-		}
-		
-		/* Contribution (1,1,1,0) */
-		dx4 = dx0 - 1 - 3 * SQUISH_CONSTANT_4D;
-		dy4 = dy0 - 1 - 3 * SQUISH_CONSTANT_4D;
-		dz4 = dz0 - 1 - 3 * SQUISH_CONSTANT_4D;
-		dw4 = dw0 - 3 * SQUISH_CONSTANT_4D;
-		attn4 = 2 - dx4 * dx4 - dy4 * dy4 - dz4 * dz4 - dw4 * dw4;
-		if (attn4 > 0) {
-			attn4 *= attn4;
-			value += attn4 * attn4 * extrapolate4(ctx, xsb + 1, ysb + 1, zsb + 1, wsb + 0, dx4, dy4, dz4, dw4);
-		}
-
-		/* Contribution (1,1,0,1) */
-		dx3 = dx4;
-		dy3 = dy4;
-		dz3 = dz0 - 3 * SQUISH_CONSTANT_4D;
-		dw3 = dw0 - 1 - 3 * SQUISH_CONSTANT_4D;
-		attn3 = 2 - dx3 * dx3 - dy3 * dy3 - dz3 * dz3 - dw3 * dw3;
-		if (attn3 > 0) {
-			attn3 *= attn3;
-			value += attn3 * attn3 * extrapolate4(ctx, xsb + 1, ysb + 1, zsb + 0, wsb + 1, dx3, dy3, dz3, dw3);
-		}
-
-		/* Contribution (1,0,1,1) */
-		dx2 = dx4;
-		dy2 = dy0 - 3 * SQUISH_CONSTANT_4D;
-		dz2 = dz4;
-		dw2 = dw3;
-		attn2 = 2 - dx2 * dx2 - dy2 * dy2 - dz2 * dz2 - dw2 * dw2;
-		if (attn2 > 0) {
-			attn2 *= attn2;
-			value += attn2 * attn2 * extrapolate4(ctx, xsb + 1, ysb + 0, zsb + 1, wsb + 1, dx2, dy2, dz2, dw2);
-		}
-
-		/* Contribution (0,1,1,1) */
-		dx1 = dx0 - 3 * SQUISH_CONSTANT_4D;
-		dz1 = dz4;
-		dy1 = dy4;
-		dw1 = dw3;
-		attn1 = 2 - dx1 * dx1 - dy1 * dy1 - dz1 * dz1 - dw1 * dw1;
-		if (attn1 > 0) {
-			attn1 *= attn1;
-			value += attn1 * attn1 * extrapolate4(ctx, xsb + 0, ysb + 1, zsb + 1, wsb + 1, dx1, dy1, dz1, dw1);
-		}
-		
-		/* Contribution (1,1,0,0) */
-		dx5 = dx0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dy5 = dy0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dz5 = dz0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dw5 = dw0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		attn5 = 2 - dx5 * dx5 - dy5 * dy5 - dz5 * dz5 - dw5 * dw5;
-		if (attn5 > 0) {
-			attn5 *= attn5;
-			value += attn5 * attn5 * extrapolate4(ctx, xsb + 1, ysb + 1, zsb + 0, wsb + 0, dx5, dy5, dz5, dw5);
-		}
-		
-		/* Contribution (1,0,1,0) */
-		dx6 = dx0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dy6 = dy0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dz6 = dz0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dw6 = dw0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		attn6 = 2 - dx6 * dx6 - dy6 * dy6 - dz6 * dz6 - dw6 * dw6;
-		if (attn6 > 0) {
-			attn6 *= attn6;
-			value += attn6 * attn6 * extrapolate4(ctx, xsb + 1, ysb + 0, zsb + 1, wsb + 0, dx6, dy6, dz6, dw6);
-		}
-
-		/* Contribution (1,0,0,1) */
-		dx7 = dx0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dy7 = dy0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dz7 = dz0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dw7 = dw0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		attn7 = 2 - dx7 * dx7 - dy7 * dy7 - dz7 * dz7 - dw7 * dw7;
-		if (attn7 > 0) {
-			attn7 *= attn7;
-			value += attn7 * attn7 * extrapolate4(ctx, xsb + 1, ysb + 0, zsb + 0, wsb + 1, dx7, dy7, dz7, dw7);
-		}
-		
-		/* Contribution (0,1,1,0) */
-		dx8 = dx0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dy8 = dy0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dz8 = dz0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dw8 = dw0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		attn8 = 2 - dx8 * dx8 - dy8 * dy8 - dz8 * dz8 - dw8 * dw8;
-		if (attn8 > 0) {
-			attn8 *= attn8;
-			value += attn8 * attn8 * extrapolate4(ctx, xsb + 0, ysb + 1, zsb + 1, wsb + 0, dx8, dy8, dz8, dw8);
-		}
-		
-		/* Contribution (0,1,0,1) */
-		dx9 = dx0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dy9 = dy0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dz9 = dz0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dw9 = dw0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		attn9 = 2 - dx9 * dx9 - dy9 * dy9 - dz9 * dz9 - dw9 * dw9;
-		if (attn9 > 0) {
-			attn9 *= attn9;
-			value += attn9 * attn9 * extrapolate4(ctx, xsb + 0, ysb + 1, zsb + 0, wsb + 1, dx9, dy9, dz9, dw9);
-		}
-		
-		/* Contribution (0,0,1,1) */
-		dx10 = dx0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dy10 = dy0 - 0 - 2 * SQUISH_CONSTANT_4D;
-		dz10 = dz0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		dw10 = dw0 - 1 - 2 * SQUISH_CONSTANT_4D;
-		attn10 = 2 - dx10 * dx10 - dy10 * dy10 - dz10 * dz10 - dw10 * dw10;
-		if (attn10 > 0) {
-			attn10 *= attn10;
-			value += attn10 * attn10 * extrapolate4(ctx, xsb + 0, ysb + 0, zsb + 1, wsb + 1, dx10, dy10, dz10, dw10);
-		}
-	}
-
-	/* First extra vertex */
-	attn_ext0 = 2 - dx_ext0 * dx_ext0 - dy_ext0 * dy_ext0 - dz_ext0 * dz_ext0 - dw_ext0 * dw_ext0;
-	if (attn_ext0 > 0)
-	{
-		attn_ext0 *= attn_ext0;
-		value += attn_ext0 * attn_ext0 * extrapolate4(ctx, xsv_ext0, ysv_ext0, zsv_ext0, wsv_ext0, dx_ext0, dy_ext0, dz_ext0, dw_ext0);
-	}
-
-	/* Second extra vertex */
-	attn_ext1 = 2 - dx_ext1 * dx_ext1 - dy_ext1 * dy_ext1 - dz_ext1 * dz_ext1 - dw_ext1 * dw_ext1;
-	if (attn_ext1 > 0)
-	{
-		attn_ext1 *= attn_ext1;
-		value += attn_ext1 * attn_ext1 * extrapolate4(ctx, xsv_ext1, ysv_ext1, zsv_ext1, wsv_ext1, dx_ext1, dy_ext1, dz_ext1, dw_ext1);
-	}
-
-	/* Third extra vertex */
-	attn_ext2 = 2 - dx_ext2 * dx_ext2 - dy_ext2 * dy_ext2 - dz_ext2 * dz_ext2 - dw_ext2 * dw_ext2;
-	if (attn_ext2 > 0)
-	{
-		attn_ext2 *= attn_ext2;
-		value += attn_ext2 * attn_ext2 * extrapolate4(ctx, xsv_ext2, ysv_ext2, zsv_ext2, wsv_ext2, dx_ext2, dy_ext2, dz_ext2, dw_ext2);
-	}
-
-	return value / NORM_CONSTANT_4D;
-}
-	
diff --git a/thirdparty/misc/open-simplex-noise.h b/thirdparty/misc/open-simplex-noise.h
deleted file mode 100644
index fd9248c3a1..0000000000
--- a/thirdparty/misc/open-simplex-noise.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef OPEN_SIMPLEX_NOISE_H__
-#define OPEN_SIMPLEX_NOISE_H__
-
-/*
- * OpenSimplex (Simplectic) Noise in C.
- * Ported to C from Kurt Spencer's java implementation by Stephen M. Cameron
- *
- * v1.1 (October 6, 2014) 
- * - Ported to C
- * 
- * v1.1 (October 5, 2014)
- * - Added 2D and 4D implementations.
- * - Proper gradient sets for all dimensions, from a
- *   dimensionally-generalizable scheme with an actual
- *   rhyme and reason behind it.
- * - Removed default permutation array in favor of
- *   default seed.
- * - Changed seed-based constructor to be independent
- *   of any particular randomization library, so results
- *   will be the same when ported to other languages.
- */
-
-#if ((__GNUC_STDC_INLINE__) || (__STDC_VERSION__ >= 199901L))
-	#include <stdint.h>
-	#define INLINE inline
-#elif (defined (_MSC_VER) || defined (__GNUC_GNU_INLINE__))
-	#include <stdint.h>
-	#define INLINE __inline
-#else 
-	/* ANSI C doesn't have inline or stdint.h. */
-	#define INLINE
-#endif
-
-#ifdef __cplusplus
-	extern "C" {
-#endif
-
-// -- GODOT start --
-// Modified to work without allocating memory, also removed some unused function. 
-
-struct osn_context {
-	int16_t perm[256];
-	int16_t permGradIndex3D[256];
-};
-
-int open_simplex_noise(int64_t seed, struct osn_context *ctx);
-//int open_simplex_noise_init_perm(struct osn_context *ctx, int16_t p[], int nelements);
-// -- GODOT end --
-void open_simplex_noise_free(struct osn_context *ctx);
-double open_simplex_noise2(const struct osn_context *ctx, double x, double y);
-double open_simplex_noise3(const struct osn_context *ctx, double x, double y, double z);
-double open_simplex_noise4(const struct osn_context *ctx, double x, double y, double z, double w);
-
-#ifdef __cplusplus
-	}
-#endif
-
-#endif
diff --git a/thirdparty/noise/FastNoise-LICENSE b/thirdparty/noise/FastNoise-LICENSE
new file mode 100644
index 0000000000..dd6df2c160
--- /dev/null
+++ b/thirdparty/noise/FastNoise-LICENSE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright(c) 2020 Jordan Peck (jordan.me2@gmail.com)
+Copyright(c) 2020 Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/thirdparty/noise/FastNoiseLite.h b/thirdparty/noise/FastNoiseLite.h
new file mode 100644
index 0000000000..3db344c149
--- /dev/null
+++ b/thirdparty/noise/FastNoiseLite.h
@@ -0,0 +1,2589 @@
+// MIT License
+//
+// Copyright(c) 2020 Jordan Peck (jordan.me2@gmail.com)
+// Copyright(c) 2020 Contributors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files(the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// .'',;:cldxkO00KKXXNNWWWNNXKOkxdollcc::::::;:::ccllloooolllllllllooollc:,'...        ...........',;cldxkO000Okxdlc::;;;,,;;;::cclllllll
+// ..',;:ldxO0KXXNNNNNNNNXXK0kxdolcc::::::;;;,,,,,,;;;;;;;;;;:::cclllllc:;'....       ...........',;:ldxO0KXXXK0Okxdolc::;;;;::cllodddddo
+// ...',:loxO0KXNNNNNXXKK0Okxdolc::;::::::::;;;,,'''''.....''',;:clllllc:;,'............''''''''',;:loxO0KXNNNNNXK0Okxdollccccllodxxxxxxd
+// ....';:ldkO0KXXXKK00Okxdolcc:;;;;;::cclllcc:;;,''..... ....',;clooddolcc:;;;;,,;;;;;::::;;;;;;:cloxk0KXNWWWWWWNXKK0Okxddoooddxxkkkkkxx
+// .....';:ldxkOOOOOkxxdolcc:;;;,,,;;:cllooooolcc:;'...      ..,:codxkkkxddooollloooooooollcc:::::clodkO0KXNWWWWWWNNXK00Okxxxxxxxxkkkkxxx
+// . ....';:cloddddo___________,,,,;;:clooddddoolc:,...      ..,:ldx__00OOOkkk___kkkkkkxxdollc::::cclodkO0KXXNNNNNNXXK0OOkxxxxxxxxxxxxddd
+// .......',;:cccc:|           |,,,;;:cclooddddoll:;'..     ..';cox|  \KKK000|   |KK00OOkxdocc___;::clldxxkO0KKKKK00Okkxdddddddddddddddoo
+// .......'',,,,,''|   ________|',,;;::cclloooooolc:;'......___:ldk|   \KK000|   |XKKK0Okxolc|   |;;::cclodxxkkkkxxdoolllcclllooodddooooo
+// ''......''''....|   |  ....'',,,,;;;::cclloooollc:;,''.'|   |oxk|    \OOO0|   |KKK00Oxdoll|___|;;;;;::ccllllllcc::;;,,;;;:cclloooooooo
+// ;;,''.......... |   |_____',,;;;____:___cllo________.___|   |___|     \xkk|   |KK_______ool___:::;________;;;_______...'',;;:ccclllloo
+// c:;,''......... |         |:::/     '   |lo/        |           |      \dx|   |0/       \d|   |cc/        |'/       \......',,;;:ccllo
+// ol:;,'..........|    _____|ll/    __    |o/   ______|____    ___|   |   \o|   |/   ___   \|   |o/   ______|/   ___   \ .......'',;:clo
+// dlc;,...........|   |::clooo|    /  |   |x\___   \KXKKK0|   |dol|   |\   \|   |   |   |   |   |d\___   \..|   |  /   /       ....',:cl
+// xoc;'...  .....'|   |llodddd|    \__|   |_____\   \KKK0O|   |lc:|   |'\       |   |___|   |   |_____\   \.|   |_/___/...      ...',;:c
+// dlc;'... ....',;|   |oddddddo\          |          |Okkx|   |::;|   |..\      |\         /|   |          | \         |...    ....',;:c
+// ol:,'.......',:c|___|xxxddollc\_____,___|_________/ddoll|___|,,,|___|...\_____|:\ ______/l|___|_________/...\________|'........',;::cc
+// c:;'.......';:codxxkkkkxxolc::;::clodxkOO0OOkkxdollc::;;,,''''',,,,''''''''''',,'''''',;:loxkkOOkxol:;,'''',,;:ccllcc:;,'''''',;::ccll
+// ;,'.......',:codxkOO0OOkxdlc:;,,;;:cldxxkkxxdolc:;;,,''.....'',;;:::;;,,,'''''........,;cldkO0KK0Okdoc::;;::cloodddoolc:;;;;;::ccllooo
+// .........',;:lodxOO0000Okdoc:,,',,;:clloddoolc:;,''.......'',;:clooollc:;;,,''.......',:ldkOKXNNXX0Oxdolllloddxxxxxxdolccccccllooodddd
+// .    .....';:cldxkO0000Okxol:;,''',,;::cccc:;,,'.......'',;:cldxxkkxxdolc:;;,'.......';coxOKXNWWWNXKOkxddddxxkkkkkkxdoollllooddxxxxkkk
+//       ....',;:codxkO000OOxdoc:;,''',,,;;;;,''.......',,;:clodkO00000Okxolc::;,,''..',;:ldxOKXNWWWNNK0OkkkkkkkkkkkxxddooooodxxkOOOOO000
+//       ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX
+//
+// VERSION: 1.0.1
+// https://github.com/Auburn/FastNoise
+
+#ifndef FASTNOISELITE_H
+#define FASTNOISELITE_H
+
+#include <cmath>
+
+namespace fastnoiselite{
+
+class FastNoiseLite
+{
+public:
+    enum NoiseType
+    {
+        NoiseType_OpenSimplex2,
+        NoiseType_OpenSimplex2S,
+        NoiseType_Cellular,
+        NoiseType_Perlin,
+        NoiseType_ValueCubic,
+        NoiseType_Value
+    };
+
+    enum RotationType3D
+    {
+        RotationType3D_None,
+        RotationType3D_ImproveXYPlanes,
+        RotationType3D_ImproveXZPlanes
+    };
+
+    enum FractalType
+    {
+        FractalType_None,
+        FractalType_FBm,
+        FractalType_Ridged,
+        FractalType_PingPong,
+        FractalType_DomainWarpProgressive,
+        FractalType_DomainWarpIndependent
+    };
+
+    enum CellularDistanceFunction
+    {
+        CellularDistanceFunction_Euclidean,
+        CellularDistanceFunction_EuclideanSq,
+        CellularDistanceFunction_Manhattan,
+        CellularDistanceFunction_Hybrid
+    };
+
+    enum CellularReturnType
+    {
+        CellularReturnType_CellValue,
+        CellularReturnType_Distance,
+        CellularReturnType_Distance2,
+        CellularReturnType_Distance2Add,
+        CellularReturnType_Distance2Sub,
+        CellularReturnType_Distance2Mul,
+        CellularReturnType_Distance2Div
+    };
+
+    enum DomainWarpType
+    {
+        DomainWarpType_OpenSimplex2,
+        DomainWarpType_OpenSimplex2Reduced,
+        DomainWarpType_BasicGrid
+    };
+
+    /// <summary>
+    /// Create new FastNoise object with optional seed
+    /// </summary>
+    FastNoiseLite(int seed = 1337)
+    {
+        mSeed = seed;
+        mFrequency = 0.01f;
+        mNoiseType = NoiseType_OpenSimplex2;
+        mRotationType3D = RotationType3D_None;
+        mTransformType3D = TransformType3D_DefaultOpenSimplex2;
+
+        mFractalType = FractalType_None;
+        mOctaves = 3;
+        mLacunarity = 2.0f;
+        mGain = 0.5f;
+        mWeightedStrength = 0.0f;
+        mPingPongStrength = 2.0f;
+
+        mFractalBounding = 1 / 1.75f;
+
+        mCellularDistanceFunction = CellularDistanceFunction_EuclideanSq;
+        mCellularReturnType = CellularReturnType_Distance;
+        mCellularJitterModifier = 1.0f;
+
+        mDomainWarpType = DomainWarpType_OpenSimplex2;
+        mWarpTransformType3D = TransformType3D_DefaultOpenSimplex2;
+        mDomainWarpAmp = 1.0f;
+    }
+
+    /// <summary>
+    /// Sets seed used for all noise types
+    /// </summary>
+    /// <remarks>
+    /// Default: 1337
+    /// </remarks>
+    void SetSeed(int seed) { mSeed = seed; }
+
+    /// <summary>
+    /// Sets frequency for all noise types
+    /// </summary>
+    /// <remarks>
+    /// Default: 0.01
+    /// </remarks>
+    void SetFrequency(float frequency) { mFrequency = frequency; }
+
+    /// <summary>
+    /// Sets noise algorithm used for GetNoise(...)
+    /// </summary>
+    /// <remarks>
+    /// Default: OpenSimplex2
+    /// </remarks>
+    void SetNoiseType(NoiseType noiseType)
+    {
+        mNoiseType = noiseType;
+        UpdateTransformType3D();
+    }
+
+    /// <summary>
+    /// Sets domain rotation type for 3D Noise and 3D DomainWarp.
+    /// Can aid in reducing directional artifacts when sampling a 2D plane in 3D
+    /// </summary>
+    /// <remarks>
+    /// Default: None
+    /// </remarks>
+    void SetRotationType3D(RotationType3D rotationType3D)
+    {
+        mRotationType3D = rotationType3D;
+        UpdateTransformType3D();
+        UpdateWarpTransformType3D();
+    }
+
+    /// <summary>
+    /// Sets method for combining octaves in all fractal noise types
+    /// </summary>
+    /// <remarks>
+    /// Default: None
+    /// Note: FractalType_DomainWarp... only affects DomainWarp(...)
+    /// </remarks>
+    void SetFractalType(FractalType fractalType) { mFractalType = fractalType; }
+
+    /// <summary>
+    /// Sets octave count for all fractal noise types 
+    /// </summary>
+    /// <remarks>
+    /// Default: 3
+    /// </remarks>
+    void SetFractalOctaves(int octaves)
+    {
+        mOctaves = octaves;
+        CalculateFractalBounding();
+    }
+
+    /// <summary>
+    /// Sets octave lacunarity for all fractal noise types
+    /// </summary>
+    /// <remarks>
+    /// Default: 2.0
+    /// </remarks>
+    void SetFractalLacunarity(float lacunarity) { mLacunarity = lacunarity; }
+
+    /// <summary>
+    /// Sets octave gain for all fractal noise types
+    /// </summary>
+    /// <remarks>
+    /// Default: 0.5
+    /// </remarks>
+    void SetFractalGain(float gain)
+    {
+        mGain = gain;
+        CalculateFractalBounding();
+    }
+
+    /// <summary>
+    /// Sets octave weighting for all none DomainWarp fratal types
+    /// </summary>
+    /// <remarks>
+    /// Default: 0.0
+    /// Note: Keep between 0...1 to maintain -1...1 output bounding
+    /// </remarks>
+    void SetFractalWeightedStrength(float weightedStrength) { mWeightedStrength = weightedStrength; }
+
+    /// <summary>
+    /// Sets strength of the fractal ping pong effect
+    /// </summary>
+    /// <remarks>
+    /// Default: 2.0
+    /// </remarks>
+    void SetFractalPingPongStrength(float pingPongStrength) { mPingPongStrength = pingPongStrength; }
+
+
+    /// <summary>
+    /// Sets distance function used in cellular noise calculations
+    /// </summary>
+    /// <remarks>
+    /// Default: Distance
+    /// </remarks>
+    void SetCellularDistanceFunction(CellularDistanceFunction cellularDistanceFunction) { mCellularDistanceFunction = cellularDistanceFunction; }
+
+    /// <summary>
+    /// Sets return type from cellular noise calculations
+    /// </summary>
+    /// <remarks>
+    /// Default: EuclideanSq
+    /// </remarks>
+    void SetCellularReturnType(CellularReturnType cellularReturnType) { mCellularReturnType = cellularReturnType; }
+
+    /// <summary>
+    /// Sets the maximum distance a cellular point can move from it's grid position
+    /// </summary>
+    /// <remarks>
+    /// Default: 1.0
+    /// Note: Setting this higher than 1 will cause artifacts
+    /// </remarks> 
+    void SetCellularJitter(float cellularJitter) { mCellularJitterModifier = cellularJitter; }
+
+
+    /// <summary>
+    /// Sets the warp algorithm when using DomainWarp(...)
+    /// </summary>
+    /// <remarks>
+    /// Default: OpenSimplex2
+    /// </remarks>
+    void SetDomainWarpType(DomainWarpType domainWarpType)
+    {
+        mDomainWarpType = domainWarpType;
+        UpdateWarpTransformType3D();
+    }
+
+
+    /// <summary>
+    /// Sets the maximum warp distance from original position when using DomainWarp(...)
+    /// </summary>
+    /// <remarks>
+    /// Default: 1.0
+    /// </remarks>
+    void SetDomainWarpAmp(float domainWarpAmp) { mDomainWarpAmp = domainWarpAmp; }
+
+
+    /// <summary>
+    /// 2D noise at given position using current settings
+    /// </summary>
+    /// <returns>
+    /// Noise output bounded between -1...1
+    /// </returns>
+    template <typename FNfloat>
+    float GetNoise(FNfloat x, FNfloat y)
+    {
+        Arguments_must_be_floating_point_values<FNfloat>();
+
+        TransformNoiseCoordinate(x, y);
+
+        switch (mFractalType)
+        {
+        default:
+            return GenNoiseSingle(mSeed, x, y);
+        case FractalType_FBm:
+            return GenFractalFBm(x, y);
+        case FractalType_Ridged:
+            return GenFractalRidged(x, y);
+        case FractalType_PingPong:
+            return GenFractalPingPong(x, y);
+        }
+    }
+
+    /// <summary>
+    /// 3D noise at given position using current settings
+    /// </summary>
+    /// <returns>
+    /// Noise output bounded between -1...1
+    /// </returns>
+    template <typename FNfloat>
+    float GetNoise(FNfloat x, FNfloat y, FNfloat z)
+    {
+        Arguments_must_be_floating_point_values<FNfloat>();
+
+        TransformNoiseCoordinate(x, y, z);
+
+        switch (mFractalType)
+        {
+        default:
+            return GenNoiseSingle(mSeed, x, y, z);
+        case FractalType_FBm:
+            return GenFractalFBm(x, y, z);
+        case FractalType_Ridged:
+            return GenFractalRidged(x, y, z);
+        case FractalType_PingPong:
+            return GenFractalPingPong(x, y, z);
+        }
+    }
+
+
+    /// <summary>
+    /// 2D warps the input position using current domain warp settings
+    /// </summary>
+    /// <example>
+    /// Example usage with GetNoise
+    /// <code>DomainWarp(x, y)
+    /// noise = GetNoise(x, y)</code>
+    /// </example>
+    template <typename FNfloat>
+    void DomainWarp(FNfloat& x, FNfloat& y)
+    {
+        Arguments_must_be_floating_point_values<FNfloat>();
+
+        switch (mFractalType)
+        {
+        default:
+            DomainWarpSingle(x, y);
+            break;
+        case FractalType_DomainWarpProgressive:
+            DomainWarpFractalProgressive(x, y);
+            break;
+        case FractalType_DomainWarpIndependent:
+            DomainWarpFractalIndependent(x, y);
+            break;
+        }
+    }
+
+    /// <summary>
+    /// 3D warps the input position using current domain warp settings
+    /// </summary>
+    /// <example>
+    /// Example usage with GetNoise
+    /// <code>DomainWarp(x, y, z)
+    /// noise = GetNoise(x, y, z)</code>
+    /// </example>
+    template <typename FNfloat>
+    void DomainWarp(FNfloat& x, FNfloat& y, FNfloat& z)
+    {
+        Arguments_must_be_floating_point_values<FNfloat>();
+
+        switch (mFractalType)
+        {
+        default:
+            DomainWarpSingle(x, y, z);
+            break;
+        case FractalType_DomainWarpProgressive:
+            DomainWarpFractalProgressive(x, y, z);
+            break;
+        case FractalType_DomainWarpIndependent:
+            DomainWarpFractalIndependent(x, y, z);
+            break;
+        }
+    }
+
+private:
+    template <typename T>
+    struct Arguments_must_be_floating_point_values;
+
+    enum TransformType3D
+    {
+        TransformType3D_None,
+        TransformType3D_ImproveXYPlanes,
+        TransformType3D_ImproveXZPlanes,
+        TransformType3D_DefaultOpenSimplex2
+    };
+
+    int mSeed;
+    float mFrequency;
+    NoiseType mNoiseType;
+    RotationType3D mRotationType3D;
+    TransformType3D mTransformType3D;
+
+    FractalType mFractalType;
+    int mOctaves;
+    float mLacunarity;
+    float mGain;
+    float mWeightedStrength;
+    float mPingPongStrength;
+
+    float mFractalBounding;
+
+    CellularDistanceFunction mCellularDistanceFunction;
+    CellularReturnType mCellularReturnType;
+    float mCellularJitterModifier;
+
+    DomainWarpType mDomainWarpType;
+    TransformType3D mWarpTransformType3D;
+    float mDomainWarpAmp;
+
+
+    template <typename T>
+    struct Lookup
+    {
+        static const T Gradients2D[];
+        static const T Gradients3D[];
+        static const T RandVecs2D[];
+        static const T RandVecs3D[];
+    };
+
+    static float FastMin(float a, float b) { return a < b ? a : b; }
+
+    static float FastMax(float a, float b) { return a > b ? a : b; }
+
+    static float FastAbs(float f) { return f < 0 ? -f : f; }
+
+    static float FastSqrt(float f) { return sqrtf(f); }
+
+    template <typename FNfloat>
+    static int FastFloor(FNfloat f) { return f >= 0 ? (int)f : (int)f - 1; }
+
+    template <typename FNfloat>
+    static int FastRound(FNfloat f) { return f >= 0 ? (int)(f + 0.5f) : (int)(f - 0.5f); }
+
+    static float Lerp(float a, float b, float t) { return a + t * (b - a); }
+
+    static float InterpHermite(float t) { return t * t * (3 - 2 * t); }
+
+    static float InterpQuintic(float t) { return t * t * t * (t * (t * 6 - 15) + 10); }
+
+    static float CubicLerp(float a, float b, float c, float d, float t)
+    {
+        float p = (d - c) - (a - b);
+        return t * t * t * p + t * t * ((a - b) - p) + t * (c - a) + b;
+    }
+
+    static float PingPong(float t)
+    {
+        t -= (int)(t * 0.5f) * 2;
+        return t < 1 ? t : 2 - t;
+    }
+
+    void CalculateFractalBounding()
+    {
+        float gain = FastAbs(mGain);
+        float amp = gain;
+        float ampFractal = 1.0f;
+        for (int i = 1; i < mOctaves; i++)
+        {
+            ampFractal += amp;
+            amp *= gain;
+        }
+        mFractalBounding = 1 / ampFractal;
+    }
+
+    // Hashing
+    static const int PrimeX = 501125321;
+    static const int PrimeY = 1136930381;
+    static const int PrimeZ = 1720413743;
+
+    static int Hash(int seed, int xPrimed, int yPrimed)
+    {
+        int hash = seed ^ xPrimed ^ yPrimed;
+
+        hash *= 0x27d4eb2d;
+        return hash;
+    }
+
+
+    static int Hash(int seed, int xPrimed, int yPrimed, int zPrimed)
+    {
+        int hash = seed ^ xPrimed ^ yPrimed ^ zPrimed;
+
+        hash *= 0x27d4eb2d;
+        return hash;
+    }
+
+
+    static float ValCoord(int seed, int xPrimed, int yPrimed)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed);
+
+        hash *= hash;
+        hash ^= hash << 19;
+        return hash * (1 / 2147483648.0f);
+    }
+
+
+    static float ValCoord(int seed, int xPrimed, int yPrimed, int zPrimed)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+
+        hash *= hash;
+        hash ^= hash << 19;
+        return hash * (1 / 2147483648.0f);
+    }
+
+
+    float GradCoord(int seed, int xPrimed, int yPrimed, float xd, float yd)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed);
+        hash ^= hash >> 15;
+        hash &= 127 << 1;
+
+        float xg = Lookup<float>::Gradients2D[hash];
+        float yg = Lookup<float>::Gradients2D[hash | 1];
+
+        return xd * xg + yd * yg;
+    }
+
+
+    float GradCoord(int seed, int xPrimed, int yPrimed, int zPrimed, float xd, float yd, float zd)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+        hash ^= hash >> 15;
+        hash &= 63 << 2;
+
+        float xg = Lookup<float>::Gradients3D[hash];
+        float yg = Lookup<float>::Gradients3D[hash | 1];
+        float zg = Lookup<float>::Gradients3D[hash | 2];
+
+        return xd * xg + yd * yg + zd * zg;
+    }
+
+
+    void GradCoordOut(int seed, int xPrimed, int yPrimed, float& xo, float& yo)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed) & (255 << 1);
+
+        xo = Lookup<float>::RandVecs2D[hash];
+        yo = Lookup<float>::RandVecs2D[hash | 1];
+    }
+
+
+    void GradCoordOut(int seed, int xPrimed, int yPrimed, int zPrimed, float& xo, float& yo, float& zo)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed, zPrimed) & (255 << 2);
+
+        xo = Lookup<float>::RandVecs3D[hash];
+        yo = Lookup<float>::RandVecs3D[hash | 1];
+        zo = Lookup<float>::RandVecs3D[hash | 2];
+    }
+
+
+    void GradCoordDual(int seed, int xPrimed, int yPrimed, float xd, float yd, float& xo, float& yo)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed);
+        int index1 = hash & (127 << 1);
+        int index2 = (hash >> 7) & (255 << 1);
+
+        float xg = Lookup<float>::Gradients2D[index1];
+        float yg = Lookup<float>::Gradients2D[index1 | 1];
+        float value = xd * xg + yd * yg;
+
+        float xgo = Lookup<float>::RandVecs2D[index2];
+        float ygo = Lookup<float>::RandVecs2D[index2 | 1];
+
+        xo = value * xgo;
+        yo = value * ygo;
+    }
+
+
+    void GradCoordDual(int seed, int xPrimed, int yPrimed, int zPrimed, float xd, float yd, float zd, float& xo, float& yo, float& zo)
+    {
+        int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+        int index1 = hash & (63 << 2);
+        int index2 = (hash >> 6) & (255 << 2);
+
+        float xg = Lookup<float>::Gradients3D[index1];
+        float yg = Lookup<float>::Gradients3D[index1 | 1];
+        float zg = Lookup<float>::Gradients3D[index1 | 2];
+        float value = xd * xg + yd * yg + zd * zg;
+
+        float xgo = Lookup<float>::RandVecs3D[index2];
+        float ygo = Lookup<float>::RandVecs3D[index2 | 1];
+        float zgo = Lookup<float>::RandVecs3D[index2 | 2];
+
+        xo = value * xgo;
+        yo = value * ygo;
+        zo = value * zgo;
+    }
+
+
+    // Generic noise gen
+
+    template <typename FNfloat>
+    float GenNoiseSingle(int seed, FNfloat x, FNfloat y)
+    {
+        switch (mNoiseType)
+        {
+        case NoiseType_OpenSimplex2:
+            return SingleSimplex(seed, x, y);
+        case NoiseType_OpenSimplex2S:
+            return SingleOpenSimplex2S(seed, x, y);
+        case NoiseType_Cellular:
+            return SingleCellular(seed, x, y);
+        case NoiseType_Perlin:
+            return SinglePerlin(seed, x, y);
+        case NoiseType_ValueCubic:
+            return SingleValueCubic(seed, x, y);
+        case NoiseType_Value:
+            return SingleValue(seed, x, y);
+        default:
+            return 0;
+        }
+    }
+
+    template <typename FNfloat>
+    float GenNoiseSingle(int seed, FNfloat x, FNfloat y, FNfloat z)
+    {
+        switch (mNoiseType)
+        {
+        case NoiseType_OpenSimplex2:
+            return SingleOpenSimplex2(seed, x, y, z);
+        case NoiseType_OpenSimplex2S:
+            return SingleOpenSimplex2S(seed, x, y, z);
+        case NoiseType_Cellular:
+            return SingleCellular(seed, x, y, z);
+        case NoiseType_Perlin:
+            return SinglePerlin(seed, x, y, z);
+        case NoiseType_ValueCubic:
+            return SingleValueCubic(seed, x, y, z);
+        case NoiseType_Value:
+            return SingleValue(seed, x, y, z);
+        default:
+            return 0;
+        }
+    }
+
+
+    // Noise Coordinate Transforms (frequency, and possible skew or rotation)
+
+    template <typename FNfloat>
+    void TransformNoiseCoordinate(FNfloat& x, FNfloat& y)
+    {
+        x *= mFrequency;
+        y *= mFrequency;
+
+        switch (mNoiseType)
+        {
+        case NoiseType_OpenSimplex2:
+        case NoiseType_OpenSimplex2S:
+            {
+                const FNfloat SQRT3 = (FNfloat)1.7320508075688772935274463415059;
+                const FNfloat F2 = 0.5f * (SQRT3 - 1);
+                FNfloat t = (x + y) * F2;
+                x += t;
+                y += t;
+            }
+            break;
+        default:
+            break;
+        }
+    }
+
+    template <typename FNfloat>
+    void TransformNoiseCoordinate(FNfloat& x, FNfloat& y, FNfloat& z)
+    {
+        x *= mFrequency;
+        y *= mFrequency;
+        z *= mFrequency;
+
+        switch (mTransformType3D)
+        {
+        case TransformType3D_ImproveXYPlanes:
+            {
+                FNfloat xy = x + y;
+                FNfloat s2 = xy * -(FNfloat)0.211324865405187;
+                z *= (FNfloat)0.577350269189626;
+                x += s2 - z;
+                y = y + s2 - z;
+                z += xy * (FNfloat)0.577350269189626;
+            }
+            break;
+        case TransformType3D_ImproveXZPlanes:
+            {
+                FNfloat xz = x + z;
+                FNfloat s2 = xz * -(FNfloat)0.211324865405187;
+                y *= (FNfloat)0.577350269189626;
+                x += s2 - y;
+                z += s2 - y;
+                y += xz * (FNfloat)0.577350269189626;
+            }
+            break;
+        case TransformType3D_DefaultOpenSimplex2:
+            {
+                const FNfloat R3 = (FNfloat)(2.0 / 3.0);
+                FNfloat r = (x + y + z) * R3; // Rotation, not skew
+                x = r - x;
+                y = r - y;
+                z = r - z;
+            }
+            break;
+        default:
+            break;
+        }
+    }
+
+    void UpdateTransformType3D()
+    {
+        switch (mRotationType3D)
+        {
+        case RotationType3D_ImproveXYPlanes:
+            mTransformType3D = TransformType3D_ImproveXYPlanes;
+            break;
+        case RotationType3D_ImproveXZPlanes:
+            mTransformType3D = TransformType3D_ImproveXZPlanes;
+            break;
+        default:
+            switch (mNoiseType)
+            {
+            case NoiseType_OpenSimplex2:
+            case NoiseType_OpenSimplex2S:
+                mTransformType3D = TransformType3D_DefaultOpenSimplex2;
+                break;
+            default:
+                mTransformType3D = TransformType3D_None;
+                break;
+            }
+            break;
+        }
+    }
+
+
+    // Domain Warp Coordinate Transforms
+
+    template <typename FNfloat>
+    void TransformDomainWarpCoordinate(FNfloat& x, FNfloat& y)
+    {
+        switch (mDomainWarpType)
+        {
+        case DomainWarpType_OpenSimplex2:
+        case DomainWarpType_OpenSimplex2Reduced:
+            {
+                const FNfloat SQRT3 = (FNfloat)1.7320508075688772935274463415059;
+                const FNfloat F2 = 0.5f * (SQRT3 - 1);
+                FNfloat t = (x + y) * F2;
+                x += t;
+                y += t;
+            }
+            break;
+        default:
+            break;
+        }
+    }
+
+    template <typename FNfloat>
+    void TransformDomainWarpCoordinate(FNfloat& x, FNfloat& y, FNfloat& z)
+    {
+        switch (mWarpTransformType3D)
+        {
+        case TransformType3D_ImproveXYPlanes:
+            {
+                FNfloat xy = x + y;
+                FNfloat s2 = xy * -(FNfloat)0.211324865405187;
+                z *= (FNfloat)0.577350269189626;
+                x += s2 - z;
+                y = y + s2 - z;
+                z += xy * (FNfloat)0.577350269189626;
+            }
+            break;
+        case TransformType3D_ImproveXZPlanes:
+            {
+                FNfloat xz = x + z;
+                FNfloat s2 = xz * -(FNfloat)0.211324865405187;
+                y *= (FNfloat)0.577350269189626;
+                x += s2 - y;
+                z += s2 - y;
+                y += xz * (FNfloat)0.577350269189626;
+            }
+            break;
+        case TransformType3D_DefaultOpenSimplex2:
+            {
+                const FNfloat R3 = (FNfloat)(2.0 / 3.0);
+                FNfloat r = (x + y + z) * R3; // Rotation, not skew
+                x = r - x;
+                y = r - y;
+                z = r - z;
+            }
+            break;
+        default:
+            break;
+        }
+    }
+
+    void UpdateWarpTransformType3D()
+    {
+        switch (mRotationType3D)
+        {
+        case RotationType3D_ImproveXYPlanes:
+            mWarpTransformType3D = TransformType3D_ImproveXYPlanes;
+            break;
+        case RotationType3D_ImproveXZPlanes:
+            mWarpTransformType3D = TransformType3D_ImproveXZPlanes;
+            break;
+        default:
+            switch (mDomainWarpType)
+            {
+            case DomainWarpType_OpenSimplex2:
+            case DomainWarpType_OpenSimplex2Reduced:
+                mWarpTransformType3D = TransformType3D_DefaultOpenSimplex2;
+                break;
+            default:
+                mWarpTransformType3D = TransformType3D_None;
+                break;
+            }
+            break;
+        }
+    }
+
+
+    // Fractal FBm
+
+    template <typename FNfloat>
+    float GenFractalFBm(FNfloat x, FNfloat y)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = GenNoiseSingle(seed++, x, y);
+            sum += noise * amp;
+            amp *= Lerp(1.0f, FastMin(noise + 1, 2) * 0.5f, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+    template <typename FNfloat>
+    float GenFractalFBm(FNfloat x, FNfloat y, FNfloat z)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = GenNoiseSingle(seed++, x, y, z);
+            sum += noise * amp;
+            amp *= Lerp(1.0f, (noise + 1) * 0.5f, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            z *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+
+    // Fractal Ridged
+
+    template <typename FNfloat>
+    float GenFractalRidged(FNfloat x, FNfloat y)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = FastAbs(GenNoiseSingle(seed++, x, y));
+            sum += (noise * -2 + 1) * amp;
+            amp *= Lerp(1.0f, 1 - noise, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+    template <typename FNfloat>
+    float GenFractalRidged(FNfloat x, FNfloat y, FNfloat z)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = FastAbs(GenNoiseSingle(seed++, x, y, z));
+            sum += (noise * -2 + 1) * amp;
+            amp *= Lerp(1.0f, 1 - noise, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            z *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+
+    // Fractal PingPong 
+
+    template <typename FNfloat>
+    float GenFractalPingPong(FNfloat x, FNfloat y)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = PingPong((GenNoiseSingle(seed++, x, y) + 1) * mPingPongStrength);
+            sum += (noise - 0.5f) * 2 * amp;
+            amp *= Lerp(1.0f, noise, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+    template <typename FNfloat>
+    float GenFractalPingPong(FNfloat x, FNfloat y, FNfloat z)
+    {
+        int seed = mSeed;
+        float sum = 0;
+        float amp = mFractalBounding;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            float noise = PingPong((GenNoiseSingle(seed++, x, y, z) + 1) * mPingPongStrength);
+            sum += (noise - 0.5f) * 2 * amp;
+            amp *= Lerp(1.0f, noise, mWeightedStrength);
+
+            x *= mLacunarity;
+            y *= mLacunarity;
+            z *= mLacunarity;
+            amp *= mGain;
+        }
+
+        return sum;
+    }
+
+
+    // Simplex/OpenSimplex2 Noise
+
+    template <typename FNfloat>
+    float SingleSimplex(int seed, FNfloat x, FNfloat y)
+    {
+        // 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex.
+
+        const float SQRT3 = 1.7320508075688772935274463415059f;
+        const float G2 = (3 - SQRT3) / 6;
+
+        /*
+         * --- Skew moved to TransformNoiseCoordinate method ---
+         * const FNfloat F2 = 0.5f * (SQRT3 - 1);
+         * FNfloat s = (x + y) * F2;
+         * x += s; y += s;
+        */
+
+        int i = FastFloor(x);
+        int j = FastFloor(y);
+        float xi = (float)(x - i);
+        float yi = (float)(y - j);
+
+        float t = (xi + yi) * G2;
+        float x0 = (float)(xi - t);
+        float y0 = (float)(yi - t);
+
+        i *= PrimeX;
+        j *= PrimeY;
+
+        float n0, n1, n2;
+
+        float a = 0.5f - x0 * x0 - y0 * y0;
+        if (a <= 0) n0 = 0;
+        else
+        {
+            n0 = (a * a) * (a * a) * GradCoord(seed, i, j, x0, y0);
+        }
+
+        float c = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a);
+        if (c <= 0) n2 = 0;
+        else
+        {
+            float x2 = x0 + (2 * (float)G2 - 1);
+            float y2 = y0 + (2 * (float)G2 - 1);
+            n2 = (c * c) * (c * c) * GradCoord(seed, i + PrimeX, j + PrimeY, x2, y2);
+        }
+
+        if (y0 > x0)
+        {
+            float x1 = x0 + (float)G2;
+            float y1 = y0 + ((float)G2 - 1);
+            float b = 0.5f - x1 * x1 - y1 * y1;
+            if (b <= 0) n1 = 0;
+            else
+            {
+                n1 = (b * b) * (b * b) * GradCoord(seed, i, j + PrimeY, x1, y1);
+            }
+        }
+        else
+        {
+            float x1 = x0 + ((float)G2 - 1);
+            float y1 = y0 + (float)G2;
+            float b = 0.5f - x1 * x1 - y1 * y1;
+            if (b <= 0) n1 = 0;
+            else
+            {
+                n1 = (b * b) * (b * b) * GradCoord(seed, i + PrimeX, j, x1, y1);
+            }
+        }
+
+        return (n0 + n1 + n2) * 99.83685446303647f;
+    }
+
+    template <typename FNfloat>
+    float SingleOpenSimplex2(int seed, FNfloat x, FNfloat y, FNfloat z)
+    {
+        // 3D OpenSimplex2 case uses two offset rotated cube grids.
+
+        /*
+         * --- Rotation moved to TransformNoiseCoordinate method ---
+         * const FNfloat R3 = (FNfloat)(2.0 / 3.0);
+         * FNfloat r = (x + y + z) * R3; // Rotation, not skew
+         * x = r - x; y = r - y; z = r - z;
+        */
+
+        int i = FastRound(x);
+        int j = FastRound(y);
+        int k = FastRound(z);
+        float x0 = (float)(x - i);
+        float y0 = (float)(y - j);
+        float z0 = (float)(z - k);
+
+        int xNSign = (int)(-1.0f - x0) | 1;
+        int yNSign = (int)(-1.0f - y0) | 1;
+        int zNSign = (int)(-1.0f - z0) | 1;
+
+        float ax0 = xNSign * -x0;
+        float ay0 = yNSign * -y0;
+        float az0 = zNSign * -z0;
+
+        i *= PrimeX;
+        j *= PrimeY;
+        k *= PrimeZ;
+
+        float value = 0;
+        float a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0);
+
+        for (int l = 0; ; l++)
+        {
+            if (a > 0)
+            {
+                value += (a * a) * (a * a) * GradCoord(seed, i, j, k, x0, y0, z0);
+            }
+
+            float b = a + 1;
+            int i1 = i;
+            int j1 = j;
+            int k1 = k;
+            float x1 = x0;
+            float y1 = y0;
+            float z1 = z0;
+
+            if (ax0 >= ay0 && ax0 >= az0)
+            {
+                x1 += xNSign;
+                b -= xNSign * 2 * x1;
+                i1 -= xNSign * PrimeX;
+            }
+            else if (ay0 > ax0 && ay0 >= az0)
+            {
+                y1 += yNSign;
+                b -= yNSign * 2 * y1;
+                j1 -= yNSign * PrimeY;
+            }
+            else
+            {
+                z1 += zNSign;
+                b -= zNSign * 2 * z1;
+                k1 -= zNSign * PrimeZ;
+            }
+
+            if (b > 0)
+            {
+                value += (b * b) * (b * b) * GradCoord(seed, i1, j1, k1, x1, y1, z1);
+            }
+
+            if (l == 1) break;
+
+            ax0 = 0.5f - ax0;
+            ay0 = 0.5f - ay0;
+            az0 = 0.5f - az0;
+
+            x0 = xNSign * ax0;
+            y0 = yNSign * ay0;
+            z0 = zNSign * az0;
+
+            a += (0.75f - ax0) - (ay0 + az0);
+
+            i += (xNSign >> 1) & PrimeX;
+            j += (yNSign >> 1) & PrimeY;
+            k += (zNSign >> 1) & PrimeZ;
+
+            xNSign = -xNSign;
+            yNSign = -yNSign;
+            zNSign = -zNSign;
+
+            seed = ~seed;
+        }
+
+        return value * 32.69428253173828125f;
+    }
+
+
+    // OpenSimplex2S Noise
+
+    template <typename FNfloat>
+    float SingleOpenSimplex2S(int seed, FNfloat x, FNfloat y)
+    {
+        // 2D OpenSimplex2S case is a modified 2D simplex noise.
+
+        const FNfloat SQRT3 = (FNfloat)1.7320508075688772935274463415059;
+        const FNfloat G2 = (3 - SQRT3) / 6;
+
+        /*
+         * --- Skew moved to TransformNoiseCoordinate method ---
+         * const FNfloat F2 = 0.5f * (SQRT3 - 1);
+         * FNfloat s = (x + y) * F2;
+         * x += s; y += s;
+        */
+
+        int i = FastFloor(x);
+        int j = FastFloor(y);
+        float xi = (float)(x - i);
+        float yi = (float)(y - j);
+
+        i *= PrimeX;
+        j *= PrimeY;
+        int i1 = i + PrimeX;
+        int j1 = j + PrimeY;
+
+        float t = (xi + yi) * (float)G2;
+        float x0 = xi - t;
+        float y0 = yi - t;
+
+        float a0 = (2.0f / 3.0f) - x0 * x0 - y0 * y0;
+        float value = (a0 * a0) * (a0 * a0) * GradCoord(seed, i, j, x0, y0);
+
+        float a1 = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a0);
+        float x1 = x0 - (float)(1 - 2 * G2);
+        float y1 = y0 - (float)(1 - 2 * G2);
+        value += (a1 * a1) * (a1 * a1) * GradCoord(seed, i1, j1, x1, y1);
+
+        // Nested conditionals were faster than compact bit logic/arithmetic.
+        float xmyi = xi - yi;
+        if (t > G2)
+        {
+            if (xi + xmyi > 1)
+            {
+                float x2 = x0 + (float)(3 * G2 - 2);
+                float y2 = y0 + (float)(3 * G2 - 1);
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i + (PrimeX << 1), j + PrimeY, x2, y2);
+                }
+            }
+            else
+            {
+                float x2 = x0 + (float)G2;
+                float y2 = y0 + (float)(G2 - 1);
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i, j + PrimeY, x2, y2);
+                }
+            }
+
+            if (yi - xmyi > 1)
+            {
+                float x3 = x0 + (float)(3 * G2 - 1);
+                float y3 = y0 + (float)(3 * G2 - 2);
+                float a3 = (2.0f / 3.0f) - x3 * x3 - y3 * y3;
+                if (a3 > 0)
+                {
+                    value += (a3 * a3) * (a3 * a3) * GradCoord(seed, i + PrimeX, j + (PrimeY << 1), x3, y3);
+                }
+            }
+            else
+            {
+                float x3 = x0 + (float)(G2 - 1);
+                float y3 = y0 + (float)G2;
+                float a3 = (2.0f / 3.0f) - x3 * x3 - y3 * y3;
+                if (a3 > 0)
+                {
+                    value += (a3 * a3) * (a3 * a3) * GradCoord(seed, i + PrimeX, j, x3, y3);
+                }
+            }
+        }
+        else
+        {
+            if (xi + xmyi < 0)
+            {
+                float x2 = x0 + (float)(1 - G2);
+                float y2 = y0 - (float)G2;
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i - PrimeX, j, x2, y2);
+                }
+            }
+            else
+            {
+                float x2 = x0 + (float)(G2 - 1);
+                float y2 = y0 + (float)G2;
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i + PrimeX, j, x2, y2);
+                }
+            }
+
+            if (yi < xmyi)
+            {
+                float x2 = x0 - (float)G2;
+                float y2 = y0 - (float)(G2 - 1);
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i, j - PrimeY, x2, y2);
+                }
+            }
+            else
+            {
+                float x2 = x0 + (float)G2;
+                float y2 = y0 + (float)(G2 - 1);
+                float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+                if (a2 > 0)
+                {
+                    value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i, j + PrimeY, x2, y2);
+                }
+            }
+        }
+
+        return value * 18.24196194486065f;
+    }
+
+    template <typename FNfloat>
+    float SingleOpenSimplex2S(int seed, FNfloat x, FNfloat y, FNfloat z)
+    {
+        // 3D OpenSimplex2S case uses two offset rotated cube grids.
+
+        /*
+         * --- Rotation moved to TransformNoiseCoordinate method ---
+         * const FNfloat R3 = (FNfloat)(2.0 / 3.0);
+         * FNfloat r = (x + y + z) * R3; // Rotation, not skew
+         * x = r - x; y = r - y; z = r - z;
+        */
+
+        int i = FastFloor(x);
+        int j = FastFloor(y);
+        int k = FastFloor(z);
+        float xi = (float)(x - i);
+        float yi = (float)(y - j);
+        float zi = (float)(z - k);
+
+        i *= PrimeX;
+        j *= PrimeY;
+        k *= PrimeZ;
+        int seed2 = seed + 1293373;
+
+        int xNMask = (int)(-0.5f - xi);
+        int yNMask = (int)(-0.5f - yi);
+        int zNMask = (int)(-0.5f - zi);
+
+        float x0 = xi + xNMask;
+        float y0 = yi + yNMask;
+        float z0 = zi + zNMask;
+        float a0 = 0.75f - x0 * x0 - y0 * y0 - z0 * z0;
+        float value = (a0 * a0) * (a0 * a0) * GradCoord(seed,
+                                                        i + (xNMask & PrimeX), j + (yNMask & PrimeY), k + (zNMask & PrimeZ), x0, y0, z0);
+
+        float x1 = xi - 0.5f;
+        float y1 = yi - 0.5f;
+        float z1 = zi - 0.5f;
+        float a1 = 0.75f - x1 * x1 - y1 * y1 - z1 * z1;
+        value += (a1 * a1) * (a1 * a1) * GradCoord(seed2,
+                                                   i + PrimeX, j + PrimeY, k + PrimeZ, x1, y1, z1);
+
+        float xAFlipMask0 = ((xNMask | 1) << 1) * x1;
+        float yAFlipMask0 = ((yNMask | 1) << 1) * y1;
+        float zAFlipMask0 = ((zNMask | 1) << 1) * z1;
+        float xAFlipMask1 = (-2 - (xNMask << 2)) * x1 - 1.0f;
+        float yAFlipMask1 = (-2 - (yNMask << 2)) * y1 - 1.0f;
+        float zAFlipMask1 = (-2 - (zNMask << 2)) * z1 - 1.0f;
+
+        bool skip5 = false;
+        float a2 = xAFlipMask0 + a0;
+        if (a2 > 0)
+        {
+            float x2 = x0 - (xNMask | 1);
+            float y2 = y0;
+            float z2 = z0;
+            value += (a2 * a2) * (a2 * a2) * GradCoord(seed,
+                                                       i + (~xNMask & PrimeX), j + (yNMask & PrimeY), k + (zNMask & PrimeZ), x2, y2, z2);
+        }
+        else
+        {
+            float a3 = yAFlipMask0 + zAFlipMask0 + a0;
+            if (a3 > 0)
+            {
+                float x3 = x0;
+                float y3 = y0 - (yNMask | 1);
+                float z3 = z0 - (zNMask | 1);
+                value += (a3 * a3) * (a3 * a3) * GradCoord(seed,
+                                                           i + (xNMask & PrimeX), j + (~yNMask & PrimeY), k + (~zNMask & PrimeZ), x3, y3, z3);
+            }
+
+            float a4 = xAFlipMask1 + a1;
+            if (a4 > 0)
+            {
+                float x4 = (xNMask | 1) + x1;
+                float y4 = y1;
+                float z4 = z1;
+                value += (a4 * a4) * (a4 * a4) * GradCoord(seed2,
+                                                           i + (xNMask & (PrimeX * 2)), j + PrimeY, k + PrimeZ, x4, y4, z4);
+                skip5 = true;
+            }
+        }
+
+        bool skip9 = false;
+        float a6 = yAFlipMask0 + a0;
+        if (a6 > 0)
+        {
+            float x6 = x0;
+            float y6 = y0 - (yNMask | 1);
+            float z6 = z0;
+            value += (a6 * a6) * (a6 * a6) * GradCoord(seed,
+                                                       i + (xNMask & PrimeX), j + (~yNMask & PrimeY), k + (zNMask & PrimeZ), x6, y6, z6);
+        }
+        else
+        {
+            float a7 = xAFlipMask0 + zAFlipMask0 + a0;
+            if (a7 > 0)
+            {
+                float x7 = x0 - (xNMask | 1);
+                float y7 = y0;
+                float z7 = z0 - (zNMask | 1);
+                value += (a7 * a7) * (a7 * a7) * GradCoord(seed,
+                                                           i + (~xNMask & PrimeX), j + (yNMask & PrimeY), k + (~zNMask & PrimeZ), x7, y7, z7);
+            }
+
+            float a8 = yAFlipMask1 + a1;
+            if (a8 > 0)
+            {
+                float x8 = x1;
+                float y8 = (yNMask | 1) + y1;
+                float z8 = z1;
+                value += (a8 * a8) * (a8 * a8) * GradCoord(seed2,
+                                                           i + PrimeX, j + (yNMask & (PrimeY << 1)), k + PrimeZ, x8, y8, z8);
+                skip9 = true;
+            }
+        }
+
+        bool skipD = false;
+        float aA = zAFlipMask0 + a0;
+        if (aA > 0)
+        {
+            float xA = x0;
+            float yA = y0;
+            float zA = z0 - (zNMask | 1);
+            value += (aA * aA) * (aA * aA) * GradCoord(seed,
+                                                       i + (xNMask & PrimeX), j + (yNMask & PrimeY), k + (~zNMask & PrimeZ), xA, yA, zA);
+        }
+        else
+        {
+            float aB = xAFlipMask0 + yAFlipMask0 + a0;
+            if (aB > 0)
+            {
+                float xB = x0 - (xNMask | 1);
+                float yB = y0 - (yNMask | 1);
+                float zB = z0;
+                value += (aB * aB) * (aB * aB) * GradCoord(seed,
+                                                           i + (~xNMask & PrimeX), j + (~yNMask & PrimeY), k + (zNMask & PrimeZ), xB, yB, zB);
+            }
+
+            float aC = zAFlipMask1 + a1;
+            if (aC > 0)
+            {
+                float xC = x1;
+                float yC = y1;
+                float zC = (zNMask | 1) + z1;
+                value += (aC * aC) * (aC * aC) * GradCoord(seed2,
+                                                           i + PrimeX, j + PrimeY, k + (zNMask & (PrimeZ << 1)), xC, yC, zC);
+                skipD = true;
+            }
+        }
+
+        if (!skip5)
+        {
+            float a5 = yAFlipMask1 + zAFlipMask1 + a1;
+            if (a5 > 0)
+            {
+                float x5 = x1;
+                float y5 = (yNMask | 1) + y1;
+                float z5 = (zNMask | 1) + z1;
+                value += (a5 * a5) * (a5 * a5) * GradCoord(seed2,
+                                                           i + PrimeX, j + (yNMask & (PrimeY << 1)), k + (zNMask & (PrimeZ << 1)), x5, y5, z5);
+            }
+        }
+
+        if (!skip9)
+        {
+            float a9 = xAFlipMask1 + zAFlipMask1 + a1;
+            if (a9 > 0)
+            {
+                float x9 = (xNMask | 1) + x1;
+                float y9 = y1;
+                float z9 = (zNMask | 1) + z1;
+                value += (a9 * a9) * (a9 * a9) * GradCoord(seed2,
+                                                           i + (xNMask & (PrimeX * 2)), j + PrimeY, k + (zNMask & (PrimeZ << 1)), x9, y9, z9);
+            }
+        }
+
+        if (!skipD)
+        {
+            float aD = xAFlipMask1 + yAFlipMask1 + a1;
+            if (aD > 0)
+            {
+                float xD = (xNMask | 1) + x1;
+                float yD = (yNMask | 1) + y1;
+                float zD = z1;
+                value += (aD * aD) * (aD * aD) * GradCoord(seed2,
+                                                           i + (xNMask & (PrimeX << 1)), j + (yNMask & (PrimeY << 1)), k + PrimeZ, xD, yD, zD);
+            }
+        }
+
+        return value * 9.046026385208288f;
+    }
+
+
+    // Cellular Noise
+
+    template <typename FNfloat>
+    float SingleCellular(int seed, FNfloat x, FNfloat y)
+    {
+        int xr = FastRound(x);
+        int yr = FastRound(y);
+
+        float distance0 = 1e10f;
+        float distance1 = 1e10f;
+        int closestHash = 0;
+
+        float cellularJitter = 0.43701595f * mCellularJitterModifier;
+
+        int xPrimed = (xr - 1) * PrimeX;
+        int yPrimedBase = (yr - 1) * PrimeY;
+
+        switch (mCellularDistanceFunction)
+        {
+        default:
+        case CellularDistanceFunction_Euclidean:
+        case CellularDistanceFunction_EuclideanSq:
+            for (int xi = xr - 1; xi <= xr + 1; xi++)
+            {
+                int yPrimed = yPrimedBase;
+
+                for (int yi = yr - 1; yi <= yr + 1; yi++)
+                {
+                    int hash = Hash(seed, xPrimed, yPrimed);
+                    int idx = hash & (255 << 1);
+
+                    float vecX = (float)(xi - x) + Lookup<float>::RandVecs2D[idx] * cellularJitter;
+                    float vecY = (float)(yi - y) + Lookup<float>::RandVecs2D[idx | 1] * cellularJitter;
+
+                    float newDistance = vecX * vecX + vecY * vecY;
+
+                    distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                    if (newDistance < distance0)
+                    {
+                        distance0 = newDistance;
+                        closestHash = hash;
+                    }
+                    yPrimed += PrimeY;
+                }
+                xPrimed += PrimeX;
+            }
+            break;
+        case CellularDistanceFunction_Manhattan:
+            for (int xi = xr - 1; xi <= xr + 1; xi++)
+            {
+                int yPrimed = yPrimedBase;
+
+                for (int yi = yr - 1; yi <= yr + 1; yi++)
+                {
+                    int hash = Hash(seed, xPrimed, yPrimed);
+                    int idx = hash & (255 << 1);
+
+                    float vecX = (float)(xi - x) + Lookup<float>::RandVecs2D[idx] * cellularJitter;
+                    float vecY = (float)(yi - y) + Lookup<float>::RandVecs2D[idx | 1] * cellularJitter;
+
+                    float newDistance = FastAbs(vecX) + FastAbs(vecY);
+
+                    distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                    if (newDistance < distance0)
+                    {
+                        distance0 = newDistance;
+                        closestHash = hash;
+                    }
+                    yPrimed += PrimeY;
+                }
+                xPrimed += PrimeX;
+            }
+            break;
+        case CellularDistanceFunction_Hybrid:
+            for (int xi = xr - 1; xi <= xr + 1; xi++)
+            {
+                int yPrimed = yPrimedBase;
+
+                for (int yi = yr - 1; yi <= yr + 1; yi++)
+                {
+                    int hash = Hash(seed, xPrimed, yPrimed);
+                    int idx = hash & (255 << 1);
+
+                    float vecX = (float)(xi - x) + Lookup<float>::RandVecs2D[idx] * cellularJitter;
+                    float vecY = (float)(yi - y) + Lookup<float>::RandVecs2D[idx | 1] * cellularJitter;
+
+                    float newDistance = (FastAbs(vecX) + FastAbs(vecY)) + (vecX * vecX + vecY * vecY);
+
+                    distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                    if (newDistance < distance0)
+                    {
+                        distance0 = newDistance;
+                        closestHash = hash;
+                    }
+                    yPrimed += PrimeY;
+                }
+                xPrimed += PrimeX;
+            }
+            break;
+        }
+
+        if (mCellularDistanceFunction == CellularDistanceFunction_Euclidean && mCellularReturnType >= CellularReturnType_Distance)
+        {
+            distance0 = FastSqrt(distance0);
+
+            if (mCellularReturnType >= CellularReturnType_Distance2)
+            {
+                distance1 = FastSqrt(distance1);
+            }
+        }
+
+        switch (mCellularReturnType)
+        {
+        case CellularReturnType_CellValue:
+            return closestHash * (1 / 2147483648.0f);
+        case CellularReturnType_Distance:
+            return distance0 - 1;
+        case CellularReturnType_Distance2:
+            return distance1 - 1;
+        case CellularReturnType_Distance2Add:
+            return (distance1 + distance0) * 0.5f - 1;
+        case CellularReturnType_Distance2Sub:
+            return distance1 - distance0 - 1;
+        case CellularReturnType_Distance2Mul:
+            return distance1 * distance0 * 0.5f - 1;
+        case CellularReturnType_Distance2Div:
+            return distance0 / distance1 - 1;
+        default:
+            return 0;
+        }
+    }
+
+    template <typename FNfloat>
+    float SingleCellular(int seed, FNfloat x, FNfloat y, FNfloat z)
+    {
+        int xr = FastRound(x);
+        int yr = FastRound(y);
+        int zr = FastRound(z);
+
+        float distance0 = 1e10f;
+        float distance1 = 1e10f;
+        int closestHash = 0;
+
+        float cellularJitter = 0.39614353f * mCellularJitterModifier;
+
+        int xPrimed = (xr - 1) * PrimeX;
+        int yPrimedBase = (yr - 1) * PrimeY;
+        int zPrimedBase = (zr - 1) * PrimeZ;
+
+        switch (mCellularDistanceFunction)
+        {
+        case CellularDistanceFunction_Euclidean:
+        case CellularDistanceFunction_EuclideanSq:
+            for (int xi = xr - 1; xi <= xr + 1; xi++)
+            {
+                int yPrimed = yPrimedBase;
+
+                for (int yi = yr - 1; yi <= yr + 1; yi++)
+                {
+                    int zPrimed = zPrimedBase;
+
+                    for (int zi = zr - 1; zi <= zr + 1; zi++)
+                    {
+                        int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+                        int idx = hash & (255 << 2);
+
+                        float vecX = (float)(xi - x) + Lookup<float>::RandVecs3D[idx] * cellularJitter;
+                        float vecY = (float)(yi - y) + Lookup<float>::RandVecs3D[idx | 1] * cellularJitter;
+                        float vecZ = (float)(zi - z) + Lookup<float>::RandVecs3D[idx | 2] * cellularJitter;
+
+                        float newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ;
+
+                        distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                        if (newDistance < distance0)
+                        {
+                            distance0 = newDistance;
+                            closestHash = hash;
+                        }
+                        zPrimed += PrimeZ;
+                    }
+                    yPrimed += PrimeY;
+                }
+                xPrimed += PrimeX;
+            }
+            break;
+        case CellularDistanceFunction_Manhattan:
+            for (int xi = xr - 1; xi <= xr + 1; xi++)
+            {
+                int yPrimed = yPrimedBase;
+
+                for (int yi = yr - 1; yi <= yr + 1; yi++)
+                {
+                    int zPrimed = zPrimedBase;
+
+                    for (int zi = zr - 1; zi <= zr + 1; zi++)
+                    {
+                        int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+                        int idx = hash & (255 << 2);
+
+                        float vecX = (float)(xi - x) + Lookup<float>::RandVecs3D[idx] * cellularJitter;
+                        float vecY = (float)(yi - y) + Lookup<float>::RandVecs3D[idx | 1] * cellularJitter;
+                        float vecZ = (float)(zi - z) + Lookup<float>::RandVecs3D[idx | 2] * cellularJitter;
+
+                        float newDistance = FastAbs(vecX) + FastAbs(vecY) + FastAbs(vecZ);
+
+                        distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                        if (newDistance < distance0)
+                        {
+                            distance0 = newDistance;
+                            closestHash = hash;
+                        }
+                        zPrimed += PrimeZ;
+                    }
+                    yPrimed += PrimeY;
+                }
+                xPrimed += PrimeX;
+            }
+            break;
+        case CellularDistanceFunction_Hybrid:
+            for (int xi = xr - 1; xi <= xr + 1; xi++)
+            {
+                int yPrimed = yPrimedBase;
+
+                for (int yi = yr - 1; yi <= yr + 1; yi++)
+                {
+                    int zPrimed = zPrimedBase;
+
+                    for (int zi = zr - 1; zi <= zr + 1; zi++)
+                    {
+                        int hash = Hash(seed, xPrimed, yPrimed, zPrimed);
+                        int idx = hash & (255 << 2);
+
+                        float vecX = (float)(xi - x) + Lookup<float>::RandVecs3D[idx] * cellularJitter;
+                        float vecY = (float)(yi - y) + Lookup<float>::RandVecs3D[idx | 1] * cellularJitter;
+                        float vecZ = (float)(zi - z) + Lookup<float>::RandVecs3D[idx | 2] * cellularJitter;
+
+                        float newDistance = (FastAbs(vecX) + FastAbs(vecY) + FastAbs(vecZ)) + (vecX * vecX + vecY * vecY + vecZ * vecZ);
+
+                        distance1 = FastMax(FastMin(distance1, newDistance), distance0);
+                        if (newDistance < distance0)
+                        {
+                            distance0 = newDistance;
+                            closestHash = hash;
+                        }
+                        zPrimed += PrimeZ;
+                    }
+                    yPrimed += PrimeY;
+                }
+                xPrimed += PrimeX;
+            }
+            break;
+        default:
+            break;
+        }
+
+        if (mCellularDistanceFunction == CellularDistanceFunction_Euclidean && mCellularReturnType >= CellularReturnType_Distance)
+        {
+            distance0 = FastSqrt(distance0);
+
+            if (mCellularReturnType >= CellularReturnType_Distance2)
+            {
+                distance1 = FastSqrt(distance1);
+            }
+        }
+
+        switch (mCellularReturnType)
+        {
+        case CellularReturnType_CellValue:
+            return closestHash * (1 / 2147483648.0f);
+        case CellularReturnType_Distance:
+            return distance0 - 1;
+        case CellularReturnType_Distance2:
+            return distance1 - 1;
+        case CellularReturnType_Distance2Add:
+            return (distance1 + distance0) * 0.5f - 1;
+        case CellularReturnType_Distance2Sub:
+            return distance1 - distance0 - 1;
+        case CellularReturnType_Distance2Mul:
+            return distance1 * distance0 * 0.5f - 1;
+        case CellularReturnType_Distance2Div:
+            return distance0 / distance1 - 1;
+        default:
+            return 0;
+        }
+    }
+
+
+    // Perlin Noise
+
+    template <typename FNfloat>
+    float SinglePerlin(int seed, FNfloat x, FNfloat y)
+    {
+        int x0 = FastFloor(x);
+        int y0 = FastFloor(y);
+
+        float xd0 = (float)(x - x0);
+        float yd0 = (float)(y - y0);
+        float xd1 = xd0 - 1;
+        float yd1 = yd0 - 1;
+
+        float xs = InterpQuintic(xd0);
+        float ys = InterpQuintic(yd0);
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+
+        float xf0 = Lerp(GradCoord(seed, x0, y0, xd0, yd0), GradCoord(seed, x1, y0, xd1, yd0), xs);
+        float xf1 = Lerp(GradCoord(seed, x0, y1, xd0, yd1), GradCoord(seed, x1, y1, xd1, yd1), xs);
+
+        return Lerp(xf0, xf1, ys) * 1.4247691104677813f;
+    }
+
+    template <typename FNfloat>
+    float SinglePerlin(int seed, FNfloat x, FNfloat y, FNfloat z)
+    {
+        int x0 = FastFloor(x);
+        int y0 = FastFloor(y);
+        int z0 = FastFloor(z);
+
+        float xd0 = (float)(x - x0);
+        float yd0 = (float)(y - y0);
+        float zd0 = (float)(z - z0);
+        float xd1 = xd0 - 1;
+        float yd1 = yd0 - 1;
+        float zd1 = zd0 - 1;
+
+        float xs = InterpQuintic(xd0);
+        float ys = InterpQuintic(yd0);
+        float zs = InterpQuintic(zd0);
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        z0 *= PrimeZ;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+        int z1 = z0 + PrimeZ;
+
+        float xf00 = Lerp(GradCoord(seed, x0, y0, z0, xd0, yd0, zd0), GradCoord(seed, x1, y0, z0, xd1, yd0, zd0), xs);
+        float xf10 = Lerp(GradCoord(seed, x0, y1, z0, xd0, yd1, zd0), GradCoord(seed, x1, y1, z0, xd1, yd1, zd0), xs);
+        float xf01 = Lerp(GradCoord(seed, x0, y0, z1, xd0, yd0, zd1), GradCoord(seed, x1, y0, z1, xd1, yd0, zd1), xs);
+        float xf11 = Lerp(GradCoord(seed, x0, y1, z1, xd0, yd1, zd1), GradCoord(seed, x1, y1, z1, xd1, yd1, zd1), xs);
+
+        float yf0 = Lerp(xf00, xf10, ys);
+        float yf1 = Lerp(xf01, xf11, ys);
+
+        return Lerp(yf0, yf1, zs) * 0.964921414852142333984375f;
+    }
+
+
+    // Value Cubic Noise
+
+    template <typename FNfloat>
+    float SingleValueCubic(int seed, FNfloat x, FNfloat y)
+    {
+        int x1 = FastFloor(x);
+        int y1 = FastFloor(y);
+
+        float xs = (float)(x - x1);
+        float ys = (float)(y - y1);
+
+        x1 *= PrimeX;
+        y1 *= PrimeY;
+        int x0 = x1 - PrimeX;
+        int y0 = y1 - PrimeY;
+        int x2 = x1 + PrimeX;
+        int y2 = y1 + PrimeY;
+        int x3 = x1 + (int)((long)PrimeX << 1);
+        int y3 = y1 + (int)((long)PrimeY << 1);
+
+        return CubicLerp(
+            CubicLerp(ValCoord(seed, x0, y0), ValCoord(seed, x1, y0), ValCoord(seed, x2, y0), ValCoord(seed, x3, y0),
+                      xs),
+            CubicLerp(ValCoord(seed, x0, y1), ValCoord(seed, x1, y1), ValCoord(seed, x2, y1), ValCoord(seed, x3, y1),
+                      xs),
+            CubicLerp(ValCoord(seed, x0, y2), ValCoord(seed, x1, y2), ValCoord(seed, x2, y2), ValCoord(seed, x3, y2),
+                      xs),
+            CubicLerp(ValCoord(seed, x0, y3), ValCoord(seed, x1, y3), ValCoord(seed, x2, y3), ValCoord(seed, x3, y3),
+                      xs),
+            ys) * (1 / (1.5f * 1.5f));
+    }
+
+    template <typename FNfloat>
+    float SingleValueCubic(int seed, FNfloat x, FNfloat y, FNfloat z)
+    {
+        int x1 = FastFloor(x);
+        int y1 = FastFloor(y);
+        int z1 = FastFloor(z);
+
+        float xs = (float)(x - x1);
+        float ys = (float)(y - y1);
+        float zs = (float)(z - z1);
+
+        x1 *= PrimeX;
+        y1 *= PrimeY;
+        z1 *= PrimeZ;
+
+        int x0 = x1 - PrimeX;
+        int y0 = y1 - PrimeY;
+        int z0 = z1 - PrimeZ;
+        int x2 = x1 + PrimeX;
+        int y2 = y1 + PrimeY;
+        int z2 = z1 + PrimeZ;
+        int x3 = x1 + (int)((long)PrimeX << 1);
+        int y3 = y1 + (int)((long)PrimeY << 1);
+        int z3 = z1 + (int)((long)PrimeZ << 1);
+
+
+        return CubicLerp(
+            CubicLerp(
+                CubicLerp(ValCoord(seed, x0, y0, z0), ValCoord(seed, x1, y0, z0), ValCoord(seed, x2, y0, z0), ValCoord(seed, x3, y0, z0), xs),
+                CubicLerp(ValCoord(seed, x0, y1, z0), ValCoord(seed, x1, y1, z0), ValCoord(seed, x2, y1, z0), ValCoord(seed, x3, y1, z0), xs),
+                CubicLerp(ValCoord(seed, x0, y2, z0), ValCoord(seed, x1, y2, z0), ValCoord(seed, x2, y2, z0), ValCoord(seed, x3, y2, z0), xs),
+                CubicLerp(ValCoord(seed, x0, y3, z0), ValCoord(seed, x1, y3, z0), ValCoord(seed, x2, y3, z0), ValCoord(seed, x3, y3, z0), xs),
+                ys),
+            CubicLerp(
+                CubicLerp(ValCoord(seed, x0, y0, z1), ValCoord(seed, x1, y0, z1), ValCoord(seed, x2, y0, z1), ValCoord(seed, x3, y0, z1), xs),
+                CubicLerp(ValCoord(seed, x0, y1, z1), ValCoord(seed, x1, y1, z1), ValCoord(seed, x2, y1, z1), ValCoord(seed, x3, y1, z1), xs),
+                CubicLerp(ValCoord(seed, x0, y2, z1), ValCoord(seed, x1, y2, z1), ValCoord(seed, x2, y2, z1), ValCoord(seed, x3, y2, z1), xs),
+                CubicLerp(ValCoord(seed, x0, y3, z1), ValCoord(seed, x1, y3, z1), ValCoord(seed, x2, y3, z1), ValCoord(seed, x3, y3, z1), xs),
+                ys),
+            CubicLerp(
+                CubicLerp(ValCoord(seed, x0, y0, z2), ValCoord(seed, x1, y0, z2), ValCoord(seed, x2, y0, z2), ValCoord(seed, x3, y0, z2), xs),
+                CubicLerp(ValCoord(seed, x0, y1, z2), ValCoord(seed, x1, y1, z2), ValCoord(seed, x2, y1, z2), ValCoord(seed, x3, y1, z2), xs),
+                CubicLerp(ValCoord(seed, x0, y2, z2), ValCoord(seed, x1, y2, z2), ValCoord(seed, x2, y2, z2), ValCoord(seed, x3, y2, z2), xs),
+                CubicLerp(ValCoord(seed, x0, y3, z2), ValCoord(seed, x1, y3, z2), ValCoord(seed, x2, y3, z2), ValCoord(seed, x3, y3, z2), xs),
+                ys),
+            CubicLerp(
+                CubicLerp(ValCoord(seed, x0, y0, z3), ValCoord(seed, x1, y0, z3), ValCoord(seed, x2, y0, z3), ValCoord(seed, x3, y0, z3), xs),
+                CubicLerp(ValCoord(seed, x0, y1, z3), ValCoord(seed, x1, y1, z3), ValCoord(seed, x2, y1, z3), ValCoord(seed, x3, y1, z3), xs),
+                CubicLerp(ValCoord(seed, x0, y2, z3), ValCoord(seed, x1, y2, z3), ValCoord(seed, x2, y2, z3), ValCoord(seed, x3, y2, z3), xs),
+                CubicLerp(ValCoord(seed, x0, y3, z3), ValCoord(seed, x1, y3, z3), ValCoord(seed, x2, y3, z3), ValCoord(seed, x3, y3, z3), xs),
+                ys),
+            zs) * (1 / (1.5f * 1.5f * 1.5f));
+    }
+
+
+    // Value Noise
+
+    template <typename FNfloat>
+    float SingleValue(int seed, FNfloat x, FNfloat y)
+    {
+        int x0 = FastFloor(x);
+        int y0 = FastFloor(y);
+
+        float xs = InterpHermite((float)(x - x0));
+        float ys = InterpHermite((float)(y - y0));
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+
+        float xf0 = Lerp(ValCoord(seed, x0, y0), ValCoord(seed, x1, y0), xs);
+        float xf1 = Lerp(ValCoord(seed, x0, y1), ValCoord(seed, x1, y1), xs);
+
+        return Lerp(xf0, xf1, ys);
+    }
+
+    template <typename FNfloat>
+    float SingleValue(int seed, FNfloat x, FNfloat y, FNfloat z)
+    {
+        int x0 = FastFloor(x);
+        int y0 = FastFloor(y);
+        int z0 = FastFloor(z);
+
+        float xs = InterpHermite((float)(x - x0));
+        float ys = InterpHermite((float)(y - y0));
+        float zs = InterpHermite((float)(z - z0));
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        z0 *= PrimeZ;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+        int z1 = z0 + PrimeZ;
+
+        float xf00 = Lerp(ValCoord(seed, x0, y0, z0), ValCoord(seed, x1, y0, z0), xs);
+        float xf10 = Lerp(ValCoord(seed, x0, y1, z0), ValCoord(seed, x1, y1, z0), xs);
+        float xf01 = Lerp(ValCoord(seed, x0, y0, z1), ValCoord(seed, x1, y0, z1), xs);
+        float xf11 = Lerp(ValCoord(seed, x0, y1, z1), ValCoord(seed, x1, y1, z1), xs);
+
+        float yf0 = Lerp(xf00, xf10, ys);
+        float yf1 = Lerp(xf01, xf11, ys);
+
+        return Lerp(yf0, yf1, zs);
+    }
+
+
+    // Domain Warp
+
+    template <typename FNfloat>
+    void DoSingleDomainWarp(int seed, float amp, float freq, FNfloat x, FNfloat y, FNfloat& xr, FNfloat& yr)
+    {
+        switch (mDomainWarpType)
+        {
+        case DomainWarpType_OpenSimplex2:
+            SingleDomainWarpSimplexGradient(seed, amp * 38.283687591552734375f, freq, x, y, xr, yr, false);
+            break;
+        case DomainWarpType_OpenSimplex2Reduced:
+            SingleDomainWarpSimplexGradient(seed, amp * 16.0f, freq, x, y, xr, yr, true);
+            break;
+        case DomainWarpType_BasicGrid:
+            SingleDomainWarpBasicGrid(seed, amp, freq, x, y, xr, yr);
+            break;
+        }
+    }
+
+    template <typename FNfloat>
+    void DoSingleDomainWarp(int seed, float amp, float freq, FNfloat x, FNfloat y, FNfloat z, FNfloat& xr, FNfloat& yr, FNfloat& zr)
+    {
+        switch (mDomainWarpType)
+        {
+        case DomainWarpType_OpenSimplex2:
+            SingleDomainWarpOpenSimplex2Gradient(seed, amp * 32.69428253173828125f, freq, x, y, z, xr, yr, zr, false);
+            break;
+        case DomainWarpType_OpenSimplex2Reduced:
+            SingleDomainWarpOpenSimplex2Gradient(seed, amp * 7.71604938271605f, freq, x, y, z, xr, yr, zr, true);
+            break;
+        case DomainWarpType_BasicGrid:
+            SingleDomainWarpBasicGrid(seed, amp, freq, x, y, z, xr, yr, zr);
+            break;
+        }
+    }
+
+
+    // Domain Warp Single Wrapper
+
+    template <typename FNfloat>
+    void DomainWarpSingle(FNfloat& x, FNfloat& y)
+    {
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        FNfloat xs = x;
+        FNfloat ys = y;
+        TransformDomainWarpCoordinate(xs, ys);
+
+        DoSingleDomainWarp(seed, amp, freq, xs, ys, x, y);
+    }
+
+    template <typename FNfloat>
+    void DomainWarpSingle(FNfloat& x, FNfloat& y, FNfloat& z)
+    {
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        FNfloat xs = x;
+        FNfloat ys = y;
+        FNfloat zs = z;
+        TransformDomainWarpCoordinate(xs, ys, zs);
+
+        DoSingleDomainWarp(seed, amp, freq, xs, ys, zs, x, y, z);
+    }
+
+
+    // Domain Warp Fractal Progressive
+
+    template <typename FNfloat>
+    void DomainWarpFractalProgressive(FNfloat& x, FNfloat& y)
+    {
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            FNfloat xs = x;
+            FNfloat ys = y;
+            TransformDomainWarpCoordinate(xs, ys);
+
+            DoSingleDomainWarp(seed, amp, freq, xs, ys, x, y);
+
+            seed++;
+            amp *= mGain;
+            freq *= mLacunarity;
+        }
+    }
+
+    template <typename FNfloat>
+    void DomainWarpFractalProgressive(FNfloat& x, FNfloat& y, FNfloat& z)
+    {
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            FNfloat xs = x;
+            FNfloat ys = y;
+            FNfloat zs = z;
+            TransformDomainWarpCoordinate(xs, ys, zs);
+
+            DoSingleDomainWarp(seed, amp, freq, xs, ys, zs, x, y, z);
+
+            seed++;
+            amp *= mGain;
+            freq *= mLacunarity;
+        }
+    }
+
+
+    // Domain Warp Fractal Independant
+
+    template <typename FNfloat>
+    void DomainWarpFractalIndependent(FNfloat& x, FNfloat& y)
+    {
+        FNfloat xs = x;
+        FNfloat ys = y;
+        TransformDomainWarpCoordinate(xs, ys);
+
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            DoSingleDomainWarp(seed, amp, freq, xs, ys, x, y);
+
+            seed++;
+            amp *= mGain;
+            freq *= mLacunarity;
+        }
+    }
+
+    template <typename FNfloat>
+    void DomainWarpFractalIndependent(FNfloat& x, FNfloat& y, FNfloat& z)
+    {
+        FNfloat xs = x;
+        FNfloat ys = y;
+        FNfloat zs = z;
+        TransformDomainWarpCoordinate(xs, ys, zs);
+
+        int seed = mSeed;
+        float amp = mDomainWarpAmp * mFractalBounding;
+        float freq = mFrequency;
+
+        for (int i = 0; i < mOctaves; i++)
+        {
+            DoSingleDomainWarp(seed, amp, freq, xs, ys, zs, x, y, z);
+
+            seed++;
+            amp *= mGain;
+            freq *= mLacunarity;
+        }
+    }
+
+
+    // Domain Warp Basic Grid
+
+    template <typename FNfloat>
+    void SingleDomainWarpBasicGrid(int seed, float warpAmp, float frequency, FNfloat x, FNfloat y, FNfloat& xr, FNfloat& yr)
+    {
+        FNfloat xf = x * frequency;
+        FNfloat yf = y * frequency;
+
+        int x0 = FastFloor(xf);
+        int y0 = FastFloor(yf);
+
+        float xs = InterpHermite((float)(xf - x0));
+        float ys = InterpHermite((float)(yf - y0));
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+
+        int hash0 = Hash(seed, x0, y0) & (255 << 1);
+        int hash1 = Hash(seed, x1, y0) & (255 << 1);
+
+        float lx0x = Lerp(Lookup<float>::RandVecs2D[hash0], Lookup<float>::RandVecs2D[hash1], xs);
+        float ly0x = Lerp(Lookup<float>::RandVecs2D[hash0 | 1], Lookup<float>::RandVecs2D[hash1 | 1], xs);
+
+        hash0 = Hash(seed, x0, y1) & (255 << 1);
+        hash1 = Hash(seed, x1, y1) & (255 << 1);
+
+        float lx1x = Lerp(Lookup<float>::RandVecs2D[hash0], Lookup<float>::RandVecs2D[hash1], xs);
+        float ly1x = Lerp(Lookup<float>::RandVecs2D[hash0 | 1], Lookup<float>::RandVecs2D[hash1 | 1], xs);
+
+        xr += Lerp(lx0x, lx1x, ys) * warpAmp;
+        yr += Lerp(ly0x, ly1x, ys) * warpAmp;
+    }
+
+    template <typename FNfloat>
+    void SingleDomainWarpBasicGrid(int seed, float warpAmp, float frequency, FNfloat x, FNfloat y, FNfloat z, FNfloat& xr, FNfloat& yr, FNfloat& zr)
+    {
+        FNfloat xf = x * frequency;
+        FNfloat yf = y * frequency;
+        FNfloat zf = z * frequency;
+
+        int x0 = FastFloor(xf);
+        int y0 = FastFloor(yf);
+        int z0 = FastFloor(zf);
+
+        float xs = InterpHermite((float)(xf - x0));
+        float ys = InterpHermite((float)(yf - y0));
+        float zs = InterpHermite((float)(zf - z0));
+
+        x0 *= PrimeX;
+        y0 *= PrimeY;
+        z0 *= PrimeZ;
+        int x1 = x0 + PrimeX;
+        int y1 = y0 + PrimeY;
+        int z1 = z0 + PrimeZ;
+
+        int hash0 = Hash(seed, x0, y0, z0) & (255 << 2);
+        int hash1 = Hash(seed, x1, y0, z0) & (255 << 2);
+
+        float lx0x = Lerp(Lookup<float>::RandVecs3D[hash0], Lookup<float>::RandVecs3D[hash1], xs);
+        float ly0x = Lerp(Lookup<float>::RandVecs3D[hash0 | 1], Lookup<float>::RandVecs3D[hash1 | 1], xs);
+        float lz0x = Lerp(Lookup<float>::RandVecs3D[hash0 | 2], Lookup<float>::RandVecs3D[hash1 | 2], xs);
+
+        hash0 = Hash(seed, x0, y1, z0) & (255 << 2);
+        hash1 = Hash(seed, x1, y1, z0) & (255 << 2);
+
+        float lx1x = Lerp(Lookup<float>::RandVecs3D[hash0], Lookup<float>::RandVecs3D[hash1], xs);
+        float ly1x = Lerp(Lookup<float>::RandVecs3D[hash0 | 1], Lookup<float>::RandVecs3D[hash1 | 1], xs);
+        float lz1x = Lerp(Lookup<float>::RandVecs3D[hash0 | 2], Lookup<float>::RandVecs3D[hash1 | 2], xs);
+
+        float lx0y = Lerp(lx0x, lx1x, ys);
+        float ly0y = Lerp(ly0x, ly1x, ys);
+        float lz0y = Lerp(lz0x, lz1x, ys);
+
+        hash0 = Hash(seed, x0, y0, z1) & (255 << 2);
+        hash1 = Hash(seed, x1, y0, z1) & (255 << 2);
+
+        lx0x = Lerp(Lookup<float>::RandVecs3D[hash0], Lookup<float>::RandVecs3D[hash1], xs);
+        ly0x = Lerp(Lookup<float>::RandVecs3D[hash0 | 1], Lookup<float>::RandVecs3D[hash1 | 1], xs);
+        lz0x = Lerp(Lookup<float>::RandVecs3D[hash0 | 2], Lookup<float>::RandVecs3D[hash1 | 2], xs);
+
+        hash0 = Hash(seed, x0, y1, z1) & (255 << 2);
+        hash1 = Hash(seed, x1, y1, z1) & (255 << 2);
+
+        lx1x = Lerp(Lookup<float>::RandVecs3D[hash0], Lookup<float>::RandVecs3D[hash1], xs);
+        ly1x = Lerp(Lookup<float>::RandVecs3D[hash0 | 1], Lookup<float>::RandVecs3D[hash1 | 1], xs);
+        lz1x = Lerp(Lookup<float>::RandVecs3D[hash0 | 2], Lookup<float>::RandVecs3D[hash1 | 2], xs);
+
+        xr += Lerp(lx0y, Lerp(lx0x, lx1x, ys), zs) * warpAmp;
+        yr += Lerp(ly0y, Lerp(ly0x, ly1x, ys), zs) * warpAmp;
+        zr += Lerp(lz0y, Lerp(lz0x, lz1x, ys), zs) * warpAmp;
+    }
+
+
+    // Domain Warp Simplex/OpenSimplex2
+
+    template <typename FNfloat>
+    void SingleDomainWarpSimplexGradient(int seed, float warpAmp, float frequency, FNfloat x, FNfloat y, FNfloat& xr, FNfloat& yr, bool outGradOnly)
+    {
+        const float SQRT3 = 1.7320508075688772935274463415059f;
+        const float G2 = (3 - SQRT3) / 6;
+
+        x *= frequency;
+        y *= frequency;
+
+        /*
+         * --- Skew moved to TransformNoiseCoordinate method ---
+         * const FNfloat F2 = 0.5f * (SQRT3 - 1);
+         * FNfloat s = (x + y) * F2;
+         * x += s; y += s;
+        */
+
+        int i = FastFloor(x);
+        int j = FastFloor(y);
+        float xi = (float)(x - i);
+        float yi = (float)(y - j);
+
+        float t = (xi + yi) * G2;
+        float x0 = (float)(xi - t);
+        float y0 = (float)(yi - t);
+
+        i *= PrimeX;
+        j *= PrimeY;
+
+        float vx, vy;
+        vx = vy = 0;
+
+        float a = 0.5f - x0 * x0 - y0 * y0;
+        if (a > 0)
+        {
+            float aaaa = (a * a) * (a * a);
+            float xo, yo;
+            if (outGradOnly)
+                GradCoordOut(seed, i, j, xo, yo);
+            else
+                GradCoordDual(seed, i, j, x0, y0, xo, yo);
+            vx += aaaa * xo;
+            vy += aaaa * yo;
+        }
+
+        float c = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a);
+        if (c > 0)
+        {
+            float x2 = x0 + (2 * (float)G2 - 1);
+            float y2 = y0 + (2 * (float)G2 - 1);
+            float cccc = (c * c) * (c * c);
+            float xo, yo;
+            if (outGradOnly)
+                GradCoordOut(seed, i + PrimeX, j + PrimeY, xo, yo);
+            else
+                GradCoordDual(seed, i + PrimeX, j + PrimeY, x2, y2, xo, yo);
+            vx += cccc * xo;
+            vy += cccc * yo;
+        }
+
+        if (y0 > x0)
+        {
+            float x1 = x0 + (float)G2;
+            float y1 = y0 + ((float)G2 - 1);
+            float b = 0.5f - x1 * x1 - y1 * y1;
+            if (b > 0)
+            {
+                float bbbb = (b * b) * (b * b);
+                float xo, yo;
+                if (outGradOnly)
+                    GradCoordOut(seed, i, j + PrimeY, xo, yo);
+                else
+                    GradCoordDual(seed, i, j + PrimeY, x1, y1, xo, yo);
+                vx += bbbb * xo;
+                vy += bbbb * yo;
+            }
+        }
+        else
+        {
+            float x1 = x0 + ((float)G2 - 1);
+            float y1 = y0 + (float)G2;
+            float b = 0.5f - x1 * x1 - y1 * y1;
+            if (b > 0)
+            {
+                float bbbb = (b * b) * (b * b);
+                float xo, yo;
+                if (outGradOnly)
+                    GradCoordOut(seed, i + PrimeX, j, xo, yo);
+                else
+                    GradCoordDual(seed, i + PrimeX, j, x1, y1, xo, yo);
+                vx += bbbb * xo;
+                vy += bbbb * yo;
+            }
+        }
+
+        xr += vx * warpAmp;
+        yr += vy * warpAmp;
+    }
+
+    template <typename FNfloat>
+    void SingleDomainWarpOpenSimplex2Gradient(int seed, float warpAmp, float frequency, FNfloat x, FNfloat y, FNfloat z, FNfloat& xr, FNfloat& yr, FNfloat& zr, bool outGradOnly)
+    {
+        x *= frequency;
+        y *= frequency;
+        z *= frequency;
+
+        /*
+         * --- Rotation moved to TransformDomainWarpCoordinate method ---
+         * const FNfloat R3 = (FNfloat)(2.0 / 3.0);
+         * FNfloat r = (x + y + z) * R3; // Rotation, not skew
+         * x = r - x; y = r - y; z = r - z;
+        */
+
+        int i = FastRound(x);
+        int j = FastRound(y);
+        int k = FastRound(z);
+        float x0 = (float)x - i;
+        float y0 = (float)y - j;
+        float z0 = (float)z - k;
+
+        int xNSign = (int)(-x0 - 1.0f) | 1;
+        int yNSign = (int)(-y0 - 1.0f) | 1;
+        int zNSign = (int)(-z0 - 1.0f) | 1;
+
+        float ax0 = xNSign * -x0;
+        float ay0 = yNSign * -y0;
+        float az0 = zNSign * -z0;
+
+        i *= PrimeX;
+        j *= PrimeY;
+        k *= PrimeZ;
+
+        float vx, vy, vz;
+        vx = vy = vz = 0;
+
+        float a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0);
+        for (int l = 0; l < 2; l++)
+        {
+            if (a > 0)
+            {
+                float aaaa = (a * a) * (a * a);
+                float xo, yo, zo;
+                if (outGradOnly)
+                    GradCoordOut(seed, i, j, k, xo, yo, zo);
+                else
+                    GradCoordDual(seed, i, j, k, x0, y0, z0, xo, yo, zo);
+                vx += aaaa * xo;
+                vy += aaaa * yo;
+                vz += aaaa * zo;
+            }
+
+            float b = a + 1;
+            int i1 = i;
+            int j1 = j;
+            int k1 = k;
+            float x1 = x0;
+            float y1 = y0;
+            float z1 = z0;
+
+            if (ax0 >= ay0 && ax0 >= az0)
+            {
+                x1 += xNSign;
+                b -= xNSign * 2 * x1;
+                i1 -= xNSign * PrimeX;
+            }
+            else if (ay0 > ax0 && ay0 >= az0)
+            {
+                y1 += yNSign;
+                b -= yNSign * 2 * y1;
+                j1 -= yNSign * PrimeY;
+            }
+            else
+            {
+                z1 += zNSign;
+                b -= zNSign * 2 * z1;
+                k1 -= zNSign * PrimeZ;
+            }
+
+            if (b > 0)
+            {
+                float bbbb = (b * b) * (b * b);
+                float xo, yo, zo;
+                if (outGradOnly)
+                    GradCoordOut(seed, i1, j1, k1, xo, yo, zo);
+                else
+                    GradCoordDual(seed, i1, j1, k1, x1, y1, z1, xo, yo, zo);
+                vx += bbbb * xo;
+                vy += bbbb * yo;
+                vz += bbbb * zo;
+            }
+
+            if (l == 1) break;
+
+            ax0 = 0.5f - ax0;
+            ay0 = 0.5f - ay0;
+            az0 = 0.5f - az0;
+
+            x0 = xNSign * ax0;
+            y0 = yNSign * ay0;
+            z0 = zNSign * az0;
+
+            a += (0.75f - ax0) - (ay0 + az0);
+
+            i += (xNSign >> 1) & PrimeX;
+            j += (yNSign >> 1) & PrimeY;
+            k += (zNSign >> 1) & PrimeZ;
+
+            xNSign = -xNSign;
+            yNSign = -yNSign;
+            zNSign = -zNSign;
+
+            seed += 1293373;
+        }
+
+        xr += vx * warpAmp;
+        yr += vy * warpAmp;
+        zr += vz * warpAmp;
+    }
+};
+
+template <>
+struct FastNoiseLite::Arguments_must_be_floating_point_values<float> {};
+template <>
+struct FastNoiseLite::Arguments_must_be_floating_point_values<double> {};
+template <>
+struct FastNoiseLite::Arguments_must_be_floating_point_values<long double> {};
+
+template <typename T>
+const T FastNoiseLite::Lookup<T>::Gradients2D[] =
+{
+    0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f,
+    0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f,
+    0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f,
+    -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+    -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f,
+    -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f,
+    0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f,
+    0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f,
+    0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f,
+    -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+    -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f,
+    -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f,
+    0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f,
+    0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f,
+    0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f,
+    -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+    -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f,
+    -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f,
+    0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f,
+    0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f,
+    0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f,
+    -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+    -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f,
+    -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f,
+    0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f,
+    0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f,
+    0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f,
+    -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+    -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f,
+    -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f,
+    0.38268343236509f, 0.923879532511287f, 0.923879532511287f, 0.38268343236509f, 0.923879532511287f, -0.38268343236509f, 0.38268343236509f, -0.923879532511287f,
+    -0.38268343236509f, -0.923879532511287f, -0.923879532511287f, -0.38268343236509f, -0.923879532511287f, 0.38268343236509f, -0.38268343236509f, 0.923879532511287f,
+};
+
+template <typename T>
+const T FastNoiseLite::Lookup<T>::RandVecs2D[] =
+{
+    -0.2700222198f, -0.9628540911f, 0.3863092627f, -0.9223693152f, 0.04444859006f, -0.999011673f, -0.5992523158f, -0.8005602176f, -0.7819280288f, 0.6233687174f, 0.9464672271f, 0.3227999196f, -0.6514146797f, -0.7587218957f, 0.9378472289f, 0.347048376f,
+    -0.8497875957f, -0.5271252623f, -0.879042592f, 0.4767432447f, -0.892300288f, -0.4514423508f, -0.379844434f, -0.9250503802f, -0.9951650832f, 0.0982163789f, 0.7724397808f, -0.6350880136f, 0.7573283322f, -0.6530343002f, -0.9928004525f, -0.119780055f,
+    -0.0532665713f, 0.9985803285f, 0.9754253726f, -0.2203300762f, -0.7665018163f, 0.6422421394f, 0.991636706f, 0.1290606184f, -0.994696838f, 0.1028503788f, -0.5379205513f, -0.84299554f, 0.5022815471f, -0.8647041387f, 0.4559821461f, -0.8899889226f,
+    -0.8659131224f, -0.5001944266f, 0.0879458407f, -0.9961252577f, -0.5051684983f, 0.8630207346f, 0.7753185226f, -0.6315704146f, -0.6921944612f, 0.7217110418f, -0.5191659449f, -0.8546734591f, 0.8978622882f, -0.4402764035f, -0.1706774107f, 0.9853269617f,
+    -0.9353430106f, -0.3537420705f, -0.9992404798f, 0.03896746794f, -0.2882064021f, -0.9575683108f, -0.9663811329f, 0.2571137995f, -0.8759714238f, -0.4823630009f, -0.8303123018f, -0.5572983775f, 0.05110133755f, -0.9986934731f, -0.8558373281f, -0.5172450752f,
+    0.09887025282f, 0.9951003332f, 0.9189016087f, 0.3944867976f, -0.2439375892f, -0.9697909324f, -0.8121409387f, -0.5834613061f, -0.9910431363f, 0.1335421355f, 0.8492423985f, -0.5280031709f, -0.9717838994f, -0.2358729591f, 0.9949457207f, 0.1004142068f,
+    0.6241065508f, -0.7813392434f, 0.662910307f, 0.7486988212f, -0.7197418176f, 0.6942418282f, -0.8143370775f, -0.5803922158f, 0.104521054f, -0.9945226741f, -0.1065926113f, -0.9943027784f, 0.445799684f, -0.8951327509f, 0.105547406f, 0.9944142724f,
+    -0.992790267f, 0.1198644477f, -0.8334366408f, 0.552615025f, 0.9115561563f, -0.4111755999f, 0.8285544909f, -0.5599084351f, 0.7217097654f, -0.6921957921f, 0.4940492677f, -0.8694339084f, -0.3652321272f, -0.9309164803f, -0.9696606758f, 0.2444548501f,
+    0.08925509731f, -0.996008799f, 0.5354071276f, -0.8445941083f, -0.1053576186f, 0.9944343981f, -0.9890284586f, 0.1477251101f, 0.004856104961f, 0.9999882091f, 0.9885598478f, 0.1508291331f, 0.9286129562f, -0.3710498316f, -0.5832393863f, -0.8123003252f,
+    0.3015207509f, 0.9534596146f, -0.9575110528f, 0.2883965738f, 0.9715802154f, -0.2367105511f, 0.229981792f, 0.9731949318f, 0.955763816f, -0.2941352207f, 0.740956116f, 0.6715534485f, -0.9971513787f, -0.07542630764f, 0.6905710663f, -0.7232645452f,
+    -0.290713703f, -0.9568100872f, 0.5912777791f, -0.8064679708f, -0.9454592212f, -0.325740481f, 0.6664455681f, 0.74555369f, 0.6236134912f, 0.7817328275f, 0.9126993851f, -0.4086316587f, -0.8191762011f, 0.5735419353f, -0.8812745759f, -0.4726046147f,
+    0.9953313627f, 0.09651672651f, 0.9855650846f, -0.1692969699f, -0.8495980887f, 0.5274306472f, 0.6174853946f, -0.7865823463f, 0.8508156371f, 0.52546432f, 0.9985032451f, -0.05469249926f, 0.1971371563f, -0.9803759185f, 0.6607855748f, -0.7505747292f,
+    -0.03097494063f, 0.9995201614f, -0.6731660801f, 0.739491331f, -0.7195018362f, -0.6944905383f, 0.9727511689f, 0.2318515979f, 0.9997059088f, -0.0242506907f, 0.4421787429f, -0.8969269532f, 0.9981350961f, -0.061043673f, -0.9173660799f, -0.3980445648f,
+    -0.8150056635f, -0.5794529907f, -0.8789331304f, 0.4769450202f, 0.0158605829f, 0.999874213f, -0.8095464474f, 0.5870558317f, -0.9165898907f, -0.3998286786f, -0.8023542565f, 0.5968480938f, -0.5176737917f, 0.8555780767f, -0.8154407307f, -0.5788405779f,
+    0.4022010347f, -0.9155513791f, -0.9052556868f, -0.4248672045f, 0.7317445619f, 0.6815789728f, -0.5647632201f, -0.8252529947f, -0.8403276335f, -0.5420788397f, -0.9314281527f, 0.363925262f, 0.5238198472f, 0.8518290719f, 0.7432803869f, -0.6689800195f,
+    -0.985371561f, -0.1704197369f, 0.4601468731f, 0.88784281f, 0.825855404f, 0.5638819483f, 0.6182366099f, 0.7859920446f, 0.8331502863f, -0.553046653f, 0.1500307506f, 0.9886813308f, -0.662330369f, -0.7492119075f, -0.668598664f, 0.743623444f,
+    0.7025606278f, 0.7116238924f, -0.5419389763f, -0.8404178401f, -0.3388616456f, 0.9408362159f, 0.8331530315f, 0.5530425174f, -0.2989720662f, -0.9542618632f, 0.2638522993f, 0.9645630949f, 0.124108739f, -0.9922686234f, -0.7282649308f, -0.6852956957f,
+    0.6962500149f, 0.7177993569f, -0.9183535368f, 0.3957610156f, -0.6326102274f, -0.7744703352f, -0.9331891859f, -0.359385508f, -0.1153779357f, -0.9933216659f, 0.9514974788f, -0.3076565421f, -0.08987977445f, -0.9959526224f, 0.6678496916f, 0.7442961705f,
+    0.7952400393f, -0.6062947138f, -0.6462007402f, -0.7631674805f, -0.2733598753f, 0.9619118351f, 0.9669590226f, -0.254931851f, -0.9792894595f, 0.2024651934f, -0.5369502995f, -0.8436138784f, -0.270036471f, -0.9628500944f, -0.6400277131f, 0.7683518247f,
+    -0.7854537493f, -0.6189203566f, 0.06005905383f, -0.9981948257f, -0.02455770378f, 0.9996984141f, -0.65983623f, 0.751409442f, -0.6253894466f, -0.7803127835f, -0.6210408851f, -0.7837781695f, 0.8348888491f, 0.5504185768f, -0.1592275245f, 0.9872419133f,
+    0.8367622488f, 0.5475663786f, -0.8675753916f, -0.4973056806f, -0.2022662628f, -0.9793305667f, 0.9399189937f, 0.3413975472f, 0.9877404807f, -0.1561049093f, -0.9034455656f, 0.4287028224f, 0.1269804218f, -0.9919052235f, -0.3819600854f, 0.924178821f,
+    0.9754625894f, 0.2201652486f, -0.3204015856f, -0.9472818081f, -0.9874760884f, 0.1577687387f, 0.02535348474f, -0.9996785487f, 0.4835130794f, -0.8753371362f, -0.2850799925f, -0.9585037287f, -0.06805516006f, -0.99768156f, -0.7885244045f, -0.6150034663f,
+    0.3185392127f, -0.9479096845f, 0.8880043089f, 0.4598351306f, 0.6476921488f, -0.7619021462f, 0.9820241299f, 0.1887554194f, 0.9357275128f, -0.3527237187f, -0.8894895414f, 0.4569555293f, 0.7922791302f, 0.6101588153f, 0.7483818261f, 0.6632681526f,
+    -0.7288929755f, -0.6846276581f, 0.8729032783f, -0.4878932944f, 0.8288345784f, 0.5594937369f, 0.08074567077f, 0.9967347374f, 0.9799148216f, -0.1994165048f, -0.580730673f, -0.8140957471f, -0.4700049791f, -0.8826637636f, 0.2409492979f, 0.9705377045f,
+    0.9437816757f, -0.3305694308f, -0.8927998638f, -0.4504535528f, -0.8069622304f, 0.5906030467f, 0.06258973166f, 0.9980393407f, -0.9312597469f, 0.3643559849f, 0.5777449785f, 0.8162173362f, -0.3360095855f, -0.941858566f, 0.697932075f, -0.7161639607f,
+    -0.002008157227f, -0.9999979837f, -0.1827294312f, -0.9831632392f, -0.6523911722f, 0.7578824173f, -0.4302626911f, -0.9027037258f, -0.9985126289f, -0.05452091251f, -0.01028102172f, -0.9999471489f, -0.4946071129f, 0.8691166802f, -0.2999350194f, 0.9539596344f,
+    0.8165471961f, 0.5772786819f, 0.2697460475f, 0.962931498f, -0.7306287391f, -0.6827749597f, -0.7590952064f, -0.6509796216f, -0.907053853f, 0.4210146171f, -0.5104861064f, -0.8598860013f, 0.8613350597f, 0.5080373165f, 0.5007881595f, -0.8655698812f,
+    -0.654158152f, 0.7563577938f, -0.8382755311f, -0.545246856f, 0.6940070834f, 0.7199681717f, 0.06950936031f, 0.9975812994f, 0.1702942185f, -0.9853932612f, 0.2695973274f, 0.9629731466f, 0.5519612192f, -0.8338697815f, 0.225657487f, -0.9742067022f,
+    0.4215262855f, -0.9068161835f, 0.4881873305f, -0.8727388672f, -0.3683854996f, -0.9296731273f, -0.9825390578f, 0.1860564427f, 0.81256471f, 0.5828709909f, 0.3196460933f, -0.9475370046f, 0.9570913859f, 0.2897862643f, -0.6876655497f, -0.7260276109f,
+    -0.9988770922f, -0.047376731f, -0.1250179027f, 0.992154486f, -0.8280133617f, 0.560708367f, 0.9324863769f, -0.3612051451f, 0.6394653183f, 0.7688199442f, -0.01623847064f, -0.9998681473f, -0.9955014666f, -0.09474613458f, -0.81453315f, 0.580117012f,
+    0.4037327978f, -0.9148769469f, 0.9944263371f, 0.1054336766f, -0.1624711654f, 0.9867132919f, -0.9949487814f, -0.100383875f, -0.6995302564f, 0.7146029809f, 0.5263414922f, -0.85027327f, -0.5395221479f, 0.841971408f, 0.6579370318f, 0.7530729462f,
+    0.01426758847f, -0.9998982128f, -0.6734383991f, 0.7392433447f, 0.639412098f, -0.7688642071f, 0.9211571421f, 0.3891908523f, -0.146637214f, -0.9891903394f, -0.782318098f, 0.6228791163f, -0.5039610839f, -0.8637263605f, -0.7743120191f, -0.6328039957f,
+};
+
+template <typename T>
+const T FastNoiseLite::Lookup<T>::Gradients3D[] =
+{
+    0, 1, 1, 0,  0,-1, 1, 0,  0, 1,-1, 0,  0,-1,-1, 0,
+    1, 0, 1, 0, -1, 0, 1, 0,  1, 0,-1, 0, -1, 0,-1, 0,
+    1, 1, 0, 0, -1, 1, 0, 0,  1,-1, 0, 0, -1,-1, 0, 0,
+    0, 1, 1, 0,  0,-1, 1, 0,  0, 1,-1, 0,  0,-1,-1, 0,
+    1, 0, 1, 0, -1, 0, 1, 0,  1, 0,-1, 0, -1, 0,-1, 0,
+    1, 1, 0, 0, -1, 1, 0, 0,  1,-1, 0, 0, -1,-1, 0, 0,
+    0, 1, 1, 0,  0,-1, 1, 0,  0, 1,-1, 0,  0,-1,-1, 0,
+    1, 0, 1, 0, -1, 0, 1, 0,  1, 0,-1, 0, -1, 0,-1, 0,
+    1, 1, 0, 0, -1, 1, 0, 0,  1,-1, 0, 0, -1,-1, 0, 0,
+    0, 1, 1, 0,  0,-1, 1, 0,  0, 1,-1, 0,  0,-1,-1, 0,
+    1, 0, 1, 0, -1, 0, 1, 0,  1, 0,-1, 0, -1, 0,-1, 0,
+    1, 1, 0, 0, -1, 1, 0, 0,  1,-1, 0, 0, -1,-1, 0, 0,
+    0, 1, 1, 0,  0,-1, 1, 0,  0, 1,-1, 0,  0,-1,-1, 0,
+    1, 0, 1, 0, -1, 0, 1, 0,  1, 0,-1, 0, -1, 0,-1, 0,
+    1, 1, 0, 0, -1, 1, 0, 0,  1,-1, 0, 0, -1,-1, 0, 0,
+    1, 1, 0, 0,  0,-1, 1, 0, -1, 1, 0, 0,  0,-1,-1, 0
+};
+
+template <typename T>
+const T FastNoiseLite::Lookup<T>::RandVecs3D[] =
+{
+    -0.7292736885f, -0.6618439697f, 0.1735581948f, 0, 0.790292081f, -0.5480887466f, -0.2739291014f, 0, 0.7217578935f, 0.6226212466f, -0.3023380997f, 0, 0.565683137f, -0.8208298145f, -0.0790000257f, 0, 0.760049034f, -0.5555979497f, -0.3370999617f, 0, 0.3713945616f, 0.5011264475f, 0.7816254623f, 0, -0.1277062463f, -0.4254438999f, -0.8959289049f, 0, -0.2881560924f, -0.5815838982f, 0.7607405838f, 0,
+    0.5849561111f, -0.662820239f, -0.4674352136f, 0, 0.3307171178f, 0.0391653737f, 0.94291689f, 0, 0.8712121778f, -0.4113374369f, -0.2679381538f, 0, 0.580981015f, 0.7021915846f, 0.4115677815f, 0, 0.503756873f, 0.6330056931f, -0.5878203852f, 0, 0.4493712205f, 0.601390195f, 0.6606022552f, 0, -0.6878403724f, 0.09018890807f, -0.7202371714f, 0, -0.5958956522f, -0.6469350577f, 0.475797649f, 0,
+    -0.5127052122f, 0.1946921978f, -0.8361987284f, 0, -0.9911507142f, -0.05410276466f, -0.1212153153f, 0, -0.2149721042f, 0.9720882117f, -0.09397607749f, 0, -0.7518650936f, -0.5428057603f, 0.3742469607f, 0, 0.5237068895f, 0.8516377189f, -0.02107817834f, 0, 0.6333504779f, 0.1926167129f, -0.7495104896f, 0, -0.06788241606f, 0.3998305789f, 0.9140719259f, 0, -0.5538628599f, -0.4729896695f, -0.6852128902f, 0,
+    -0.7261455366f, -0.5911990757f, 0.3509933228f, 0, -0.9229274737f, -0.1782808786f, 0.3412049336f, 0, -0.6968815002f, 0.6511274338f, 0.3006480328f, 0, 0.9608044783f, -0.2098363234f, -0.1811724921f, 0, 0.06817146062f, -0.9743405129f, 0.2145069156f, 0, -0.3577285196f, -0.6697087264f, -0.6507845481f, 0, -0.1868621131f, 0.7648617052f, -0.6164974636f, 0, -0.6541697588f, 0.3967914832f, 0.6439087246f, 0,
+    0.6993340405f, -0.6164538506f, 0.3618239211f, 0, -0.1546665739f, 0.6291283928f, 0.7617583057f, 0, -0.6841612949f, -0.2580482182f, -0.6821542638f, 0, 0.5383980957f, 0.4258654885f, 0.7271630328f, 0, -0.5026987823f, -0.7939832935f, -0.3418836993f, 0, 0.3202971715f, 0.2834415347f, 0.9039195862f, 0, 0.8683227101f, -0.0003762656404f, -0.4959995258f, 0, 0.791120031f, -0.08511045745f, 0.6057105799f, 0,
+    -0.04011016052f, -0.4397248749f, 0.8972364289f, 0, 0.9145119872f, 0.3579346169f, -0.1885487608f, 0, -0.9612039066f, -0.2756484276f, 0.01024666929f, 0, 0.6510361721f, -0.2877799159f, -0.7023778346f, 0, -0.2041786351f, 0.7365237271f, 0.644859585f, 0, -0.7718263711f, 0.3790626912f, 0.5104855816f, 0, -0.3060082741f, -0.7692987727f, 0.5608371729f, 0, 0.454007341f, -0.5024843065f, 0.7357899537f, 0,
+    0.4816795475f, 0.6021208291f, -0.6367380315f, 0, 0.6961980369f, -0.3222197429f, 0.641469197f, 0, -0.6532160499f, -0.6781148932f, 0.3368515753f, 0, 0.5089301236f, -0.6154662304f, -0.6018234363f, 0, -0.1635919754f, -0.9133604627f, -0.372840892f, 0, 0.52408019f, -0.8437664109f, 0.1157505864f, 0, 0.5902587356f, 0.4983817807f, -0.6349883666f, 0, 0.5863227872f, 0.494764745f, 0.6414307729f, 0,
+    0.6779335087f, 0.2341345225f, 0.6968408593f, 0, 0.7177054546f, -0.6858979348f, 0.120178631f, 0, -0.5328819713f, -0.5205125012f, 0.6671608058f, 0, -0.8654874251f, -0.0700727088f, -0.4960053754f, 0, -0.2861810166f, 0.7952089234f, 0.5345495242f, 0, -0.04849529634f, 0.9810836427f, -0.1874115585f, 0, -0.6358521667f, 0.6058348682f, 0.4781800233f, 0, 0.6254794696f, -0.2861619734f, 0.7258696564f, 0,
+    -0.2585259868f, 0.5061949264f, -0.8227581726f, 0, 0.02136306781f, 0.5064016808f, -0.8620330371f, 0, 0.200111773f, 0.8599263484f, 0.4695550591f, 0, 0.4743561372f, 0.6014985084f, -0.6427953014f, 0, 0.6622993731f, -0.5202474575f, -0.5391679918f, 0, 0.08084972818f, -0.6532720452f, 0.7527940996f, 0, -0.6893687501f, 0.0592860349f, 0.7219805347f, 0, -0.1121887082f, -0.9673185067f, 0.2273952515f, 0,
+    0.7344116094f, 0.5979668656f, -0.3210532909f, 0, 0.5789393465f, -0.2488849713f, 0.7764570201f, 0, 0.6988182827f, 0.3557169806f, -0.6205791146f, 0, -0.8636845529f, -0.2748771249f, -0.4224826141f, 0, -0.4247027957f, -0.4640880967f, 0.777335046f, 0, 0.5257722489f, -0.8427017621f, 0.1158329937f, 0, 0.9343830603f, 0.316302472f, -0.1639543925f, 0, -0.1016836419f, -0.8057303073f, -0.5834887393f, 0,
+    -0.6529238969f, 0.50602126f, -0.5635892736f, 0, -0.2465286165f, -0.9668205684f, -0.06694497494f, 0, -0.9776897119f, -0.2099250524f, -0.007368825344f, 0, 0.7736893337f, 0.5734244712f, 0.2694238123f, 0, -0.6095087895f, 0.4995678998f, 0.6155736747f, 0, 0.5794535482f, 0.7434546771f, 0.3339292269f, 0, -0.8226211154f, 0.08142581855f, 0.5627293636f, 0, -0.510385483f, 0.4703667658f, 0.7199039967f, 0,
+    -0.5764971849f, -0.07231656274f, -0.8138926898f, 0, 0.7250628871f, 0.3949971505f, -0.5641463116f, 0, -0.1525424005f, 0.4860840828f, -0.8604958341f, 0, -0.5550976208f, -0.4957820792f, 0.667882296f, 0, -0.1883614327f, 0.9145869398f, 0.357841725f, 0, 0.7625556724f, -0.5414408243f, -0.3540489801f, 0, -0.5870231946f, -0.3226498013f, -0.7424963803f, 0, 0.3051124198f, 0.2262544068f, -0.9250488391f, 0,
+    0.6379576059f, 0.577242424f, -0.5097070502f, 0, -0.5966775796f, 0.1454852398f, -0.7891830656f, 0, -0.658330573f, 0.6555487542f, -0.3699414651f, 0, 0.7434892426f, 0.2351084581f, 0.6260573129f, 0, 0.5562114096f, 0.8264360377f, -0.0873632843f, 0, -0.3028940016f, -0.8251527185f, 0.4768419182f, 0, 0.1129343818f, -0.985888439f, -0.1235710781f, 0, 0.5937652891f, -0.5896813806f, 0.5474656618f, 0,
+    0.6757964092f, -0.5835758614f, -0.4502648413f, 0, 0.7242302609f, -0.1152719764f, 0.6798550586f, 0, -0.9511914166f, 0.0753623979f, -0.2992580792f, 0, 0.2539470961f, -0.1886339355f, 0.9486454084f, 0, 0.571433621f, -0.1679450851f, -0.8032795685f, 0, -0.06778234979f, 0.3978269256f, 0.9149531629f, 0, 0.6074972649f, 0.733060024f, -0.3058922593f, 0, -0.5435478392f, 0.1675822484f, 0.8224791405f, 0,
+    -0.5876678086f, -0.3380045064f, -0.7351186982f, 0, -0.7967562402f, 0.04097822706f, -0.6029098428f, 0, -0.1996350917f, 0.8706294745f, 0.4496111079f, 0, -0.02787660336f, -0.9106232682f, -0.4122962022f, 0, -0.7797625996f, -0.6257634692f, 0.01975775581f, 0, -0.5211232846f, 0.7401644346f, -0.4249554471f, 0, 0.8575424857f, 0.4053272873f, -0.3167501783f, 0, 0.1045223322f, 0.8390195772f, -0.5339674439f, 0,
+    0.3501822831f, 0.9242524096f, -0.1520850155f, 0, 0.1987849858f, 0.07647613266f, 0.9770547224f, 0, 0.7845996363f, 0.6066256811f, -0.1280964233f, 0, 0.09006737436f, -0.9750989929f, -0.2026569073f, 0, -0.8274343547f, -0.542299559f, 0.1458203587f, 0, -0.3485797732f, -0.415802277f, 0.840000362f, 0, -0.2471778936f, -0.7304819962f, -0.6366310879f, 0, -0.3700154943f, 0.8577948156f, 0.3567584454f, 0,
+    0.5913394901f, -0.548311967f, -0.5913303597f, 0, 0.1204873514f, -0.7626472379f, -0.6354935001f, 0, 0.616959265f, 0.03079647928f, 0.7863922953f, 0, 0.1258156836f, -0.6640829889f, -0.7369967419f, 0, -0.6477565124f, -0.1740147258f, -0.7417077429f, 0, 0.6217889313f, -0.7804430448f, -0.06547655076f, 0, 0.6589943422f, -0.6096987708f, 0.4404473475f, 0, -0.2689837504f, -0.6732403169f, -0.6887635427f, 0,
+    -0.3849775103f, 0.5676542638f, 0.7277093879f, 0, 0.5754444408f, 0.8110471154f, -0.1051963504f, 0, 0.9141593684f, 0.3832947817f, 0.131900567f, 0, -0.107925319f, 0.9245493968f, 0.3654593525f, 0, 0.377977089f, 0.3043148782f, 0.8743716458f, 0, -0.2142885215f, -0.8259286236f, 0.5214617324f, 0, 0.5802544474f, 0.4148098596f, -0.7008834116f, 0, -0.1982660881f, 0.8567161266f, -0.4761596756f, 0,
+    -0.03381553704f, 0.3773180787f, -0.9254661404f, 0, -0.6867922841f, -0.6656597827f, 0.2919133642f, 0, 0.7731742607f, -0.2875793547f, -0.5652430251f, 0, -0.09655941928f, 0.9193708367f, -0.3813575004f, 0, 0.2715702457f, -0.9577909544f, -0.09426605581f, 0, 0.2451015704f, -0.6917998565f, -0.6792188003f, 0, 0.977700782f, -0.1753855374f, 0.1155036542f, 0, -0.5224739938f, 0.8521606816f, 0.02903615945f, 0,
+    -0.7734880599f, -0.5261292347f, 0.3534179531f, 0, -0.7134492443f, -0.269547243f, 0.6467878011f, 0, 0.1644037271f, 0.5105846203f, -0.8439637196f, 0, 0.6494635788f, 0.05585611296f, 0.7583384168f, 0, -0.4711970882f, 0.5017280509f, -0.7254255765f, 0, -0.6335764307f, -0.2381686273f, -0.7361091029f, 0, -0.9021533097f, -0.270947803f, -0.3357181763f, 0, -0.3793711033f, 0.872258117f, 0.3086152025f, 0,
+    -0.6855598966f, -0.3250143309f, 0.6514394162f, 0, 0.2900942212f, -0.7799057743f, -0.5546100667f, 0, -0.2098319339f, 0.85037073f, 0.4825351604f, 0, -0.4592603758f, 0.6598504336f, -0.5947077538f, 0, 0.8715945488f, 0.09616365406f, -0.4807031248f, 0, -0.6776666319f, 0.7118504878f, -0.1844907016f, 0, 0.7044377633f, 0.312427597f, 0.637304036f, 0, -0.7052318886f, -0.2401093292f, -0.6670798253f, 0,
+    0.081921007f, -0.7207336136f, -0.6883545647f, 0, -0.6993680906f, -0.5875763221f, -0.4069869034f, 0, -0.1281454481f, 0.6419895885f, 0.7559286424f, 0, -0.6337388239f, -0.6785471501f, -0.3714146849f, 0, 0.5565051903f, -0.2168887573f, -0.8020356851f, 0, -0.5791554484f, 0.7244372011f, -0.3738578718f, 0, 0.1175779076f, -0.7096451073f, 0.6946792478f, 0, -0.6134619607f, 0.1323631078f, 0.7785527795f, 0,
+    0.6984635305f, -0.02980516237f, -0.715024719f, 0, 0.8318082963f, -0.3930171956f, 0.3919597455f, 0, 0.1469576422f, 0.05541651717f, -0.9875892167f, 0, 0.708868575f, -0.2690503865f, 0.6520101478f, 0, 0.2726053183f, 0.67369766f, -0.68688995f, 0, -0.6591295371f, 0.3035458599f, -0.6880466294f, 0, 0.4815131379f, -0.7528270071f, 0.4487723203f, 0, 0.9430009463f, 0.1675647412f, -0.2875261255f, 0,
+    0.434802957f, 0.7695304522f, -0.4677277752f, 0, 0.3931996188f, 0.594473625f, 0.7014236729f, 0, 0.7254336655f, -0.603925654f, 0.3301814672f, 0, 0.7590235227f, -0.6506083235f, 0.02433313207f, 0, -0.8552768592f, -0.3430042733f, 0.3883935666f, 0, -0.6139746835f, 0.6981725247f, 0.3682257648f, 0, -0.7465905486f, -0.5752009504f, 0.3342849376f, 0, 0.5730065677f, 0.810555537f, -0.1210916791f, 0,
+    -0.9225877367f, -0.3475211012f, -0.167514036f, 0, -0.7105816789f, -0.4719692027f, -0.5218416899f, 0, -0.08564609717f, 0.3583001386f, 0.929669703f, 0, -0.8279697606f, -0.2043157126f, 0.5222271202f, 0, 0.427944023f, 0.278165994f, 0.8599346446f, 0, 0.5399079671f, -0.7857120652f, -0.3019204161f, 0, 0.5678404253f, -0.5495413974f, -0.6128307303f, 0, -0.9896071041f, 0.1365639107f, -0.04503418428f, 0,
+    -0.6154342638f, -0.6440875597f, 0.4543037336f, 0, 0.1074204368f, -0.7946340692f, 0.5975094525f, 0, -0.3595449969f, -0.8885529948f, 0.28495784f, 0, -0.2180405296f, 0.1529888965f, 0.9638738118f, 0, -0.7277432317f, -0.6164050508f, -0.3007234646f, 0, 0.7249729114f, -0.00669719484f, 0.6887448187f, 0, -0.5553659455f, -0.5336586252f, 0.6377908264f, 0, 0.5137558015f, 0.7976208196f, -0.3160000073f, 0,
+    -0.3794024848f, 0.9245608561f, -0.03522751494f, 0, 0.8229248658f, 0.2745365933f, -0.4974176556f, 0, -0.5404114394f, 0.6091141441f, 0.5804613989f, 0, 0.8036581901f, -0.2703029469f, 0.5301601931f, 0, 0.6044318879f, 0.6832968393f, 0.4095943388f, 0, 0.06389988817f, 0.9658208605f, -0.2512108074f, 0, 0.1087113286f, 0.7402471173f, -0.6634877936f, 0, -0.713427712f, -0.6926784018f, 0.1059128479f, 0,
+    0.6458897819f, -0.5724548511f, -0.5050958653f, 0, -0.6553931414f, 0.7381471625f, 0.159995615f, 0, 0.3910961323f, 0.9188871375f, -0.05186755998f, 0, -0.4879022471f, -0.5904376907f, 0.6429111375f, 0, 0.6014790094f, 0.7707441366f, -0.2101820095f, 0, -0.5677173047f, 0.7511360995f, 0.3368851762f, 0, 0.7858573506f, 0.226674665f, 0.5753666838f, 0, -0.4520345543f, -0.604222686f, -0.6561857263f, 0,
+    0.002272116345f, 0.4132844051f, -0.9105991643f, 0, -0.5815751419f, -0.5162925989f, 0.6286591339f, 0, -0.03703704785f, 0.8273785755f, 0.5604221175f, 0, -0.5119692504f, 0.7953543429f, -0.3244980058f, 0, -0.2682417366f, -0.9572290247f, -0.1084387619f, 0, -0.2322482736f, -0.9679131102f, -0.09594243324f, 0, 0.3554328906f, -0.8881505545f, 0.2913006227f, 0, 0.7346520519f, -0.4371373164f, 0.5188422971f, 0,
+    0.9985120116f, 0.04659011161f, -0.02833944577f, 0, -0.3727687496f, -0.9082481361f, 0.1900757285f, 0, 0.91737377f, -0.3483642108f, 0.1925298489f, 0, 0.2714911074f, 0.4147529736f, -0.8684886582f, 0, 0.5131763485f, -0.7116334161f, 0.4798207128f, 0, -0.8737353606f, 0.18886992f, -0.4482350644f, 0, 0.8460043821f, -0.3725217914f, 0.3814499973f, 0, 0.8978727456f, -0.1780209141f, -0.4026575304f, 0,
+    0.2178065647f, -0.9698322841f, -0.1094789531f, 0, -0.1518031304f, -0.7788918132f, -0.6085091231f, 0, -0.2600384876f, -0.4755398075f, -0.8403819825f, 0, 0.572313509f, -0.7474340931f, -0.3373418503f, 0, -0.7174141009f, 0.1699017182f, -0.6756111411f, 0, -0.684180784f, 0.02145707593f, -0.7289967412f, 0, -0.2007447902f, 0.06555605789f, -0.9774476623f, 0, -0.1148803697f, -0.8044887315f, 0.5827524187f, 0,
+    -0.7870349638f, 0.03447489231f, 0.6159443543f, 0, -0.2015596421f, 0.6859872284f, 0.6991389226f, 0, -0.08581082512f, -0.10920836f, -0.9903080513f, 0, 0.5532693395f, 0.7325250401f, -0.396610771f, 0, -0.1842489331f, -0.9777375055f, -0.1004076743f, 0, 0.0775473789f, -0.9111505856f, 0.4047110257f, 0, 0.1399838409f, 0.7601631212f, -0.6344734459f, 0, 0.4484419361f, -0.845289248f, 0.2904925424f, 0
+};
+
+}
+#endif // namespace fastnoiselite
diff --git a/thirdparty/noise/patches/FastNoiseLite.patch b/thirdparty/noise/patches/FastNoiseLite.patch
new file mode 100644
index 0000000000..acb1edfd73
--- /dev/null
+++ b/thirdparty/noise/patches/FastNoiseLite.patch
@@ -0,0 +1,18 @@
+--- orig/FastNoiseLite.h	1900-01-00 00:00:00 +0000
++++ noise/FastNoiseLite.h	1900-01-00 00:00:00 +0000
+@@ -52,6 +52,8 @@
+ 
+ #include <cmath>
+ 
++namespace fastnoiselite{
++
+ class FastNoiseLite
+ {
+ public:
+@@ -2583,4 +2585,5 @@
+     -0.7870349638f, 0.03447489231f, 0.6159443543f, 0, -0.2015596421f, 0.6859872284f, 0.6991389226f, 0, -0.08581082512f, -0.10920836f, -0.9903080513f, 0, 0.5532693395f, 0.7325250401f, -0.396610771f, 0, -0.1842489331f, -0.9777375055f, -0.1004076743f, 0, 0.0775473789f, -0.9111505856f, 0.4047110257f, 0, 0.1399838409f, 0.7601631212f, -0.6344734459f, 0, 0.4484419361f, -0.845289248f, 0.2904925424f, 0
+ };
+ 
+-#endif
++}
++#endif // namespace fastnoiselite