diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,120 @@ ## 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 + +- Fixed some errata in the documentation + +## 0.2.1.0 2025-10-31 + +### Added + +- 1D noise support with `noise1At` evaluation function +- Noise slicing functions (`sliceX2`, `sliceY2`, `sliceX3`, `sliceY3`, `sliceZ3`) for reducing noise dimensionality +- Comprehensive Haddock documentation for: + - Core `Noise p v` type with usage examples + - All utility functions (`warp`, `reseed`, `remap`, `blend`) + - All slicing functions with examples +- Exported utility functions: + - `warp` - transform coordinate space + - `reseed` - modify seed for independent layers (generalizes `alterSeed2`/`alterSeed3`) + - `remap` - transform noise values (alias for `fmap`) + - `blend` - combine noise functions with custom blending (alias for `liftA2`) +- Exported `Noise` type for advanced usage and type annotations + +### Changed + +- Refactored to unified noise representation using `newtype Noise p v` + - `Noise2` and `Noise3` are now type aliases: `Noise (a,a) a` and `Noise (a,a,a) a` + - Provides `Functor`, `Applicative`, `Monad`, `Num`, `Fractional`, and `Floating` instances + - All dimensions share the same instance implementations for consistency +- Updated module documentation with examples of new features (slicing, warping, layering) +- Improved README with advanced usage examples + +### Performance + +- **Overall**: 90% of benchmarks improved with +32.4% average performance gain +- **Ping-pong fractals**: Branchless optimization yields 110-148% improvement (perlin, value, openSimplex) +- **Cellular noise**: REWRITE RULES for gradient lookups provide 61-70% improvement +- **3D ValueCubic fractals**: Fixed performance regression, achieving 45-80% improvement +- **Perlin noise**: 10-63% improvements from optimized lerp/cubic interpolation with REWRITE RULES +- **Value noise**: 11-43% improvements from interpolation optimizations +- **OpenSimplex2**: 6-16% improvement for Float; minor regression (~5%) for Double variants +- **SuperSimplex2**: Shows 3-21% regression due to improved benchmark methodology + - Previous benchmarks used same X/Y offset (diagonal sampling), which favored SuperSimplex's triangular lattice + - New benchmarks use independent X/Y offsets for realistic 2D coordinate distributions + - Algorithm remains functionally correct; numbers now reflect true 2D performance + +## 0.2.0.0 - 2025-10-21 + +### Added + +- Comprehensive haddock documentation for main `Numeric.Noise` module with usage examples + +### Changed + +- Migrated internal implementation from `vector` to `primitive` (PrimArray) +- Removed `vector` dependency from library (still used in benchmarks) +- Require GHC 9.2+ (base >= 4.16) +- Hide internal modules from public API (`Numeric.Noise.Internal`, `Numeric.Noise.Internal.Math`) +- Improved cellular noise performance by 20-30% through specialized computation paths for different result types + +### Fixed + +- Fixed intermediate list allocation in fractal functions on GHC 9.6+ +- Improved division performance for `Noise3` instances + ## 0.1.0.1 - 2024-10-15 - Add bounds for vector diff --git a/LICENSE_FastNoiseLite b/LICENSE_FastNoiseLite new file mode 100644 --- /dev/null +++ b/LICENSE_FastNoiseLite @@ -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. diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -2,75 +2,269 @@ Performant, modern noise generation for Haskell with a minimal dependency footprint. -The algorithms used in this library are ported from [FastNoiseLite](https://github.com/Auburn/FastNoiseLite). The library structure has been retuned to fit better with Haskell semantics. +## Core features -The public interface for this library is unlikely to change much, although the implementations (`noiseBaseN` functions and anything in `Numeric.Noise.Internal`) are subject to change and may change between minor versions. +- **algebraic composition** of noise functions. You can combine, + layer, and transform noise sources using standard operators (E.g., `Num`, + `Fractional`, `Monad`, etc). +- **Complex effects** like domain warping and multi-octave fractals with clean, + type-safe composition. +- **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).** + +The public interface for this library is unlikely to change much, although the +implementations (`noiseBaseN` functions and anything in `Numeric.Noise.Internal`) +are subject to change and may change between minor versions. + +## Acknowledgments + +- 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 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. +- The original FastNoiseLite code, from which the core algorithms in this library + 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 exports newtypes for N-dimensional noise. Currently, these are just functions that accept a seed and a point in N-dimensional space. They can be arbitrarily unwrapped by with the `noiseNAt` family of functions. Since they abstract over the given seed and parameters, they can be composed with `Num` or `Fractional` methods at will with little-to-no performance cost. +The library provides composable noise functions. `Noise2` and `Noise3` are type +aliases for 2D and 3D noise. Noise functions can be composed transparently using +standard operators with minimal performance cost. -Noise values are generally clamped to `[-1, 1]`, although some noise 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 Example + ```haskell import Numeric.Noise qualified as Noise -myNoise2 :: (RealFrac a) => Seed -> a -> a -> a +-- Compose multiple noise sources +myNoise2 :: (RealFrac a) => Noise.Seed -> a -> a -> a myNoise2 = let fractalConfig = Noise.defaultFractalConfig - in Noise.noise2At $ - Noise.fractal2 fractalConfig ((perlin2 + superSimplex2) / 2) + combined = (Noise.perlin2 + Noise.superSimplex2) / 2 + in Noise.noise2At $ Noise.fractal2 fractalConfig combined ``` +### Advanced Features + +The library's unified `Noise p v` type enables powerful composition patterns: + +#### Complex Compositions + +The `Monad` instance is useful to create noise that depends on other noise values: + +```haskell +-- Use one noise function's output to modulate another +complexNoise :: Noise.Noise2 Float +complexNoise = do + baseNoise <- Noise.perlin2 + detailNoise <- Noise.next2 Noise.superSimplex2 + -- Blend based on base noise: smooth areas get less detail + pure $ baseNoise * 0.7 + detailNoise * (0.3 * (1 + baseNoise) / 2) +``` + +This is especially useful for creating organic, varied terrain where one noise pattern +influences the characteristics of another. + +#### 1D Noise via Slicing + +Generate 1D noise by slicing higher-dimensional noise at a fixed coordinate: + +```haskell +-- Create 1D noise by fixing one dimension +noise1d :: Noise.Noise1 Float +noise1d = Noise.sliceY2 0.0 Noise.perlin2 + +-- Evaluate at a point +value = Noise.noise1At noise1d seed 5.0 +``` + +**Coordinate Transformation:** + +Scale, rotate, or warp the coordinate space: + +```haskell +-- Double the frequency +scaled = Noise.warp (\(x, y) -> (x * 2, y * 2)) Noise.perlin2 + +-- Rotate 45 degrees +rotated = Noise.warp (\(x, y) -> + let a = pi / 4 + in (x * cos a - y * sin a, x * sin a + y * cos a)) Noise.perlin2 +``` + +#### Layering Independent Noise + +Use `reseed` or `next2`/`next3` to create independent layers: + +```haskell +layered = (Noise.perlin2 + Noise.next2 Noise.perlin2) / 2 +``` + More examples can be found in `bench` and `demo`. +#### Domain Warping + +Domain warping uses one noise function to distort the coordinate space of another, +creating organic, flowing patterns ideal for terrain, clouds, and natural textures: + +```haskell +domainWarped :: Noise.Noise2 Float +domainWarped = do + -- Generate 3D fractal for warp offsets + let warpNoise = Noise.fractal3 Noise.defaultFractalConfig{Noise.octaves = 5} Noise.perlin3 + -- Sample 3D noise at different slices to create warp offsets + warpX <- Noise.sliceX3 0.0 warpNoise -- Samples at (0, x, y) + warpY <- Noise.sliceY3 0.0 warpNoise -- Samples at (x, 0, y) + -- Apply warping to base noise coordinates + Noise.warp (\(x, y) -> (x + 30 * warpX, y + 30 * warpY)) + $ Noise.fractal2 Noise.defaultFractalConfig{Noise.octaves = 5} Noise.openSimplex2 +``` + +![Domain Warped Noise](https://raw.githubusercontent.com/jtnuttall/pure-noise/main/demo/images/domain-warp.png) + +See the [demo app](demo/) for an interactive version with adjustable parameters. + ## Performance notes -- 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. -## Benchmarks +### Recommended build flags -### Results +#### Native optimization flags for the library -Measured by values / second generated by the noise functions. These results come from a benchmark with `-fllvm` enabled. +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). -All results are for `Float`s. +For bulk generation, prefer parallel evaluation via `massiv`. -There's inevitably some noise in the measurements because all of the results are forced into an unboxed vector. +#### Fused multiply add -#### 2D +For the fastest downstream executables, compile the modules that _call_ the +noise functions (the kernels inline into your code) with: -| name | values / second | -| ------------- | --------------- | -| value2 | 157_347_680 | -| perlin2 | 129_541_747 | -| openSimplex2 | 64_758_006 | -| superSimplex2 | 64_072_639 | -| valueCubic2 | 52_110_819 | -| cellular2 | 15_743_434 | +``` +-fllvm -mavx -mfma -optlc-fp-contract=fast +``` -#### 3D +> [!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. -| name | values / second | -| ----------- | --------------- | -| value3 | 85_438_023 | -| perlin3 | 56_830_482 | -| valueCubic3 | 15_559_523 | +`-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 evaluation reaches roughly 6-9x +single-threaded throughput on a 14-core machine in pinned-clock measurements. + +> [!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, in the +`llvm-bench` configuration (LLVM backend + FP contraction), on an i7-1370P +**pinned at 1.9 GHz** for measurement stability — + +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 | 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 | 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 -There's an interactive [demo app](demo/README.md) in the `demo` directory. +There's an interactive [demo app](https://github.com/jtnuttall/pure-noise/tree/main/demo) in the `demo` directory. -_OpenSimplex2_ +### OpenSimplex2 -![OpenSimplex2](demo/images/opensimplex.png) -![OpenSimplex2 ridged](demo/images/opensimplex-ridged.png) +![OpenSimplex2](https://raw.githubusercontent.com/jtnuttall/pure-noise/main/demo/images/opensimplex.png) +![OpenSimplex2 ridged](https://raw.githubusercontent.com/jtnuttall/pure-noise/main/demo/images/opensimplex-ridged.png) -_Perlin_ +### Perlin -![Perlin fBm](demo/images/perlin-fbm.png) +![Perlin fBm](https://raw.githubusercontent.com/jtnuttall/pure-noise/main/demo/images/perlin-fbm.png) -_Cellular_ +### Cellular -![value](demo/images/cell-value.png) -![distance2add](demo/images/cell-d2.png) +![value](https://raw.githubusercontent.com/jtnuttall/pure-noise/main/demo/images/cell-value.png) +![distance2add](https://raw.githubusercontent.com/jtnuttall/pure-noise/main/demo/images/cell-d2.png) diff --git a/bench/Bench.hs b/bench/Bench.hs --- a/bench/Bench.hs +++ b/bench/Bench.hs @@ -1,295 +1,457 @@ import BenchLib +import Data.Massiv.Array qualified as MA import Data.Typeable import Data.Vector.Unboxed qualified as U import Numeric.Noise -import Numeric.Noise.Internal (const2, const3) -import System.Random.MWC qualified as MWC +import System.Random.Stateful (StatefulGen, UniformRange, newAtomicGenM, newStdGen, uniformRM) main :: IO () main = do let sz = 1_000_000 - seed = 1337 octaves = 8 + massivW = 1_000 + massivH = 1_000 defaultMain [ bgroup "2D" - ( baseline2 seed sz - <> benchPerlin2 seed octaves sz - <> benchOpenSimplex2 seed octaves sz - <> benchOpenSimplexSmooth2 seed octaves sz - <> benchValue2 seed octaves sz - <> benchValueCubic2 seed octaves sz - <> benchCombo2 seed octaves sz - <> benchCellular2 seed octaves sz + ( baseline2 sz + <> benchPerlin2 octaves sz + <> benchOpenSimplex2 octaves sz + <> benchOpenSimplexSmooth2 octaves sz + <> benchValue2 octaves sz + <> benchValueCubic2 octaves sz + <> benchCombo2 octaves sz + <> benchCellular2 octaves sz ) , bgroup "3D" - ( baseline3 seed sz - <> benchPerlin3 seed octaves sz - <> benchValue3 seed octaves sz - <> benchValueCubic3 seed octaves sz + ( 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 + ) ] -label :: (Typeable a) => String -> Int -> Seed -> Proxy a -> String -label lbl sz seed px = +label :: (Typeable a) => String -> Int -> Proxy a -> String +label lbl sz px = let lbl' = case lbl of "" -> "" v -> v <> ": " - in lbl' <> showsTypeRep (typeRep px) "" <> "[seed=" <> show seed <> "] x" <> show sz + in lbl' <> showsTypeRep (typeRep px) "" <> " x" <> show sz -createEnv2 :: forall a. (U.Unbox a, MWC.UniformRange a, RealFrac a) => Int -> IO (U.Vector (a, a)) +-- most of these functions zero at whole numbers and can short-circuit, +-- so a random offset should give a better signal of real world performance +generate2DCoords + :: ( UniformRange a + , RealFrac a + , StatefulGen g IO + ) + => g + -> Int + -> Int + -> IO (a, a) +generate2DCoords g i j = do + offsetX <- uniformRM (0.00001, 0.99999) g + offsetY <- uniformRM (0.00001, 0.99999) g + let r = fromIntegral i + c = fromIntegral j + + pure (r + offsetX, c + offsetY) +{-# INLINE generate2DCoords #-} + +createEnv2 :: forall a. (U.Unbox a, UniformRange a, RealFrac a) => Int -> IO (Seed, U.Vector (a, a)) createEnv2 sz = do - g <- MWC.createSystemRandom - U.generateM sz $ \i -> do - -- most of these functions zero at whole numbers and can short-circuit, - -- so a random offset should give a better signal of real world performance - offset <- MWC.uniformRM (0.00001, 0.99999) g - pure $ - let r = fromIntegral $ i `div` (sz `div` 2) - c = fromIntegral $ i `mod` (sz `div` 2) - in (r + offset, c + offset) + g <- newAtomicGenM =<< newStdGen + seed <- uniformRM (minBound, maxBound) g + v <- U.generateM sz $ \i -> + generate2DCoords + g + (i `div` (sz `div` 2)) + (i `mod` (sz `div` 2)) + pure (seed, v) {-# INLINE createEnv2 #-} benchMany2 :: forall a - . (Typeable a, MWC.UniformRange a, U.Unbox a, RealFrac a) + . (Typeable a, UniformRange a, U.Unbox a, RealFrac a) => String -> Int - -> Seed -> Noise2 a -> Benchmark -benchMany2 lbl sz seed f = - env (createEnv2 sz) $ \ ~v -> - bench (label lbl sz seed (Proxy @(U.Vector a))) $ +benchMany2 lbl sz f = + env (createEnv2 sz) $ \ ~(seed, v) -> + bench (label lbl sz (Proxy @(U.Vector a))) $ nf (U.map (uncurry (noise2At f seed))) v {-# INLINE benchMany2 #-} -baseline2 :: Seed -> Int -> [Benchmark] -baseline2 seed sz = +baseline2 :: Int -> [Benchmark] +baseline2 sz = [ bgroup "baseline2" - [ benchMany2 @Float "" sz seed (const2 1) - , benchMany2 @Double "" sz seed (const2 2) + [ benchMany2 @Float "" sz (const2 1) + , benchMany2 @Double "" sz (const2 2) ] ] -{-# INLINE baseline2 #-} -benchPerlin2 :: Seed -> Int -> Int -> [Benchmark] -benchPerlin2 seed octaves sz = +benchPerlin2 :: Int -> Int -> [Benchmark] +benchPerlin2 octaves sz = [ bgroup "perlin2" - [ benchMany2 @Float "" sz seed perlin2 - , benchMany2 @Double "" sz seed perlin2 - , benchMany2 @Float "fractal" sz seed (fractal2 defaultFractalConfig{octaves} perlin2) - , benchMany2 @Double "fractal" sz seed (fractal2 defaultFractalConfig{octaves} perlin2) - , benchMany2 @Float "ridged" sz seed (ridged2 defaultFractalConfig{octaves} perlin2) - , benchMany2 @Double "ridged" sz seed (ridged2 defaultFractalConfig{octaves} perlin2) - , benchMany2 @Float "billow" sz seed (billow2 defaultFractalConfig{octaves} perlin2) - , benchMany2 @Double "billow" sz seed (billow2 defaultFractalConfig{octaves} perlin2) - , benchMany2 @Float "pingPong" sz seed (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength perlin2) - , benchMany2 @Double "pingPong" sz seed (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength perlin2) + [ benchMany2 @Float "" sz perlin2 + , benchMany2 @Double "" sz perlin2 + , benchMany2 @Float "fractal" sz (fractal2 defaultFractalConfig{octaves} perlin2) + , benchMany2 @Double "fractal" sz (fractal2 defaultFractalConfig{octaves} perlin2) + , benchMany2 @Float "ridged" sz (ridged2 defaultFractalConfig{octaves} perlin2) + , benchMany2 @Double "ridged" sz (ridged2 defaultFractalConfig{octaves} perlin2) + , benchMany2 @Float "billow" sz (billow2 defaultFractalConfig{octaves} perlin2) + , benchMany2 @Double "billow" sz (billow2 defaultFractalConfig{octaves} perlin2) + , benchMany2 @Float "pingPong" sz (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength perlin2) + , benchMany2 @Double "pingPong" sz (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength perlin2) ] ] -{-# INLINE benchPerlin2 #-} -benchOpenSimplex2 :: Seed -> Int -> Int -> [Benchmark] -benchOpenSimplex2 seed octaves sz = +benchOpenSimplex2 :: Int -> Int -> [Benchmark] +benchOpenSimplex2 octaves sz = [ bgroup "openSimplex2" - [ benchMany2 @Float "" sz seed openSimplex2 - , benchMany2 @Double "" sz seed openSimplex2 - , benchMany2 @Float "fractal" sz seed (fractal2 defaultFractalConfig{octaves} openSimplex2) - , benchMany2 @Double "fractal" sz seed (fractal2 defaultFractalConfig{octaves} openSimplex2) - , benchMany2 @Float "ridged" sz seed (ridged2 defaultFractalConfig{octaves} openSimplex2) - , benchMany2 @Double "ridged" sz seed (ridged2 defaultFractalConfig{octaves} openSimplex2) - , benchMany2 @Float "billow" sz seed (billow2 defaultFractalConfig{octaves} openSimplex2) - , benchMany2 @Double "billow" sz seed (billow2 defaultFractalConfig{octaves} openSimplex2) - , benchMany2 @Float "pingPong" sz seed (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength openSimplex2) - , benchMany2 @Double "pingPong" sz seed (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength openSimplex2) + [ benchMany2 @Float "" sz openSimplex2 + , benchMany2 @Double "" sz openSimplex2 + , benchMany2 @Float "fractal" sz (fractal2 defaultFractalConfig{octaves} openSimplex2) + , benchMany2 @Double "fractal" sz (fractal2 defaultFractalConfig{octaves} openSimplex2) + , benchMany2 @Float "ridged" sz (ridged2 defaultFractalConfig{octaves} openSimplex2) + , benchMany2 @Double "ridged" sz (ridged2 defaultFractalConfig{octaves} openSimplex2) + , benchMany2 @Float "billow" sz (billow2 defaultFractalConfig{octaves} openSimplex2) + , benchMany2 @Double "billow" sz (billow2 defaultFractalConfig{octaves} openSimplex2) + , benchMany2 @Float "pingPong" sz (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength openSimplex2) + , benchMany2 @Double "pingPong" sz (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength openSimplex2) ] ] -{-# INLINE benchOpenSimplex2 #-} -benchOpenSimplexSmooth2 :: Seed -> Int -> Int -> [Benchmark] -benchOpenSimplexSmooth2 seed octaves sz = +benchOpenSimplexSmooth2 :: Int -> Int -> [Benchmark] +benchOpenSimplexSmooth2 octaves sz = [ bgroup "superSimplex2" - [ benchMany2 @Float "" sz seed superSimplex2 - , benchMany2 @Double "" sz seed superSimplex2 - , benchMany2 @Float "fractal" sz seed (fractal2 defaultFractalConfig{octaves} superSimplex2) - , benchMany2 @Double "fractal" sz seed (fractal2 defaultFractalConfig{octaves} superSimplex2) - , benchMany2 @Float "ridged" sz seed (ridged2 defaultFractalConfig{octaves} superSimplex2) - , benchMany2 @Double "ridged" sz seed (ridged2 defaultFractalConfig{octaves} superSimplex2) - , benchMany2 @Float "billow" sz seed (billow2 defaultFractalConfig{octaves} superSimplex2) - , benchMany2 @Double "billow" sz seed (billow2 defaultFractalConfig{octaves} superSimplex2) - , benchMany2 @Float "pingPong" sz seed (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength superSimplex2) - , benchMany2 @Double "pingPong" sz seed (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength superSimplex2) + [ benchMany2 @Float "" sz superSimplex2 + , benchMany2 @Double "" sz superSimplex2 + , benchMany2 @Float "fractal" sz (fractal2 defaultFractalConfig{octaves} superSimplex2) + , benchMany2 @Double "fractal" sz (fractal2 defaultFractalConfig{octaves} superSimplex2) + , benchMany2 @Float "ridged" sz (ridged2 defaultFractalConfig{octaves} superSimplex2) + , benchMany2 @Double "ridged" sz (ridged2 defaultFractalConfig{octaves} superSimplex2) + , benchMany2 @Float "billow" sz (billow2 defaultFractalConfig{octaves} superSimplex2) + , benchMany2 @Double "billow" sz (billow2 defaultFractalConfig{octaves} superSimplex2) + , benchMany2 @Float "pingPong" sz (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength superSimplex2) + , benchMany2 @Double "pingPong" sz (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength superSimplex2) ] ] -{-# INLINE benchOpenSimplexSmooth2 #-} -benchValue2 :: Seed -> Int -> Int -> [Benchmark] -benchValue2 seed octaves sz = +benchValue2 :: Int -> Int -> [Benchmark] +benchValue2 octaves sz = [ bgroup "value2" - [ benchMany2 @Float "" sz seed value2 - , benchMany2 @Double "" sz seed value2 - , benchMany2 @Float "fractal" sz seed (fractal2 defaultFractalConfig{octaves} value2) - , benchMany2 @Double "fractal" sz seed (fractal2 defaultFractalConfig{octaves} value2) - , benchMany2 @Float "ridged" sz seed (ridged2 defaultFractalConfig{octaves} value2) - , benchMany2 @Double "ridged" sz seed (ridged2 defaultFractalConfig{octaves} value2) - , benchMany2 @Float "billow" sz seed (billow2 defaultFractalConfig{octaves} value2) - , benchMany2 @Double "billow" sz seed (billow2 defaultFractalConfig{octaves} value2) - , benchMany2 @Float "pingPong" sz seed (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength value2) - , benchMany2 @Double "pingPong" sz seed (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength value2) + [ benchMany2 @Float "" sz value2 + , benchMany2 @Double "" sz value2 + , benchMany2 @Float "fractal" sz (fractal2 defaultFractalConfig{octaves} value2) + , benchMany2 @Double "fractal" sz (fractal2 defaultFractalConfig{octaves} value2) + , benchMany2 @Float "ridged" sz (ridged2 defaultFractalConfig{octaves} value2) + , benchMany2 @Double "ridged" sz (ridged2 defaultFractalConfig{octaves} value2) + , benchMany2 @Float "billow" sz (billow2 defaultFractalConfig{octaves} value2) + , benchMany2 @Double "billow" sz (billow2 defaultFractalConfig{octaves} value2) + , benchMany2 @Float "pingPong" sz (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength value2) + , benchMany2 @Double "pingPong" sz (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength value2) ] ] -{-# INLINE benchValue2 #-} -benchValueCubic2 :: Seed -> Int -> Int -> [Benchmark] -benchValueCubic2 seed octaves sz = +benchValueCubic2 :: Int -> Int -> [Benchmark] +benchValueCubic2 octaves sz = [ bgroup "valueCubic2" - [ benchMany2 @Float "" sz seed valueCubic2 - , benchMany2 @Double "" sz seed valueCubic2 - , benchMany2 @Float "fractal" sz seed (fractal2 defaultFractalConfig{octaves} valueCubic2) - , benchMany2 @Double "fractal" sz seed (fractal2 defaultFractalConfig{octaves} valueCubic2) - , benchMany2 @Float "ridged" sz seed (ridged2 defaultFractalConfig{octaves} valueCubic2) - , benchMany2 @Double "ridged" sz seed (ridged2 defaultFractalConfig{octaves} valueCubic2) - , benchMany2 @Float "billow" sz seed (billow2 defaultFractalConfig{octaves} valueCubic2) - , benchMany2 @Double "billow" sz seed (billow2 defaultFractalConfig{octaves} valueCubic2) - , benchMany2 @Float "pingPong" sz seed (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength valueCubic2) - , benchMany2 @Double "pingPong" sz seed (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength valueCubic2) + [ benchMany2 @Float "" sz valueCubic2 + , benchMany2 @Double "" sz valueCubic2 + , benchMany2 @Float "fractal" sz (fractal2 defaultFractalConfig{octaves} valueCubic2) + , benchMany2 @Double "fractal" sz (fractal2 defaultFractalConfig{octaves} valueCubic2) + , benchMany2 @Float "ridged" sz (ridged2 defaultFractalConfig{octaves} valueCubic2) + , benchMany2 @Double "ridged" sz (ridged2 defaultFractalConfig{octaves} valueCubic2) + , benchMany2 @Float "billow" sz (billow2 defaultFractalConfig{octaves} valueCubic2) + , benchMany2 @Double "billow" sz (billow2 defaultFractalConfig{octaves} valueCubic2) + , benchMany2 @Float "pingPong" sz (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength valueCubic2) + , benchMany2 @Double "pingPong" sz (pingPong2 defaultFractalConfig{octaves} defaultPingPongStrength valueCubic2) ] ] -{-# INLINE benchValueCubic2 #-} -benchCombo2 :: Seed -> Int -> Int -> [Benchmark] -benchCombo2 seed octaves sz = +benchCombo2 :: Int -> Int -> [Benchmark] +benchCombo2 octaves sz = [ bgroup "numeric combination" - [ benchMany2 @Float "perlin * opensimplex/2" sz seed $ + [ benchMany2 @Float "perlin * opensimplex/2" sz $ openSimplex2 / 2 * perlin2 - , benchMany2 @Float "(4 * perlin) / 4" sz seed $ + , benchMany2 @Float "(4 * perlin) / 4" sz $ 4 * perlin2 / 4 - , benchMany2 @Float "(perlin + perlin + perlin + perlin) / 4" sz seed $ + , benchMany2 @Float "(perlin + perlin + perlin + perlin) / 4" sz $ (perlin2 + perlin2 + perlin2 + perlin2) / 4 - , benchMany2 @Float "fractal (perlin * opensimplex/2)" sz seed $ + , benchMany2 @Float "fractal (perlin * opensimplex/2)" sz $ fractal2 defaultFractalConfig{octaves} (openSimplex2 / 2 * perlin2) - , benchMany2 @Float "fractal perlin * fractal opensimplex" sz seed $ + , benchMany2 @Float "fractal perlin * fractal opensimplex" sz $ fractal2 defaultFractalConfig{octaves} perlin2 * fractal2 defaultFractalConfig{octaves} openSimplex2 ] ] -{-# INLINE benchCombo2 #-} -benchCellular2 :: Seed -> Int -> Int -> [Benchmark] -benchCellular2 seed _ sz = +benchCellular2 :: Int -> Int -> [Benchmark] +benchCellular2 _ sz = [ bgroup "cellular2" - ( benches @Float Proxy - <> benches @Double Proxy - ) + [ benchMany2 @Float + "DistEuclidean CellValue" + sz + (cellular2 defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = CellValue}) + , benchMany2 @Float + "DistEuclidean Distance2Add" + sz + (cellular2 defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = Distance2Add}) + , benchMany2 @Float + "DistManhattan CellValue" + sz + (cellular2 defaultCellularConfig{cellularDistanceFn = DistManhattan, cellularResult = CellValue}) + , benchMany2 @Float + "DistManhattan Distance2Add" + sz + (cellular2 defaultCellularConfig{cellularDistanceFn = DistManhattan, cellularResult = Distance2Add}) + , benchMany2 @Double + "DistEuclidean CellValue" + sz + (cellular2 defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = CellValue}) + , benchMany2 @Double + "DistEuclidean Distance2Add" + sz + (cellular2 defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = Distance2Add}) + , benchMany2 @Double + "DistManhattan CellValue" + sz + (cellular2 defaultCellularConfig{cellularDistanceFn = DistManhattan, cellularResult = CellValue}) + , benchMany2 @Double + "DistManhattan Distance2Add" + sz + (cellular2 defaultCellularConfig{cellularDistanceFn = DistManhattan, cellularResult = Distance2Add}) + ] ] - where - benches - :: forall a. (Typeable a, MWC.UniformRange a, U.Unbox a, RealFrac a, Floating a) => Proxy a -> [Benchmark] - benches _ = - [ benchMany2 @a (show d <> " " <> show r) sz seed (cellular2 config) - | d <- [DistEuclidean] - , r <- [CellValue, Distance2Add] - , let config = defaultCellularConfig{cellularDistanceFn = d, cellularResult = r} - ] - {-# INLINE benches #-} -{-# INLINE benchCellular2 #-} -createEnv3 :: forall a m. (Monad m, U.Unbox a, Num a) => Int -> m (U.Vector (a, a, a)) +-- 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 - !ixs <- U.generateM sz $ \i -> - pure $ - let d = sz `div` 3 - !x = fromIntegral $ i `div` d `mod` d - !y = fromIntegral $ i `div` (d * d) - !z = fromIntegral $ i `div` d - in (x, y, z) - pure ixs + g <- newAtomicGenM =<< newStdGen + seed <- uniformRM (minBound, maxBound) g + let d = ceiling (fromIntegral sz ** (1 / 3) :: Double) + !ixs <- U.generateM sz $ \i -> do + 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 #-} benchMany3 :: forall a - . (Typeable a, RealFrac a, U.Unbox a) + . (Typeable a, UniformRange a, RealFrac a, U.Unbox a) => String -> Int - -> Seed -> Noise3 a -> Benchmark -benchMany3 lbl sz seed f = - env (createEnv3 sz) $ \ ~v -> - bench (label lbl sz seed (Proxy @(U.Vector a))) $ +benchMany3 lbl sz f = + env (createEnv3 sz) $ \ ~(seed, v) -> + bench (label lbl sz (Proxy @(U.Vector a))) $ nf (U.map (\(x, y, z) -> noise3At f seed x y z)) v {-# INLINE benchMany3 #-} -baseline3 :: Seed -> Int -> [Benchmark] -baseline3 seed sz = +baseline3 :: Int -> [Benchmark] +baseline3 sz = [ bgroup "baseline3" - [ benchMany3 @Float "" sz seed (const3 1) - , benchMany3 @Double "" sz seed (const3 2) + [ benchMany3 @Float "" sz (const3 1) + , benchMany3 @Double "" sz (const3 2) ] ] -{-# INLINE baseline3 #-} -benchPerlin3 :: Seed -> Int -> Int -> [Benchmark] -benchPerlin3 seed octaves sz = +benchPerlin3 :: Int -> Int -> [Benchmark] +benchPerlin3 octaves sz = [ bgroup "perlin3" - [ benchMany3 @Float "" sz seed perlin3 - , benchMany3 @Double "" sz seed perlin3 - , benchMany3 @Float "fractal" sz seed (fractal3 defaultFractalConfig{octaves} perlin3) - , benchMany3 @Double "fractal" sz seed (fractal3 defaultFractalConfig{octaves} perlin3) - , benchMany3 @Float "ridged" sz seed (ridged3 defaultFractalConfig{octaves} perlin3) - , benchMany3 @Double "ridged" sz seed (ridged3 defaultFractalConfig{octaves} perlin3) - , benchMany3 @Float "billow" sz seed (billow3 defaultFractalConfig{octaves} perlin3) - , benchMany3 @Double "billow" sz seed (billow3 defaultFractalConfig{octaves} perlin3) - , benchMany3 @Float "pingPong" sz seed (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength perlin3) - , benchMany3 @Double "pingPong" sz seed (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength perlin3) + [ benchMany3 @Float "" sz perlin3 + , benchMany3 @Double "" sz perlin3 + , benchMany3 @Float "fractal" sz (fractal3 defaultFractalConfig{octaves} perlin3) + , benchMany3 @Double "fractal" sz (fractal3 defaultFractalConfig{octaves} perlin3) + , benchMany3 @Float "ridged" sz (ridged3 defaultFractalConfig{octaves} perlin3) + , benchMany3 @Double "ridged" sz (ridged3 defaultFractalConfig{octaves} perlin3) + , benchMany3 @Float "billow" sz (billow3 defaultFractalConfig{octaves} perlin3) + , benchMany3 @Double "billow" sz (billow3 defaultFractalConfig{octaves} perlin3) + , benchMany3 @Float "pingPong" sz (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength perlin3) + , benchMany3 @Double "pingPong" sz (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength perlin3) ] ] -{-# INLINE benchPerlin3 #-} -benchValue3 :: Seed -> Int -> Int -> [Benchmark] -benchValue3 seed octaves sz = +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 "value3" - [ benchMany3 @Float "" sz seed value3 - , benchMany3 @Double "" sz seed value3 - , benchMany3 @Float "fractal" sz seed (fractal3 defaultFractalConfig{octaves} value3) - , benchMany3 @Double "fractal" sz seed (fractal3 defaultFractalConfig{octaves} value3) - , benchMany3 @Float "ridged" sz seed (ridged3 defaultFractalConfig{octaves} value3) - , benchMany3 @Double "ridged" sz seed (ridged3 defaultFractalConfig{octaves} value3) - , benchMany3 @Float "billow" sz seed (billow3 defaultFractalConfig{octaves} value3) - , benchMany3 @Double "billow" sz seed (billow3 defaultFractalConfig{octaves} value3) - , benchMany3 @Float "pingPong" sz seed (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength value3) - , benchMany3 @Double "pingPong" sz seed (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength value3) + [ benchMany3 @Float "" sz value3 + , benchMany3 @Double "" sz value3 + , benchMany3 @Float "fractal" sz (fractal3 defaultFractalConfig{octaves} value3) + , benchMany3 @Double "fractal" sz (fractal3 defaultFractalConfig{octaves} value3) + , benchMany3 @Float "ridged" sz (ridged3 defaultFractalConfig{octaves} value3) + , benchMany3 @Double "ridged" sz (ridged3 defaultFractalConfig{octaves} value3) + , benchMany3 @Float "billow" sz (billow3 defaultFractalConfig{octaves} value3) + , benchMany3 @Double "billow" sz (billow3 defaultFractalConfig{octaves} value3) + , benchMany3 @Float "pingPong" sz (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength value3) + , benchMany3 @Double "pingPong" sz (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength value3) ] ] -{-# INLINE benchValue3 #-} -benchValueCubic3 :: Seed -> Int -> Int -> [Benchmark] -benchValueCubic3 seed octaves sz = +benchValueCubic3 :: Int -> Int -> [Benchmark] +benchValueCubic3 octaves sz = [ bgroup "valueCubic3" - [ benchMany3 @Float "" sz seed valueCubic3 - , benchMany3 @Double "" sz seed valueCubic3 - , benchMany3 @Float "fractal" sz seed (fractal3 defaultFractalConfig{octaves} valueCubic3) - , benchMany3 @Double "fractal" sz seed (fractal3 defaultFractalConfig{octaves} valueCubic3) - , benchMany3 @Float "ridged" sz seed (ridged3 defaultFractalConfig{octaves} valueCubic3) - , benchMany3 @Double "ridged" sz seed (ridged3 defaultFractalConfig{octaves} valueCubic3) - , benchMany3 @Float "billow" sz seed (billow3 defaultFractalConfig{octaves} valueCubic3) - , benchMany3 @Double "billow" sz seed (billow3 defaultFractalConfig{octaves} valueCubic3) - , benchMany3 @Float "pingPong" sz seed (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength valueCubic3) - , benchMany3 @Double "pingPong" sz seed (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength valueCubic3) + [ benchMany3 @Float "" sz valueCubic3 + , benchMany3 @Double "" sz valueCubic3 + , benchMany3 @Float "fractal" sz (fractal3 defaultFractalConfig{octaves} valueCubic3) + , benchMany3 @Double "fractal" sz (fractal3 defaultFractalConfig{octaves} valueCubic3) + , benchMany3 @Float "ridged" sz (ridged3 defaultFractalConfig{octaves} valueCubic3) + , benchMany3 @Double "ridged" sz (ridged3 defaultFractalConfig{octaves} valueCubic3) + , benchMany3 @Float "billow" sz (billow3 defaultFractalConfig{octaves} valueCubic3) + , benchMany3 @Double "billow" sz (billow3 defaultFractalConfig{octaves} valueCubic3) + , benchMany3 @Float "pingPong" sz (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength valueCubic3) + , benchMany3 @Double "pingPong" sz (pingPong3 defaultFractalConfig{octaves} defaultPingPongStrength valueCubic3) ] ] -{-# INLINE benchValueCubic3 #-} + +benchMassiv2 + :: forall a + . (Typeable a, U.Unbox a, RealFrac a, UniformRange a) + => String + -> Int + -> Int + -> Noise2 a + -> Benchmark +benchMassiv2 lbl !w !h noiseF = + env + ( do + g <- newAtomicGenM =<< newStdGen + seed <- uniformRM (minBound, maxBound) g + -- This intentionally breaks the optimizer's ability to DCE. If we try to calculate + -- inline it seems that GHC is smart enough to figure out that the whole-number + -- integral points involve relatively simple code paths. + (arr :: MA.Array MA.U MA.Ix2 (a, a)) <- + MA.generateArray @MA.U MA.Par (MA.Sz2 h w) $ \(i MA.:. j) -> + generate2DCoords g i j + + pure (seed, arr) + ) + $ \ ~(seed, arr) -> + bench (label lbl (w * h) (Proxy @a)) $ + nf + ( MA.computeP @MA.U + . MA.map + ( \(!x, !y) -> + noise2At noiseF seed x y + ) + ) + arr +{-# INLINE benchMassiv2 #-} + +benchMassivBase2 :: Int -> Int -> [Benchmark] +benchMassivBase2 !w !h = + [ bgroup + "massiv base2" + [ benchMassiv2 @Float "perlin2" w h perlin2 + , benchMassiv2 @Double "perlin2" w h perlin2 + , benchMassiv2 @Float "openSimplex2" w h openSimplex2 + , benchMassiv2 @Double "openSimplex2" w h openSimplex2 + , benchMassiv2 @Float "superSimplex2" w h superSimplex2 + , benchMassiv2 @Double "superSimplex2" w h superSimplex2 + , benchMassiv2 @Float "value2" w h value2 + , benchMassiv2 @Double "value2" w h value2 + , benchMassiv2 @Float "valueCubic2" w h valueCubic2 + , benchMassiv2 @Double "valueCubic2" w h valueCubic2 + , benchMassiv2 @Float + "cellular2" + w + h + (cellular2 defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = CellValue}) + , benchMassiv2 @Double + "cellular2" + w + h + (cellular2 defaultCellularConfig{cellularDistanceFn = DistEuclidean, cellularResult = CellValue}) + ] + ] + +benchMassivFractal2 :: Int -> Int -> Int -> [Benchmark] +benchMassivFractal2 octaves w h = + [ bgroup + "massiv fractal2" + [ benchMassiv2 @Float "perlin2 fractal" w h (fractal2 defaultFractalConfig{octaves} perlin2) + , benchMassiv2 @Double "perlin2 fractal" w h (fractal2 defaultFractalConfig{octaves} perlin2) + , benchMassiv2 @Float "value2 fractal" w h (fractal2 defaultFractalConfig{octaves} value2) + , benchMassiv2 @Double "value2 fractal" w h (fractal2 defaultFractalConfig{octaves} value2) + , benchMassiv2 @Float "openSimplex2 fractal" w h (fractal2 defaultFractalConfig{octaves} openSimplex2) + , benchMassiv2 @Double "openSimplex2 fractal" w h (fractal2 defaultFractalConfig{octaves} openSimplex2) + , benchMassiv2 @Float "superSimplex2 fractal" w h (fractal2 defaultFractalConfig{octaves} superSimplex2) + , benchMassiv2 @Double "superSimplex2 fractal" w h (fractal2 defaultFractalConfig{octaves} superSimplex2) + ] + ] diff --git a/bench/BenchLib.hs b/bench/BenchLib.hs --- a/bench/BenchLib.hs +++ b/bench/BenchLib.hs diff --git a/bench/fnl-compare/FnlBench.hs b/bench/fnl-compare/FnlBench.hs new file mode 100644 --- /dev/null +++ b/bench/fnl-compare/FnlBench.hs @@ -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)) + ) diff --git a/bench/fnl-compare/cbits/FastNoiseLite.h b/bench/fnl-compare/cbits/FastNoiseLite.h new file mode 100644 --- /dev/null +++ b/bench/fnl-compare/cbits/FastNoiseLite.h @@ -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 + +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 + }; + + /// + /// Create new FastNoise object with optional seed + /// + 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; + } + + /// + /// Sets seed used for all noise types + /// + /// + /// Default: 1337 + /// + void SetSeed(int seed) { mSeed = seed; } + + /// + /// Sets frequency for all noise types + /// + /// + /// Default: 0.01 + /// + void SetFrequency(float frequency) { mFrequency = frequency; } + + /// + /// Sets noise algorithm used for GetNoise(...) + /// + /// + /// Default: OpenSimplex2 + /// + void SetNoiseType(NoiseType noiseType) + { + mNoiseType = noiseType; + UpdateTransformType3D(); + } + + /// + /// Sets domain rotation type for 3D Noise and 3D DomainWarp. + /// Can aid in reducing directional artifacts when sampling a 2D plane in 3D + /// + /// + /// Default: None + /// + void SetRotationType3D(RotationType3D rotationType3D) + { + mRotationType3D = rotationType3D; + UpdateTransformType3D(); + UpdateWarpTransformType3D(); + } + + /// + /// Sets method for combining octaves in all fractal noise types + /// + /// + /// Default: None + /// Note: FractalType_DomainWarp... only affects DomainWarp(...) + /// + void SetFractalType(FractalType fractalType) { mFractalType = fractalType; } + + /// + /// Sets octave count for all fractal noise types + /// + /// + /// Default: 3 + /// + void SetFractalOctaves(int octaves) + { + mOctaves = octaves; + CalculateFractalBounding(); + } + + /// + /// Sets octave lacunarity for all fractal noise types + /// + /// + /// Default: 2.0 + /// + void SetFractalLacunarity(float lacunarity) { mLacunarity = lacunarity; } + + /// + /// Sets octave gain for all fractal noise types + /// + /// + /// Default: 0.5 + /// + void SetFractalGain(float gain) + { + mGain = gain; + CalculateFractalBounding(); + } + + /// + /// Sets octave weighting for all none DomainWarp fratal types + /// + /// + /// Default: 0.0 + /// Note: Keep between 0...1 to maintain -1...1 output bounding + /// + void SetFractalWeightedStrength(float weightedStrength) { mWeightedStrength = weightedStrength; } + + /// + /// Sets strength of the fractal ping pong effect + /// + /// + /// Default: 2.0 + /// + void SetFractalPingPongStrength(float pingPongStrength) { mPingPongStrength = pingPongStrength; } + + + /// + /// Sets distance function used in cellular noise calculations + /// + /// + /// Default: Distance + /// + void SetCellularDistanceFunction(CellularDistanceFunction cellularDistanceFunction) { mCellularDistanceFunction = cellularDistanceFunction; } + + /// + /// Sets return type from cellular noise calculations + /// + /// + /// Default: EuclideanSq + /// + void SetCellularReturnType(CellularReturnType cellularReturnType) { mCellularReturnType = cellularReturnType; } + + /// + /// Sets the maximum distance a cellular point can move from it's grid position + /// + /// + /// Default: 1.0 + /// Note: Setting this higher than 1 will cause artifacts + /// + void SetCellularJitter(float cellularJitter) { mCellularJitterModifier = cellularJitter; } + + + /// + /// Sets the warp algorithm when using DomainWarp(...) + /// + /// + /// Default: OpenSimplex2 + /// + void SetDomainWarpType(DomainWarpType domainWarpType) + { + mDomainWarpType = domainWarpType; + UpdateWarpTransformType3D(); + } + + + /// + /// Sets the maximum warp distance from original position when using DomainWarp(...) + /// + /// + /// Default: 1.0 + /// + void SetDomainWarpAmp(float domainWarpAmp) { mDomainWarpAmp = domainWarpAmp; } + + + /// + /// 2D noise at given position using current settings + /// + /// + /// Noise output bounded between -1...1 + /// + template + float GetNoise(FNfloat x, FNfloat y) const + { + Arguments_must_be_floating_point_values(); + + 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); + } + } + + /// + /// 3D noise at given position using current settings + /// + /// + /// Noise output bounded between -1...1 + /// + template + float GetNoise(FNfloat x, FNfloat y, FNfloat z) const + { + Arguments_must_be_floating_point_values(); + + 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); + } + } + + + /// + /// 2D warps the input position using current domain warp settings + /// + /// + /// Example usage with GetNoise + /// DomainWarp(x, y) + /// noise = GetNoise(x, y) + /// + template + void DomainWarp(FNfloat& x, FNfloat& y) const + { + Arguments_must_be_floating_point_values(); + + switch (mFractalType) + { + default: + DomainWarpSingle(x, y); + break; + case FractalType_DomainWarpProgressive: + DomainWarpFractalProgressive(x, y); + break; + case FractalType_DomainWarpIndependent: + DomainWarpFractalIndependent(x, y); + break; + } + } + + /// + /// 3D warps the input position using current domain warp settings + /// + /// + /// Example usage with GetNoise + /// DomainWarp(x, y, z) + /// noise = GetNoise(x, y, z) + /// + template + void DomainWarp(FNfloat& x, FNfloat& y, FNfloat& z) const + { + Arguments_must_be_floating_point_values(); + + 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 + 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 + 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 + static int FastFloor(FNfloat f) { return f >= 0 ? (int)f : (int)f - 1; } + + template + 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::Gradients2D[hash]; + float yg = Lookup::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::Gradients3D[hash]; + float yg = Lookup::Gradients3D[hash | 1]; + float zg = Lookup::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::RandVecs2D[hash]; + yo = Lookup::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::RandVecs3D[hash]; + yo = Lookup::RandVecs3D[hash | 1]; + zo = Lookup::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::Gradients2D[index1]; + float yg = Lookup::Gradients2D[index1 | 1]; + float value = xd * xg + yd * yg; + + float xgo = Lookup::RandVecs2D[index2]; + float ygo = Lookup::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::Gradients3D[index1]; + float yg = Lookup::Gradients3D[index1 | 1]; + float zg = Lookup::Gradients3D[index1 | 2]; + float value = xd * xg + yd * yg + zd * zg; + + float xgo = Lookup::RandVecs3D[index2]; + float ygo = Lookup::RandVecs3D[index2 | 1]; + float zgo = Lookup::RandVecs3D[index2 | 2]; + + xo = value * xgo; + yo = value * ygo; + zo = value * zgo; + } + + + // Generic noise gen + + template + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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::RandVecs2D[idx] * cellularJitter; + float vecY = (float)(yi - y) + Lookup::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::RandVecs2D[idx] * cellularJitter; + float vecY = (float)(yi - y) + Lookup::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::RandVecs2D[idx] * cellularJitter; + float vecY = (float)(yi - y) + Lookup::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 + 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::RandVecs3D[idx] * cellularJitter; + float vecY = (float)(yi - y) + Lookup::RandVecs3D[idx | 1] * cellularJitter; + float vecZ = (float)(zi - z) + Lookup::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::RandVecs3D[idx] * cellularJitter; + float vecY = (float)(yi - y) + Lookup::RandVecs3D[idx | 1] * cellularJitter; + float vecZ = (float)(zi - z) + Lookup::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::RandVecs3D[idx] * cellularJitter; + float vecY = (float)(yi - y) + Lookup::RandVecs3D[idx | 1] * cellularJitter; + float vecZ = (float)(zi - z) + Lookup::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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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::RandVecs2D[hash0], Lookup::RandVecs2D[hash1], xs); + float ly0x = Lerp(Lookup::RandVecs2D[hash0 | 1], Lookup::RandVecs2D[hash1 | 1], xs); + + hash0 = Hash(seed, x0, y1) & (255 << 1); + hash1 = Hash(seed, x1, y1) & (255 << 1); + + float lx1x = Lerp(Lookup::RandVecs2D[hash0], Lookup::RandVecs2D[hash1], xs); + float ly1x = Lerp(Lookup::RandVecs2D[hash0 | 1], Lookup::RandVecs2D[hash1 | 1], xs); + + xr += Lerp(lx0x, lx1x, ys) * warpAmp; + yr += Lerp(ly0x, ly1x, ys) * warpAmp; + } + + template + 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::RandVecs3D[hash0], Lookup::RandVecs3D[hash1], xs); + float ly0x = Lerp(Lookup::RandVecs3D[hash0 | 1], Lookup::RandVecs3D[hash1 | 1], xs); + float lz0x = Lerp(Lookup::RandVecs3D[hash0 | 2], Lookup::RandVecs3D[hash1 | 2], xs); + + hash0 = Hash(seed, x0, y1, z0) & (255 << 2); + hash1 = Hash(seed, x1, y1, z0) & (255 << 2); + + float lx1x = Lerp(Lookup::RandVecs3D[hash0], Lookup::RandVecs3D[hash1], xs); + float ly1x = Lerp(Lookup::RandVecs3D[hash0 | 1], Lookup::RandVecs3D[hash1 | 1], xs); + float lz1x = Lerp(Lookup::RandVecs3D[hash0 | 2], Lookup::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::RandVecs3D[hash0], Lookup::RandVecs3D[hash1], xs); + ly0x = Lerp(Lookup::RandVecs3D[hash0 | 1], Lookup::RandVecs3D[hash1 | 1], xs); + lz0x = Lerp(Lookup::RandVecs3D[hash0 | 2], Lookup::RandVecs3D[hash1 | 2], xs); + + hash0 = Hash(seed, x0, y1, z1) & (255 << 2); + hash1 = Hash(seed, x1, y1, z1) & (255 << 2); + + lx1x = Lerp(Lookup::RandVecs3D[hash0], Lookup::RandVecs3D[hash1], xs); + ly1x = Lerp(Lookup::RandVecs3D[hash0 | 1], Lookup::RandVecs3D[hash1 | 1], xs); + lz1x = Lerp(Lookup::RandVecs3D[hash0 | 2], Lookup::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 + 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 + 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 {}; +template <> +struct FastNoiseLite::Arguments_must_be_floating_point_values {}; +template <> +struct FastNoiseLite::Arguments_must_be_floating_point_values {}; + +template +const T FastNoiseLite::Lookup::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 +const T FastNoiseLite::Lookup::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 +const T FastNoiseLite::Lookup::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 +const T FastNoiseLite::Lookup::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 diff --git a/bench/fnl-compare/fnl_bench_shim.cpp b/bench/fnl-compare/fnl_bench_shim.cpp new file mode 100644 --- /dev/null +++ b/bench/fnl-compare/fnl_bench_shim.cpp @@ -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(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" diff --git a/pure-noise.cabal b/pure-noise.cabal --- a/pure-noise.cabal +++ b/pure-noise.cabal @@ -1,43 +1,85 @@ cabal-version: 2.2 --- This file has been generated from package.yaml by hpack version 0.37.0. +-- 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.1.0.1 -synopsis: Performant, modern noise generation for Haskell with minimal dependencies. Based on FastNoiseLite. -description: Please see the README on GitHub at +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.12.2 extra-source-files: README.md + LICENSE + LICENSE_FastNoiseLite + bench/fnl-compare/cbits/FastNoiseLite.h +extra-doc-files: CHANGELOG.md source-repository head 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 Numeric.Noise.Cellular Numeric.Noise.Fractal - Numeric.Noise.Internal - Numeric.Noise.Internal.Math Numeric.Noise.OpenSimplex Numeric.Noise.Perlin Numeric.Noise.SuperSimplex Numeric.Noise.Value Numeric.Noise.ValueCubic other-modules: + Numeric.Noise.Internal + Numeric.Noise.Internal.Math Paths_pure_noise autogen-modules: Paths_pure_noise @@ -45,31 +87,58 @@ src ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints build-depends: - base >=4.7 && <5 - , vector <=0.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 main-is: Driver.hs other-modules: + CellularSpec + FractalSpec + Golden.Util Noise2Spec Noise3Spec + OpenSimplexSpec PerlinSpec + SuperSimplexSpec + TotalitySpec + ValueCubicSpec + ValueSpec Paths_pure_noise autogen-modules: Paths_pure_noise 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: - base >=4.7 && <5 + JuicyPixels ==3.3.* + , aeson >=2.0 && <2.3 + , aeson-pretty + , base >=4.16 && <5 + , bytestring + , directory + , filepath + , massiv >=1.0 && <2.0 + , primitive >=0.8 && <0.10 , pure-noise , tasty - , tasty-discover + , tasty-golden , tasty-hunit , tasty-quickcheck - , vector <=0.14 + , text + , typed-process default-language: GHC2021 benchmark pure-noise-bench @@ -82,13 +151,53 @@ 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 -fproc-alignment=64 -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.7 && <5 + base >=4.16 && <5 , deepseq - , mwc-random + , massiv >=1.0 && <2.0 + , primitive >=0.8 && <0.10 , pure-noise + , 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++ diff --git a/src/Numeric/Noise.hs b/src/Numeric/Noise.hs --- a/src/Numeric/Noise.hs +++ b/src/Numeric/Noise.hs @@ -1,112 +1,288 @@ +{-# LANGUAGE DataKinds #-} {-# LANGUAGE Strict #-} -- | -- Maintainer: Jeremy Nuttall -- Stability : experimental +-- +-- Performant noise generation with composable noise functions. +-- +-- Noise functions are built on a unified 'Noise' type that abstracts over +-- the seed and coordinate parameters. 'Noise2' and 'Noise3' are convenient +-- type aliases for 2D and 3D noise. These can be composed algebraically +-- with minimal performance overhead. +-- +-- Noise values are generally clamped to @[-1, 1]@, although some noise +-- functions may occasionally produce values slightly outside this range. +-- +-- == Basic Usage +-- +-- Generate 2D Perlin noise: +-- +-- @ +-- import Numeric.Noise qualified as Noise +-- +-- myNoise :: Noise.Seed -> Float -> Float -> Float +-- myNoise = Noise.noise2At Noise.perlin2 +-- @ +-- +-- Compose multiple noise functions: +-- +-- @ +-- combined :: (RealFrac a) => Noise.Noise2 a +-- combined = (Noise.perlin2 + Noise.superSimplex2) / 2 +-- +-- myNoise2 :: Noise.Seed -> Float -> Float -> Float +-- myNoise2 = Noise.noise2At combined +-- @ +-- +-- Apply fractal Brownian motion: +-- +-- @ +-- fbm :: (RealFrac a) => Noise.Noise2 a +-- fbm = Noise.fractal2 Noise.defaultFractalConfig Noise.perlin2 +-- @ +-- +-- == Advanced Features +-- +-- Generate 1D noise by slicing higher-dimensional noise: +-- +-- @ +-- noise1d :: Noise.Noise1 Float +-- noise1d = Noise.sliceY2 0.5 Noise.perlin2 +-- +-- evaluate :: Float -> Float +-- evaluate = Noise.noise1At noise1d 0 +-- @ +-- +-- Transform coordinates with 'warp': +-- +-- @ +-- scaledAndLayered :: Noise.Noise2 Float +-- scaledAndLayered = +-- Noise.warp (\\(x, y) -> (x * 2, y * 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 +-- @ +-- +-- == 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 functions + -- * Noise - -- ** Noise functions - module NoiseTypes, + -- + + -- | 'Noise1', 'Noise2', and 'Noise3' are type aliases for 1D, 2D, and 3D noise + -- functions built on the unified 'Noise' type. They can be evaluated with + -- 'noise1At', 'noise2At', and 'noise3At' respectively. + -- + -- 'Seed' is a 'Data.Word.Word64' value used for deterministic noise generation. + Noise, + Noise1, + Noise1', + Noise2, + Noise2', + Noise3, + Noise3', + Seed, + + -- * Accessors + noise1At, noise2At, noise3At, - -- ** 2D Noise - cellular2, + -- * Noise functions + + -- ** Perlin + perlin2, + perlin3, + + -- ** OpenSimplex openSimplex2, + openSimplex3, + + -- ** OpenSimplex2S superSimplex2, - perlin2, + superSimplex3, + + -- ** Cellular + cellular2, + cellular3, + + -- *** Configuration + CellularConfig (..), + defaultCellularConfig, + CellularDistanceFn (..), + CellularResult (..), + + -- ** Value value2, valueCubic2, - - -- ** 3D Noise - perlin3, value3, valueCubic3, - -- * Noise manipulation + -- ** Constant fields + const2, + const3, - -- ** Math utility functions - module NoiseUtility, + -- * Noise alteration - -- ** Fractal Brownian Motion - module Fractal, + -- ** Altering values + remap, - -- ** Cellular noise configuration - module Cellular, -) where + -- ** Altering parameters + warp, + reseed, + next2, + next3, -import Numeric.Noise.Cellular as Cellular ( - CellularConfig (..), - CellularDistanceFn (..), - CellularResult (..), - defaultCellularConfig, - ) -import Numeric.Noise.Cellular qualified as Cellular -import Numeric.Noise.Fractal as Fractal -import Numeric.Noise.Internal -import Numeric.Noise.Internal as NoiseTypes ( - Noise2, - Noise3, - Seed, - ) -import Numeric.Noise.Internal as NoiseUtility ( + -- ** Slicing (projecting) + sliceX2, + sliceX3, + sliceY2, + sliceY3, + sliceZ3, + + -- * Fractals + + -- + + -- | Fractal noise combines multiple octaves at different frequencies and + -- amplitudes to create natural-looking, multi-scale patterns. + -- + -- For custom fractal implementations using per-octave modifier functions, + -- see "Numeric.Noise.Fractal". + + -- ** Fractal Brownian Motion (FBM) + fractal2, + fractal3, + + -- ** Fractal variants + billow2, + billow3, + ridged2, + ridged3, + pingPong2, + pingPong3, + + -- ** Configuration + FractalConfig (..), + defaultFractalConfig, + 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, clamp3, cubicInterp, hermiteInterp, lerp, - next2, - next3, quinticInterp, - ) +) where + +import Numeric.Noise.Cellular (CellularConfig, CellularDistanceFn (..), CellularResult (..), defaultCellularConfig) +import Numeric.Noise.Cellular qualified as Cellular +import Numeric.Noise.Fractal +import Numeric.Noise.Internal import Numeric.Noise.OpenSimplex qualified as OpenSimplex import Numeric.Noise.Perlin qualified as Perlin import Numeric.Noise.SuperSimplex qualified as SuperSimplex import Numeric.Noise.Value qualified as Value import Numeric.Noise.ValueCubic qualified as ValueCubic -noise2At :: Noise2 a -> Seed -> a -> a -> a -noise2At = unNoise2 -{-# INLINE noise2At #-} - +-- | 2D Cellular (Worley) noise. Configure with 'CellularConfig' to control +-- distance functions and return values. +-- +-- Cellular noise creates patterns based on distances to randomly distributed +-- cell points. cellular2 :: (RealFrac a, Floating a) => CellularConfig a -> Noise2 a 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 perlin2 = Perlin.noise2 {-# INLINE perlin2 #-} -noise3At :: Noise3 a -> Seed -> a -> a -> a -> a -noise3At = unNoise3 -{-# INLINE noise3At #-} - +-- | 3D Perlin noise. Classic gradient noise algorithm. perlin3 :: (RealFrac a) => Noise3 a perlin3 = Perlin.noise3 {-# INLINE perlin3 #-} +-- | 2D Value noise. Simple noise based on interpolated random values at grid points. value2 :: (RealFrac a) => Noise2 a value2 = Value.noise2 {-# INLINE value2 #-} +-- | 3D Value noise. Simple noise based on interpolated random values at grid points. value3 :: (RealFrac a) => Noise3 a value3 = Value.noise3 {-# INLINE value3 #-} +-- | 2D Value noise with cubic interpolation for smoother results. valueCubic2 :: (RealFrac a) => Noise2 a valueCubic2 = ValueCubic.noise2 {-# INLINE valueCubic2 #-} +-- | 3D Value noise with cubic interpolation for smoother results. valueCubic3 :: (RealFrac a) => Noise3 a valueCubic3 = ValueCubic.noise3 {-# INLINE valueCubic3 #-} diff --git a/src/Numeric/Noise/Cellular.hs b/src/Numeric/Noise/Cellular.hs --- a/src/Numeric/Noise/Cellular.hs +++ b/src/Numeric/Noise/Cellular.hs @@ -1,6 +1,7 @@ {-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedLists #-} {-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE StrictData #-} -- | -- Maintainer: Jeremy Nuttall @@ -14,23 +15,35 @@ -- * 2D Noise noise2, - noise2BaseWith, + + -- * 3D Noise + noise3, ) where import Data.Bits -import Data.Foldable -import Data.Vector.Unboxed qualified as U +import Data.Foldable (foldl') -- redundant since GHC 9.10.1, here for compat +import Data.Primitive.PrimArray import GHC.Generics (Generic) import Numeric.Noise.Internal import Numeric.Noise.Internal.Math +-- | Configuration for cellular (Worley) noise generation. +-- +-- Cellular noise is based on distances to randomly distributed cell points, +-- creating a distinctive cellular or organic pattern. data CellularConfig a = CellularConfig - { cellularDistanceFn :: !CellularDistanceFn - , cellularJitter :: !a - , cellularResult :: !CellularResult + { cellularDistanceFn :: CellularDistanceFn + -- ^ Distance metric to use when computing distance to cell points. + , cellularJitter :: a + -- ^ Amount of randomness in cell point positions. + -- \( 0 \) creates a regular grid, \( 1 \) creates fully random positions. + -- Values outside \( [0, 1] \) may produce unusual results. + , cellularResult :: CellularResult + -- ^ What value to return from the noise function. } deriving (Generic, Show) +-- | Default configuration for cellular noise generation. defaultCellularConfig :: (RealFrac a) => CellularConfig a defaultCellularConfig = CellularConfig @@ -38,22 +51,52 @@ , cellularJitter = 1 , cellularResult = CellValue } +{-# INLINEABLE defaultCellularConfig #-} +-- | Distance function for cellular noise calculations. +-- +-- Different distance metrics produce different visual characteristics +-- in the cellular pattern. data CellularDistanceFn - = DistEuclidean - | DistEuclideanSq - | DistManhattan - | DistHybrid + = -- | \( \sqrt{dx^2 + dy^2} \) - Creates circular cells with smooth edges. + DistEuclidean + | -- | \( dx^2 + dy^2 \) - Faster than 'DistEuclidean' with similar appearance. + DistEuclideanSq + | -- | \( |dx| + |dy| \) - Creates diamond-shaped cells with sharp edges. + DistManhattan + | -- | Hybrid of Euclidean and Manhattan distances. + DistHybrid deriving (Generic, Read, Show, Eq, Ord, Enum, Bounded) +-- | What value to return from cellular noise evaluation. +-- +-- 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 - = CellValue - | Distance - | Distance2 - | Distance2Add - | Distance2Sub - | Distance2Mul - | Distance2Div + = -- | Return the hash value of the nearest cell point. + -- Creates discrete regions with constant values. + CellValue + | -- | Return the distance to the nearest cell point. + -- Creates a classic Worley noise pattern with cell boundaries. + Distance + | -- | Return the distance to the second-nearest cell point. + -- Creates larger, more organic-looking cells. + Distance2 + | -- | Return the sum of distances to the two nearest cell points. + -- Creates smooth, rounded cells. + Distance2Add + | -- | Return the difference between distances to the two nearest cell points. + -- Emphasizes cell boundaries and creates sharp edges. + Distance2Sub + | -- | Return the product of distances to the two nearest cell points. + -- Creates cells with varying contrast. + Distance2Mul + | -- | Return the ratio of nearest to second-nearest distance. + -- Creates normalized cell patterns. + Distance2Div deriving (Generic, Read, Show, Eq, Ord, Enum, Bounded) distance :: (RealFrac a) => CellularDistanceFn -> a -> a -> a @@ -70,70 +113,149 @@ _ -> id {-# INLINE normDist #-} +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 #-} + +-- | 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 selectMinHash #-} + selectMinHash = + let minHash (!hMin, !dMin) (!h, !d) + | d < dMin = (h, d) + | otherwise = (hMin, dMin) + in foldl' minHash (0, infinity) points + + {-# INLINE selectMinDist #-} + selectMinDist = + let minDist !dMin (_, !d) + | d < dMin = d + | otherwise = dMin + in foldl' minDist infinity points + + {-# INLINE selectSmallestTwo #-} + selectSmallestTwo = + let smallestTwo (!c, !d0, !d1) (!h, !d) + | d < d0 = (h, d, d0) + | d < d1 = (c, d0, d) + | otherwise = (c, d0, d1) + in foldl' smallestTwo (0, infinity, infinity) points + in case res of + CellValue -> + let (!hash, !_) = selectMinHash + in fromIntegral hash * coeff + Distance -> + let !d0 = selectMinDist + in norm d0 - 1 + Distance2 -> + let (!_, !_, !d1) = selectSmallestTwo + in norm d1 - 1 + Distance2Add -> + let (!_, !d0, !d1) = selectSmallestTwo + in (norm d1 + norm d0) * 0.5 - 1 + Distance2Sub -> + let (!_, !d0, !d1) = selectSmallestTwo + in norm d1 - norm d0 - 1 + Distance2Mul -> + let (!_, !d0, !d1) = selectSmallestTwo + in norm d1 * norm d0 * 0.5 - 1 + Distance2Div -> + let (!_, !d0, !d1) = selectSmallestTwo + in norm d0 / norm d1 - 1 +{-# INLINE selectResult #-} + noise2 :: (RealFrac a, Floating a) => CellularConfig a -> Noise2 a -noise2 CellularConfig{..} = +noise2 CellularConfig{..} = mkNoise2 $ \ !seed !x !y -> let !jitter = cellularJitter * 0.43701595 - !dist = distance cellularDistanceFn - !norm = normDist cellularDistanceFn - coeff = 1 / (fromIntegral (maxBound @Hash) + 1) - in Noise2 $ \seed x y -> - let (!hash, !d0u, !d1u) = noise2BaseWith jitter dist seed x y - !d0 = norm d0u - !d1 = norm d1u - in case cellularResult of - CellValue -> fromIntegral hash * coeff - Distance -> d0 - 1 - Distance2 -> d1 - 1 - Distance2Add -> (d1 + d0) * 0.5 - 1 - Distance2Sub -> d1 - d0 - 1 - Distance2Mul -> d1 * d0 * 0.5 - 1 - Distance2Div -> d0 / d1 - 1 -{-# INLINE noise2 #-} + !rx = fastRound x + !ry = fastRound y --- | Calculate 2D cellular noise values at a given point using the given distance function -noise2BaseWith - :: (RealFrac a) - => a - -- ^ cellular jitter - -> (a -> a -> a) - -- ^ distance function - -> Seed - -> a - -- ^ x - -> a - -- ^ y - -> (Hash, a, a) -noise2BaseWith !jitter !dist !seed !x !y = - foldl' @[] - minmax - (0, infinity, infinity) - [pointDist (rx + xi) (ry + yi) | !xi <- [-1 .. 1], !yi <- [-1 .. 1]] - where - !rx = round x - !ry = round y + dist = distance cellularDistanceFn - minmax (!c, !d0, !d1) (!h, !d) - | d < d0 = (h, d, d1') - | otherwise = (c, d0, d1') - where - !d1' = max (min d1 d) d0 + {-# 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) - pointDist !xi !yi = - let !px = fromIntegral xi - x - !py = fromIntegral yi - y - !h = hash2 seed (primeX * xi) (primeY * yi) - !i = h .&. 510 - !rvx = randVecs2d `U.unsafeIndex` fromIntegral i - !rvy = randVecs2d `U.unsafeIndex` (fromIntegral i .|. 1) - !d = dist (px + realToFrac rvx * jitter) (py + realToFrac rvy * jitter) - in (h, d) -{-# INLINE noise2BaseWith #-} + -- 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 #-} --- >>> U.length randVecs2d == 512 +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 #-} + +{-# RULES +"lookupRandVec2d/Float" forall h. + lookupRandVec2d h = + indexPrimArray randVecs2df (fromIntegral h) +"lookupRandVec2d/Double" forall h. + lookupRandVec2d h = + indexPrimArray randVecs2dd (fromIntegral h) + #-} + +randVecs2df :: PrimArray Float +randVecs2df = mapPrimArray realToFrac randVecs2dd + +-- >>> sizeofPrimArray randVecs2dd == 512 -- True {- ORMOLU_DISABLE -} -randVecs2d :: U.Vector Float -randVecs2d = +randVecs2dd :: PrimArray Double +randVecs2dd = [-0.2700222198,-0.9628540911,0.3863092627,-0.9223693152,0.04444859006,-0.999011673,-0.5992523158,-0.8005602176 ,-0.7819280288,0.6233687174,0.9464672271,0.3227999196,-0.6514146797,-0.7587218957,0.9378472289,0.347048376 ,-0.8497875957,-0.5271252623,-0.879042592,0.4767432447,-0.892300288,-0.4514423508,-0.379844434,-0.9250503802 @@ -199,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 -} diff --git a/src/Numeric/Noise/Fractal.hs b/src/Numeric/Noise/Fractal.hs --- a/src/Numeric/Noise/Fractal.hs +++ b/src/Numeric/Noise/Fractal.hs @@ -1,5 +1,5 @@ {-# LANGUAGE RecordWildCards #-} -{-# LANGUAGE Strict #-} +{-# LANGUAGE StrictData #-} -- | -- Maintainer: Jeremy Nuttall @@ -37,14 +37,34 @@ import GHC.Generics import Numeric.Noise.Internal +-- | Configuration for fractal noise generation. +-- +-- Fractal noise combines multiple octaves (layers) of noise at different +-- frequencies and amplitudes to create more complex, natural-looking patterns. data FractalConfig a = FractalConfig { octaves :: Int + -- ^ Number of noise layers to combine. More octaves create more detail + -- 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. , gain :: a + -- ^ Amplitude multiplier between octaves. Each octave's amplitude is + -- the previous octave's amplitude multiplied by gain. + -- 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 (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) +-- | Default configuration for fractal noise generation. defaultFractalConfig :: (RealFrac a) => FractalConfig a defaultFractalConfig = FractalConfig @@ -53,23 +73,66 @@ , gain = 0.5 , weightedStrength = 0 } +{-# INLINEABLE defaultFractalConfig #-} +-- | Apply Fractal Brownian Motion (FBM) to a 2D noise function. +-- +-- FBM combines multiple octaves of noise at increasing frequencies and +-- decreasing amplitudes to create natural-looking, multi-scale patterns. +-- This is the standard fractal noise implementation. +-- +-- @ +-- fbm :: Noise2 Float +-- fbm = fractal2 defaultFractalConfig perlin2 +-- @ fractal2 :: (RealFrac a) => FractalConfig a -> Noise2 a -> Noise2 a -fractal2 config = Noise2 . fractal2With fractalNoiseMod (fractalAmpMod config) config . unNoise2 -{-# INLINE fractal2 #-} +fractal2 config = mkNoise2 . fractal2With fractalNoiseMod (fractalAmpMod config) config . noise2At +{-# INLINE [2] fractal2 #-} +-- | Apply billow fractal to a 2D noise function. +-- +-- Billow creates a cloud-like or billowy appearance by taking the absolute +-- value of each octave. This produces sharp ridges in the negative regions +-- of the noise, creating a distinct puffy or cloudy look. +-- +-- @ +-- clouds :: Noise2 Float +-- clouds = billow2 defaultFractalConfig perlin2 +-- @ billow2 :: (RealFrac a) => FractalConfig a -> Noise2 a -> Noise2 a -billow2 config = Noise2 . fractal2With billowNoiseMod (billowAmpMod config) config . unNoise2 -{-# INLINE billow2 #-} +billow2 config = mkNoise2 . fractal2With billowNoiseMod (billowAmpMod config) config . noise2At +{-# INLINE [2] billow2 #-} +-- | Apply ridged fractal to a 2D noise function. +-- +-- Ridged creates sharp ridges by inverting and taking the absolute value +-- of each octave. This is particularly useful for terrain generation, +-- creating mountain ridges and valleys. +-- +-- @ +-- mountains :: Noise2 Float +-- mountains = ridged2 defaultFractalConfig perlin2 +-- @ ridged2 :: (RealFrac a) => FractalConfig a -> Noise2 a -> Noise2 a -ridged2 config = Noise2 . fractal2With ridgedNoiseMod (ridgedAmpMod config) config . unNoise2 -{-# INLINE ridged2 #-} +ridged2 config = mkNoise2 . fractal2With ridgedNoiseMod (ridgedAmpMod config) config . noise2At +{-# INLINE [2] ridged2 #-} +-- | Apply ping-pong fractal to a 2D noise function. +-- +-- 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 +-- waves = pingPong2 defaultFractalConfig defaultPingPongStrength perlin2 +-- @ pingPong2 :: (RealFrac a) => FractalConfig a -> PingPongStrength a -> Noise2 a -> Noise2 a pingPong2 config strength = - Noise2 . fractal2With (pingPongNoiseMod strength) (pingPongAmpMod config) config . unNoise2 -{-# INLINE pingPong2 #-} + mkNoise2 . fractal2With (pingPongNoiseMod strength) (pingPongAmpMod config) config . noise2At +{-# INLINE [2] pingPong2 #-} fractal2With :: (RealFrac a) @@ -84,34 +147,46 @@ -> a -> a fractal2With modNoise modAmps FractalConfig{..} noise2 seed x y - | octaves < 1 = error "octaves must be a positive integer" + | octaves < 1 = 0 | otherwise = - let bounding = fractalBounding FractalConfig{..} + let !bounding = fractalBounding FractalConfig{..} in go octaves 0 seed 1 bounding where - go 0 acc _ _ _ = acc - go o acc s freq amp = - let noise = amp * modNoise (noise2 s (freq * x) (freq * y)) - amp' = amp * gain * modAmps (min (noise + 1) 2) + go 0 !acc !_ !_ !_ = acc + go !o !acc !s !freq !amp = + let !noise = amp * modNoise (noise2 s (freq * x) (freq * y)) + !amp' = amp * gain * modAmps (min (noise + 1) 2) in go (o - 1) (acc + noise) (s + 1) (freq * lacunarity) amp' -{-# INLINE fractal2With #-} +{-# INLINE [1] fractal2With #-} +-- | Apply Fractal Brownian Motion (FBM) to a 3D noise function. +-- +-- 3D version of 'fractal2'. See 'fractal2' for details. fractal3 :: (RealFrac a) => FractalConfig a -> Noise3 a -> Noise3 a -fractal3 config = Noise3 . fractal3With fractalNoiseMod (fractalAmpMod config) config . unNoise3 -{-# INLINE fractal3 #-} +fractal3 config = mkNoise3 . fractal3With fractalNoiseMod (fractalAmpMod config) config . noise3At +{-# INLINE [2] fractal3 #-} +-- | Apply billow fractal to a 3D noise function. +-- +-- 3D version of 'billow2'. See 'billow2' for details. billow3 :: (RealFrac a) => FractalConfig a -> Noise3 a -> Noise3 a -billow3 config = Noise3 . fractal3With billowNoiseMod (billowAmpMod config) config . unNoise3 -{-# INLINE billow3 #-} +billow3 config = mkNoise3 . fractal3With billowNoiseMod (billowAmpMod config) config . noise3At +{-# INLINE [2] billow3 #-} +-- | Apply ridged fractal to a 3D noise function. +-- +-- 3D version of 'ridged2'. See 'ridged2' for details. ridged3 :: (RealFrac a) => FractalConfig a -> Noise3 a -> Noise3 a -ridged3 config = Noise3 . fractal3With ridgedNoiseMod (ridgedAmpMod config) config . unNoise3 -{-# INLINE ridged3 #-} +ridged3 config = mkNoise3 . fractal3With ridgedNoiseMod (ridgedAmpMod config) config . noise3At +{-# INLINE [2] ridged3 #-} +-- | Apply ping-pong fractal to a 3D noise function. +-- +-- 3D version of 'pingPong2'. See 'pingPong2' for details. pingPong3 :: (RealFrac a) => FractalConfig a -> PingPongStrength a -> Noise3 a -> Noise3 a pingPong3 config strength = - Noise3 . fractal3With (pingPongNoiseMod strength) (pingPongAmpMod config) config . unNoise3 -{-# INLINE pingPong3 #-} + mkNoise3 . fractal3With (pingPongNoiseMod strength) (pingPongAmpMod config) config . noise3At +{-# INLINE [2] pingPong3 #-} fractal3With :: (RealFrac a) @@ -127,61 +202,98 @@ -> a -> a fractal3With modNoise modAmps FractalConfig{..} noise3 seed x y z - | octaves < 1 = error "octaves must be a positive integer" + | octaves < 1 = 0 | otherwise = - let bounding = fractalBounding FractalConfig{..} + let !bounding = fractalBounding FractalConfig{..} in go octaves 0 seed 1 bounding where - go 0 acc _ _ _ = acc - go o acc s freq amp = - let noise = amp * modNoise (noise3 s (freq * x) (freq * y) (freq * z)) - amp' = amp * gain * modAmps (min (noise + 1) 2) + go 0 !acc !_ !_ !_ = acc + go !o !acc !s !freq !amp = + let !noise = amp * modNoise (noise3 s (freq * x) (freq * y) (freq * z)) + !amp' = amp * gain * modAmps (min (noise + 1) 2) in go (o - 1) (acc + noise) (s + 1) (freq * lacunarity) amp' -{-# INLINE fractal3With #-} +{-# INLINE [1] fractal3With #-} fractalBounding :: (RealFrac a) => FractalConfig a -> a -fractalBounding FractalConfig{..} = - let amps = take octaves $ iterate (* gain) gain - in 1 / (sum amps + 1) -{-# INLINE fractalBounding #-} +fractalBounding FractalConfig{..} = recip (sum amps + 1) + where + amps = take octaves $ iterate (* gain) gain +{-# INLINE [2] fractalBounding #-} +-- | Identity noise modifier for standard FBM. +-- +-- This is used internally by 'fractal2' and 'fractal3'. +-- Exposed for users creating custom fractal implementations. fractalNoiseMod :: a -> a fractalNoiseMod = id {-# INLINE fractalNoiseMod #-} + +-- | Amplitude modifier for standard FBM. +-- +-- Uses the 'weightedStrength' parameter to influence amplitude based on +-- the previous octave's value. Exposed for custom fractal implementations. fractalAmpMod :: (Num a) => FractalConfig a -> a -> a fractalAmpMod FractalConfig{..} n = lerp 1 n weightedStrength {-# INLINE fractalAmpMod #-} +-- | Noise modifier for billow fractal. +-- +-- Transforms noise value to @abs(n) * 2 - 1@, creating the billow effect. +-- Exposed for custom fractal implementations. billowNoiseMod :: (Num a) => a -> a billowNoiseMod n = abs n * 2 - 1 {-# INLINE billowNoiseMod #-} +-- | Amplitude modifier for billow fractal. +-- +-- Uses the 'weightedStrength' parameter. Exposed for custom fractal implementations. billowAmpMod :: (Num a) => FractalConfig a -> a -> a billowAmpMod FractalConfig{..} n = lerp 1 n weightedStrength {-# INLINE billowAmpMod #-} +-- | Noise modifier for ridged fractal. +-- +-- Transforms noise value to @abs(n) * (-2) + 1@, creating the ridge effect. +-- Exposed for custom fractal implementations. ridgedNoiseMod :: (Num a) => a -> a ridgedNoiseMod n = abs n * (-2) + 1 {-# INLINE ridgedNoiseMod #-} +-- | Amplitude modifier for ridged fractal. +-- +-- Uses the 'weightedStrength' parameter with inverted noise value. +-- Exposed for custom fractal implementations. ridgedAmpMod :: (Num a) => FractalConfig a -> a -> a ridgedAmpMod FractalConfig{..} n = lerp 1 (1 - n) weightedStrength {-# INLINE ridgedAmpMod #-} +-- | Strength parameter for ping-pong fractal noise. +-- +-- Controls the intensity of the ping-pong folding effect. +-- Higher values create more frequent oscillations. newtype PingPongStrength a = PingPongStrength a deriving (Generic) +-- | Default ping-pong strength value. defaultPingPongStrength :: (RealFrac a) => PingPongStrength a defaultPingPongStrength = PingPongStrength 2 {-# INLINE defaultPingPongStrength #-} +-- | Noise modifier for ping-pong fractal. +-- +-- Folds noise values back and forth within a range, creating a wave-like +-- pattern. The strength parameter controls the folding intensity. +-- Exposed for custom fractal implementations. pingPongNoiseMod :: (RealFrac a) => PingPongStrength a -> a -> a pingPongNoiseMod (PingPongStrength s) n = let n' = (n + 1) * s t = n' - fromIntegral @Int (truncate (n' * 0.5) * 2) - in if t < 1 then t else 2 - t + in 1 - abs (t - 1) {-# INLINE pingPongNoiseMod #-} +-- | Amplitude modifier for ping-pong fractal. +-- +-- Uses the 'weightedStrength' parameter. Exposed for custom fractal implementations. pingPongAmpMod :: (Num a) => FractalConfig a -> a -> a pingPongAmpMod FractalConfig{..} n = lerp 1 n weightedStrength {-# INLINE pingPongAmpMod #-} diff --git a/src/Numeric/Noise/Internal.hs b/src/Numeric/Noise/Internal.hs --- a/src/Numeric/Noise/Internal.hs +++ b/src/Numeric/Noise/Internal.hs @@ -3,14 +3,33 @@ -- Stability : experimental module Numeric.Noise.Internal ( module Math, - Noise2 (..), + Noise (..), + constant, + remap, + warp, + reseed, + blend, + sliceX2, + sliceY2, + sliceX3, + sliceY3, + sliceZ3, + Noise1', + Noise1, + mkNoise1, + noise1At, + Noise2', + Noise2, + mkNoise2, + noise2At, next2, - map2, clamp2, const2, - Noise3 (..), + Noise3', + Noise3, + mkNoise3, + noise3At, next3, - map3, clamp3, const3, ) where @@ -25,138 +44,355 @@ quinticInterp, ) -newtype Noise2 a = Noise2 - {unNoise2 :: Seed -> a -> a -> a} +-- | 'Noise' represents a function from a 'Seed' and coordinates @p@ to a noise +-- value @v@. +-- +-- 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'. +-- +-- 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 +-- a minimal dependency footprint and so will not provide this instance itself. +-- +-- === __Algebraic composition__ +-- +-- 'Noise' can be composed algebraically: +-- +-- @ +-- combined :: Noise (Float, Float) Float +-- combined = (perlin2 + superSimplex2) / 2 +-- @ +-- +-- === __Coordinate Transformation__ +-- +-- This allows you to, for example, compose multiple layers of noise at different +-- offsets. +-- +-- @ +-- scaled :: Noise2 Float +-- scaled = warp (\\(x, y) -> (x * 2, y * 2)) perlin2 +-- @ +newtype Noise p v = Noise {unNoise :: Seed -> p -> v} +-- NOTE: Noise p v is isomorphic to Reader (Seed, p), so it has trivial +-- instances of Monad and Category, Arrow, ArrowChoice, ArrowApply, etc. +-- +-- I've decided not to include Category et al. as instances for now +-- because I can't come up with a use-case that is not sufficiently +-- covered by the monad instance. + +-- | Noise admits 'Functor' on the value it produces +instance Functor (Noise p) where + fmap f (Noise g) = Noise (\seed -> f . g seed) + +-- | Noise admits 'Applicative' on the value it produces +instance Applicative (Noise p) where + pure a = Noise $ \_ _ -> a + liftA2 f (Noise g) (Noise h) = Noise (\s p -> g s p `f` h s p) + +-- | Note: The 'Monad' instance evaluates all noise functions at the same +-- seed and coordinate. For independent sampling at different coordinates, +-- use 'warp' to transform the coordinate space. +-- +-- @ +-- do n1 <- perlin2 +-- n2 <- superSimplex2 +-- return (n1 + n2) +-- @ +-- +-- is equivalent to: +-- +-- @ +-- perlin2 + superSimplex2 +-- @ +-- +-- This is useful for domain warping. +instance Monad (Noise p) where + Noise g >>= f = Noise (\s p -> unNoise (f (g s p)) s p) + +instance (Num a) => Num (Noise p a) where + (+) = liftA2 (+) + (*) = liftA2 (*) + abs = fmap abs + signum = fmap signum + fromInteger i = pure (fromInteger i) + negate = fmap negate + +instance (Fractional a) => Fractional (Noise p a) where + fromRational = pure . fromRational + recip = fmap recip + (/) = liftA2 (/) + +instance (Floating a) => Floating (Noise p a) where + pi = pure pi + exp = fmap exp + log = fmap log + sin = fmap sin + cos = fmap cos + asin = fmap asin + acos = fmap acos + atan = fmap atan + sinh = fmap sinh + cosh = fmap cosh + asinh = fmap asinh + 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 '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 #-} + +-- | Evaluate a 2D noise function at the given coordinates with the given seed. +noise2At + :: Noise2 a + -> Seed + -- ^ deterministic seed + -> a + -- ^ x coordinate + -> a + -- ^ y coordinate + -> a +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 #-} + +-- | Evaluate a 3D noise function at the given coordinates with the given seed. +noise3At + :: Noise3 a + -> Seed + -- ^ deterministic seed + -> a + -- ^ x coordinate + -> a + -- ^ y coordinate + -> a + -- ^ z coordinate + -> a +noise3At (Noise f) seed x y z = f seed (x, y, z) +{-# INLINE noise3At #-} + +-- | Transform the values produced by a noise function. +-- +-- This is an alias for 'fmap'. Use it to transform noise values after generation: +-- +-- === __Examples__ +-- +-- @ +-- -- Scale noise from [-1, 1] to [0, 1] +-- normalized :: Noise2 Float +-- normalized = remap (\\x -> (x + 1) / 2) perlin2 +-- @ +remap :: (a -> b) -> Noise p a -> Noise p b +remap = fmap +{-# INLINE remap #-} + +-- | Transform the coordinate space of a noise function. +-- +-- This allows you to scale, rotate, or otherwise modify coordinates before +-- they're passed to the noise function: +-- +-- NB: This is 'Data.Functor.Contravariant.contramap' +-- +-- === __Examples__ +-- +-- @ +-- -- Scale the noise frequency +-- scaled :: Noise2 Float +-- scaled = warp (\\(x, y) -> (x * 2, y * 2)) perlin2 +-- +-- -- Rotate the noise field +-- rotated :: Noise2 Float +-- rotated = warp (\\(x, y) -> (x * cos a - y * sin a, x * sin a + y * cos a)) perlin2 +-- where a = pi / 4 +-- @ +warp :: (p -> p') -> Noise p' v -> Noise p v +warp f (Noise g) = Noise (\s p -> g s (f p)) +{-# INLINE warp #-} + +-- | Modify the seed used by a noise function. +-- +-- This is useful for generating independent layers of noise: +-- +-- See also 'next2' and 'next3' for convenient increment-by-one variants. +-- +-- === __Examples__ +-- @ +-- layer1 = perlin2 +-- layer2 = reseed (+1) perlin2 +-- layer3 = reseed (+2) perlin2 +-- +-- combined = (layer1 + layer2 + layer3) / 3 +-- @ +reseed :: (Seed -> Seed) -> Noise p a -> Noise p a +reseed f (Noise g) = Noise (g . f) +{-# INLINE reseed #-} + +constant :: a -> Noise c a +constant = pure +{-# INLINE constant #-} + +-- | Combine two noise functions with a custom blending function. +-- +-- This is an alias for 'liftA2'. Use it to mix multiple noise sources: +-- +-- @ +-- -- Multiply two noise functions +-- multiplied :: Noise2 Float +-- multiplied = blend (*) perlin2 superSimplex2 +-- +-- -- Custom blending based on values +-- custom :: Noise2 Float +-- custom = blend (\\a b -> if a > 0 then a else b) perlin2 superSimplex2 +-- @ +blend :: (a -> b -> c) -> Noise p a -> Noise p b -> Noise p c +blend = liftA2 +{-# INLINE blend #-} + +-- | Clamp a noise function between the given lower and higher bound +clampNoise :: (Ord a) => a -> a -> Noise p a -> Noise p a +clampNoise l u = fmap (clamp l u) +{-# INLINE clampNoise #-} + +-- | Slice a 2D noise function at a fixed X coordinate to produce 1D noise. +-- +-- === __Examples__ +-- +-- @ +-- noise1d :: Noise1 Float +-- noise1d = sliceX2 0.0 perlin2 -- Fix X at 0, vary Y +-- +-- -- Evaluate at Y = 5.0 +-- value = noise1At noise1d seed 5.0 +-- @ +sliceX2 :: p -> Noise2' p v -> Noise1' p v +sliceX2 x = warp (x,) +{-# INLINE sliceX2 #-} + +-- | Slice a 2D noise function at a fixed Y coordinate to produce 1D noise. +-- +-- === __Examples__ +-- +-- @ +-- noise1d :: Noise1 Float +-- noise1d = sliceY2 0.0 perlin2 -- Fix Y at 0, vary X +-- +-- -- Evaluate at X = 5.0 +-- value = noise1At noise1d seed 5.0 +-- @ +sliceY2 :: p -> Noise2' p v -> Noise1' p v +sliceY2 y = warp (,y) +{-# INLINE sliceY2 #-} + +-- | Slice a 3D noise function at a fixed X coordinate to produce 2D noise. +-- +-- === __Examples__ +-- +-- @ +-- noise2d :: Noise2 Float +-- noise2d = sliceX3 0.0 perlin3 -- Fix X at 0, vary Y and Z +-- +-- -- Evaluate at Y = 1.0, Z = 2.0 +-- value = noise2At noise2d seed 1.0 2.0 +-- @ +sliceX3 :: p -> Noise3' p v -> Noise2' p v +sliceX3 x = warp (\(y, z) -> (x, y, z)) +{-# INLINE sliceX3 #-} + +-- | Slice a 3D noise function at a fixed Y coordinate to produce 2D noise. +-- +-- === __Examples__ +-- +-- @ +-- noise2d :: Noise2 Float +-- noise2d = sliceY3 0.0 perlin3 -- Fix Y at 0, vary X and Z +-- @ +sliceY3 :: p -> Noise3' p v -> Noise2' p v +sliceY3 y = warp (\(x, z) -> (x, y, z)) +{-# INLINE sliceY3 #-} + +-- | Slice a 3D noise function at a fixed Z coordinate to produce 2D noise. +-- +-- This is useful for extracting 2D slices from 3D noise at different heights: +-- +-- === __Examples__ +-- +-- @ +-- heightmap :: Noise2 Float +-- heightmap = sliceZ3 10.0 perlin3 -- Sample at Z = 10 +-- @ +sliceZ3 :: p -> Noise3' p v -> Noise2' p v +sliceZ3 z = warp (\(x, y) -> (x, y, z)) +{-# INLINE sliceZ3 #-} + +-- | Increment the seed for a 2D noise function. See 'reseed'. next2 :: Noise2 a -> Noise2 a -next2 (Noise2 f) = Noise2 (\s x y -> f (s + 1) x y) +next2 = reseed (+ 1) {-# INLINE next2 #-} -map2 :: (a -> a) -> Noise2 a -> Noise2 a -map2 f (Noise2 g) = Noise2 (\s x y -> f (g s x y)) -{-# INLINE map2 #-} - +-- | Clamp the output of a 2D noise function to the range @[lower, upper]@. clamp2 :: (Ord a) => a -> a -> Noise2 a -> Noise2 a -clamp2 l u (Noise2 f) = Noise2 $ \s x y -> clamp l u (f s x y) +clamp2 = clampNoise {-# INLINE clamp2 #-} +-- | A noise function that produces the same value everywhere. Alias of 'pure'. const2 :: a -> Noise2 a -const2 a = Noise2 (\_ _ _ -> a) +const2 = pure {-# INLINE const2 #-} -instance (Num a) => Num (Noise2 a) where - Noise2 f + Noise2 g = Noise2 $ \s x y -> f s x y + g s x y - {-# INLINE (+) #-} - Noise2 f * Noise2 g = Noise2 $ \s x y -> f s x y * g s x y - {-# INLINE (*) #-} - abs (Noise2 f) = Noise2 $ \s x y -> abs (f s x y) - {-# INLINE abs #-} - signum (Noise2 f) = Noise2 $ \s x y -> signum (f s x y) - {-# INLINE signum #-} - fromInteger i = const2 (fromInteger i) - {-# INLINE fromInteger #-} - negate (Noise2 f) = Noise2 $ \s x y -> negate (f s x y) - {-# INLINE negate #-} - -instance (Fractional a) => Fractional (Noise2 a) where - fromRational r = const2 (fromRational r) - {-# INLINE fromRational #-} - recip (Noise2 f) = Noise2 $ \s x y -> recip (f s x y) - {-# INLINE recip #-} - Noise2 f / Noise2 g = Noise2 $ \s x y -> f s x y / g s x y - {-# INLINE (/) #-} - -instance (Floating a) => Floating (Noise2 a) where - pi = const2 pi - {-# INLINE pi #-} - exp (Noise2 f) = Noise2 $ \s x y -> exp (f s x y) - {-# INLINE exp #-} - log (Noise2 f) = Noise2 $ \s x y -> log (f s x y) - {-# INLINE log #-} - sin (Noise2 f) = Noise2 $ \s x y -> sin (f s x y) - {-# INLINE sin #-} - cos (Noise2 f) = Noise2 $ \s x y -> cos (f s x y) - {-# INLINE cos #-} - asin (Noise2 f) = Noise2 $ \s x y -> asin (f s x y) - {-# INLINE asin #-} - acos (Noise2 f) = Noise2 $ \s x y -> acos (f s x y) - {-# INLINE acos #-} - atan (Noise2 f) = Noise2 $ \s x y -> atan (f s x y) - {-# INLINE atan #-} - sinh (Noise2 f) = Noise2 $ \s x y -> sinh (f s x y) - {-# INLINE sinh #-} - cosh (Noise2 f) = Noise2 $ \s x y -> cosh (f s x y) - {-# INLINE cosh #-} - asinh (Noise2 f) = Noise2 $ \s x y -> asinh (f s x y) - {-# INLINE asinh #-} - acosh (Noise2 f) = Noise2 $ \s x y -> acosh (f s x y) - {-# INLINE acosh #-} - atanh (Noise2 f) = Noise2 $ \s x y -> atanh (f s x y) - {-# INLINE atanh #-} - -newtype Noise3 a = Noise3 - {unNoise3 :: Seed -> a -> a -> a -> a} - +-- | Increment the seed for a 3D noise function. See 'reseed'. next3 :: Noise3 a -> Noise3 a -next3 (Noise3 f) = Noise3 (\s x y z -> f (s + 1) x y z) +next3 = reseed (+ 1) {-# INLINE next3 #-} -map3 :: (a -> a) -> Noise3 a -> Noise3 a -map3 f (Noise3 g) = Noise3 (\s x y z -> f (g s x y z)) -{-# INLINE map3 #-} - +-- | A noise function that produces the same value everywhere. Alias of 'pure'. const3 :: a -> Noise3 a -const3 a = Noise3 (\_ _ _ _ -> a) +const3 = pure {-# INLINE const3 #-} +-- | Clamp the output of a 3D noise function to the range @[lower, upper]@. clamp3 :: (Ord a) => a -> a -> Noise3 a -> Noise3 a -clamp3 l u (Noise3 f) = Noise3 $ \s x y z -> clamp l u (f s x y z) +clamp3 = clampNoise {-# INLINE clamp3 #-} - -instance (Num a) => Num (Noise3 a) where - Noise3 f + Noise3 g = Noise3 $ \s x y z -> f s x y z + g s x y z - {-# INLINE (+) #-} - Noise3 f * Noise3 g = Noise3 $ \s x y z -> f s x y z * g s x y z - {-# INLINE (*) #-} - abs (Noise3 f) = Noise3 $ \s x y z -> abs (f s x y z) - {-# INLINE abs #-} - signum (Noise3 f) = Noise3 $ \s x y z -> signum (f s x y z) - {-# INLINE signum #-} - fromInteger i = const3 (fromInteger i) - {-# INLINE fromInteger #-} - negate (Noise3 f) = Noise3 $ \s x y z -> negate (f s x y z) - {-# INLINE negate #-} - -instance (Fractional a) => Fractional (Noise3 a) where - fromRational r = const3 (fromRational r) - {-# INLINE fromRational #-} - recip (Noise3 f) = Noise3 $ \s x y z -> recip (f s x y z) - {-# INLINE recip #-} - -instance (Floating a) => Floating (Noise3 a) where - pi = const3 pi - {-# INLINE pi #-} - exp (Noise3 f) = Noise3 $ \s x y z -> exp (f s x y z) - {-# INLINE exp #-} - log (Noise3 f) = Noise3 $ \s x y z -> log (f s x y z) - {-# INLINE log #-} - sin (Noise3 f) = Noise3 $ \s x y z -> sin (f s x y z) - {-# INLINE sin #-} - cos (Noise3 f) = Noise3 $ \s x y z -> cos (f s x y z) - {-# INLINE cos #-} - asin (Noise3 f) = Noise3 $ \s x y z -> asin (f s x y z) - {-# INLINE asin #-} - acos (Noise3 f) = Noise3 $ \s x y z -> acos (f s x y z) - {-# INLINE acos #-} - atan (Noise3 f) = Noise3 $ \s x y z -> atan (f s x y z) - {-# INLINE atan #-} - sinh (Noise3 f) = Noise3 $ \s x y z -> sinh (f s x y z) - {-# INLINE sinh #-} - cosh (Noise3 f) = Noise3 $ \s x y z -> cosh (f s x y z) - {-# INLINE cosh #-} - asinh (Noise3 f) = Noise3 $ \s x y z -> asinh (f s x y z) - {-# INLINE asinh #-} - acosh (Noise3 f) = Noise3 $ \s x y z -> acosh (f s x y z) - {-# INLINE acosh #-} - atanh (Noise3 f) = Noise3 $ \s x y z -> atanh (f s x y z) - {-# INLINE atanh #-} diff --git a/src/Numeric/Noise/Internal/Math.hs b/src/Numeric/Noise/Internal/Math.hs --- a/src/Numeric/Noise/Internal/Math.hs +++ b/src/Numeric/Noise/Internal/Math.hs @@ -12,6 +12,7 @@ hermiteInterp, quinticInterp, clamp, + fastRound, primeX, primeY, primeZ, @@ -20,6 +21,7 @@ infinity, g2, sqrt3, + rotate3, valCoord2, valCoord3, gradCoord2, @@ -28,14 +30,28 @@ ) where import Data.Bits +import Data.Bool (bool) import Data.Int -import Data.Vector.Unboxed qualified as U +import Data.Primitive.PrimArray import Data.Word +-- | Seed value for deterministic noise generation. +-- +-- 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. type Hash = Int32 --- | monotonic lerp +-- | Linear interpolation between two values. +-- +-- Monotonic lerp lerp :: (Num a) => a @@ -46,25 +62,97 @@ -- ^ parameter in range [0, 1] -> a lerp v0 v1 t = v0 + t * (v1 - v0) -{-# INLINE lerp #-} +{-# INLINE [1] lerp #-} --- | cubic interpolation +{-# RULES +"lerp/Float/0" forall (a :: Float) b. + lerp a b 0 = + a +"lerp/Double/0" forall (a :: Double) b. + lerp a b 0 = + a +"lerp/Float/1" forall (a :: Float) b. + lerp a b 1 = + b +"lerp/Double/1" forall (a :: Double) b. + lerp a b 1 = + b +"lerp/id" forall a t. lerp a a t = a +"lerp/compose/start" forall a b t u. + lerp (lerp a b u) b t = + lerp a b (u + t - t * u) +"lerp/compose/end" forall a b t u. + lerp a (lerp a b u) t = + lerp a b (t * u) + #-} + +-- | Cubic interpolation through four control points. cubicInterp :: (Num a) => a -> a -> a -> a -> a -> a -cubicInterp a b c d t = - let !p = (d - c) - (a - b) - in t * t * t * p + t * t * ((a - b) - p) + t * (c - a) + b -{-# INLINE cubicInterp #-} +cubicInterp a !b c d !t = + let !c' = c - a + !a' = a - b + !p = (d - c) - a' + !b' = a' - p + in b + t * (c' + t * (b' + t * p)) +{-# INLINE [1] cubicInterp #-} --- | hermite interpolation +{-# RULES +"cubicInterp/Float/0" forall (a :: Float) b c d. + cubicInterp a b c d 0 = + b +"cubicInterp/Double/0" forall (a :: Double) b c d. + cubicInterp a b c d 0 = + b +"cubicInterp/Float/1" forall (a :: Float) b c d. + cubicInterp a b c d 1 = + c +"cubicInterp/Double/1" forall (a :: Double) b c d. + cubicInterp a b c d 1 = + c +"cubicInterp/Float/0.5" forall (a :: Float) b c d. + cubicInterp a b c d (0.5 :: Float) = + 0.125 * (-a + 5 * b + 5 * c - d) +"cubicInterp/Double/0.5" forall (a :: Double) b c d. + cubicInterp a b c d (0.5 :: Double) = + 0.125 * (-a + 5 * b + 5 * c - d) + #-} + +-- | Hermite interpolation curve (smoothstep). hermiteInterp :: (Num a) => a -> a hermiteInterp t = t * t * (3 - 2 * t) -{-# INLINE hermiteInterp #-} +{-# INLINE [1] hermiteInterp #-} --- | quintic interpolation +{-# RULES +"hermiteInterp/Float/0" hermiteInterp (0 :: Float) = 0 +"hermiteInterp/Double/0" hermiteInterp (0 :: Double) = 0 +"hermiteInterp/Float/1" hermiteInterp (1 :: Float) = 1 +"hermiteInterp/Double/1" hermiteInterp (1 :: Double) = 1 + #-} + +-- | Quintic interpolation curve (smootherstep). quinticInterp :: (Num a) => a -> a quinticInterp t = t * t * t * (t * (t * 6 - 15) + 10) -{-# INLINE quinticInterp #-} +{-# INLINE [1] quinticInterp #-} +{-# RULES +"quinticInterp/Float/0" + quinticInterp (0 :: Float) = + 0 +"quinticInterp/Double/0" + quinticInterp (0 :: Double) = + 0 +"quinticInterp/Float/1" + quinticInterp (1 :: Float) = + 1 +"quinticInterp/Double/1" + quinticInterp (1 :: Double) = + 1 + #-} + +-- | Clamp a value to a specified range. +-- +-- Returns the value if it's within bounds, otherwise returns +-- the nearest boundary. clamp :: (Ord a) => a @@ -74,12 +162,18 @@ -> a -- ^ value -> a -clamp l u v - | v < l = l - | v > u = u - | otherwise = v +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 #-} @@ -112,48 +206,73 @@ sqrt3 = 1.7320508075688772935274463415059 {-# INLINE sqrt3 #-} -valCoord2 :: (RealFrac a) => Word64 -> Hash -> Hash -> a +-- | 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 = let !hash = hash2 seed xPrimed yPrimed !val = (hash * hash) `xor` (hash `shiftL` 19) - in fromIntegral val / maxHash + in fromIntegral val * recip (maxHash + 1) {-# INLINE valCoord2 #-} -valCoord3 :: (RealFrac a) => Word64 -> Hash -> Hash -> Hash -> a +valCoord3 :: (RealFrac a) => Seed -> Hash -> Hash -> Hash -> a valCoord3 seed xPrimed yPrimed zPrimed = let !hash = hash3 seed xPrimed yPrimed zPrimed !val = (hash * hash) `xor` (hash `shiftL` 19) - in fromIntegral val / maxHash + in fromIntegral val * recip (maxHash + 1) {-# INLINE valCoord3 #-} gradCoord2 :: (RealFrac a) => Seed -> Hash -> Hash -> a -> a -> a gradCoord2 seed xPrimed yPrimed xd yd = let !hash = hash2 seed xPrimed yPrimed !ix = (hash `xor` (hash `shiftR` 15)) .&. 0xFE - !xg = grad2d `U.unsafeIndex` fromIntegral ix - !yg = grad2d `U.unsafeIndex` fromIntegral (ix .|. 1) - in xd * realToFrac xg + yd * realToFrac yg -{-# INLINE gradCoord2 #-} + !xg = lookupGrad2 ix + !yg = lookupGrad2 (ix .|. 1) + in xd * xg + yd * yg +-- Phase 2 inlining ensures specialization happens after hash computation +-- but before gradient lookup, allowing REWRITE RULES to fire effectively +{-# INLINE [2] gradCoord2 #-} gradCoord3 :: (RealFrac a) => Seed -> Hash -> Hash -> Hash -> a -> a -> a -> a gradCoord3 seed xPrimed yPrimed zPrimed xd yd zd = let !hash = hash3 seed xPrimed yPrimed zPrimed !ix = (hash `xor` (hash `shiftR` 15)) .&. 0xFC - !xg = grad3d `U.unsafeIndex` fromIntegral ix - !yg = grad3d `U.unsafeIndex` fromIntegral (ix .|. 1) - !zg = grad3d `U.unsafeIndex` fromIntegral (ix .|. 2) - in xd * fromIntegral xg + yd * fromIntegral yg + zd * fromIntegral zg + !xg = lookupGrad3 ix + !yg = lookupGrad3 (ix .|. 1) + !zg = lookupGrad3 (ix .|. 2) + in xd * xg + yd * yg + zd * zg {-# INLINE gradCoord3 #-} maxHash :: (RealFrac a) => a -maxHash = realToFrac (maxBound @Hash) +maxHash = fromIntegral (maxBound @Hash) {-# INLINE maxHash #-} +lookupGrad2 :: (RealFrac a) => Hash -> a +lookupGrad2 = realToFrac . (grad2dd `indexPrimArray`) . fromIntegral +{-# INLINE [0] lookupGrad2 #-} + +{-# RULES +"lookupGrad2/Float" forall (i :: Hash). + lookupGrad2 i = + indexPrimArray grad2df (fromIntegral i) +"lookupGrad2/Double" forall (i :: Hash). + lookupGrad2 i = + indexPrimArray grad2dd (fromIntegral i) + #-} + +grad2df :: PrimArray Float +grad2df = mapPrimArray realToFrac grad2dd + {- ORMOLU_DISABLE -} --- >>> U.length grad2d == 256 +-- >>> sizeofPrimArray grad2d == 256 -- True -grad2d :: U.Vector Float -grad2d = +grad2dd :: PrimArray Double +grad2dd = [ 0.130526192220052, 0.99144486137381 , 0.38268343236509 , 0.923879532511287, 0.608761429008721, 0.793353340291235, 0.793353340291235, 0.608761429008721, 0.923879532511287, 0.38268343236509 , 0.99144486137381 , 0.130526192220051, 0.99144486137381 , -0.130526192220051, 0.923879532511287, -0.38268343236509, 0.793353340291235, -0.60876142900872 , 0.608761429008721, -0.793353340291235, 0.38268343236509 , -0.923879532511287, 0.130526192220052, -0.99144486137381, @@ -188,10 +307,29 @@ -0.38268343236509 , -0.923879532511287, -0.923879532511287, -0.38268343236509 , -0.923879532511287, 0.38268343236509 , -0.38268343236509 , 0.923879532511287 ] --- >>> U.length grad3d == 256 +{- ORMOLU_ENABLE -} + +lookupGrad3 :: (RealFrac a) => Hash -> a +lookupGrad3 = realToFrac . (grad3dd `indexPrimArray`) . fromIntegral +{-# INLINE [0] lookupGrad3 #-} + +{-# RULES +"lookupGrad3/Float" forall (i :: Hash). + lookupGrad3 i = + indexPrimArray grad3df (fromIntegral i) +"lookupGrad3/Double" forall (i :: Hash). + lookupGrad3 i = + indexPrimArray grad3dd (fromIntegral i) + #-} + +grad3df :: PrimArray Float +grad3df = mapPrimArray realToFrac grad3dd + +{- ORMOLU_DISABLE -} +-- >>> sizeofPrimArray grad3d == 256 -- True -grad3d :: U.Vector Int -grad3d = +grad3dd :: PrimArray Double +grad3dd = [ 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 diff --git a/src/Numeric/Noise/OpenSimplex.hs b/src/Numeric/Noise/OpenSimplex.hs --- a/src/Numeric/Noise/OpenSimplex.hs +++ b/src/Numeric/Noise/OpenSimplex.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE Strict #-} - -- | -- Maintainer: Jeremy Nuttall -- Stability: experimental @@ -9,78 +7,149 @@ -- * 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 noise2 :: (RealFrac a) => Noise2 a -noise2 = Noise2 noise2Base +noise2 = mkNoise2 noise2Base {-# INLINE noise2 #-} noise2Base :: (RealFrac a) => Seed -> a -> a -> a noise2Base seed xo yo = - let f2 = 0.5 * (sqrt3 - 1) - to = (xo + yo) * f2 - x = xo + to - y = yo + to + let !f2 = 0.5 * (sqrt3 - 1) + !to = (xo + yo) * f2 + !x = xo + to + !y = yo + to - fx = floor x - fy = floor y - xi = x - fromIntegral fx - yi = y - fromIntegral fy + !fx = floor x + !fy = floor y + !xi = x - fromIntegral fx + !yi = y - fromIntegral fy - t = (xi + yi) * g2 - x0 = xi - t - y0 = yi - t - i = fx * primeX - j = fy * primeY + !t = (xi + yi) * g2 + !x0 = xi - t + !y0 = yi - t + !i = fx * primeX + !j = fy * primeY - a = 0.5 - x0 * x0 - y0 * y0 - n0 - | a <= 0 = 0 - | otherwise = - (a * a) - * (a * a) - * gradCoord2 seed i j x0 y0 + !a = 0.5 - x0 * x0 - y0 * y0 + n0 = attenuate a seed i j x0 y0 - n1 - | y0 > x0 = - let ~x1 = x0 + g2 - ~i1 = i - ~y1 = y0 + (g2 - 1) - ~j1 = j + primeY - ~b = 0.5 - x1 * x1 - y1 * y1 - in if b <= 0 - then 0 - else - (b * b) - * (b * b) - * gradCoord2 seed i1 j1 x1 y1 - | otherwise = - let ~x1 = x0 + (g2 - 1) - ~i1 = i + primeX - ~y1 = y0 + g2 - ~j1 = j - ~b = 0.5 - x1 * x1 - y1 * y1 - in if b <= 0 - then 0 - else - (b * b) - * (b * b) - * gradCoord2 seed i1 j1 x1 y1 + n1 = + 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 - c = + !n2 = let g2t = 1 - 2 * g2 - in 2 * g2t * (1 / g2 - 2) * t - + (-2 * g2t * g2t + a) - n2 - | c <= 0 = 0 - | otherwise = - let ~x2 = x0 + (2 * g2 - 1) - ~y2 = y0 + (2 * g2 - 1) - in (c * c) - * (c * c) - * gradCoord2 seed (i + primeX) (j + primeY) x2 y2 - in (n0 + n1 + n2) * 99.83685446303647 -{-# INLINE noise2Base #-} + c = 2 * g2t * (1 / g2 - 2) * t + (-2 * g2t * g2t + a) + x2 = x0 + (2 * g2 - 1) + y2 = y0 + (2 * g2 - 1) + in attenuate c seed (i + primeX) (j + primeY) x2 y2 + in normalize $ n0 + n1 + n2 +{-# INLINE [2] noise2Base #-} + +attenuate :: (RealFrac a) => a -> Seed -> Hash -> Hash -> a -> a -> a +attenuate !vi seed i j x y = + let !v = max 0 vi + in (v * v) * (v * v) * gradCoord2 seed i j x y +{-# INLINE attenuate #-} + +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 #-} diff --git a/src/Numeric/Noise/Perlin.hs b/src/Numeric/Noise/Perlin.hs --- a/src/Numeric/Noise/Perlin.hs +++ b/src/Numeric/Noise/Perlin.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE Strict #-} - -- | -- Maintainer: Jeremy Nuttall -- Stability : experimental @@ -18,7 +16,7 @@ import Numeric.Noise.Internal.Math noise2 :: (RealFrac a) => Noise2 a -noise2 = Noise2 noise2Base +noise2 = mkNoise2 noise2Base {-# INLINE noise2 #-} noise2Base :: forall a. (RealFrac a) => Seed -> a -> a -> a @@ -39,8 +37,8 @@ x1p = x0p + primeX y1p = y0p + primeY - in 1.4247691104677813 - * lerp + in normalize2 $ + lerp ( lerp (gradCoord2 seed x0p y0p xd0 yd0) (gradCoord2 seed x1p y0p xd1 yd0) @@ -52,10 +50,14 @@ u ) v -{-# INLINE noise2Base #-} +{-# INLINE [2] noise2Base #-} +normalize2 :: (RealFrac a) => a -> a +normalize2 = (1.4247691104677813 *) +{-# INLINE normalize2 #-} + noise3 :: (RealFrac a) => Noise3 a -noise3 = Noise3 noise3Base +noise3 = mkNoise3 noise3Base {-# INLINE noise3 #-} noise3Base :: (RealFrac a) => Seed -> a -> a -> a -> a @@ -82,8 +84,8 @@ x1p = x0p + primeX y1p = y0p + primeY z1p = z0p + primeZ - in 0.96492141485214233398437 - * lerp + in normalize3 $ + lerp ( lerp ( lerp (gradCoord3 seed x0p y0p z0p xd0 yd0 zd0) @@ -111,4 +113,8 @@ v ) w -{-# INLINE noise3Base #-} +{-# INLINE [2] noise3Base #-} + +normalize3 :: (RealFrac a) => a -> a +normalize3 = (0.96492141485214233398437 *) +{-# INLINE normalize3 #-} diff --git a/src/Numeric/Noise/SuperSimplex.hs b/src/Numeric/Noise/SuperSimplex.hs --- a/src/Numeric/Noise/SuperSimplex.hs +++ b/src/Numeric/Noise/SuperSimplex.hs @@ -4,20 +4,26 @@ -- Maintainer: Jeremy Nuttall -- 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 noise2 :: (RealFrac a) => Noise2 a -noise2 = Noise2 noise2Base +noise2 = mkNoise2 noise2Base {-# INLINE noise2 #-} noise2Base :: (RealFrac a) => Seed -> a -> a -> a @@ -60,89 +66,225 @@ let ~x2 = x0 + (3 * g2 - 2) ~y2 = y0 + (3 * g2 - 1) ~a2 = (2 / 3) - x2 * x2 - y2 * y2 - in if a2 > 0 - then - (a2 * a2) - * (a2 * a2) - * gradCoord2 seed (i + (primeX `shiftL` 1)) (j + primeY) x2 y2 - else 0 + in attenuate a2 seed (i + (primeX `shiftL` 1)) (j + primeY) x2 y2 | otherwise = let ~x2 = x0 + g2 ~y2 = y0 + (g2 - 1) ~a2 = (2 / 3) - x2 * x2 - y2 * y2 - in if a2 > 0 - then - (a2 * a2) - * (a2 * a2) - * gradCoord2 seed i (j + primeY) x2 y2 - else 0 + in attenuate a2 seed i (j + primeY) x2 y2 + ~vgy | yi - xmyi > 1 = let ~x3 = x0 + (3 * g2 - 1) ~y3 = y0 + (3 * g2 - 2) ~a3 = (2 / 3) - x3 * x3 - y3 * y3 - in if a3 > 0 - then - (a3 * a3) - * (a3 * a3) - * gradCoord2 seed (i + primeX) (j + (primeY `shiftL` 1)) x3 y3 - else 0 + in attenuate a3 seed (i + primeX) (j + (primeY `shiftL` 1)) x3 y3 | otherwise = let ~x3 = x0 + (g2 - 1) ~y3 = y0 + g2 ~a3 = (2 / 3) - x3 * x3 - y3 * y3 - in if a3 > 0 - then - (a3 * a3) - * (a3 * a3) - * gradCoord2 seed (i + primeX) j x3 y3 - else 0 + in attenuate a3 seed (i + primeX) j x3 y3 ~vlx | xi + xmyi < 0 = let ~x2 = x0 + (1 - g2) ~y2 = y0 - g2 ~a2 = (2 / 3) - x2 * x2 - y2 * y2 - in if a2 > 0 - then - (a2 * a2) - * (a2 * a2) - * gradCoord2 seed (i - primeX) j x2 y2 - else 0 + in attenuate a2 seed (i - primeX) j x2 y2 | otherwise = let ~x2 = x0 + (g2 - 1) ~y2 = y0 + g2 ~a2 = (2 / 3) - x2 * x2 - y2 * y2 - in if a2 > 0 - then - (a2 * a2) - * (a2 * a2) - * gradCoord2 seed (i + primeX) j x2 y2 - else 0 + in attenuate a2 seed (i + primeX) j x2 y2 ~vly | yi < xmyi = let ~x2 = x0 - g2 ~y2 = y0 - (g2 - 1) ~a2 = (2 / 3) - x2 * x2 - y2 * y2 - in if a2 > 0 - then - (a2 * a2) - * (a2 * a2) - * gradCoord2 seed i (j - primeY) x2 y2 - else 0 + in attenuate a2 seed i (j - primeY) x2 y2 | otherwise = let ~x2 = x0 + g2 ~y2 = y0 + (g2 - 1) ~a2 = (2 / 3) - x2 * x2 - y2 * y2 - in if a2 > 0 - then - (a2 * a2) - * (a2 * a2) - * gradCoord2 seed i (j + primeY) x2 y2 - else 0 + in attenuate a2 seed i (j + primeY) x2 y2 v2 | t > g2 = vgx + vgy | otherwise = vlx + vly - in (v0 + v1 + v2) * 18.24196194486065 -{-# INLINE noise2Base #-} + in normalize $ v0 + v1 + v2 +{-# INLINE [2] noise2Base #-} + +attenuate :: (RealFrac a) => a -> Seed -> Hash -> Hash -> a -> a -> a +attenuate !vi !seed !i !j !x !y = + let !v = max 0 vi + in (v * v) * (v * v) * gradCoord2 seed i j x y +{-# INLINE attenuate #-} + +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 #-} diff --git a/src/Numeric/Noise/Value.hs b/src/Numeric/Noise/Value.hs --- a/src/Numeric/Noise/Value.hs +++ b/src/Numeric/Noise/Value.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE Strict #-} - -- | -- Maintainer: Jeremy Nuttall -- Stability: experimental @@ -20,7 +18,7 @@ import Numeric.Noise.Internal.Math noise2 :: (RealFrac a) => Noise2 a -noise2 = Noise2 noise2Base +noise2 = mkNoise2 noise2Base {-# INLINE noise2 #-} noise2Base :: (RealFrac a) => Seed -> a -> a -> a @@ -48,10 +46,10 @@ xs ) ys -{-# INLINE noise2Base #-} +{-# INLINE [2] noise2Base #-} noise3 :: (RealFrac a) => Noise3 a -noise3 = Noise3 noise3Base +noise3 = mkNoise3 noise3Base {-# INLINE noise3 #-} noise3Base :: (RealFrac a) => Seed -> a -> a -> a -> a @@ -99,4 +97,4 @@ ys ) zs -{-# INLINE noise3Base #-} +{-# INLINE [2] noise3Base #-} diff --git a/src/Numeric/Noise/ValueCubic.hs b/src/Numeric/Noise/ValueCubic.hs --- a/src/Numeric/Noise/ValueCubic.hs +++ b/src/Numeric/Noise/ValueCubic.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE Strict #-} - -- | -- Maintainer: Jeremy Nuttall -- Stability : experimental @@ -18,7 +16,7 @@ import Numeric.Noise.Internal.Math noise2 :: (RealFrac a) => Noise2 a -noise2 = Noise2 noise2Base +noise2 = mkNoise2 noise2Base {-# INLINE noise2 #-} noise2Base :: (RealFrac a) => Seed -> a -> a -> a @@ -68,10 +66,10 @@ xs ) ys -{-# INLINE noise2Base #-} +{-# INLINE [2] noise2Base #-} noise3 :: (RealFrac a) => Noise3 a -noise3 = Noise3 noise3Base +noise3 = mkNoise3 noise3Base {-# INLINE noise3 #-} noise3Base :: (RealFrac a) => Seed -> a -> a -> a -> a @@ -223,4 +221,4 @@ ys ) zs -{-# INLINE noise3Base #-} +{-# INLINE [2] noise3Base #-} diff --git a/test/CellularSpec.hs b/test/CellularSpec.hs new file mode 100644 --- /dev/null +++ b/test/CellularSpec.hs @@ -0,0 +1,67 @@ +{-# LANGUAGE OverloadedStrings #-} + +module CellularSpec (test_golden_cellular) where + +import Golden.Util +import Numeric.Noise +import Test.Tasty (TestTree, testGroup) + +test_golden_cellular :: TestTree +test_golden_cellular = + testGroup + "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 +allCellularConfigs :: [(CellularDistanceFn, CellularResult)] +allCellularConfigs = [(df, rt) | df <- [minBound .. maxBound], rt <- [minBound .. maxBound]] + +cellularGridTests :: [TestTree] +cellularGridTests = + [ goldenImageTest2D "cellular" variant (cellular2 config) seed + | (distFn, result) <- allCellularConfigs + , let config = defaultCellularConfig{cellularDistanceFn = distFn, cellularResult = result} + , seed <- cellularSeeds + , let variant = show distFn ++ "-" <> show result <> "-seed" ++ show seed + ] + +cellularSparseTests :: [TestTree] +cellularSparseTests = + [ goldenSparseTest2D "cellular" variant (cellular2 config) seed + | (distFn, result) <- allCellularConfigs + , 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 + ] diff --git a/test/FractalSpec.hs b/test/FractalSpec.hs new file mode 100644 --- /dev/null +++ b/test/FractalSpec.hs @@ -0,0 +1,68 @@ +{-# LANGUAGE OverloadedStrings #-} + +module FractalSpec (test_golden_fractal) where + +import Golden.Util +import Numeric.Noise +import Test.Tasty (TestTree, testGroup) + +test_golden_fractal :: TestTree +test_golden_fractal = + testGroup + "Fractal Golden Tests" + [ testGroup "2D Grid Tests" fractal2DGridTests + , testGroup "2D Sparse Tests" fractal2DSparseTests + , testGroup "3D Grid Tests" fractal3DGridTests + , testGroup "3D Sparse Tests" fractal3DSparseTests + ] + +-- Fractal types to test +data FractalType = FBM | Billow | Ridged | PingPong + deriving (Show, Eq, Enum, Bounded) + +-- Apply the fractal type to a 2D noise function +applyFractal2D :: FractalType -> Noise2 Double -> Noise2 Double +applyFractal2D FBM = fractal2 defaultFractalConfig +applyFractal2D Billow = billow2 defaultFractalConfig +applyFractal2D Ridged = ridged2 defaultFractalConfig +applyFractal2D PingPong = pingPong2 defaultFractalConfig defaultPingPongStrength + +-- Apply the fractal type to a 3D noise function +applyFractal3D :: FractalType -> Noise3 Double -> Noise3 Double +applyFractal3D FBM = fractal3 defaultFractalConfig +applyFractal3D Billow = billow3 defaultFractalConfig +applyFractal3D Ridged = ridged3 defaultFractalConfig +applyFractal3D PingPong = pingPong3 defaultFractalConfig defaultPingPongStrength + +fractal2DGridTests :: [TestTree] +fractal2DGridTests = + [ goldenImageTest2D "fractal" variant (applyFractal2D fractalType perlin2) seed + | fractalType <- [minBound .. maxBound] + , seed <- cellularSeeds + , let variant = show fractalType ++ "-perlin-2d-seed" ++ show seed + ] + +fractal2DSparseTests :: [TestTree] +fractal2DSparseTests = + [ goldenSparseTest2D "fractal" variant (applyFractal2D fractalType perlin2) seed + | fractalType <- [minBound .. maxBound] + , seed <- cellularSeeds + , let variant = show fractalType ++ "-perlin-2d-seed" ++ show seed + ] + +fractal3DGridTests :: [TestTree] +fractal3DGridTests = + [ goldenImageTest3D "fractal" variant (applyFractal3D fractalType perlin3) seed zOffset + | fractalType <- [minBound .. maxBound] + , seed <- cellularSeeds + , (idx, zOffset) <- zip [0 :: Int ..] sliceOffsets3D + , let variant = show fractalType ++ "-perlin-3d-seed_" ++ show seed ++ "-slice_" ++ show idx + ] + +fractal3DSparseTests :: [TestTree] +fractal3DSparseTests = + [ goldenSparseTest3D "fractal" variant (applyFractal3D fractalType perlin3) seed + | fractalType <- [minBound .. maxBound] + , seed <- cellularSeeds + , let variant = show fractalType ++ "-perlin-3d-seed" ++ show seed + ] diff --git a/test/Golden/Util.hs b/test/Golden/Util.hs new file mode 100644 --- /dev/null +++ b/test/Golden/Util.hs @@ -0,0 +1,387 @@ +{-# LANGUAGE OverloadedStrings #-} + +-- | Utilities for golden testing of noise functions +module Golden.Util ( + -- * Test configuration + defaultSeeds, + cellularSeeds, + sliceOffsets3D, + + -- * Grid generation + generateGrid2D, + generateGrid3D, + + -- * Sparse sampling + SparseTest (..), + generateSparse2D, + generateSparse3D, + + -- * High-level test builders + goldenImageTest2D, + goldenImageTest3D, + goldenSparseTest2D, + goldenSparseTest3D, + + -- * Convenience batch functions + golden2DImageTests, + golden2DSparseTests, + golden3DImageTests, + golden3DSparseTests, +) where + +import Codec.Picture +import Control.Monad +import Data.Aeson (FromJSON, ToJSON) +import Data.Aeson.Encode.Pretty (encodePretty) +import Data.ByteString qualified as BS +import Data.ByteString.Lazy qualified as LB +import Data.Massiv.Array (Array, B (..), Comp (..), Ix2 (..), Ix3, IxN (..), Sz (..)) +import Data.Massiv.Array qualified as M +import Data.Text.Lazy qualified as LT +import Data.Text.Lazy.Encoding qualified as LT +import Foreign.C (eNOENT) +import Foreign.C.Error (errnoToIOError) +import GHC.Generics (Generic) +import Numeric.Noise (Noise2, Noise3, Seed, noise2At, noise3At, sliceZ3) +import System.Directory +import System.Exit +import System.FilePath +import System.Process.Typed qualified as PT +import Test.Tasty (TestName, TestTree, askOption) +import Test.Tasty.Golden +import Test.Tasty.Golden.Advanced (goldenTest2) + +defaultSeeds :: [Seed] +defaultSeeds = [0, 42, 12345] + +cellularSeeds :: [Seed] +cellularSeeds = [0, 42] + +width2D, height2D :: Int +width2D = 1024 +height2D = 1024 + +width3D, height3D :: Int +width3D = 256 +height3D = 256 + +-- | Z-offsets for 3D slicing (fractional positions avoiding edges) +sliceOffsets3D :: [Double] +sliceOffsets3D = [0.125, 0.375, 0.625, 0.875] + +data SparseTest a = SparseTest + { coordinates :: [a] + , expected :: a + } + deriving (Eq, Show, Generic) + +instance (FromJSON a) => FromJSON (SparseTest a) +instance (ToJSON a) => ToJSON (SparseTest a) + +-- | Generate a 2D noise grid using massiv +generateGrid2D + :: Noise2 Double + -> Seed + -> Int + -- ^ Width + -> Int + -- ^ Height + -> Array B Ix2 Double +generateGrid2D noise seed width height = + M.makeArray Par (Sz2 height width) $ \(row :. col) -> + let x = fromIntegral col / fromIntegral width + y = fromIntegral row / fromIntegral height + in noise2At noise seed x y +{-# INLINE generateGrid2D #-} + +-- | Generate a 3D noise grid using massiv +generateGrid3D + :: Noise3 Double + -> Seed + -> Int + -- ^ Width + -> Int + -- ^ Height + -> Int + -- ^ Depth + -> Array B Ix3 Double +generateGrid3D noise seed width height depth = + M.makeArray Par (Sz3 depth height width) $ \(d :> row :. col) -> + let x = fromIntegral col / fromIntegral width + y = fromIntegral row / fromIntegral height + z = fromIntegral d / fromIntegral depth + in noise3At noise seed x y z +{-# INLINE generateGrid3D #-} + +-- | Convert a 2D noise grid to a grayscale PNG image +-- Maps noise values from [-1, 1] to pixel values [0, 255] +noiseGridToImage :: Array B Ix2 Double -> Image Pixel8 +noiseGridToImage arr = + let Sz2 height width = M.size arr + getPixel x y = + let val = arr M.! (y :. x) + -- Map [-1, 1] to [0, 255] + normalized = (val + 1.0) / 2.0 + clamped = max 0.0 (min 1.0 normalized) + in round (clamped * 255.0) + in generateImage getPixel width height +{-# INLINE noiseGridToImage #-} + +-- | Strategic test points for 2D noise +-- Includes corners, edges, zero, unit values, negatives, and fractional coordinates +sparseTestPoints2D :: [(Double, Double)] +sparseTestPoints2D = + [ -- Corners and edges + (0.0, 0.0) + , (1.0, 1.0) + , (0.0, 1.0) + , (1.0, 0.0) + , -- Negative values + (-1.0, -1.0) + , (-1.0, 0.0) + , (0.0, -1.0) + , (-1.0, 1.0) + , (1.0, -1.0) + , -- Fractional coordinates + (0.5, 0.5) + , (0.25, 0.75) + , (0.75, 0.25) + , (0.1, 0.9) + , (0.9, 0.1) + , -- Larger values + (10.0, 10.0) + , (100.0, 100.0) + , (-10.0, -10.0) + , (5.5, 7.3) + , (-3.2, 4.7) + , -- Edge cases + (1.0e-10, 1.0e-10) + , -- More varied points + (2.5, 3.7) + , (-5.2, 8.9) + , (12.34, -56.78) + , (0.123, 0.456) + , (0.789, 0.321) + , (-0.5, -0.5) + , (0.5, -0.5) + , (-0.5, 0.5) + , -- Prime-like coordinates for good distribution + (2.0, 3.0) + , (5.0, 7.0) + , (11.0, 13.0) + , (17.0, 19.0) + , (23.0, 29.0) + , (31.0, 37.0) + , (41.0, 43.0) + , (47.0, 53.0) + , -- Diagonal patterns + (2.0, 2.0) + , (3.0, 3.0) + , (-2.0, -2.0) + , -- Anti-diagonal + (2.0, -2.0) + , (-2.0, 2.0) + , -- Discontinuity + (0.999999, 0.999999) + , (0.000001, 0.000001) + , (0.999999999, 0.999999999) + , (1.000000001, 1.000000001) + , -- Powers of two + (256.0, 256.0) + , (1024.0, 1024.1) + , (65536.5, 65536.5) + , -- Large inputs + (10000.0, 10000.0) + , (10000.1, 10000.1) + ] + +-- | Strategic test points for 3D noise +sparseTestPoints3D :: [(Double, Double, Double)] +sparseTestPoints3D = + [ -- Corners + (0.0, 0.0, 0.0) + , (1.0, 1.0, 1.0) + , (0.0, 0.0, 1.0) + , (0.0, 1.0, 0.0) + , (1.0, 0.0, 0.0) + , (0.0, 1.0, 1.0) + , (1.0, 0.0, 1.0) + , (1.0, 1.0, 0.0) + , -- Negative corners + (-1.0, -1.0, -1.0) + , (-1.0, -1.0, 1.0) + , (-1.0, 1.0, -1.0) + , (1.0, -1.0, -1.0) + , -- Fractional center and edges + (0.5, 0.5, 0.5) + , (0.25, 0.5, 0.75) + , (0.75, 0.25, 0.5) + , -- Larger values + (10.0, 10.0, 10.0) + , (100.0, 100.0, 100.0) + , (-10.0, -10.0, -10.0) + , -- Varied points + (2.5, 3.7, 4.2) + , (-5.2, 8.9, -3.1) + , (1.23, -4.56, 7.89) + , -- Edge cases + (1.0e-10, 1.0e-10, 1.0e-10) + , -- Mixed signs + (1.0, -1.0, 1.0) + , (-1.0, 1.0, -1.0) + , (1.0, 1.0, -1.0) + , (-1.0, -1.0, 1.0) + , -- Prime-like distribution + (2.0, 3.0, 5.0) + , (7.0, 11.0, 13.0) + , (17.0, 19.0, 23.0) + ] + +-- | Generate sparse test samples for 2D noise +generateSparse2D :: Noise2 Double -> Seed -> [SparseTest Double] +generateSparse2D noise seed = + map (\(x, y) -> SparseTest [x, y] (noise2At noise seed x y)) sparseTestPoints2D + +-- | Generate sparse test samples for 3D noise +generateSparse3D :: Noise3 Double -> Seed -> [SparseTest Double] +generateSparse3D noise seed = + map (\(x, y, z) -> SparseTest [x, y, z] (noise3At noise seed x y z)) sparseTestPoints3D + +-- ----------------------------------------------------------------------------- +-- High-level test builders +-- ----------------------------------------------------------------------------- + +goldenDir :: FilePath +goldenDir = "test-data" "golden" + +goldenImageTest :: String -> String -> (String -> IO ()) -> TestTree +goldenImageTest noiseName variant act = + let testName = noiseName <> " " <> variant + imageRoot = goldenDir "images" noiseName + goldenPath = imageRoot variant <.> "png" + actualPath = imageRoot variant <.> "actual" <.> "png" + in goldenVsImage + testName + goldenPath + actualPath + (createDirectoryIfMissing True imageRoot >> act actualPath) + +-- This is more-or-less the same as goldenVsFileDiff, but it doesn't share stdio with +-- the child process, which is pretty important because odiff doesn't have a quiet option +goldenVsImage :: TestName -> FilePath -> FilePath -> IO () -> TestTree +goldenVsImage name ref new act = askOption $ \sizeCutoff -> + goldenTest2 + name + throwIfDoesNotExist + act + (\_ _ -> runDiff sizeCutoff) + update + delete + where + throwIfDoesNotExist = do + exists <- doesFileExist ref + unless exists $ + ioError $ + errnoToIOError "goldenVsFileDiff" eNOENT Nothing Nothing + runDiff + :: SizeCutoff + -> IO (Maybe String) + runDiff sizeCutoff = do + let (refName, refExt) = splitExtension ref + proc = + PT.proc + "odiff" + [ "-t" + , "0.004" -- Tolerate roughly +/- 1 error for 8-bit grayscale. + , "--diff-overlay" + , "--fail-on-layout" + , "--output-diff-lines" + , ref + , new + , refName <.> "diff" <.> refExt + ] + procConf = PT.setStdin PT.closed proc + + (exitCode, out) <- PT.readProcessInterleaved procConf + return $ case exitCode of + ExitSuccess -> Nothing + _ -> Just . LT.unpack . LT.decodeUtf8 . truncateLargeOutput sizeCutoff $ out + truncateLargeOutput (SizeCutoff n) str = + if LB.length str <= n + then str + else + LB.take n str + <> "" + <> "\nUse --accept or increase --size-cutoff to see full output." + update _ = do + f <- BS.readFile new + createDirectoriesAndWriteFile ref (LB.fromStrict f) + delete = removeFile new + +goldenImageTest2D :: String -> String -> Noise2 Double -> Seed -> TestTree +goldenImageTest2D noiseName variant noise seed = goldenImageTest noiseName variant $ \path -> do + let grid = generateGrid2D noise seed width2D height2D + img = noiseGridToImage grid + savePngImage path (ImageY8 img) + +goldenImageTest3D :: String -> String -> Noise3 Double -> Seed -> Double -> TestTree +goldenImageTest3D noiseName variant noise seed zOffset = goldenImageTest noiseName variant $ \path -> do + let grid2D = generateGrid2D (sliceZ3 zOffset noise) seed width3D height3D + img = noiseGridToImage grid2D + savePngImage path (ImageY8 img) + +goldenSparseTest :: String -> String -> (String -> IO ()) -> TestTree +goldenSparseTest noiseName variant act = + let testName = noiseName <> " " <> variant <> " (sparse)" + jsonRoot = goldenDir "sparse" noiseName + goldenPath = jsonRoot variant <.> "json" + actualPath = jsonRoot variant <.> "actual" <.> "json" + in goldenVsFileDiff + testName + (\ref new -> ["diff", "-u", ref, new]) + goldenPath + actualPath + (createDirectoryIfMissing True jsonRoot >> act actualPath) + +goldenSparseTest2D :: String -> String -> Noise2 Double -> Seed -> TestTree +goldenSparseTest2D noiseName variant noise seed = goldenSparseTest noiseName variant $ \path -> do + let samples = generateSparse2D noise seed + json = encodePretty samples + LB.writeFile path json + +goldenSparseTest3D :: String -> String -> Noise3 Double -> Seed -> TestTree +goldenSparseTest3D noiseName variant noise seed = goldenSparseTest noiseName variant $ \path -> do + let samples = generateSparse3D noise seed + json = encodePretty samples + LB.writeFile path json + +labelBatch :: (Show a) => String -> a -> String +labelBatch dim seed = dim <> "-seed_" <> show seed + +labelBatch3D :: Seed -> Int -> String +labelBatch3D seed sliceIdx = "3d-seed_" <> show seed <> "-slice_" <> show sliceIdx + +golden2DImageTests :: String -> [Seed] -> Noise2 Double -> [TestTree] +golden2DImageTests noiseName seeds noise = + [ goldenImageTest2D noiseName (labelBatch "2d" seed) noise seed + | seed <- seeds + ] + +golden2DSparseTests :: String -> [Seed] -> Noise2 Double -> [TestTree] +golden2DSparseTests noiseName seeds noise = + [ goldenSparseTest2D noiseName (labelBatch "2d" seed) noise seed + | seed <- seeds + ] + +golden3DImageTests :: String -> [Seed] -> Noise3 Double -> [TestTree] +golden3DImageTests noiseName seeds noise = + [ goldenImageTest3D noiseName (labelBatch3D seed idx) noise seed zOffset + | seed <- seeds + , (idx, zOffset) <- zip [0 ..] sliceOffsets3D + ] + +golden3DSparseTests :: String -> [Seed] -> Noise3 Double -> [TestTree] +golden3DSparseTests noiseName seeds noise = + [ goldenSparseTest3D noiseName (labelBatch "3d" seed) noise seed + | seed <- seeds + ] diff --git a/test/Noise2Spec.hs b/test/Noise2Spec.hs --- a/test/Noise2Spec.hs +++ b/test/Noise2Spec.hs @@ -1,7 +1,6 @@ module Noise2Spec where import Numeric.Noise -import Numeric.Noise.Internal seed :: Seed seed = 55 @@ -25,12 +24,12 @@ prop_0_is_additive_identity :: Rational -> Rational -> Rational -> Bool prop_0_is_additive_identity v x y = let n1 = const2 v - in noise2At (n1 + fromInteger 0) seed x y == noise2At n1 seed x y + in noise2At (n1 + 0) seed x y == noise2At n1 seed x y prop_negate_is_additive_inverse :: Rational -> Rational -> Rational -> Bool prop_negate_is_additive_inverse v x y = let n1 = const2 v - in noise2At (n1 + negate n1) seed x y == 0 + in noise2At (n1 - n1) seed x y == 0 prop_multiplication :: Rational -> Rational -> Bool prop_multiplication x y = noise2At (const2 x * const2 y) seed x y == x * y @@ -41,8 +40,3 @@ n2 = const2 2027 n3 = const2 2069 in noise2At ((n1 * n2) * n3) seed x y == noise2At (n1 * (n2 * n3)) seed x y - -prop_1_is_multiplicative_identity :: Rational -> Rational -> Rational -> Bool -prop_1_is_multiplicative_identity v x y = - let n1 = const2 v - in noise2At (n1 * fromInteger 1) seed x y == v diff --git a/test/Noise3Spec.hs b/test/Noise3Spec.hs --- a/test/Noise3Spec.hs +++ b/test/Noise3Spec.hs @@ -1,7 +1,6 @@ module Noise3Spec where import Numeric.Noise -import Numeric.Noise.Internal seed :: Seed seed = 2381 @@ -26,12 +25,12 @@ prop_0_is_additive_identity :: Rational -> Rational -> Rational -> Rational -> Bool prop_0_is_additive_identity v x y z = let n1 = const3 v - in noise3At (n1 + fromInteger 0) seed x y z == noise3At n1 seed x y z + in noise3At (n1 + 0) seed x y z == noise3At n1 seed x y z prop_negate_is_additive_inverse :: Rational -> Rational -> Rational -> Rational -> Bool prop_negate_is_additive_inverse v x y z = let n1 = const3 v - in noise3At (n1 + negate n1) seed x y z == 0 + in noise3At (n1 - n1) seed x y z == 0 prop_multiplication :: Rational -> Rational -> Rational -> Bool prop_multiplication x y z = @@ -47,4 +46,4 @@ prop_1_is_multiplicative_identity :: Rational -> Rational -> Rational -> Rational -> Bool prop_1_is_multiplicative_identity v x y z = let n1 = const3 v - in noise3At (n1 * fromInteger 1) seed x y z == v + in noise3At (n1 * 1) seed x y z == v diff --git a/test/OpenSimplexSpec.hs b/test/OpenSimplexSpec.hs new file mode 100644 --- /dev/null +++ b/test/OpenSimplexSpec.hs @@ -0,0 +1,29 @@ +{-# LANGUAGE OverloadedStrings #-} + +module OpenSimplexSpec (test_golden_opensimplex) where + +import Golden.Util +import Numeric.Noise +import Test.Tasty (TestTree, testGroup) + +test_golden_opensimplex :: TestTree +test_golden_opensimplex = + testGroup + "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] +openSimplex2DGridTests = golden2DImageTests "opensimplex" defaultSeeds openSimplex2 + +openSimplex2DSparseTests :: [TestTree] +openSimplex2DSparseTests = golden2DSparseTests "opensimplex" defaultSeeds openSimplex2 + +openSimplex3DGridTests :: [TestTree] +openSimplex3DGridTests = golden3DImageTests "opensimplex" defaultSeeds openSimplex3 + +openSimplex3DSparseTests :: [TestTree] +openSimplex3DSparseTests = golden3DSparseTests "opensimplex" defaultSeeds openSimplex3 diff --git a/test/PerlinSpec.hs b/test/PerlinSpec.hs --- a/test/PerlinSpec.hs +++ b/test/PerlinSpec.hs @@ -1,6 +1,9 @@ module PerlinSpec where +import GHC.Exts (noinline) +import Golden.Util import Numeric.Noise +import Test.Tasty (TestTree, testGroup) seed :: Seed seed = 82384 @@ -12,8 +15,32 @@ prop_noise2_addition_associative :: Rational -> Rational -> Bool prop_noise2_addition_associative x y = - noise2At ((perlin2 + perlin2) + perlin2) seed x y == noise2At (perlin2 + (perlin2 + perlin2)) seed x y + noise2At ((noinline perlin2 + noinline superSimplex2) + noinline openSimplex2) seed x y + == noise2At (perlin2 + (noinline superSimplex2 + noinline openSimplex2)) seed x y prop_noise2_addition_commutative :: Rational -> Rational -> Bool prop_noise2_addition_commutative x y = - noise2At (perlin2 + perlin2) seed x y == noise2At (perlin2 + perlin2) seed x y + noise2At (noinline perlin2 + noinline superSimplex2) seed x y + == noise2At (noinline superSimplex2 + noinline perlin2) seed x y + +test_golden_perlin :: TestTree +test_golden_perlin = + testGroup + "Perlin Golden Tests" + [ testGroup "2D Grid Tests" perlin2DGridTests + , testGroup "2D Sparse Tests" perlin2DSparseTests + , testGroup "3D Grid Tests" perlin3DGridTests + , testGroup "3D Sparse Tests" perlin3DSparseTests + ] + +perlin2DGridTests :: [TestTree] +perlin2DGridTests = golden2DImageTests "perlin" defaultSeeds perlin2 + +perlin2DSparseTests :: [TestTree] +perlin2DSparseTests = golden2DSparseTests "perlin" defaultSeeds perlin2 + +perlin3DGridTests :: [TestTree] +perlin3DGridTests = golden3DImageTests "perlin" defaultSeeds perlin3 + +perlin3DSparseTests :: [TestTree] +perlin3DSparseTests = golden3DSparseTests "perlin" defaultSeeds perlin3 diff --git a/test/SuperSimplexSpec.hs b/test/SuperSimplexSpec.hs new file mode 100644 --- /dev/null +++ b/test/SuperSimplexSpec.hs @@ -0,0 +1,27 @@ +module SuperSimplexSpec (test_golden_supersimplex) where + +import Golden.Util +import Numeric.Noise +import Test.Tasty (TestTree, testGroup) + +test_golden_supersimplex :: TestTree +test_golden_supersimplex = + testGroup + "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] +superSimplex2DGridTests = golden2DImageTests "supersimplex" defaultSeeds superSimplex2 + +superSimplex2DSparseTests :: [TestTree] +superSimplex2DSparseTests = golden2DSparseTests "supersimplex" defaultSeeds superSimplex2 + +superSimplex3DGridTests :: [TestTree] +superSimplex3DGridTests = golden3DImageTests "supersimplex" defaultSeeds superSimplex3 + +superSimplex3DSparseTests :: [TestTree] +superSimplex3DSparseTests = golden3DSparseTests "supersimplex" defaultSeeds superSimplex3 diff --git a/test/TotalitySpec.hs b/test/TotalitySpec.hs new file mode 100644 --- /dev/null +++ b/test/TotalitySpec.hs @@ -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 + ] + ] diff --git a/test/ValueCubicSpec.hs b/test/ValueCubicSpec.hs new file mode 100644 --- /dev/null +++ b/test/ValueCubicSpec.hs @@ -0,0 +1,27 @@ +module ValueCubicSpec (test_golden_valuecubic) where + +import Golden.Util +import Numeric.Noise +import Test.Tasty (TestTree, testGroup) + +test_golden_valuecubic :: TestTree +test_golden_valuecubic = + testGroup + "ValueCubic Golden Tests" + [ testGroup "2D Grid Tests" valueCubic2DGridTests + , testGroup "2D Sparse Tests" valueCubic2DSparseTests + , testGroup "3D Grid Tests" valueCubic3DGridTests + , testGroup "3D Sparse Tests" valueCubic3DSparseTests + ] + +valueCubic2DGridTests :: [TestTree] +valueCubic2DGridTests = golden2DImageTests "valuecubic" defaultSeeds valueCubic2 + +valueCubic2DSparseTests :: [TestTree] +valueCubic2DSparseTests = golden2DSparseTests "valuecubic" defaultSeeds valueCubic2 + +valueCubic3DGridTests :: [TestTree] +valueCubic3DGridTests = golden3DImageTests "valuecubic" defaultSeeds valueCubic3 + +valueCubic3DSparseTests :: [TestTree] +valueCubic3DSparseTests = golden3DSparseTests "valuecubic" defaultSeeds valueCubic3 diff --git a/test/ValueSpec.hs b/test/ValueSpec.hs new file mode 100644 --- /dev/null +++ b/test/ValueSpec.hs @@ -0,0 +1,29 @@ +{-# LANGUAGE OverloadedStrings #-} + +module ValueSpec (test_golden_value) where + +import Golden.Util +import Numeric.Noise +import Test.Tasty (TestTree, testGroup) + +test_golden_value :: TestTree +test_golden_value = + testGroup + "Value Golden Tests" + [ testGroup "2D Grid Tests" value2DGridTests + , testGroup "2D Sparse Tests" value2DSparseTests + , testGroup "3D Grid Tests" value3DGridTests + , testGroup "3D Sparse Tests" value3DSparseTests + ] + +value2DGridTests :: [TestTree] +value2DGridTests = golden2DImageTests "value" defaultSeeds value2 + +value2DSparseTests :: [TestTree] +value2DSparseTests = golden2DSparseTests "value" defaultSeeds value2 + +value3DGridTests :: [TestTree] +value3DGridTests = golden3DImageTests "value" defaultSeeds value3 + +value3DSparseTests :: [TestTree] +value3DSparseTests = golden3DSparseTests "value" defaultSeeds value3