pure-noise 0.2.1.1 → 0.2.2.0
raw patch · 20 files changed
+3916/−201 lines, 20 filesdep +mtldep +splitmixdep −tasty-discoverdep ~tasty-benchdep ~vectorPVP ok
version bump matches the API change (PVP)
Dependencies added: mtl, splitmix
Dependencies removed: tasty-discover
Dependency ranges changed: tasty-bench, vector
API changes (from Hackage documentation)
+ Numeric.Noise: cellular3 :: (RealFrac a, Floating a) => CellularConfig a -> Noise3 a
+ Numeric.Noise: mkNoise1 :: (Seed -> p -> v) -> Noise1' p v
+ Numeric.Noise: mkNoise2 :: (Seed -> p -> p -> v) -> Noise2' p v
+ Numeric.Noise: mkNoise3 :: (Seed -> p -> p -> p -> v) -> Noise3' p v
+ Numeric.Noise: openSimplex3 :: RealFrac a => Noise3 a
+ Numeric.Noise: superSimplex3 :: RealFrac a => Noise3 a
+ Numeric.Noise.Cellular: noise3 :: (RealFrac a, Floating a) => CellularConfig a -> Noise3 a
+ Numeric.Noise.OpenSimplex: noise3 :: RealFrac a => Noise3 a
+ Numeric.Noise.OpenSimplex: noise3Base :: RealFrac a => Seed -> a -> a -> a -> a
+ Numeric.Noise.SuperSimplex: noise3 :: RealFrac a => Noise3 a
+ Numeric.Noise.SuperSimplex: noise3Base :: RealFrac a => Seed -> a -> a -> a -> a
Files
- CHANGELOG.md +49/−0
- LICENSE_FastNoiseLite +22/−0
- README.md +98/−25
- bench/Bench.hs +59/−103
- bench/fnl-compare/FnlBench.hs +234/−0
- bench/fnl-compare/cbits/FastNoiseLite.h +2586/−0
- bench/fnl-compare/fnl_bench_shim.cpp +54/−0
- pure-noise.cabal +94/−13
- src/Numeric/Noise.hs +54/−8
- src/Numeric/Noise/Cellular.hs +234/−23
- src/Numeric/Noise/Fractal.hs +10/−4
- src/Numeric/Noise/Internal.hs +24/−9
- src/Numeric/Noise/Internal/Math.hs +26/−3
- src/Numeric/Noise/OpenSimplex.hs +93/−5
- src/Numeric/Noise/SuperSimplex.hs +173/−2
- test/CellularSpec.hs +30/−0
- test/Golden/Util.hs +0/−6
- test/OpenSimplexSpec.hs +8/−0
- test/SuperSimplexSpec.hs +8/−0
- test/TotalitySpec.hs +60/−0
CHANGELOG.md view
@@ -8,6 +8,55 @@ ## Unreleased +## 0.2.2.0 2026-07-19++This is the final release of the 0.2.2.0 line.++### Added++- Exports for `mkNoise1`, `mkNoise2`, and `mkNoise3`, in case library users+ wish to hoist custom kernels.+- FastNoiseLite comparisons are now in-repository and reproducible. Comparison+ mechanism goes through tasty-bench.+- The sdist now includes `bench/fnl-compare/cbits/FastNoiseLite.h`, so the+ FNL comparison benchmark can build from a Hackage tarball.+- 3D counterparts for the simplex and cellular families: `openSimplex3`,+ `superSimplex3`, and `cellular3`.+- Flag `optimize`, with default `true`, which bumps the library's optimization level+ to `-O2` by default. Refer to the flag's documentation for rationale.+- Flag `mfma`, which will set `-mfma` for GHC, and may open pathways to+ fused-multiply-add optimizations+- Flag `mavx`, which will set `-mavx` for GHC, and may open pathways for AVX2+ SIMD optimization in the future.+- Flag `llvm-bench` (manual, default off) gating all LLVM-specific benchmark+ options (`-fllvm`, pinned `opt`/`llc`/`clang`, `-mavx`, `-mfma`,+ `-optlc-fp-contract=fast`).+- Benchmark runs now write a `.meta` provenance sidecar (toolchain versions,+ CPU governor/turbo state, AC power state, pinning) next to each CSV.++### Changed++- `pure-noise` now builds at `-O2` by default.+- Project now uses haskell.nix instead of Stack.+- Various updates to documentation, to improve quality+- Performance documentation and results tables re-collected on the 0.2.2.0+ toolchain (README.md and bench/README.md).+- `tested-with: GHC == 9.6.7, 9.8.4, 9.12.2`.++### Fixed++- Replace `round`-based rounding with a truncating `fastRound`. This replaces an+ `rintFloat` call in the core lowering with a `float2Int` call, which improves+ performance in hot loops.+ - This changes `cellular2` output at half-integer coordinates: cell selection+ now rounds half away from zero, matching FastNoiseLite's `FastRound`, rather+ than half to even. Numerically observable but visually imperceptible.+- Match FastNoiseLite's evaluation order in `openSimplex2`'s middle-corner+ contribution. Output changes by a few ULP.+- Fix an issue with the 3D benchmark harness where degenerate index math+ collapsed the sample set to ~4 distinct points, providing a poor signal on+ real-world performance.+ ## 0.2.1.1 2025-10-31 ### Changed
+ LICENSE_FastNoiseLite view
@@ -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.
README.md view
@@ -9,8 +9,9 @@ `Fractional`, `Monad`, etc). - **Complex effects** like domain warping and multi-octave fractals with clean, type-safe composition.-- **84-95% of C++ FastNoiseLite performance** through aggressive optimization and- LLVM compilation.+- **Competitive with C++**: roughly 70-100% of FastNoiseLite's single-threaded+ random-access throughput under the LLVM backend. And 2D cellular noise runs+ ahead of C++, measured against an optimized FNL build. **For detailed FastNoiseLite comparison, methodology, and reproducibility instructions, see the [benchmark README](https://github.com/jtnuttall/pure-noise/blob/main/bench/README.md).**@@ -24,7 +25,7 @@ - This project grew from a port of the excellent [FastNoiseLite](https://github.com/Auburn/FastNoiseLite) library. The library structure has been tuned to perform well in Haskell and fit well with Haskell- semantics, but the core noise implementations are the same.+ semantics, but the core noise share their origin with FNL. - All credit for the original design, algorithms, and implementation goes to its creator **[Jordan Peck (@Auburn)](https://github.com/Auburn)**. I'm grateful for their work and the opportunity to learn from it.@@ -32,6 +33,26 @@ were originally ported, is (C) 2020 Jordan Peck and is licensed under the MIT license, a copy of which is included in this repository. +## FastNoiseLite compatibility++pure-noise shares its lineage with FNL, but it isn't intended as a 1:1 port —+kernels are restructured for GHC, and some families intentionally diverge.+Where outputs stand today:++| family | output vs FNL |+| ---------------------------------------- | --------------------------------------------- |+| `perlin2/3`, `cellular2/3` | bit-exact |+| `openSimplex2/3`, `superSimplex2/3` | within a few ULP |+| `value2/3`, `valueCubic2/3` | diverges (hash finalization) |+| `fractal2/3`, `ridged2/3`, `pingPong2/3` | diverges (octave normalization and weighting) |+| `billow2/3` | no FNL counterpart |++> [!IMPORTANT]+>+> The `value`, `valueCubic`, and fractal families will align with FNL in 0.3,+> which changes their output for a given seed. Pin `pure-noise < 0.3` if you+> depend on seed-stable output from them.+ ## Usage The library provides composable noise functions. `Noise2` and `Noise3` are type@@ -136,47 +157,99 @@ ## Performance notes -- In single-threaded scenarios with LLVM enabled, this library achieves **84-95%- of C++ FastNoiseLite performance**.-- This library benefits considerably from compilation with the LLVM backend- (`-fllvm`). Benchmarks suggest a ~50-80% difference depending on the kind of noise.+- In single-threaded scenarios with LLVM enabled, this library reaches+ **roughly 70-100% of C++ FastNoiseLite throughput at random access, with 2D+ cellular noise ~7% faster than C++**. Grid-coherent workloads measure lower+ for the simplex family. These numbers are measured against an optimized+ FNL build (AVX2+FMA, FP contraction on).+- This library performs significantly better under the LLVM backend+ (`-fllvm`); the native code generator is not recommended where generation+ speed is a real concern.+- See the [benchmark README](https://github.com/jtnuttall/pure-noise/blob/main/bench/README.md)+ for per-algorithm, per-workload results and methodology. +### Recommended build flags++#### Native optimization flags for the library++For the library itself, copy `cabal.project.local.template` into your project+(`+optimize` is on by default; `+mfma +mavx` are safe on modern x86-64).++For bulk generation, prefer parallel evaluation via `massiv`.++#### Fused multiply add++For the fastest downstream executables, compile the modules that _call_ the+noise functions (the kernels inline into your code) with:++```+-fllvm -mavx -mfma -optlc-fp-contract=fast+```++> [!WARNING]+>+> 1. Results differ from a build without fma fusion by a few ULP.+> 2. Fusion decisions may vary across LLVM versions.+> Skip this flag if you need bit-identical output across builds/toolchains.+> 3. You must use `-fllvm` to use this flag. It has no effect on the native+> code generator.++`-optlc-fp-contract=fast` lets LLVM fuse multiply-add chains into FMA+instructions, an optimization modern C++ compilers apply by default. This+gives a ~5-15% improvement on these kernels in testing.+ ### Parallel noise generation This library integrates well with [massiv](https://hackage.haskell.org/package/massiv)-for parallel computation. Parallel performance can reach 10-15x single-threaded-performance.+for parallel computation. Parallel evaluation reaches roughly 6-9x+single-threaded throughput on a 14-core machine in pinned-clock measurements. -**This is the recommended approach for generating large noise textures or datasets.**+> [!IMPORTANT]+>+> Massiv integration is the recommended approach for generating large noise+> textures or datasets. ### Benchmarks #### Results -Measured by values / second generated by the noise functions. These results come-from a benchmark with `-fllvm` enabled.+Measured by values / second generated by the noise functions, in the+`llvm-bench` configuration (LLVM backend + FP contraction), on an i7-1370P+**pinned at 1.9 GHz** for measurement stability — -There's inevitably some noise in the measurements because all of the results are-forced into an unboxed vector.+Absolute figures scale with CPU clock. The FastNoiseLite ratios are intended+to be clock-invariant. +There's inevitably some noise in the measurements because the results are forced+into an unboxed vector.++> [!NOTE]+>+> These numbers are lower than the initial release because they were re-run on a+> slower processor. Order-of-magnitude/comparative difference remains reasonably+> stable. See the benchmark README for details.+ ##### 2D | name | Float (values/sec) | Double (values/sec) | | ------------- | ------------------ | ------------------- |-| value2 | 173_511_654 | 189_119_731 |-| perlin2 | 154_674_464 | 161_114_532 |-| openSimplex2 | 74_747_031 | 74_332_345 |-| valueCubic2 | 61_415_544 | 62_481_313 |-| superSimplex2 | 51_295_369 | 50_383_577 |-| cellular2 | 34_996_382 | 32_652_899 |+| value2 | 64_407_126 | 68_260_653 |+| perlin2 | 61_301_663 | 65_143_707 |+| openSimplex2 | 25_982_291 | 27_045_472 |+| valueCubic2 | 22_743_642 | 23_403_842 |+| superSimplex2 | 17_167_069 | 17_762_669 |+| cellular2 | 16_025_950 | 16_007_044 | ##### 3D -| name | Float (values/sec) | Double (values/sec) |-| ----------- | ------------------ | ------------------- |-| value3 | 90_805_572 | 93_188_363 |-| perlin3 | 74_080_032 | 82_477_882 |-| valueCubic3 | 18_765_912 | 18_284_749 |+| name | Float (values/sec) | Double (values/sec) |+| ------------- | ------------------ | ------------------- |+| value3 | 34_673_623 | 35_929_146 |+| perlin3 | 29_325_590 | 30_432_482 |+| openSimplex3 | 10_975_857 | 10_922_644 |+| superSimplex3 | 9_232_128 | 9_166_843 |+| valueCubic3 | 7_453_365 | 7_278_612 |+| cellular3 | 5_238_497 | 5_061_911 | ## Examples
bench/Bench.hs view
@@ -3,7 +3,7 @@ import Data.Typeable import Data.Vector.Unboxed qualified as U import Numeric.Noise-import System.Random.Stateful+import System.Random.Stateful (StatefulGen, UniformRange, newAtomicGenM, newStdGen, uniformRM) main :: IO () main = do@@ -27,16 +27,17 @@ "3D" ( baseline3 sz <> benchPerlin3 octaves sz+ <> benchOpenSimplex3 octaves sz+ <> benchSuperSimplex3 octaves sz <> benchValue3 octaves sz <> benchValueCubic3 octaves sz+ <> benchCellular3 sz ) , bgroup "2D massiv" ( benchMassivBase2 massivW massivH <> benchMassivFractal2 octaves massivW massivH )- , bgroup "FNL compare 2D" benchFnlCompare2D- , bgroup "FNL compare 3D" benchFnlCompare3D ] label :: (Typeable a) => String -> Int -> Proxy a -> String@@ -242,66 +243,21 @@ ] ] --- | Create environment for FNL-style 2D benchmarks with integer-aligned coordinates--- Mimics FastNoiseLite's benchmark methodology exactly:--- for(y = 0; y < gridSize; y++)--- for(x = 0; x < gridSize; x++)--- noise(float(x), float(y))-createEnvFnl2 :: Int -> IO (Seed, U.Vector (Float, Float))-createEnvFnl2 gridSize = do- g <- newAtomicGenM =<< newStdGen- seed <- uniformRM (minBound, maxBound) g- let v = U.generate (gridSize * gridSize) $ \i ->- let x = fromIntegral (i `mod` gridSize) :: Float- y = fromIntegral (i `div` gridSize) :: Float- in (x, y)- pure (seed, v)-{-# INLINE createEnvFnl2 #-}---- | Benchmark for FNL comparison (integer coordinates, Float only)--- Uses foldl' to avoid vector materialization overhead, matching FNL's DoNotOptimize approach--- Sums results to prevent DCE while keeping overhead minimal-benchFnlCompare2- :: String- -> Int- -> Noise2 Float- -> Benchmark-benchFnlCompare2 lbl gridSize f =- env (createEnvFnl2 gridSize) $ \ ~(seed, v) ->- bench (lbl <> ": Float (FNL grid) x" <> show (gridSize * gridSize)) $- nf (\vec -> U.foldl' (\acc (x, y) -> acc + (noise2At f seed) x y) 0 vec) v-{-# INLINE benchFnlCompare2 #-}---- | FNL-style 2D benchmarks: 512x512 grid with integer coordinates-benchFnlCompare2D :: [Benchmark]-benchFnlCompare2D =- let gridSize = 512- in [ bgroup- "FNL compare"- [ benchFnlCompare2 "value2" gridSize value2- , benchFnlCompare2 "perlin2" gridSize perlin2- , benchFnlCompare2 "openSimplex2" gridSize openSimplex2- , benchFnlCompare2 "superSimplex2" gridSize superSimplex2- , benchFnlCompare2 "valueCubic2" gridSize valueCubic2- , benchFnlCompare2- "cellular2 (Distance)"- gridSize- (cellular2 defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = Distance})- ]- ]-+-- offsets are drawn per element (like createEnv2) and the strides are+-- independent per axis; the previous version drew one offset triple and+-- collapsed the index math to ~4 distinct points createEnv3 :: (U.Unbox a, UniformRange a, RealFrac a) => Int -> IO (Seed, U.Vector (a, a, a)) createEnv3 sz = do g <- newAtomicGenM =<< newStdGen seed <- uniformRM (minBound, maxBound) g- offsetX <- uniformRM (0.00001, 0.99999) g- offsetY <- uniformRM (0.00001, 0.99999) g- offsetZ <- uniformRM (0.00001, 0.99999) g+ let d = ceiling (fromIntegral sz ** (1 / 3) :: Double) !ixs <- U.generateM sz $ \i -> do- let d = sz `div` 3- !x = fromIntegral $ i `div` d `mod` d- !y = fromIntegral $ i `div` (d * d)- !z = fromIntegral $ i `div` d+ offsetX <- uniformRM (0.00001, 0.99999) g+ offsetY <- uniformRM (0.00001, 0.99999) g+ offsetZ <- uniformRM (0.00001, 0.99999) g+ let !x = fromIntegral (i `mod` d)+ !y = fromIntegral ((i `div` d) `mod` d)+ !z = fromIntegral (i `div` (d * d)) pure (x + offsetX, y + offsetY, z + offsetZ) pure (seed, ixs) {-# INLINE createEnv3 #-}@@ -345,6 +301,51 @@ ] ] +benchOpenSimplex3 :: Int -> Int -> [Benchmark]+benchOpenSimplex3 octaves sz =+ [ bgroup+ "openSimplex3"+ [ benchMany3 @Float "" sz openSimplex3+ , benchMany3 @Double "" sz openSimplex3+ , benchMany3 @Float "fractal" sz (fractal3 defaultFractalConfig{octaves} openSimplex3)+ , benchMany3 @Double "fractal" sz (fractal3 defaultFractalConfig{octaves} openSimplex3)+ ]+ ]++benchSuperSimplex3 :: Int -> Int -> [Benchmark]+benchSuperSimplex3 octaves sz =+ [ bgroup+ "superSimplex3"+ [ benchMany3 @Float "" sz superSimplex3+ , benchMany3 @Double "" sz superSimplex3+ , benchMany3 @Float "fractal" sz (fractal3 defaultFractalConfig{octaves} superSimplex3)+ , benchMany3 @Double "fractal" sz (fractal3 defaultFractalConfig{octaves} superSimplex3)+ ]+ ]++benchCellular3 :: Int -> [Benchmark]+benchCellular3 sz =+ [ bgroup+ "cellular3"+ [ benchMany3 @Float+ "DistEuclidean CellValue"+ sz+ (cellular3 defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = CellValue})+ , benchMany3 @Float+ "DistEuclidean Distance2Add"+ sz+ (cellular3 defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = Distance2Add})+ , benchMany3 @Double+ "DistEuclidean CellValue"+ sz+ (cellular3 defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = CellValue})+ , benchMany3 @Double+ "DistEuclidean Distance2Add"+ sz+ (cellular3 defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = Distance2Add})+ ]+ ]+ benchValue3 :: Int -> Int -> [Benchmark] benchValue3 octaves sz = [ bgroup@@ -378,51 +379,6 @@ , benchMany3 @Double "pingPong" sz (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength valueCubic3) ] ]---- | Create environment for FNL-style 3D benchmarks with integer-aligned coordinates--- Mimics FastNoiseLite's benchmark methodology exactly:--- for(z = 0; z < gridSize; z++)--- for(y = 0; y < gridSize; y++)--- for(x = 0; x < gridSize; x++)--- noise(float(x), float(y), float(z))-createEnvFnl3 :: Int -> IO (Seed, U.Vector (Float, Float, Float))-createEnvFnl3 gridSize = do- g <- newAtomicGenM =<< newStdGen- seed <- uniformRM (minBound, maxBound) g- let gridSq = gridSize * gridSize- v = U.generate (gridSize * gridSize * gridSize) $ \i ->- let x = fromIntegral (i `mod` gridSize) :: Float- y = fromIntegral ((i `div` gridSize) `mod` gridSize) :: Float- z = fromIntegral (i `div` gridSq) :: Float- in (x, y, z)- pure (seed, v)-{-# INLINE createEnvFnl3 #-}---- | Benchmark for FNL 3D comparison (integer coordinates, Float only)--- Uses foldl' to avoid vector materialization overhead, matching FNL's DoNotOptimize approach--- Sums results to prevent DCE while keeping overhead minimal-benchFnlCompare3- :: String- -> Int- -> Noise3 Float- -> Benchmark-benchFnlCompare3 lbl gridSize f =- env (createEnvFnl3 gridSize) $ \ ~(seed, v) ->- bench (lbl <> ": Float (FNL grid) x" <> show (gridSize * gridSize * gridSize)) $- nf (\vec -> U.foldl' (\acc (x, y, z) -> acc + noise3At f seed x y z) 0 vec) v-{-# INLINE benchFnlCompare3 #-}---- | FNL-style 3D benchmarks: 64x64x64 grid with integer coordinates-benchFnlCompare3D :: [Benchmark]-benchFnlCompare3D =- let gridSize = 64- in [ bgroup- "FNL compare"- [ benchFnlCompare3 "value3" gridSize value3- , benchFnlCompare3 "perlin3" gridSize perlin3- , benchFnlCompare3 "valueCubic3" gridSize valueCubic3- ]- ] benchMassiv2 :: forall a
+ bench/fnl-compare/FnlBench.hs view
@@ -0,0 +1,234 @@+-- | Performance comparison against the vendored FastNoiseLite+--+-- Ratios are printed by tasty-bench's 'bcompare': each @pure-noise@ line ends+-- with e.g. @1.05x@ = its mean time relative to the matching @fnl@ line+-- (lower is better; 1.05x means pure-noise is 5% slower).+--+-- Ratios only print when the matching fnl benchmark runs in the same invocation,+-- so filter by group (e.g. @-p \/perlin\/@), not by side.+module Main (main) where++import Control.Monad.State.Strict (evalState, state)+import Data.Vector.Storable qualified as S+import Foreign.C.Types (CFloat (..), CInt (..))+import Foreign.Ptr (Ptr)+import Numeric.Noise+import System.Random.SplitMix (SMGen, mkSMGen, nextFloat)+import Test.Tasty.Bench+import Test.Tasty.Patterns.Printer (printAwkExpr)++main :: IO ()+main =+ defaultMain (map (mapLeafBenchmarks addCompare) benchmarks)++-- | Attach a bcompare ratio to every pure-noise leaf, targeting the fnl leaf+-- in the same group (the pattern matches exactly one benchmark).+addCompare :: [String] -> Benchmark -> Benchmark+addCompare (leaf : path) b+ | leaf == pnLeaf = bcompare (printAwkExpr (locateBenchmark (fnlLeaf : path))) b+addCompare _ b = b++fnlLeaf, pnLeaf :: String+fnlLeaf = "fnl x" <> show samples+pnLeaf = "pure-noise x" <> show samples++benchmarks :: [Benchmark]+benchmarks =+ [ env mkEnv2 $ \ ~(grid, rand, kOne, kSmall) ->+ bgroup+ "2D"+ [ algo2 grid rand kOne kSmall "value" fnlValue value2+ , algo2 grid rand kOne kSmall "valueCubic" fnlValueCubic valueCubic2+ , algo2 grid rand kOne kSmall "perlin" fnlPerlin perlin2+ , algo2 grid rand kOne kSmall "openSimplex2" fnlOpenSimplex2 openSimplex2+ , algo2 grid rand kOne kSmall "superSimplex2" fnlOpenSimplex2S superSimplex2+ , algo2 grid rand kOne kSmall "cellular" fnlCellular (cellular2 benchCellularConfig)+ ]+ , env mkEnv3 $ \ ~(grid, rand, kOne, kSmall) ->+ bgroup+ "3D"+ [ algo3 grid rand kOne kSmall "value" fnlValue value3+ , algo3 grid rand kOne kSmall "valueCubic" fnlValueCubic valueCubic3+ , algo3 grid rand kOne kSmall "perlin" fnlPerlin perlin3+ , algo3 grid rand kOne kSmall "openSimplex2" fnlOpenSimplex2 openSimplex3+ , algo3 grid rand kOne kSmall "superSimplex2" fnlOpenSimplex2S superSimplex3+ , algo3 grid rand kOne kSmall "cellular" fnlCellular (cellular3 benchCellularConfig)+ ]+ ]++algo2+ :: (S.Vector Float, S.Vector Float)+ -> (S.Vector Float, S.Vector Float)+ -> Float+ -> Float+ -> String+ -> CInt+ -> Noise2 Float+ -> Benchmark+algo2 grid rand kOne kSmall name ty nz =+ bgroup+ name+ [ bgroup "grid" (pair grid kOne)+ , bgroup "freq001" (pair grid kSmall)+ , bgroup "random" (pair rand kOne)+ ]+ where+ pair ~(xs, ys) k =+ [ bench fnlLeaf $ whnfIO (fnlSum2 ty k xs ys)+ , bench pnLeaf $ whnf (\kk -> sumNoise2 nz kk xs ys) k+ ]+{-# INLINE algo2 #-}++algo3+ :: (S.Vector Float, S.Vector Float, S.Vector Float)+ -> (S.Vector Float, S.Vector Float, S.Vector Float)+ -> Float+ -> Float+ -> String+ -> CInt+ -> Noise3 Float+ -> Benchmark+algo3 grid rand kOne kSmall name ty nz =+ bgroup+ name+ [ bgroup "grid" (pair grid kOne)+ , bgroup "freq001" (pair grid kSmall)+ , bgroup "random" (pair rand kOne)+ ]+ where+ -- lazy pattern: see algo2+ pair ~(xs, ys, zs) k =+ [ bench fnlLeaf $ whnfIO (fnlSum3 ty k xs ys zs)+ , bench pnLeaf $ whnf (\kk -> sumNoise3 nz kk xs ys zs) k+ ]+{-# INLINE algo3 #-}++----------------------------------------------------------------------------------------------------+-- Matched sweeps+----------------------------------------------------------------------------------------------------++sumNoise2 :: Noise2 Float -> Float -> S.Vector Float -> S.Vector Float -> Float+sumNoise2 nz k xs ys = go 0 0+ where+ !n = S.length xs+ go !i !acc+ | i >= n = acc+ | otherwise =+ go (i + 1) (acc + noise2At nz benchSeed (k * S.unsafeIndex xs i) (k * S.unsafeIndex ys i))+{-# INLINE sumNoise2 #-}++sumNoise3 :: Noise3 Float -> Float -> S.Vector Float -> S.Vector Float -> S.Vector Float -> Float+sumNoise3 nz k xs ys zs = go 0 0+ where+ !n = S.length xs+ go !i !acc+ | i >= n = acc+ | otherwise =+ go+ (i + 1)+ (acc + noise3At nz benchSeed (k * S.unsafeIndex xs i) (k * S.unsafeIndex ys i) (k * S.unsafeIndex zs i))+{-# INLINE sumNoise3 #-}++----------------------------------------------------------------------------------------------------+-- FFI (fnl_bench_shim.cpp)+----------------------------------------------------------------------------------------------------++foreign import ccall unsafe "fnl_bench_sum2"+ c_fnlSum2 :: CInt -> CInt -> CFloat -> CInt -> Ptr Float -> Ptr Float -> IO CFloat++foreign import ccall unsafe "fnl_bench_sum3"+ c_fnlSum3 :: CInt -> CInt -> CFloat -> CInt -> Ptr Float -> Ptr Float -> Ptr Float -> IO CFloat++fnlSum2 :: CInt -> Float -> S.Vector Float -> S.Vector Float -> IO Float+fnlSum2 ty k xs ys =+ S.unsafeWith xs $ \px ->+ S.unsafeWith ys $ \py -> do+ CFloat r <- c_fnlSum2 ty fnlBenchSeed (CFloat k) (fromIntegral (S.length xs)) px py+ pure r++fnlSum3 :: CInt -> Float -> S.Vector Float -> S.Vector Float -> S.Vector Float -> IO Float+fnlSum3 ty k xs ys zs =+ S.unsafeWith xs $ \px ->+ S.unsafeWith ys $ \py ->+ S.unsafeWith zs $ \pz -> do+ CFloat r <- c_fnlSum3 ty fnlBenchSeed (CFloat k) (fromIntegral (S.length xs)) px py pz+ pure r++fnlOpenSimplex2, fnlOpenSimplex2S, fnlCellular, fnlPerlin, fnlValueCubic, fnlValue :: CInt+fnlOpenSimplex2 = 0+fnlOpenSimplex2S = 1+fnlCellular = 2+fnlPerlin = 3+fnlValueCubic = 4+fnlValue = 5++-- 1337 is the FNL bench convention.+benchSeed :: Seed+benchSeed = 1337++fnlBenchSeed :: CInt+fnlBenchSeed = 1337++benchCellularConfig :: CellularConfig Float+benchCellularConfig = defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = Distance}++-- ---------------------------------------------------------------------------+-- Coordinate environments (built once per dimension)+-- ---------------------------------------------------------------------------++-- n = 262144 everywhere: 512*512 (2D grid), 64^3 (3D grid), and the random+-- streams, so every leaf carries the same "xN" count for vps.py.+gridSize2, gridSize3, samples :: Int+gridSize2 = 512+gridSize3 = 64+samples = gridSize2 * gridSize2++-- (grid xs/ys, random xs/ys, kOne = 1.0, kSmall = 0.01). The ks come out of+-- the IO action so the simplifier cannot constant-fold the per-point multiply+-- on the Haskell side only.+mkEnv2 :: IO ((S.Vector Float, S.Vector Float), (S.Vector Float, S.Vector Float), Float, Float)+mkEnv2 = pure (mkGrid2, mkRand2 samples, 1.0, 0.01)++mkEnv3+ :: IO+ ( (S.Vector Float, S.Vector Float, S.Vector Float)+ , (S.Vector Float, S.Vector Float, S.Vector Float)+ , Float+ , Float+ )+mkEnv3 = pure (mkGrid3, mkRand3 samples, 1.0, 0.01)++-- Integer lattice in FNL benchmark loop order (x fastest, then y, then z).+mkGrid2 :: (S.Vector Float, S.Vector Float)+mkGrid2 =+ ( S.generate samples (\i -> fromIntegral (i `mod` gridSize2))+ , S.generate samples (\i -> fromIntegral (i `div` gridSize2))+ )++mkGrid3 :: (S.Vector Float, S.Vector Float, S.Vector Float)+mkGrid3 =+ ( S.generate samples (\i -> fromIntegral (i `mod` gridSize3))+ , S.generate samples (\i -> fromIntegral ((i `div` gridSize3) `mod` gridSize3))+ , S.generate samples (\i -> fromIntegral (i `div` (gridSize3 * gridSize3)))+ )++smgen :: SMGen+smgen = mkSMGen 0x9E3779B97F4A7C15++draws :: Int -> S.Vector Float+draws n = S.map (* 512) . evalState (S.generateM n . const . state $ nextFloat) $ smgen++mkRand2 :: Int -> (S.Vector Float, S.Vector Float)+mkRand2 n =+ let v = draws (2 * n)+ in ( S.generate n (\i -> v S.! (2 * i))+ , S.generate n (\i -> v S.! (2 * i + 1))+ )++mkRand3 :: Int -> (S.Vector Float, S.Vector Float, S.Vector Float)+mkRand3 n =+ let v = draws (3 * n)+ in ( S.generate n (\i -> v S.! (3 * i))+ , S.generate n (\i -> v S.! (3 * i + 1))+ , S.generate n (\i -> v S.! (3 * i + 2))+ )
+ bench/fnl-compare/cbits/FastNoiseLite.h view
@@ -0,0 +1,2586 @@+// MIT License+//+// Copyright(c) 2023 Jordan Peck (jordan.me2@gmail.com)+// Copyright(c) 2023 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.1.1+// https://github.com/Auburn/FastNoiseLite++#ifndef FASTNOISELITE_H+#define FASTNOISELITE_H++#include <cmath>++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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ // 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) const+ {+ // 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) const+ {+ // 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) const+ {+ // 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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) const+ {+ 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+ {+ 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) const+ {+ 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
+ bench/fnl-compare/fnl_bench_shim.cpp view
@@ -0,0 +1,54 @@+// Bulk-loop shim over the vendored FastNoiseLite.h (./cbits/FastNoiseLite.h)+// to provide a fair comparison to FNL.+//+// Sticking the loop in C++ should prevent FFI overhead from skewing results. +// Unsafe calls should have double-digit nanosecond overhead, so the signal from +// the bench itself should dominate.+//+// tasty-bench handles timing and statistics; simpler and less numerically fraught +// than trying to cross-compare Google benchmark to tasty/criterion.+//+// This should be compiled the way a user would build FNL: -O3 -march=native. We+// want to give C++ every edge it can have for a meaningful comparison.+//+// NOTE: noiseType convention is:+// 0=OpenSimplex2 +// 1=OpenSimplex2S +// 2=Cellular +// 3=Perlin +// 4=ValueCubic +// 5=Value+#include "FastNoiseLite.h"++static FastNoiseLite mk(int noiseType, int seed, float freq) {+ FastNoiseLite fnl(seed);+ fnl.SetNoiseType(static_cast<FastNoiseLite::NoiseType>(noiseType));+ // pure-noise's loop multiplies every coordinate by a runtime k; FNL pays+ // the same multiply here via mFrequency.+ fnl.SetFrequency(freq);+ if (noiseType == 2) { // match audit-bench: Euclidean distance, Distance result+ fnl.SetCellularDistanceFunction(FastNoiseLite::CellularDistanceFunction_Euclidean);+ fnl.SetCellularReturnType(FastNoiseLite::CellularReturnType_Distance);+ }+ return fnl;+}++extern "C" {++float fnl_bench_sum2(int noiseType, int seed, float freq, int n,+ const float* __restrict xs, const float* __restrict ys) {+ FastNoiseLite fnl = mk(noiseType, seed, freq);+ float acc = 0.0f;+ for (int i = 0; i < n; i++) acc += fnl.GetNoise(xs[i], ys[i]);+ return acc;+}++float fnl_bench_sum3(int noiseType, int seed, float freq, int n,+ const float* __restrict xs, const float* __restrict ys, const float* __restrict zs) {+ FastNoiseLite fnl = mk(noiseType, seed, freq);+ float acc = 0.0f;+ for (int i = 0; i < n; i++) acc += fnl.GetNoise(xs[i], ys[i], zs[i]);+ return acc;+}++} // extern "C"
pure-noise.cabal view
@@ -1,32 +1,32 @@ cabal-version: 2.2 --- This file has been generated from package.yaml by hpack version 0.38.1.+-- This file has been generated from package.yaml by hpack version 0.39.6. -- -- see: https://github.com/sol/hpack name: pure-noise-version: 0.2.1.1-synopsis: High-performance composable noise generation (Perlin, Simplex, Cellular)-description: A high-performance noise generation library ported from FastNoiseLite.- Provides N-dimensional noise functions (Perlin, OpenSimplex, SuperSimplex,- Value, Cellular) that can be composed using Num or Fractional methods with- minimal performance overhead. Noise values are generally clamped to [-1, 1].- Benefits significantly from LLVM backend compilation (~50-80% performance improvement).+version: 0.2.2.0+synopsis: Performant, modern noise generation (Perlin, OpenSimplex2, Cellular)+description: Fast, modern noise generation In pure Haskell with an algebraic interface.+ Provides Perlin, OpenSimplex2, OpenSimplex2S, Value, and Cellular noise variants. category: Math, Numeric, Noise homepage: https://github.com/jtnuttall/pure-noise#readme bug-reports: https://github.com/jtnuttall/pure-noise/issues author: Jeremy Nuttall maintainer: jeremy@jeremy-nuttall.com-copyright: 2024 Jeremy Nuttall+copyright: 2026 Jeremy Nuttall license: BSD-3-Clause license-file: LICENSE build-type: Simple tested-with: GHC == 9.6.7 , GHC == 9.8.4- , GHC == 9.10.2+ , GHC == 9.12.2 extra-source-files: README.md+ LICENSE+ LICENSE_FastNoiseLite+ bench/fnl-compare/cbits/FastNoiseLite.h extra-doc-files: CHANGELOG.md @@ -34,6 +34,39 @@ type: git location: https://github.com/jtnuttall/pure-noise +flag llvm-bench+ description: Build the benchmark suites via GHC's LLVM backend with a pinned toolchain+ (-fllvm, -pgmlo opt, -pgmlc llc, -pgmlas clang) plus -mavx -mfma and fast+ FP contraction in llc (-optlc-fp-contract=fast). Requires opt/llc/clang+ on PATH (LLVM <= 19 for GHC 9.12) and GHC >= 9.10 (for -pgmlas). Off by+ default so `cabal build --enable-benchmarks` works on machines and CI+ runners without LLVM. Published benchmark numbers are collected with this+ flag on; see bench/README.md.+ manual: True+ default: False++flag mavx+ description: Compile with AVX instructions+ manual: True+ default: False++flag mfma+ description: Compile with native fused-multiply-add instructions+ manual: True+ default: False++flag optimize+ description: Turns on -O2 for pure-noise. Since the library is pretty small, this shouldn't be+ too much trouble, but you can disable this flag if it's slowing your builds too+ much.+ .+ Rationale:+ - -O1 leaves ~3x on the table for tight noise loops in downstream code.+ - -O2 seems to produce higher-quality unfoldings, which in turn causes pure-noise's+ kernels to inline and optimize more reliably at call sites.+ manual: True+ default: True+ library exposed-modules: Numeric.Noise@@ -57,6 +90,14 @@ base >=4.16 && <5 , primitive >=0.8 && <0.10 default-language: GHC2021+ if flag(optimize)+ ghc-options: -O2+ if flag(mfma)+ ghc-options: -mfma+ cpp-options: -DHAS_FMA+ if flag(mavx)+ ghc-options: -mavx+ cpp-options: -DHAS_AVX test-suite pure-noise-test type: exitcode-stdio-1.0@@ -70,6 +111,7 @@ OpenSimplexSpec PerlinSpec SuperSimplexSpec+ TotalitySpec ValueCubicSpec ValueSpec Paths_pure_noise@@ -78,6 +120,8 @@ hs-source-dirs: test ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -Wno-missing-export-lists -threaded -rtsopts -with-rtsopts=-N+ build-tool-depends:+ tasty-discover:tasty-discover build-depends: JuicyPixels ==3.3.* , aeson >=2.0 && <2.3@@ -90,7 +134,6 @@ , primitive >=0.8 && <0.10 , pure-noise , tasty- , tasty-discover , tasty-golden , tasty-hunit , tasty-quickcheck@@ -108,7 +151,7 @@ Paths_pure_noise hs-source-dirs: bench- ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -threaded -rtsopts -with-rtsopts=-N +RTS -A32m --nonmoving-gc -T -RTS -O2 -optc-O3 -fsimpl-tick-factor=1000+ ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -threaded -rtsopts "-with-rtsopts=-N -A32m -T" -O2 -fsimpl-tick-factor=1000 build-depends: base >=4.16 && <5 , deepseq@@ -118,5 +161,43 @@ , random , tasty , tasty-bench- , vector <=0.14+ , vector >=0.12 && <0.14 default-language: GHC2021+ if flag(llvm-bench)+ ghc-options: -fllvm -pgmlo opt -pgmlc llc -pgmlas clang -mavx -mfma -optlc-fp-contract=fast++benchmark pure-noise-fnl-bench+ type: exitcode-stdio-1.0+ main-is: FnlBench.hs+ other-modules:+ Paths_pure_noise+ autogen-modules:+ Paths_pure_noise+ hs-source-dirs:+ bench/fnl-compare+ ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -threaded -rtsopts "-with-rtsopts=-A64m -T" -O2 -fsimpl-tick-factor=1000+ cxx-options: -O3 -std=c++14 -ffp-contract=fast -fstrict-overflow+ include-dirs:+ bench/fnl-compare/cbits+ cxx-sources:+ bench/fnl-compare/fnl_bench_shim.cpp+ build-depends:+ base >=4.16 && <5+ , mtl >=2.1 && <2.4+ , primitive >=0.8 && <0.10+ , pure-noise+ , splitmix ==0.1.*+ , tasty+ , tasty-bench >=0.4 && <0.6+ , vector >=0.12 && <0.14+ default-language: GHC2021+ if flag(llvm-bench)+ ghc-options: -fllvm -pgmlo opt -pgmlc llc -pgmlas clang -mavx -mfma -optlc-fp-contract=fast+ if arch(x86_64)+ cxx-options: -march=x86-64-v3+ if os(darwin)+ extra-libraries:+ c+++ else+ extra-libraries:+ stdc++
src/Numeric/Noise.hs view
@@ -12,8 +12,8 @@ -- type aliases for 2D and 3D noise. These can be composed algebraically -- with minimal performance overhead. ----- Noise values are generally clamped to @[-1, 1]@, though some functions may--- occasionally produce values slightly outside this range.+-- Noise values are generally clamped to @[-1, 1]@, although some noise+-- functions may occasionally produce values slightly outside this range. -- -- == Basic Usage --@@ -61,15 +61,28 @@ -- scaledAndLayered :: Noise.Noise2 Float -- scaledAndLayered = -- Noise.warp (\\(x, y) -> (x * 2, y * 2)) Noise.perlin2--- + fmap (logBase 2) Noise.perlin2+-- + fmap (* 0.5) Noise.perlin2 -- @ -- -- Layer independent noise with 'reseed' or 'next2': -- -- @ -- layered :: Noise.Noise2 Float--- layered = Noise.perlin2 + Noise.next2 Noise.perlin2 \/ 2+-- layered = (Noise.perlin2 + Noise.next2 Noise.perlin2) \/ 2 -- @+--+-- == Coordinate domain+--+-- Coordinates are supported on the Int32 lattice range (@|x| < 2^31@; in+-- practice 'Float' precision runs out well before that).+--+-- The OpenSimplex2\/2S family first rotates coordinates into its lattice domain,+-- which shrinks its usable range by the rotation factor — up to ~1.73x, so roughly+-- @|x| < 1.2e9@.+--+-- Outside those domains, or for non-finite inputs, results are unspecified.+--+-- This behavior mirrors FastNoiseLite, but may change in a future major version. module Numeric.Noise ( -- * Noise @@ -102,12 +115,15 @@ -- ** OpenSimplex openSimplex2,+ openSimplex3, -- ** OpenSimplex2S superSimplex2,+ superSimplex3, -- ** Cellular cellular2,+ cellular3, -- *** Configuration CellularConfig (..),@@ -127,9 +143,10 @@ -- * Noise alteration - -- ** Altering values+ -- ** Altering values remap,- -- ** Altering parameters++ -- ** Altering parameters warp, reseed, next2,@@ -149,8 +166,8 @@ -- | Fractal noise combines multiple octaves at different frequencies and -- amplitudes to create natural-looking, multi-scale patterns. --- -- For custom fractal implementations using modifier functions, see- -- "Numeric.Noise.Fractal".+ -- For custom fractal implementations using per-octave modifier functions,+ -- see "Numeric.Noise.Fractal". -- ** Fractal Brownian Motion (FBM) fractal2,@@ -170,6 +187,18 @@ PingPongStrength (..), defaultPingPongStrength, + -- * Custom kernels++ --++ -- | Lift a plain @seed -> coordinates -> value@ function into a composable+ -- 'Noise' value — the inverses of the accessors above.+ --+ -- You may use these to construct custom kernels.+ mkNoise1,+ mkNoise2,+ mkNoise3,+ -- * Math utilities clamp, clamp2,@@ -199,17 +228,34 @@ cellular2 = Cellular.noise2 {-# INLINE cellular2 #-} +-- | 3D Cellular (Worley) noise. See 'cellular2'.+cellular3 :: (RealFrac a, Floating a) => CellularConfig a -> Noise3 a+cellular3 = Cellular.noise3+{-# INLINE cellular3 #-}+ -- | 2D OpenSimplex noise. Smooth gradient noise similar to Perlin but without -- directional artifacts. openSimplex2 :: (RealFrac a) => Noise2 a openSimplex2 = OpenSimplex.noise2 {-# INLINE openSimplex2 #-} +-- | 3D OpenSimplex noise (FastNoiseLite's OpenSimplex2, two offset rotated+-- cube grids), including its default coordinate rotation.+openSimplex3 :: (RealFrac a) => Noise3 a+openSimplex3 = OpenSimplex.noise3+{-# INLINE openSimplex3 #-}+ -- | 2D SuperSimplex noise. Improved OpenSimplex variant with better visual -- characteristics. superSimplex2 :: (RealFrac a) => Noise2 a superSimplex2 = SuperSimplex.noise2 {-# INLINE superSimplex2 #-}++-- | 3D SuperSimplex noise (FastNoiseLite's OpenSimplex2S, two offset rotated+-- cube grids), including its default coordinate rotation.+superSimplex3 :: (RealFrac a) => Noise3 a+superSimplex3 = SuperSimplex.noise3+{-# INLINE superSimplex3 #-} -- | 2D Perlin noise. Classic gradient noise algorithm. perlin2 :: (RealFrac a) => Noise2 a
src/Numeric/Noise/Cellular.hs view
@@ -15,6 +15,9 @@ -- * 2D Noise noise2,++ -- * 3D Noise+ noise3, ) where import Data.Bits@@ -69,6 +72,9 @@ -- -- These options allow for different visual effects by returning different -- properties of the cell structure.+--+-- Distance-based results are not confined to @[-1, 1]@ under every metric —+-- 'DistManhattan' and 'DistHybrid' can exceed 1, matching FastNoiseLite. data CellularResult = -- | Return the hash value of the nearest cell point. -- Creates discrete regions with constant values.@@ -107,30 +113,22 @@ _ -> id {-# INLINE normDist #-} -noise2 :: (RealFrac a, Floating a) => CellularConfig a -> Noise2 a-noise2 CellularConfig{..} = mkNoise2 $ \ !seed !x !y ->- let !jitter = cellularJitter * 0.43701595- !rx = round x- !ry = round y+distance3 :: (RealFrac a) => CellularDistanceFn -> a -> a -> a -> a+distance3 = \case+ DistEuclidean -> \ !x !y !z -> x * x + y * y + z * z+ DistEuclideanSq -> \ !x !y !z -> x * x + y * y + z * z+ DistManhattan -> \ !x !y !z -> abs x + abs y + abs z+ DistHybrid -> \ !x !y !z -> abs x + abs y + abs z + (x * x + y * y + z * z)+{-# INLINE distance3 #-} - dist = distance cellularDistanceFn- norm = normDist cellularDistanceFn+-- | Fold the candidate cell points with the selector 'cellularResult' needs.+-- Shared by 'noise2' and 'noise3'; INLINE so the folds fuse with the callers'+-- point comprehensions (see the note on @points@ in 'noise2').+selectResult :: (RealFrac a, Floating a) => CellularResult -> CellularDistanceFn -> [(Hash, a)] -> a+selectResult res distFn points =+ let norm = normDist distFn coeff = 1 / (maxHash + 1) - {-# INLINE pointDist #-}- pointDist !xi !yi =- let !px = fromIntegral xi - x- !py = fromIntegral yi - y- !h = hash2 seed (primeX * xi) (primeY * yi)- !i = h .&. 0x1FE- !rvx = lookupRandVec2d i- !rvy = lookupRandVec2d (i .|. 1)- !d = dist (px + rvx * jitter) (py + rvy * jitter)- in (h, d)-- {-# INLINE points #-}- points = [pointDist (rx + xi) (ry + yi) | !xi <- [-1 .. 1], !yi <- [-1 .. 1]]- {-# INLINE selectMinHash #-} selectMinHash = let minHash (!hMin, !dMin) (!h, !d)@@ -152,7 +150,7 @@ | d < d1 = (c, d0, d) | otherwise = (c, d0, d1) in foldl' smallestTwo (0, infinity, infinity) points- in case cellularResult of+ in case res of CellValue -> let (!hash, !_) = selectMinHash in fromIntegral hash * coeff@@ -174,8 +172,69 @@ Distance2Div -> let (!_, !d0, !d1) = selectSmallestTwo in norm d0 / norm d1 - 1+{-# INLINE selectResult #-}++noise2 :: (RealFrac a, Floating a) => CellularConfig a -> Noise2 a+noise2 CellularConfig{..} = mkNoise2 $ \ !seed !x !y ->+ let !jitter = cellularJitter * 0.43701595+ !rx = fastRound x+ !ry = fastRound y++ dist = distance cellularDistanceFn++ {-# INLINE pointDist #-}+ pointDist !xi !yi =+ let !px = fromIntegral xi - x+ !py = fromIntegral yi - y+ !h = hash2 seed (primeX * xi) (primeY * yi)+ !i = h .&. 0x1FE+ !rvx = lookupRandVec2d i+ !rvy = lookupRandVec2d (i .|. 1)+ !d = dist (px + rvx * jitter) (py + rvy * jitter)+ in (h, d)++ -- The [-1 .. 1] comprehension is load-bearing: enumFromTo takes part in+ -- foldr/build fusion with the folds below, so no list is ever built.+ -- OverloadedLists literals here would desugar to fromListN (no fusion),+ -- and hand-unrolled cons-chains defeat the fold's fusion entirely+ -- (measured ~5x slower). Same applies to the 3D comprehension.+ {-# INLINE points #-}+ points = [pointDist (rx + xi) (ry + yi) | !xi <- [-1 .. 1], !yi <- [-1 .. 1]]+ in selectResult cellularResult cellularDistanceFn points {-# INLINE [2] noise2 #-} +noise3 :: (RealFrac a, Floating a) => CellularConfig a -> Noise3 a+noise3 CellularConfig{..} = mkNoise3 $ \ !seed !x !y !z ->+ let !jitter = cellularJitter * 0.39614353+ !rx = fastRound x+ !ry = fastRound y+ !rz = fastRound z++ dist = distance3 cellularDistanceFn++ {-# INLINE pointDist #-}+ pointDist !xi !yi !zi =+ let !px = fromIntegral xi - x+ !py = fromIntegral yi - y+ !pz = fromIntegral zi - z+ !h = hash3 seed (primeX * xi) (primeY * yi) (primeZ * zi)+ !i = h .&. 0x3FC+ !rvx = lookupRandVec3d i+ !rvy = lookupRandVec3d (i .|. 1)+ !rvz = lookupRandVec3d (i .|. 2)+ !d = dist (px + rvx * jitter) (py + rvy * jitter) (pz + rvz * jitter)+ in (h, d)++ {-# INLINE points #-}+ points =+ [ pointDist (rx + xi) (ry + yi) (rz + zi)+ | !xi <- [-1 .. 1]+ , !yi <- [-1 .. 1]+ , !zi <- [-1 .. 1]+ ]+ in selectResult cellularResult cellularDistanceFn points+{-# INLINE [2] noise3 #-}+ lookupRandVec2d :: (RealFrac a) => Hash -> a lookupRandVec2d = realToFrac . indexPrimArray randVecs2dd . fromIntegral {-# NOINLINE [1] lookupRandVec2d #-}@@ -192,7 +251,7 @@ randVecs2df :: PrimArray Float randVecs2df = mapPrimArray realToFrac randVecs2dd --- >>> sizeofPrimArray randVecs2d == 512+-- >>> sizeofPrimArray randVecs2dd == 512 -- True {- ORMOLU_DISABLE -} randVecs2dd :: PrimArray Double@@ -262,3 +321,155 @@ ,0.01426758847,-0.9998982128,-0.6734383991,0.7392433447,0.639412098,-0.7688642071,0.9211571421,0.3891908523 ,-0.146637214,-0.9891903394,-0.782318098,0.6228791163,-0.5039610839,-0.8637263605,-0.7743120191,-0.6328039957 ]++lookupRandVec3d :: (RealFrac a) => Hash -> a+lookupRandVec3d = realToFrac . indexPrimArray randVecs3dd . fromIntegral+{-# NOINLINE [1] lookupRandVec3d #-}++{-# RULES+"lookupRandVec3d/Float" forall h.+ lookupRandVec3d h =+ indexPrimArray randVecs3df (fromIntegral h)+"lookupRandVec3d/Double" forall h.+ lookupRandVec3d h =+ indexPrimArray randVecs3dd (fromIntegral h)+ #-}++randVecs3df :: PrimArray Float+randVecs3df = mapPrimArray realToFrac randVecs3dd++-- >>> sizeofPrimArray randVecs3dd == 1024+-- True+{- ORMOLU_DISABLE -}+randVecs3dd :: PrimArray Double+randVecs3dd =+ [-0.7292736885,-0.6618439697,0.1735581948,0,0.790292081,-0.5480887466,-0.2739291014,0+ ,0.7217578935,0.6226212466,-0.3023380997,0,0.565683137,-0.8208298145,-0.0790000257,0+ ,0.760049034,-0.5555979497,-0.3370999617,0,0.3713945616,0.5011264475,0.7816254623,0+ ,-0.1277062463,-0.4254438999,-0.8959289049,0,-0.2881560924,-0.5815838982,0.7607405838,0+ ,0.5849561111,-0.662820239,-0.4674352136,0,0.3307171178,0.0391653737,0.94291689,0+ ,0.8712121778,-0.4113374369,-0.2679381538,0,0.580981015,0.7021915846,0.4115677815,0+ ,0.503756873,0.6330056931,-0.5878203852,0,0.4493712205,0.601390195,0.6606022552,0+ ,-0.6878403724,0.09018890807,-0.7202371714,0,-0.5958956522,-0.6469350577,0.475797649,0+ ,-0.5127052122,0.1946921978,-0.8361987284,0,-0.9911507142,-0.05410276466,-0.1212153153,0+ ,-0.2149721042,0.9720882117,-0.09397607749,0,-0.7518650936,-0.5428057603,0.3742469607,0+ ,0.5237068895,0.8516377189,-0.02107817834,0,0.6333504779,0.1926167129,-0.7495104896,0+ ,-0.06788241606,0.3998305789,0.9140719259,0,-0.5538628599,-0.4729896695,-0.6852128902,0+ ,-0.7261455366,-0.5911990757,0.3509933228,0,-0.9229274737,-0.1782808786,0.3412049336,0+ ,-0.6968815002,0.6511274338,0.3006480328,0,0.9608044783,-0.2098363234,-0.1811724921,0+ ,0.06817146062,-0.9743405129,0.2145069156,0,-0.3577285196,-0.6697087264,-0.6507845481,0+ ,-0.1868621131,0.7648617052,-0.6164974636,0,-0.6541697588,0.3967914832,0.6439087246,0+ ,0.6993340405,-0.6164538506,0.3618239211,0,-0.1546665739,0.6291283928,0.7617583057,0+ ,-0.6841612949,-0.2580482182,-0.6821542638,0,0.5383980957,0.4258654885,0.7271630328,0+ ,-0.5026987823,-0.7939832935,-0.3418836993,0,0.3202971715,0.2834415347,0.9039195862,0+ ,0.8683227101,-0.0003762656404,-0.4959995258,0,0.791120031,-0.08511045745,0.6057105799,0+ ,-0.04011016052,-0.4397248749,0.8972364289,0,0.9145119872,0.3579346169,-0.1885487608,0+ ,-0.9612039066,-0.2756484276,0.01024666929,0,0.6510361721,-0.2877799159,-0.7023778346,0+ ,-0.2041786351,0.7365237271,0.644859585,0,-0.7718263711,0.3790626912,0.5104855816,0+ ,-0.3060082741,-0.7692987727,0.5608371729,0,0.454007341,-0.5024843065,0.7357899537,0+ ,0.4816795475,0.6021208291,-0.6367380315,0,0.6961980369,-0.3222197429,0.641469197,0+ ,-0.6532160499,-0.6781148932,0.3368515753,0,0.5089301236,-0.6154662304,-0.6018234363,0+ ,-0.1635919754,-0.9133604627,-0.372840892,0,0.52408019,-0.8437664109,0.1157505864,0+ ,0.5902587356,0.4983817807,-0.6349883666,0,0.5863227872,0.494764745,0.6414307729,0+ ,0.6779335087,0.2341345225,0.6968408593,0,0.7177054546,-0.6858979348,0.120178631,0+ ,-0.5328819713,-0.5205125012,0.6671608058,0,-0.8654874251,-0.0700727088,-0.4960053754,0+ ,-0.2861810166,0.7952089234,0.5345495242,0,-0.04849529634,0.9810836427,-0.1874115585,0+ ,-0.6358521667,0.6058348682,0.4781800233,0,0.6254794696,-0.2861619734,0.7258696564,0+ ,-0.2585259868,0.5061949264,-0.8227581726,0,0.02136306781,0.5064016808,-0.8620330371,0+ ,0.200111773,0.8599263484,0.4695550591,0,0.4743561372,0.6014985084,-0.6427953014,0+ ,0.6622993731,-0.5202474575,-0.5391679918,0,0.08084972818,-0.6532720452,0.7527940996,0+ ,-0.6893687501,0.0592860349,0.7219805347,0,-0.1121887082,-0.9673185067,0.2273952515,0+ ,0.7344116094,0.5979668656,-0.3210532909,0,0.5789393465,-0.2488849713,0.7764570201,0+ ,0.6988182827,0.3557169806,-0.6205791146,0,-0.8636845529,-0.2748771249,-0.4224826141,0+ ,-0.4247027957,-0.4640880967,0.777335046,0,0.5257722489,-0.8427017621,0.1158329937,0+ ,0.9343830603,0.316302472,-0.1639543925,0,-0.1016836419,-0.8057303073,-0.5834887393,0+ ,-0.6529238969,0.50602126,-0.5635892736,0,-0.2465286165,-0.9668205684,-0.06694497494,0+ ,-0.9776897119,-0.2099250524,-0.007368825344,0,0.7736893337,0.5734244712,0.2694238123,0+ ,-0.6095087895,0.4995678998,0.6155736747,0,0.5794535482,0.7434546771,0.3339292269,0+ ,-0.8226211154,0.08142581855,0.5627293636,0,-0.510385483,0.4703667658,0.7199039967,0+ ,-0.5764971849,-0.07231656274,-0.8138926898,0,0.7250628871,0.3949971505,-0.5641463116,0+ ,-0.1525424005,0.4860840828,-0.8604958341,0,-0.5550976208,-0.4957820792,0.667882296,0+ ,-0.1883614327,0.9145869398,0.357841725,0,0.7625556724,-0.5414408243,-0.3540489801,0+ ,-0.5870231946,-0.3226498013,-0.7424963803,0,0.3051124198,0.2262544068,-0.9250488391,0+ ,0.6379576059,0.577242424,-0.5097070502,0,-0.5966775796,0.1454852398,-0.7891830656,0+ ,-0.658330573,0.6555487542,-0.3699414651,0,0.7434892426,0.2351084581,0.6260573129,0+ ,0.5562114096,0.8264360377,-0.0873632843,0,-0.3028940016,-0.8251527185,0.4768419182,0+ ,0.1129343818,-0.985888439,-0.1235710781,0,0.5937652891,-0.5896813806,0.5474656618,0+ ,0.6757964092,-0.5835758614,-0.4502648413,0,0.7242302609,-0.1152719764,0.6798550586,0+ ,-0.9511914166,0.0753623979,-0.2992580792,0,0.2539470961,-0.1886339355,0.9486454084,0+ ,0.571433621,-0.1679450851,-0.8032795685,0,-0.06778234979,0.3978269256,0.9149531629,0+ ,0.6074972649,0.733060024,-0.3058922593,0,-0.5435478392,0.1675822484,0.8224791405,0+ ,-0.5876678086,-0.3380045064,-0.7351186982,0,-0.7967562402,0.04097822706,-0.6029098428,0+ ,-0.1996350917,0.8706294745,0.4496111079,0,-0.02787660336,-0.9106232682,-0.4122962022,0+ ,-0.7797625996,-0.6257634692,0.01975775581,0,-0.5211232846,0.7401644346,-0.4249554471,0+ ,0.8575424857,0.4053272873,-0.3167501783,0,0.1045223322,0.8390195772,-0.5339674439,0+ ,0.3501822831,0.9242524096,-0.1520850155,0,0.1987849858,0.07647613266,0.9770547224,0+ ,0.7845996363,0.6066256811,-0.1280964233,0,0.09006737436,-0.9750989929,-0.2026569073,0+ ,-0.8274343547,-0.542299559,0.1458203587,0,-0.3485797732,-0.415802277,0.840000362,0+ ,-0.2471778936,-0.7304819962,-0.6366310879,0,-0.3700154943,0.8577948156,0.3567584454,0+ ,0.5913394901,-0.548311967,-0.5913303597,0,0.1204873514,-0.7626472379,-0.6354935001,0+ ,0.616959265,0.03079647928,0.7863922953,0,0.1258156836,-0.6640829889,-0.7369967419,0+ ,-0.6477565124,-0.1740147258,-0.7417077429,0,0.6217889313,-0.7804430448,-0.06547655076,0+ ,0.6589943422,-0.6096987708,0.4404473475,0,-0.2689837504,-0.6732403169,-0.6887635427,0+ ,-0.3849775103,0.5676542638,0.7277093879,0,0.5754444408,0.8110471154,-0.1051963504,0+ ,0.9141593684,0.3832947817,0.131900567,0,-0.107925319,0.9245493968,0.3654593525,0+ ,0.377977089,0.3043148782,0.8743716458,0,-0.2142885215,-0.8259286236,0.5214617324,0+ ,0.5802544474,0.4148098596,-0.7008834116,0,-0.1982660881,0.8567161266,-0.4761596756,0+ ,-0.03381553704,0.3773180787,-0.9254661404,0,-0.6867922841,-0.6656597827,0.2919133642,0+ ,0.7731742607,-0.2875793547,-0.5652430251,0,-0.09655941928,0.9193708367,-0.3813575004,0+ ,0.2715702457,-0.9577909544,-0.09426605581,0,0.2451015704,-0.6917998565,-0.6792188003,0+ ,0.977700782,-0.1753855374,0.1155036542,0,-0.5224739938,0.8521606816,0.02903615945,0+ ,-0.7734880599,-0.5261292347,0.3534179531,0,-0.7134492443,-0.269547243,0.6467878011,0+ ,0.1644037271,0.5105846203,-0.8439637196,0,0.6494635788,0.05585611296,0.7583384168,0+ ,-0.4711970882,0.5017280509,-0.7254255765,0,-0.6335764307,-0.2381686273,-0.7361091029,0+ ,-0.9021533097,-0.270947803,-0.3357181763,0,-0.3793711033,0.872258117,0.3086152025,0+ ,-0.6855598966,-0.3250143309,0.6514394162,0,0.2900942212,-0.7799057743,-0.5546100667,0+ ,-0.2098319339,0.85037073,0.4825351604,0,-0.4592603758,0.6598504336,-0.5947077538,0+ ,0.8715945488,0.09616365406,-0.4807031248,0,-0.6776666319,0.7118504878,-0.1844907016,0+ ,0.7044377633,0.312427597,0.637304036,0,-0.7052318886,-0.2401093292,-0.6670798253,0+ ,0.081921007,-0.7207336136,-0.6883545647,0,-0.6993680906,-0.5875763221,-0.4069869034,0+ ,-0.1281454481,0.6419895885,0.7559286424,0,-0.6337388239,-0.6785471501,-0.3714146849,0+ ,0.5565051903,-0.2168887573,-0.8020356851,0,-0.5791554484,0.7244372011,-0.3738578718,0+ ,0.1175779076,-0.7096451073,0.6946792478,0,-0.6134619607,0.1323631078,0.7785527795,0+ ,0.6984635305,-0.02980516237,-0.715024719,0,0.8318082963,-0.3930171956,0.3919597455,0+ ,0.1469576422,0.05541651717,-0.9875892167,0,0.708868575,-0.2690503865,0.6520101478,0+ ,0.2726053183,0.67369766,-0.68688995,0,-0.6591295371,0.3035458599,-0.6880466294,0+ ,0.4815131379,-0.7528270071,0.4487723203,0,0.9430009463,0.1675647412,-0.2875261255,0+ ,0.434802957,0.7695304522,-0.4677277752,0,0.3931996188,0.594473625,0.7014236729,0+ ,0.7254336655,-0.603925654,0.3301814672,0,0.7590235227,-0.6506083235,0.02433313207,0+ ,-0.8552768592,-0.3430042733,0.3883935666,0,-0.6139746835,0.6981725247,0.3682257648,0+ ,-0.7465905486,-0.5752009504,0.3342849376,0,0.5730065677,0.810555537,-0.1210916791,0+ ,-0.9225877367,-0.3475211012,-0.167514036,0,-0.7105816789,-0.4719692027,-0.5218416899,0+ ,-0.08564609717,0.3583001386,0.929669703,0,-0.8279697606,-0.2043157126,0.5222271202,0+ ,0.427944023,0.278165994,0.8599346446,0,0.5399079671,-0.7857120652,-0.3019204161,0+ ,0.5678404253,-0.5495413974,-0.6128307303,0,-0.9896071041,0.1365639107,-0.04503418428,0+ ,-0.6154342638,-0.6440875597,0.4543037336,0,0.1074204368,-0.7946340692,0.5975094525,0+ ,-0.3595449969,-0.8885529948,0.28495784,0,-0.2180405296,0.1529888965,0.9638738118,0+ ,-0.7277432317,-0.6164050508,-0.3007234646,0,0.7249729114,-0.00669719484,0.6887448187,0+ ,-0.5553659455,-0.5336586252,0.6377908264,0,0.5137558015,0.7976208196,-0.3160000073,0+ ,-0.3794024848,0.9245608561,-0.03522751494,0,0.8229248658,0.2745365933,-0.4974176556,0+ ,-0.5404114394,0.6091141441,0.5804613989,0,0.8036581901,-0.2703029469,0.5301601931,0+ ,0.6044318879,0.6832968393,0.4095943388,0,0.06389988817,0.9658208605,-0.2512108074,0+ ,0.1087113286,0.7402471173,-0.6634877936,0,-0.713427712,-0.6926784018,0.1059128479,0+ ,0.6458897819,-0.5724548511,-0.5050958653,0,-0.6553931414,0.7381471625,0.159995615,0+ ,0.3910961323,0.9188871375,-0.05186755998,0,-0.4879022471,-0.5904376907,0.6429111375,0+ ,0.6014790094,0.7707441366,-0.2101820095,0,-0.5677173047,0.7511360995,0.3368851762,0+ ,0.7858573506,0.226674665,0.5753666838,0,-0.4520345543,-0.604222686,-0.6561857263,0+ ,0.002272116345,0.4132844051,-0.9105991643,0,-0.5815751419,-0.5162925989,0.6286591339,0+ ,-0.03703704785,0.8273785755,0.5604221175,0,-0.5119692504,0.7953543429,-0.3244980058,0+ ,-0.2682417366,-0.9572290247,-0.1084387619,0,-0.2322482736,-0.9679131102,-0.09594243324,0+ ,0.3554328906,-0.8881505545,0.2913006227,0,0.7346520519,-0.4371373164,0.5188422971,0+ ,0.9985120116,0.04659011161,-0.02833944577,0,-0.3727687496,-0.9082481361,0.1900757285,0+ ,0.91737377,-0.3483642108,0.1925298489,0,0.2714911074,0.4147529736,-0.8684886582,0+ ,0.5131763485,-0.7116334161,0.4798207128,0,-0.8737353606,0.18886992,-0.4482350644,0+ ,0.8460043821,-0.3725217914,0.3814499973,0,0.8978727456,-0.1780209141,-0.4026575304,0+ ,0.2178065647,-0.9698322841,-0.1094789531,0,-0.1518031304,-0.7788918132,-0.6085091231,0+ ,-0.2600384876,-0.4755398075,-0.8403819825,0,0.572313509,-0.7474340931,-0.3373418503,0+ ,-0.7174141009,0.1699017182,-0.6756111411,0,-0.684180784,0.02145707593,-0.7289967412,0+ ,-0.2007447902,0.06555605789,-0.9774476623,0,-0.1148803697,-0.8044887315,0.5827524187,0+ ,-0.7870349638,0.03447489231,0.6159443543,0,-0.2015596421,0.6859872284,0.6991389226,0+ ,-0.08581082512,-0.10920836,-0.9903080513,0,0.5532693395,0.7325250401,-0.396610771,0+ ,-0.1842489331,-0.9777375055,-0.1004076743,0,0.0775473789,-0.9111505856,0.4047110257,0+ ,0.1399838409,0.7601631212,-0.6344734459,0,0.4484419361,-0.845289248,0.2904925424,0+ ]+{- ORMOLU_ENABLE -}
src/Numeric/Noise/Fractal.hs view
@@ -44,7 +44,8 @@ data FractalConfig a = FractalConfig { octaves :: Int -- ^ Number of noise layers to combine. More octaves create more detail- -- but are more expensive to compute. Must be \( >= 1 \).+ -- but are more expensive to compute. Fewer than 1 octave produces+ -- constant 0. , lacunarity :: a -- ^ Frequency multiplier between octaves. Each octave's frequency is -- the previous octave's frequency multiplied by lacunarity.@@ -54,9 +55,12 @@ -- Values \( < 1 \) create smoother noise, values \( > 1 \) create rougher noise. , weightedStrength :: a -- ^ Controls how much each octave's amplitude is influenced by the- -- previous octave's value. At 0, octaves have independent amplitudes.- -- At 1, lower-valued areas in previous octaves reduce the amplitude- -- of subsequent octaves. Range: \( [0, 1] \).+ -- previous octave's value. At 0 (the default), octaves have independent+ -- amplitudes. Range: \( [0, 1] \).+ --+ -- The weighting currently tracks the amplitude-scaled octave value, which+ -- diverges from FastNoiseLite — values near 1 can misbehave (e.g. inverted+ -- ridged octaves). It will align with FNL in 0.3. } deriving (Generic, Read, Show, Eq) @@ -118,6 +122,8 @@ -- Ping-pong creates a wave-like pattern by folding the noise values back -- and forth within a range, creating a distinctive undulating appearance. -- The strength parameter controls the intensity of the ping-pong effect.+--+-- Output spans @[0, 1]@; it will align with FNL's @[-1, 1]@ in 0.3. -- -- @ -- waves :: Noise2 Float
src/Numeric/Noise/Internal.hs view
@@ -47,11 +47,13 @@ -- | 'Noise' represents a function from a 'Seed' and coordinates @p@ to a noise -- value @v@. ----- For convenience, dimension-specific type aliases are provided:+-- For convenience, dimension-specific type aliases are provided: 'Noise1',+-- 'Noise2', and 'Noise3', plus primed variants that separate the coordinate+-- and value types. -- -- Use 'warp' to transform coordinates and 'remap' (or 'fmap') to transform values. ----- To evaluate noise functions, use 'noise1At', 'noise2At', or 'noise3At'+-- To evaluate noise functions, use 'noise1At', 'noise2At', or 'noise3At'. -- -- NB: 'Noise' is a lawful 'Profunctor' where 'lmap' = warp and 'rmap' = remap. -- There are some useful implications to this, but pure-noise is committed to@@ -141,23 +143,33 @@ acosh = fmap acosh atanh = fmap atanh +-- | 1D noise: a single coordinate of type @p@ producing values of type @v@. type Noise1' p v = Noise p v++-- | 1D noise with a single type for coordinates and values. type Noise1 v = Noise1' v v +-- | Build a 1D noise function from a plain @seed -> coordinate -> value@+-- function. Inverse of 'noise1At'. mkNoise1 :: (Seed -> p -> v) -> Noise1' p v mkNoise1 = Noise {-# INLINE mkNoise1 #-} -- | Evaluate a 1D noise function at the given coordinates with the given seed.--- Currently, you must use a slicing function like 'sliceX' to reduce+-- Currently, you must use a slicing function like 'sliceX2' to reduce -- higher-dimensional noise into 1D noise. noise1At :: Noise1 a -> Seed -> a -> a noise1At = unNoise {-# INLINE noise1At #-} +-- | 2D noise: a pair of coordinates of type @p@ producing values of type @v@. type Noise2' p v = Noise (p, p) v++-- | 2D noise with a single type for coordinates and values. type Noise2 v = Noise2' v v +-- | Build a 2D noise function from a plain @seed -> x -> y -> value@+-- function. Inverse of 'noise2At'. mkNoise2 :: (Seed -> p -> p -> v) -> Noise2' p v mkNoise2 f = Noise (\s (x, y) -> f s x y) {-# INLINE mkNoise2 #-}@@ -175,9 +187,14 @@ noise2At (Noise f) seed x y = f seed (x, y) {-# INLINE noise2At #-} +-- | 3D noise: a triple of coordinates of type @p@ producing values of type @v@. type Noise3' p v = Noise (p, p, p) v++-- | 3D noise with a single type for coordinates and values. type Noise3 v = Noise3' v v +-- | Build a 3D noise function from a plain @seed -> x -> y -> z -> value@+-- function. Inverse of 'noise3At'. mkNoise3 :: (Seed -> p -> p -> p -> v) -> Noise3' p v mkNoise3 f = Noise (\s (x, y, z) -> f s x y z) {-# INLINE mkNoise3 #-}@@ -217,7 +234,7 @@ -- This allows you to scale, rotate, or otherwise modify coordinates before -- they're passed to the noise function: ----- NB: This is 'contramap'+-- NB: This is 'Data.Functor.Contravariant.contramap' -- -- === __Examples__ --@@ -350,7 +367,7 @@ sliceZ3 z = warp (\(x, y) -> (x, y, z)) {-# INLINE sliceZ3 #-} --- | Increment the seed for a 2D noise function. See 'reseed'+-- | Increment the seed for a 2D noise function. See 'reseed'. next2 :: Noise2 a -> Noise2 a next2 = reseed (+ 1) {-# INLINE next2 #-}@@ -365,14 +382,12 @@ const2 = pure {-# INLINE const2 #-} --- | Increment the seed for a 3D noise function. See 'reseed'+-- | Increment the seed for a 3D noise function. See 'reseed'. next3 :: Noise3 a -> Noise3 a next3 = reseed (+ 1) {-# INLINE next3 #-} --- | A noise function that produces the same value everywhere. Alias of 'pure'------ Used to provide the 'Num' instance.+-- | A noise function that produces the same value everywhere. Alias of 'pure'. const3 :: a -> Noise3 a const3 = pure {-# INLINE const3 #-}
src/Numeric/Noise/Internal/Math.hs view
@@ -12,6 +12,7 @@ hermiteInterp, quinticInterp, clamp,+ fastRound, primeX, primeY, primeZ,@@ -20,6 +21,7 @@ infinity, g2, sqrt3,+ rotate3, valCoord2, valCoord3, gradCoord2,@@ -28,6 +30,7 @@ ) where import Data.Bits+import Data.Bool (bool) import Data.Int import Data.Primitive.PrimArray import Data.Word@@ -37,6 +40,10 @@ -- Using the same 'Seed' value will produce the same noise pattern, -- allowing for reproducible results. Different seed values produce -- different, independent noise patterns.+--+-- Only the low 32 bits participate in hashing (matching FastNoiseLite's+-- @int@ seed): seeds that differ only in their upper 32 bits generate+-- identical noise. type Seed = Word64 -- | Internal hash value type used in noise calculations.@@ -79,7 +86,7 @@ lerp a b (t * u) #-} --- | cubic interpolation+-- | Cubic interpolation through four control points. cubicInterp :: (Num a) => a -> a -> a -> a -> a -> a cubicInterp a !b c d !t = let !c' = c - a@@ -110,7 +117,7 @@ 0.125 * (-a + 5 * b + 5 * c - d) #-} --- | hermite interpolation+-- | Hermite interpolation curve (smoothstep). hermiteInterp :: (Num a) => a -> a hermiteInterp t = t * t * (3 - 2 * t) {-# INLINE [1] hermiteInterp #-}@@ -122,7 +129,7 @@ "hermiteInterp/Double/1" hermiteInterp (1 :: Double) = 1 #-} --- | quintic interpolation+-- | Quintic interpolation curve (smootherstep). quinticInterp :: (Num a) => a -> a quinticInterp t = t * t * t * (t * (t * 6 - 15) + 10) {-# INLINE [1] quinticInterp #-}@@ -158,6 +165,15 @@ clamp l u v = min (max v l) u {-# INLINE clamp #-} +-- | Round half away from zero, matching FastNoiseLite's @FastRound@.+--+-- 'round' rounds half to even and, more importantly, GHC lowers it to an+-- @rintFloat@ FFI call that dominates hot loops; 'truncate' compiles to an+-- inline @float2Int#@.+fastRound :: (RealFrac a) => a -> Hash+fastRound v = truncate (v + bool (-0.5) 0.5 (v >= 0))+{-# INLINE fastRound #-}+ primeX, primeY, primeZ :: Hash primeX = 501125321 {-# INLINE primeX #-}@@ -189,6 +205,13 @@ sqrt3 :: (Fractional a) => a sqrt3 = 1.7320508075688772935274463415059 {-# INLINE sqrt3 #-}++-- | Rotation for OpenSimplex2\/2S+rotate3 :: (Fractional a) => a -> a -> a -> (a, a, a)+rotate3 xo yo zo =+ let !r = (xo + yo + zo) * (2 / 3)+ in (r - xo, r - yo, r - zo)+{-# INLINE rotate3 #-} valCoord2 :: (RealFrac a) => Seed -> Hash -> Hash -> a valCoord2 seed xPrimed yPrimed =
src/Numeric/Noise/OpenSimplex.hs view
@@ -7,8 +7,13 @@ -- * 2D Noise noise2, noise2Base,++ -- * 3D Noise+ noise3,+ noise3Base, ) where +import Data.Bits (complement, shiftR, (.&.)) import Data.Bool (bool) import Numeric.Noise.Internal import Numeric.Noise.Internal.Math@@ -39,11 +44,15 @@ n0 = attenuate a seed i j x0 y0 n1 =- let cond = bool 0 1 (y0 > x0)- x1 = (x0 + g2 - 1) + fromIntegral cond- y1 = (y0 + g2) - fromIntegral cond- i1 = i + (1 - cond) * primeX- j1 = j + cond * primeY+ let gt = y0 > x0+ -- Select the constant-folded addend per branch (g2 or g2 - 1),+ -- reproducing FNL's `x0 + (float)G2` / `x0 + ((float)G2 - 1)`+ -- rounding. Arithmetic on the selector, e.g.+ -- (x0 + g2 - 1) + cond, rounds differently when |x0 + g2| < 1.+ x1 = x0 + bool (g2 - 1) g2 gt+ y1 = y0 + bool g2 (g2 - 1) gt+ i1 = i + bool primeX 0 gt+ j1 = j + bool 0 primeY gt b = 0.5 - x1 * x1 - y1 * y1 in attenuate b seed i1 j1 x1 y1 @@ -65,3 +74,82 @@ normalize :: (RealFrac a) => a -> a normalize = (99.83685446303647 *) {-# INLINE normalize #-}++noise3 :: (RealFrac a) => Noise3 a+noise3 = mkNoise3 noise3Base+{-# INLINE noise3 #-}++noise3Base :: forall a. (RealFrac a) => Seed -> a -> a -> a -> a+noise3Base seed0 xo yo zo =+ let !(x, y, z) = rotate3 xo yo zo++ !i0 = fastRound x+ !j0 = fastRound y+ !k0 = fastRound z+ !x0 = x - fromIntegral i0+ !y0 = y - fromIntegral j0+ !z0 = z - fromIntegral k0++ -- FNL: (int)(-1.0f - x0) | 1, i.e. -1 when the offset is >= 0+ !xns = bool 1 (-1) (x0 >= 0) :: Hash+ !yns = bool 1 (-1) (y0 >= 0) :: Hash+ !zns = bool 1 (-1) (z0 >= 0) :: Hash++ !ax0 = fromIntegral xns * negate x0+ !ay0 = fromIntegral yns * negate y0+ !az0 = fromIntegral zns * negate z0++ !ip = i0 * primeX+ !jp = j0 * primeY+ !kp = k0 * primeZ++ !a0 = (0.6 - x0 * x0) - (y0 * y0 + z0 * z0)++ !v0 = iteration seed0 a0 ip jp kp x0 y0 z0 ax0 ay0 az0 xns yns zns++ -- second lattice: reflect offsets, flip signs, complement the seed+ !ax1 = 0.5 - ax0+ !ay1 = 0.5 - ay0+ !az1 = 0.5 - az0+ !x1 = fromIntegral xns * ax1+ !y1 = fromIntegral yns * ay1+ !z1 = fromIntegral zns * az1+ !a1 = a0 + ((0.75 - ax1) - (ay1 + az1))+ !ip' = ip + ((xns `shiftR` 1) .&. primeX)+ !jp' = jp + ((yns `shiftR` 1) .&. primeY)+ !kp' = kp + ((zns `shiftR` 1) .&. primeZ)++ !v1 = iteration (complement seed0) a1 ip' jp' kp' x1 y1 z1 ax1 ay1 az1 (negate xns) (negate yns) (negate zns)+ in (v0 + v1) * 32.69428253173828125+ where+ -- one loop iteration of the FNL reference: the cell contribution plus one+ -- step along the dominant axis+ iteration+ :: Seed -> a -> Hash -> Hash -> Hash -> a -> a -> a -> a -> a -> a -> Hash -> Hash -> Hash -> a+ iteration !sd !a !i !j !k !x0 !y0 !z0 !ax !ay !az !xns !yns !zns =+ let !va+ | a > 0 = (a * a) * (a * a) * gradCoord3 sd i j k x0 y0 z0+ | otherwise = 0+ !b0 = a + 1+ !vb+ | ax >= ay && ax >= az =+ let !x1 = x0 + fromIntegral xns+ !b = b0 - fromIntegral (xns * 2) * x1+ in bContrib sd b (i - xns * primeX) j k x1 y0 z0+ | ay > ax && ay >= az =+ let !y1 = y0 + fromIntegral yns+ !b = b0 - fromIntegral (yns * 2) * y1+ in bContrib sd b i (j - yns * primeY) k x0 y1 z0+ | otherwise =+ let !z1 = z0 + fromIntegral zns+ !b = b0 - fromIntegral (zns * 2) * z1+ in bContrib sd b i j (k - zns * primeZ) x0 y0 z1+ in va + vb+ {-# INLINE iteration #-}++ bContrib :: Seed -> a -> Hash -> Hash -> Hash -> a -> a -> a -> a+ bContrib !sd !b !i !j !k !x1 !y1 !z1+ | b > 0 = (b * b) * (b * b) * gradCoord3 sd i j k x1 y1 z1+ | otherwise = 0+ {-# INLINE bContrib #-}+{-# INLINE [2] noise3Base #-}
src/Numeric/Noise/SuperSimplex.hs view
@@ -4,15 +4,21 @@ -- Maintainer: Jeremy Nuttall <jeremy@jeremy-nuttall.com> -- Stability: experimental ----- This module implements a variation of OpenSimplex2 noise derived from FastNoiseLite.--- See openSimplex2S+-- This module implements a variation of OpenSimplex2S noise derived from+-- FastNoiseLite, exported from "Numeric.Noise" as 'Numeric.Noise.superSimplex2'+-- and 'Numeric.Noise.superSimplex3'. module Numeric.Noise.SuperSimplex ( -- * 2D Noise noise2, noise2Base,++ -- * 3D Noise+ noise3,+ noise3Base, ) where import Data.Bits+import Data.Bool (bool) import Numeric.Noise.Internal import Numeric.Noise.Internal.Math @@ -117,3 +123,168 @@ normalize :: (RealFrac a) => a -> a normalize = (18.24196194486065 *) {-# INLINE normalize #-}++noise3 :: (RealFrac a) => Noise3 a+noise3 = mkNoise3 noise3Base+{-# INLINE noise3 #-}++noise3Base :: (RealFrac a) => Seed -> a -> a -> a -> a+noise3Base seed xo yo zo =+ let (x, y, z) = rotate3 xo yo zo++ fi = floor x :: Hash+ fj = floor y :: Hash+ fk = floor z :: Hash+ xi = x - fromIntegral fi+ yi = y - fromIntegral fj+ zi = z - fromIntegral fk++ i = fi * primeX+ j = fj * primeY+ k = fk * primeZ+ seed2 = seed + 1293373++ -- FNL: (int)(-0.5f - xi), i.e. -1 when the offset is >= 0.5, else 0+ xnm = bool 0 (-1) (xi >= 0.5) :: Hash+ ynm = bool 0 (-1) (yi >= 0.5) :: Hash+ znm = bool 0 (-1) (zi >= 0.5) :: Hash++ x0 = xi + fromIntegral xnm+ y0 = yi + fromIntegral ynm+ z0 = zi + fromIntegral znm+ a0 = 0.75 - x0 * x0 - y0 * y0 - z0 * z0+ v0 =+ q a0+ * gradCoord3 seed (i + (xnm .&. primeX)) (j + (ynm .&. primeY)) (k + (znm .&. primeZ)) x0 y0 z0++ x1 = xi - 0.5+ y1 = yi - 0.5+ z1 = zi - 0.5+ a1 = 0.75 - x1 * x1 - y1 * y1 - z1 * z1+ v1 = q a1 * gradCoord3 seed2 (i + primeX) (j + primeY) (k + primeZ) x1 y1 z1++ xFlip0 = fromIntegral ((xnm .|. 1) `shiftL` 1) * x1+ yFlip0 = fromIntegral ((ynm .|. 1) `shiftL` 1) * y1+ zFlip0 = fromIntegral ((znm .|. 1) `shiftL` 1) * z1+ xFlip1 = fromIntegral (-2 - (xnm `shiftL` 2)) * x1 - 1.0+ yFlip1 = fromIntegral (-2 - (ynm `shiftL` 2)) * y1 - 1.0+ zFlip1 = fromIntegral (-2 - (znm `shiftL` 2)) * z1 - 1.0++ a2 = xFlip0 + a0+ ~(vX, skip5)+ | a2 > 0 =+ let ~x2 = x0 - fromIntegral (xnm .|. 1)+ in ( q a2+ * gradCoord3 seed (i + (complement xnm .&. primeX)) (j + (ynm .&. primeY)) (k + (znm .&. primeZ)) x2 y0 z0+ , False+ )+ | otherwise =+ let a3 = yFlip0 + zFlip0 + a0+ ~v3+ | a3 > 0 =+ let ~y3 = y0 - fromIntegral (ynm .|. 1)+ ~z3 = z0 - fromIntegral (znm .|. 1)+ in q a3+ * gradCoord3 seed (i + (xnm .&. primeX)) (j + (complement ynm .&. primeY)) (k + (complement znm .&. primeZ)) x0 y3 z3+ | otherwise = 0+ a4 = xFlip1 + a1+ ~(v4, sk)+ | a4 > 0 =+ let ~x4 = fromIntegral (xnm .|. 1) + x1+ in ( q a4+ * gradCoord3 seed2 (i + (xnm .&. (primeX * 2))) (j + primeY) (k + primeZ) x4 y1 z1+ , True+ )+ | otherwise = (0, False)+ in (v3 + v4, sk)++ a6 = yFlip0 + a0+ ~(vY, skip9)+ | a6 > 0 =+ let ~y6 = y0 - fromIntegral (ynm .|. 1)+ in ( q a6+ * gradCoord3 seed (i + (xnm .&. primeX)) (j + (complement ynm .&. primeY)) (k + (znm .&. primeZ)) x0 y6 z0+ , False+ )+ | otherwise =+ let a7 = xFlip0 + zFlip0 + a0+ ~v7+ | a7 > 0 =+ let ~x7 = x0 - fromIntegral (xnm .|. 1)+ ~z7 = z0 - fromIntegral (znm .|. 1)+ in q a7+ * gradCoord3 seed (i + (complement xnm .&. primeX)) (j + (ynm .&. primeY)) (k + (complement znm .&. primeZ)) x7 y0 z7+ | otherwise = 0+ a8 = yFlip1 + a1+ ~(v8, sk)+ | a8 > 0 =+ let ~y8 = fromIntegral (ynm .|. 1) + y1+ in ( q a8+ * gradCoord3 seed2 (i + primeX) (j + (ynm .&. (primeY `shiftL` 1))) (k + primeZ) x1 y8 z1+ , True+ )+ | otherwise = (0, False)+ in (v7 + v8, sk)++ aA = zFlip0 + a0+ ~(vZ, skipD)+ | aA > 0 =+ let ~zA = z0 - fromIntegral (znm .|. 1)+ in ( q aA+ * gradCoord3 seed (i + (xnm .&. primeX)) (j + (ynm .&. primeY)) (k + (complement znm .&. primeZ)) x0 y0 zA+ , False+ )+ | otherwise =+ let aB = xFlip0 + yFlip0 + a0+ ~vB+ | aB > 0 =+ let ~xB = x0 - fromIntegral (xnm .|. 1)+ ~yB = y0 - fromIntegral (ynm .|. 1)+ in q aB+ * gradCoord3 seed (i + (complement xnm .&. primeX)) (j + (complement ynm .&. primeY)) (k + (znm .&. primeZ)) xB yB z0+ | otherwise = 0+ aC = zFlip1 + a1+ ~(vC, sk)+ | aC > 0 =+ let ~zC = fromIntegral (znm .|. 1) + z1+ in ( q aC+ * gradCoord3 seed2 (i + primeX) (j + primeY) (k + (znm .&. (primeZ `shiftL` 1))) x1 y1 zC+ , True+ )+ | otherwise = (0, False)+ in (vB + vC, sk)++ ~v5+ | not skip5+ , a5 <- yFlip1 + zFlip1 + a1+ , a5 > 0 =+ let ~y5 = fromIntegral (ynm .|. 1) + y1+ ~z5 = fromIntegral (znm .|. 1) + z1+ in q a5+ * gradCoord3 seed2 (i + primeX) (j + (ynm .&. (primeY `shiftL` 1))) (k + (znm .&. (primeZ `shiftL` 1))) x1 y5 z5+ | otherwise = 0++ ~v9+ | not skip9+ , a9 <- xFlip1 + zFlip1 + a1+ , a9 > 0 =+ let ~x9 = fromIntegral (xnm .|. 1) + x1+ ~z9 = fromIntegral (znm .|. 1) + z1+ in q a9+ * gradCoord3 seed2 (i + (xnm .&. (primeX * 2))) (j + primeY) (k + (znm .&. (primeZ `shiftL` 1))) x9 y1 z9+ | otherwise = 0++ ~vD+ | not skipD+ , aD <- xFlip1 + yFlip1 + a1+ , aD > 0 =+ let ~xD = fromIntegral (xnm .|. 1) + x1+ ~yD = fromIntegral (ynm .|. 1) + y1+ in q aD+ * gradCoord3 seed2 (i + (xnm .&. (primeX `shiftL` 1))) (j + (ynm .&. (primeY `shiftL` 1))) (k + primeZ) xD yD z1+ | otherwise = 0+ in (v0 + v1 + vX + vY + vZ + v5 + v9 + vD) * 9.046026385208288+ where+ q a = (a * a) * (a * a)+ {-# INLINE q #-}+{-# INLINE [2] noise3Base #-}
test/CellularSpec.hs view
@@ -12,6 +12,8 @@ "Cellular Golden Tests" [ testGroup "Grid Tests" cellularGridTests , testGroup "Sparse Tests" cellularSparseTests+ , testGroup "3D Grid Tests" cellular3DGridTests+ , testGroup "3D Sparse Tests" cellular3DSparseTests ] -- All combinations of distance functions and result types@@ -34,4 +36,32 @@ , let config = defaultCellularConfig{cellularDistanceFn = distFn, cellularResult = result} , seed <- cellularSeeds , let variant = show distFn <> "-" <> show result <> "-seed" ++ show seed+ ]++-- Full 3D image goldens would add ~200 PNGs; sparse JSON covers the whole+-- config matrix, images sample one distance function across result shapes.+cellular3DImageConfigs :: [(CellularDistanceFn, CellularResult)]+cellular3DImageConfigs =+ [ (DistEuclidean, CellValue)+ , (DistEuclidean, Distance)+ , (DistEuclidean, Distance2Add)+ ]++cellular3DGridTests :: [TestTree]+cellular3DGridTests =+ [ goldenImageTest3D "cellular" variant (cellular3 config) seed zOffset+ | (distFn, result) <- cellular3DImageConfigs+ , let config = defaultCellularConfig{cellularDistanceFn = distFn, cellularResult = result}+ , seed <- cellularSeeds+ , (idx, zOffset) <- zip [0 :: Int ..] sliceOffsets3D+ , let variant = "3d-" <> show distFn <> "-" <> show result <> "-seed_" <> show seed <> "-slice_" <> show idx+ ]++cellular3DSparseTests :: [TestTree]+cellular3DSparseTests =+ [ goldenSparseTest3D "cellular" variant (cellular3 config) seed+ | (distFn, result) <- allCellularConfigs+ , let config = defaultCellularConfig{cellularDistanceFn = distFn, cellularResult = result}+ , seed <- cellularSeeds+ , let variant = "3d-" <> show distFn <> "-" <> show result <> "-seed" <> show seed ]
test/Golden/Util.hs view
@@ -156,7 +156,6 @@ , (-3.2, 4.7) , -- Edge cases (1.0e-10, 1.0e-10)- , (1.0e10, 1.0e10) , -- More varied points (2.5, 3.7) , (-5.2, 8.9)@@ -194,10 +193,6 @@ , -- Large inputs (10000.0, 10000.0) , (10000.1, 10000.1)- , -- Floating-point tomfoolery- (1 / 0, 1.0) -- infinity- , (-1 / 0, 1.0) -- negative infinity- , (0 / 0, 1.0) -- NaN ] -- | Strategic test points for 3D noise@@ -231,7 +226,6 @@ , (1.23, -4.56, 7.89) , -- Edge cases (1.0e-10, 1.0e-10, 1.0e-10)- , (1.0e10, 1.0e10, 1.0e10) , -- Mixed signs (1.0, -1.0, 1.0) , (-1.0, 1.0, -1.0)
test/OpenSimplexSpec.hs view
@@ -12,6 +12,8 @@ "OpenSimplex Golden Tests" [ testGroup "2D Grid Tests" openSimplex2DGridTests , testGroup "2D Sparse Tests" openSimplex2DSparseTests+ , testGroup "3D Grid Tests" openSimplex3DGridTests+ , testGroup "3D Sparse Tests" openSimplex3DSparseTests ] openSimplex2DGridTests :: [TestTree]@@ -19,3 +21,9 @@ openSimplex2DSparseTests :: [TestTree] openSimplex2DSparseTests = golden2DSparseTests "opensimplex" defaultSeeds openSimplex2++openSimplex3DGridTests :: [TestTree]+openSimplex3DGridTests = golden3DImageTests "opensimplex" defaultSeeds openSimplex3++openSimplex3DSparseTests :: [TestTree]+openSimplex3DSparseTests = golden3DSparseTests "opensimplex" defaultSeeds openSimplex3
test/SuperSimplexSpec.hs view
@@ -10,6 +10,8 @@ "SuperSimplex Golden Tests" [ testGroup "2D Grid Tests" superSimplex2DGridTests , testGroup "2D Sparse Tests" superSimplex2DSparseTests+ , testGroup "3D Grid Tests" superSimplex3DGridTests+ , testGroup "3D Sparse Tests" superSimplex3DSparseTests ] superSimplex2DGridTests :: [TestTree]@@ -17,3 +19,9 @@ superSimplex2DSparseTests :: [TestTree] superSimplex2DSparseTests = golden2DSparseTests "supersimplex" defaultSeeds superSimplex2++superSimplex3DGridTests :: [TestTree]+superSimplex3DGridTests = golden3DImageTests "supersimplex" defaultSeeds superSimplex3++superSimplex3DSparseTests :: [TestTree]+superSimplex3DSparseTests = golden3DSparseTests "supersimplex" defaultSeeds superSimplex3
+ test/TotalitySpec.hs view
@@ -0,0 +1,60 @@+-- | Out-of-domain inputs (beyond the Int32 lattice, non-finite) produce+-- unspecified /values/, but they must stay values: every noise function is+-- total, so one bad coordinate upstream can't crash a whole render. These+-- assertions replace the old out-of-domain golden points, which pinned the+-- exact garbage and so broke on any implementation change.+module TotalitySpec (test_totality) where++import Control.Exception (evaluate)+import Control.Monad (forM_, void)+import Numeric.Noise+import Test.Tasty (TestTree, testGroup)+import Test.Tasty.HUnit (testCase)++-- Beyond the Int32 lattice, past Double integer precision, and non-finite.+badCoords :: [Double]+badCoords = [1.0e10, -1.0e10, 2 ^ (53 :: Int), 1 / 0, -1 / 0, 0 / 0]++noises2 :: [(String, Noise2 Double)]+noises2 =+ [ ("perlin2", perlin2)+ , ("openSimplex2", openSimplex2)+ , ("superSimplex2", superSimplex2)+ , ("value2", value2)+ , ("valueCubic2", valueCubic2)+ , ("cellular2", cellular2 defaultCellularConfig)+ , ("fractal2 perlin2", fractal2 defaultFractalConfig perlin2)+ ]++noises3 :: [(String, Noise3 Double)]+noises3 =+ [ ("perlin3", perlin3)+ , ("openSimplex3", openSimplex3)+ , ("superSimplex3", superSimplex3)+ , ("value3", value3)+ , ("valueCubic3", valueCubic3)+ , ("cellular3", cellular3 defaultCellularConfig)+ , ("fractal3 perlin3", fractal3 defaultFractalConfig perlin3)+ ]++test_totality :: TestTree+test_totality =+ testGroup+ "Totality on out-of-domain inputs"+ [ testGroup+ "2D"+ [ testCase name $+ forM_ badCoords $ \c ->+ forM_ [(c, 0.5), (0.5, c), (c, c)] $ \(x, y) ->+ void $ evaluate (noise2At noise 0 x y)+ | (name, noise) <- noises2+ ]+ , testGroup+ "3D"+ [ testCase name $+ forM_ badCoords $ \c ->+ forM_ [(c, 0.5, 0.5), (0.5, c, 0.5), (0.5, 0.5, c), (c, c, c)] $ \(x, y, z) ->+ void $ evaluate (noise3At noise 0 x y z)+ | (name, noise) <- noises3+ ]+ ]