diff --git a/.github/workflows/publish-js.yml b/.github/workflows/publish-js.yml new file mode 100644 index 0000000..c3cc2d1 --- /dev/null +++ b/.github/workflows/publish-js.yml @@ -0,0 +1,28 @@ +on: + push: + branches: + - master + paths: + - 'JavaScript/package.json' # The version number must be bumped in order to publish to npm + workflow_dispatch: + +name: Publish to npm + +jobs: + publish: + name: Publish + runs-on: ubuntu-latest + steps: + - name: Checkout sources + uses: actions/checkout@v4 + + - name: Set up Node.js + uses: actions/setup-node@v3 + with: + node-version: '20.x' + registry-url: 'https://registry.npmjs.org' + + - name: Publish to npm + run: cd JavaScript && npm publish + env: + NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }} diff --git a/.github/workflows/publish-rust.yml b/.github/workflows/publish-rust.yml new file mode 100644 index 0000000..a4d9dba --- /dev/null +++ b/.github/workflows/publish-rust.yml @@ -0,0 +1,28 @@ +on: + push: + branches: + - master + paths: + - 'Rust/Cargo.toml' # The version number must be bumped in order to publish to crates.io + +name: Publish Rust (crates.io) + +jobs: + publish: + name: Publish to crates.io + runs-on: ubuntu-latest + steps: + - name: Checkout repo + uses: actions/checkout@v4 + + - name: Install Rust toolchain + uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: stable + override: true + + - name: Publish to crates.io + run: cd Rust && cargo publish + env: + CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }} diff --git a/.gitignore b/.gitignore index 5261bf2..9921d69 100644 --- a/.gitignore +++ b/.gitignore @@ -23,6 +23,7 @@ nupkg/ [Rr]elease/ [Rr]eleases/ [Pp]ublish/ +[Tt]arget/ x64/ x86/ build/ diff --git a/C/FastNoiseLite.h b/C/FastNoiseLite.h index 30f5f9f..441da4c 100644 --- a/C/FastNoiseLite.h +++ b/C/FastNoiseLite.h @@ -45,7 +45,7 @@ // ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX // // VERSION: 1.0.1 -// https://github.com/Auburn/FastNoise +// https://github.com/Auburn/FastNoiseLite // In *one* C or C++ file, use #define FNL_IMPL to generate implementation diff --git a/CSharp/FastNoiseLite.cs b/CSharp/FastNoiseLite.cs index 1518d3a..60cd7ee 100644 --- a/CSharp/FastNoiseLite.cs +++ b/CSharp/FastNoiseLite.cs @@ -1,4 +1,4 @@ -// MIT License +// MIT License // // Copyright(c) 2020 Jordan Peck (jordan.me2@gmail.com) // Copyright(c) 2020 Contributors @@ -45,7 +45,7 @@ // ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX // // VERSION: 1.0.1 -// https://github.com/Auburn/FastNoise +// https://github.com/Auburn/FastNoiseLite using System; using System.Runtime.CompilerServices; diff --git a/Cpp/FastNoiseLite.h b/Cpp/FastNoiseLite.h index 2ad56a0..d685ff2 100644 --- a/Cpp/FastNoiseLite.h +++ b/Cpp/FastNoiseLite.h @@ -45,7 +45,7 @@ // ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX // // VERSION: 1.0.1 -// https://github.com/Auburn/FastNoise +// https://github.com/Auburn/FastNoiseLite #ifndef FASTNOISELITE_H #define FASTNOISELITE_H diff --git a/GLSL/FastNoiseLite.glsl b/GLSL/FastNoiseLite.glsl index d76c70c..64e7fe6 100644 --- a/GLSL/FastNoiseLite.glsl +++ b/GLSL/FastNoiseLite.glsl @@ -45,7 +45,7 @@ // ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX // // VERSION: 1.0.1 -// https://github.com/Auburn/FastNoise +// https://github.com/Auburn/FastNoiseLite // Switch between using floats or doubles for input position #define FNLfloat float diff --git a/Go/README.md b/Go/README.md new file mode 100644 index 0000000..179a920 --- /dev/null +++ b/Go/README.md @@ -0,0 +1,23 @@ +## Getting Started + +Here's an example for creating a 128x128 array of Perlin noise + +```go +import "fastnoise" + +// Create and configure noise state (either float32 or float64) +noise := fastnoise.New[float32]() +noise.NoiseType(fastnoise.Perlin) + +// Gather noise data +const size = 128 +data := make([]float32, size * size) + +for i := 0; i < len(data); i++ { + x := i % size + y := i / size + data[i] = noise.Noise2D(x, y) +} + +// Use noise data (all values are in range of -1.0 and 1.0) +``` diff --git a/Go/fastnoise.go b/Go/fastnoise.go new file mode 100644 index 0000000..364fcb4 --- /dev/null +++ b/Go/fastnoise.go @@ -0,0 +1,2464 @@ +// MIT License +// +// Copyright(c) 2020 Jordan Peck (jordan.me2@gmail.com) +// Copyright(c) 2020 Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +// .'',;:cldxkO00KKXXNNWWWNNXKOkxdollcc::::::;:::ccllloooolllllllllooollc:,'... ...........',;cldxkO000Okxdlc::;;;,,;;;::cclllllll +// ..',;:ldxO0KXXNNNNNNNNXXK0kxdolcc::::::;;;,,,,,,;;;;;;;;;;:::cclllllc:;'.... ...........',;:ldxO0KXXXK0Okxdolc::;;;;::cllodddddo +// ...',:loxO0KXNNNNNXXKK0Okxdolc::;::::::::;;;,,'''''.....''',;:clllllc:;,'............''''''''',;:loxO0KXNNNNNXK0Okxdollccccllodxxxxxxd +// ....';:ldkO0KXXXKK00Okxdolcc:;;;;;::cclllcc:;;,''..... ....',;clooddolcc:;;;;,,;;;;;::::;;;;;;:cloxk0KXNWWWWWWNXKK0Okxddoooddxxkkkkkxx +// .....';:ldxkOOOOOkxxdolcc:;;;,,,;;:cllooooolcc:;'... ..,:codxkkkxddooollloooooooollcc:::::clodkO0KXNWWWWWWNNXK00Okxxxxxxxxkkkkxxx +// . ....';:cloddddo___________,,,,;;:clooddddoolc:,... ..,:ldx__00OOOkkk___kkkkkkxxdollc::::cclodkO0KXXNNNNNNXXK0OOkxxxxxxxxxxxxddd +// .......',;:cccc:| |,,,;;:cclooddddoll:;'.. ..';cox| \KKK000| |KK00OOkxdocc___;::clldxxkO0KKKKK00Okkxdddddddddddddddoo +// .......'',,,,,''| ________|',,;;::cclloooooolc:;'......___:ldk| \KK000| |XKKK0Okxolc| |;;::cclodxxkkkkxxdoolllcclllooodddooooo +// ''......''''....| | ....'',,,,;;;::cclloooollc:;,''.'| |oxk| \OOO0| |KKK00Oxdoll|___|;;;;;::ccllllllcc::;;,,;;;:cclloooooooo +// ;;,''.......... | |_____',,;;;____:___cllo________.___| |___| \xkk| |KK_______ool___:::;________;;;_______...'',;;:ccclllloo +// c:;,''......... | |:::/ ' |lo/ | | \dx| |0/ \d| |cc/ |'/ \......',,;;:ccllo +// ol:;,'..........| _____|ll/ __ |o/ ______|____ ___| | \o| |/ ___ \| |o/ ______|/ ___ \ .......'',;:clo +// dlc;,...........| |::clooo| / | |x\___ \KXKKK0| |dol| |\ \| | | | | |d\___ \..| | / / ....',:cl +// xoc;'... .....'| |llodddd| \__| |_____\ \KKK0O| |lc:| |'\ | |___| | |_____\ \.| |_/___/... ...',;:c +// dlc;'... ....',;| |oddddddo\ | |Okkx| |::;| |..\ |\ /| | | \ |... ....',;:c +// ol:,'.......',:c|___|xxxddollc\_____,___|_________/ddoll|___|,,,|___|...\_____|:\ ______/l|___|_________/...\________|'........',;::cc +// c:;'.......';:codxxkkkkxxolc::;::clodxkOO0OOkkxdollc::;;,,''''',,,,''''''''''',,'''''',;:loxkkOOkxol:;,'''',,;:ccllcc:;,'''''',;::ccll +// ;,'.......',:codxkOO0OOkxdlc:;,,;;:cldxxkkxxdolc:;;,,''.....'',;;:::;;,,,'''''........,;cldkO0KK0Okdoc::;;::cloodddoolc:;;;;;::ccllooo +// .........',;:lodxOO0000Okdoc:,,',,;:clloddoolc:;,''.......'',;:clooollc:;;,,''.......',:ldkOKXNNXX0Oxdolllloddxxxxxxdolccccccllooodddd +// . .....';:cldxkO0000Okxol:;,''',,;::cccc:;,,'.......'',;:cldxxkkxxdolc:;;,'.......';coxOKXNWWWNXKOkxddddxxkkkkkkxdoollllooddxxxxkkk +// ....',;:codxkO000OOxdoc:;,''',,,;;;;,''.......',,;:clodkO00000Okxolc::;,,''..',;:ldxOKXNWWWNNK0OkkkkkkkkkkkxxddooooodxxkOOOOO000 +// ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX +// +// VERSION: 1.0.1 +// https://github.com/Auburn/FastNoiseLite + +package fastnoise + +import ( + "math" +) + +// Float represents a floating-point number type. +type Float interface { + float32 | float64 +} + +// Enum types +type ( + // NoiseType describes a noise algorithm. + NoiseType int + // RotationType3D describes a rotation method to apply to 3D noise. + RotationType3D int + // FractalType describes the fractal method for fractal noise types. + FractalType int + // CellularDistanceFunc describes the method for cellular distance functions. + CellularDistanceFunc int + // CellularReturnType describes the return type for cellular distance noise. + CellularReturnType int + // DomainWarpType describes the method used for domain warps. + DomainWarpType int +) + +const ( + OpenSimplex2 NoiseType = iota + OpenSimplex2S + Cellular + Perlin + ValueCubic + Value + TypeCount // The number of noise types +) + +const ( + RotationNone RotationType3D = iota + RotationImproveXYPlanes + RotationImproveXZPlanes +) + +const ( + FractalNone FractalType = iota + FractalFBm + FractalRidged + FractalPingPong + FractalDomainWarpProgressive + FractalDomainWarpIndependent +) + +const ( + CellularDistanceEuclidean CellularDistanceFunc = iota + CellularDistanceEuclideanSq + CellularDistanceManhattan + CellularDistanceHybrid +) + +const ( + CellularReturnCellValue CellularReturnType = iota + CellularReturnDistance + CellularReturnDistance2 + CellularReturnDistance2Add + CellularReturnDistance2Sub + CellularReturnDistance2Mul + CellularReturnDistance2Div +) + +const ( + DomainWarpOpenSimplex2 DomainWarpType = iota + DomainWarpOpenSimplex2Reduced + DomainWarpBasicGrid +) + +type ( + // noise2DFunc is a prototype for a function that generates 2D noise. + noise2DFunc[T Float] func(state *State[T], seed int, x, y T) T + // noise3DFunc is a prototype for a function that generates 3D noise. + noise3DFunc[T Float] func(state *State[T], seed int, x, y, z T) T +) + +// State contains the configuration for generating a noise. This should only be created +// with NewState, as it will initialize with sane defaults, including any private members. +// +// May be used to generate either float32 or float64 values. +type State[T Float] struct { + // Seed for all noise types. + // + // Default: 1337 + Seed int + // Frequency for all noise types. + // + // Default: 0.01 + Frequency T + // noiseType specifies the algorithm that will be used with GetNoise2D and GetNoise3D. + // + // Default: OpenSimplex2 + noiseType NoiseType + // RotationType3D specified the type of rotation applied to 3D noise. + // + // Default: RotationNone + RotationType3D RotationType3D + // fractalType specifies the method used for combining octaves for all fractal noise types. + // Only effects DomainWarp2D and DomainWarp3D functions. + // + // Default: FractalNone + fractalType FractalType + // Octaves is the number of octaves used for all fractal noise types. + // + // Default: 3 + Octaves int + // Lacunarity is the octave Lacunarity for all fractal noise types. + // + // Default: 2.0 + Lacunarity T + // Gain is the octave gain for all fractal noise types. + // + // Default: 0.5 + Gain T + // WeightedStrength is the octave weighting for all non-domain warp fractal types. + // + // Default: 0.0 + WeightedStrength T + // PingPongStrength is the strength of the fractal ping pong effect. + // + // Default: 2.0 + PingPongStrength T + // CellularDistanceFunc specifies the distance function used in cellular noise calculations. + // + // Default: CellularDistanceEuclideanSq, + CellularDistanceFunc CellularDistanceFunc + // CellularReturnType specifies the cellular return type from cellular noise calculations. + // + // Default: CellularReturnDistance, + CellularReturnType CellularReturnType + // CellularJitterMod is the maximum distance a cellular point can move from it's grid position. + // Setting this higher than 1 will cause artifacts. + // + // Default: 1.0 + CellularJitterMod T + // DomainWarpType specifies the algorithm when using DomainWarp2D or DomainWarp3D. + // + // Default: DomainWarpOpenSimplex2 + DomainWarpType DomainWarpType + // DomainWarpAmp is the maximum warp distance from original position when using DomainWarp2D + // or DomainWarp3D. + // + // Default: 1.0 + DomainWarpAmp T + // noise2D contains the function used to generate 2D noise based on the state settings. + noise2D noise2DFunc[T] + // noise3D contains the function used to generate 3D noise based on the state settings. + noise3D noise3DFunc[T] +} + +// Constants + +var gradients2D = []float32{ + 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, + -0.130526192220052, -0.99144486137381, -0.38268343236509, -0.923879532511287, -0.608761429008721, -0.793353340291235, -0.793353340291235, -0.608761429008721, + -0.923879532511287, -0.38268343236509, -0.99144486137381, -0.130526192220052, -0.99144486137381, 0.130526192220051, -0.923879532511287, 0.38268343236509, + -0.793353340291235, 0.608761429008721, -0.608761429008721, 0.793353340291235, -0.38268343236509, 0.923879532511287, -0.130526192220052, 0.99144486137381, + 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, + -0.130526192220052, -0.99144486137381, -0.38268343236509, -0.923879532511287, -0.608761429008721, -0.793353340291235, -0.793353340291235, -0.608761429008721, + -0.923879532511287, -0.38268343236509, -0.99144486137381, -0.130526192220052, -0.99144486137381, 0.130526192220051, -0.923879532511287, 0.38268343236509, + -0.793353340291235, 0.608761429008721, -0.608761429008721, 0.793353340291235, -0.38268343236509, 0.923879532511287, -0.130526192220052, 0.99144486137381, + 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, + -0.130526192220052, -0.99144486137381, -0.38268343236509, -0.923879532511287, -0.608761429008721, -0.793353340291235, -0.793353340291235, -0.608761429008721, + -0.923879532511287, -0.38268343236509, -0.99144486137381, -0.130526192220052, -0.99144486137381, 0.130526192220051, -0.923879532511287, 0.38268343236509, + -0.793353340291235, 0.608761429008721, -0.608761429008721, 0.793353340291235, -0.38268343236509, 0.923879532511287, -0.130526192220052, 0.99144486137381, + 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, + -0.130526192220052, -0.99144486137381, -0.38268343236509, -0.923879532511287, -0.608761429008721, -0.793353340291235, -0.793353340291235, -0.608761429008721, + -0.923879532511287, -0.38268343236509, -0.99144486137381, -0.130526192220052, -0.99144486137381, 0.130526192220051, -0.923879532511287, 0.38268343236509, + -0.793353340291235, 0.608761429008721, -0.608761429008721, 0.793353340291235, -0.38268343236509, 0.923879532511287, -0.130526192220052, 0.99144486137381, + 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, + -0.130526192220052, -0.99144486137381, -0.38268343236509, -0.923879532511287, -0.608761429008721, -0.793353340291235, -0.793353340291235, -0.608761429008721, + -0.923879532511287, -0.38268343236509, -0.99144486137381, -0.130526192220052, -0.99144486137381, 0.130526192220051, -0.923879532511287, 0.38268343236509, + -0.793353340291235, 0.608761429008721, -0.608761429008721, 0.793353340291235, -0.38268343236509, 0.923879532511287, -0.130526192220052, 0.99144486137381, + 0.38268343236509, 0.923879532511287, 0.923879532511287, 0.38268343236509, 0.923879532511287, -0.38268343236509, 0.38268343236509, -0.923879532511287, + -0.38268343236509, -0.923879532511287, -0.923879532511287, -0.38268343236509, -0.923879532511287, 0.38268343236509, -0.38268343236509, 0.923879532511287, +} + +var randVecs2D = []float32{ + -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, + -0.9951650832, 0.0982163789, 0.7724397808, -0.6350880136, + 0.7573283322, -0.6530343002, -0.9928004525, -0.119780055, + -0.0532665713, 0.9985803285, 0.9754253726, -0.2203300762, + -0.7665018163, 0.6422421394, 0.991636706, 0.1290606184, + -0.994696838, 0.1028503788, -0.5379205513, -0.84299554, + 0.5022815471, -0.8647041387, 0.4559821461, -0.8899889226, + -0.8659131224, -0.5001944266, 0.0879458407, -0.9961252577, + -0.5051684983, 0.8630207346, 0.7753185226, -0.6315704146, + -0.6921944612, 0.7217110418, -0.5191659449, -0.8546734591, + 0.8978622882, -0.4402764035, -0.1706774107, 0.9853269617, + -0.9353430106, -0.3537420705, -0.9992404798, 0.03896746794, + -0.2882064021, -0.9575683108, -0.9663811329, 0.2571137995, + -0.8759714238, -0.4823630009, -0.8303123018, -0.5572983775, + 0.05110133755, -0.9986934731, -0.8558373281, -0.5172450752, + 0.09887025282, 0.9951003332, 0.9189016087, 0.3944867976, + -0.2439375892, -0.9697909324, -0.8121409387, -0.5834613061, + -0.9910431363, 0.1335421355, 0.8492423985, -0.5280031709, + -0.9717838994, -0.2358729591, 0.9949457207, 0.1004142068, + 0.6241065508, -0.7813392434, 0.662910307, 0.7486988212, + -0.7197418176, 0.6942418282, -0.8143370775, -0.5803922158, + 0.104521054, -0.9945226741, -0.1065926113, -0.9943027784, + 0.445799684, -0.8951327509, 0.105547406, 0.9944142724, + -0.992790267, 0.1198644477, -0.8334366408, 0.552615025, + 0.9115561563, -0.4111755999, 0.8285544909, -0.5599084351, + 0.7217097654, -0.6921957921, 0.4940492677, -0.8694339084, + -0.3652321272, -0.9309164803, -0.9696606758, 0.2444548501, + 0.08925509731, -0.996008799, 0.5354071276, -0.8445941083, + -0.1053576186, 0.9944343981, -0.9890284586, 0.1477251101, + 0.004856104961, 0.9999882091, 0.9885598478, 0.1508291331, + 0.9286129562, -0.3710498316, -0.5832393863, -0.8123003252, + 0.3015207509, 0.9534596146, -0.9575110528, 0.2883965738, + 0.9715802154, -0.2367105511, 0.229981792, 0.9731949318, + 0.955763816, -0.2941352207, 0.740956116, 0.6715534485, + -0.9971513787, -0.07542630764, 0.6905710663, -0.7232645452, + -0.290713703, -0.9568100872, 0.5912777791, -0.8064679708, + -0.9454592212, -0.325740481, 0.6664455681, 0.74555369, + 0.6236134912, 0.7817328275, 0.9126993851, -0.4086316587, + -0.8191762011, 0.5735419353, -0.8812745759, -0.4726046147, + 0.9953313627, 0.09651672651, 0.9855650846, -0.1692969699, + -0.8495980887, 0.5274306472, 0.6174853946, -0.7865823463, + 0.8508156371, 0.52546432, 0.9985032451, -0.05469249926, + 0.1971371563, -0.9803759185, 0.6607855748, -0.7505747292, + -0.03097494063, 0.9995201614, -0.6731660801, 0.739491331, + -0.7195018362, -0.6944905383, 0.9727511689, 0.2318515979, + 0.9997059088, -0.0242506907, 0.4421787429, -0.8969269532, + 0.9981350961, -0.061043673, -0.9173660799, -0.3980445648, + -0.8150056635, -0.5794529907, -0.8789331304, 0.4769450202, + 0.0158605829, 0.999874213, -0.8095464474, 0.5870558317, + -0.9165898907, -0.3998286786, -0.8023542565, 0.5968480938, + -0.5176737917, 0.8555780767, -0.8154407307, -0.5788405779, + 0.4022010347, -0.9155513791, -0.9052556868, -0.4248672045, + 0.7317445619, 0.6815789728, -0.5647632201, -0.8252529947, + -0.8403276335, -0.5420788397, -0.9314281527, 0.363925262, + 0.5238198472, 0.8518290719, 0.7432803869, -0.6689800195, + -0.985371561, -0.1704197369, 0.4601468731, 0.88784281, + 0.825855404, 0.5638819483, 0.6182366099, 0.7859920446, + 0.8331502863, -0.553046653, 0.1500307506, 0.9886813308, + -0.662330369, -0.7492119075, -0.668598664, 0.743623444, + 0.7025606278, 0.7116238924, -0.5419389763, -0.8404178401, + -0.3388616456, 0.9408362159, 0.8331530315, 0.5530425174, + -0.2989720662, -0.9542618632, 0.2638522993, 0.9645630949, + 0.124108739, -0.9922686234, -0.7282649308, -0.6852956957, + 0.6962500149, 0.7177993569, -0.9183535368, 0.3957610156, + -0.6326102274, -0.7744703352, -0.9331891859, -0.359385508, + -0.1153779357, -0.9933216659, 0.9514974788, -0.3076565421, + -0.08987977445, -0.9959526224, 0.6678496916, 0.7442961705, + 0.7952400393, -0.6062947138, -0.6462007402, -0.7631674805, + -0.2733598753, 0.9619118351, 0.9669590226, -0.254931851, + -0.9792894595, 0.2024651934, -0.5369502995, -0.8436138784, + -0.270036471, -0.9628500944, -0.6400277131, 0.7683518247, + -0.7854537493, -0.6189203566, 0.06005905383, -0.9981948257, + -0.02455770378, 0.9996984141, -0.65983623, 0.751409442, + -0.6253894466, -0.7803127835, -0.6210408851, -0.7837781695, + 0.8348888491, 0.5504185768, -0.1592275245, 0.9872419133, + 0.8367622488, 0.5475663786, -0.8675753916, -0.4973056806, + -0.2022662628, -0.9793305667, 0.9399189937, 0.3413975472, + 0.9877404807, -0.1561049093, -0.9034455656, 0.4287028224, + 0.1269804218, -0.9919052235, -0.3819600854, 0.924178821, + 0.9754625894, 0.2201652486, -0.3204015856, -0.9472818081, + -0.9874760884, 0.1577687387, 0.02535348474, -0.9996785487, + 0.4835130794, -0.8753371362, -0.2850799925, -0.9585037287, + -0.06805516006, -0.99768156, -0.7885244045, -0.6150034663, + 0.3185392127, -0.9479096845, 0.8880043089, 0.4598351306, + 0.6476921488, -0.7619021462, 0.9820241299, 0.1887554194, + 0.9357275128, -0.3527237187, -0.8894895414, 0.4569555293, + 0.7922791302, 0.6101588153, 0.7483818261, 0.6632681526, + -0.7288929755, -0.6846276581, 0.8729032783, -0.4878932944, + 0.8288345784, 0.5594937369, 0.08074567077, 0.9967347374, + 0.9799148216, -0.1994165048, -0.580730673, -0.8140957471, + -0.4700049791, -0.8826637636, 0.2409492979, 0.9705377045, + 0.9437816757, -0.3305694308, -0.8927998638, -0.4504535528, + -0.8069622304, 0.5906030467, 0.06258973166, 0.9980393407, + -0.9312597469, 0.3643559849, 0.5777449785, 0.8162173362, + -0.3360095855, -0.941858566, 0.697932075, -0.7161639607, + -0.002008157227, -0.9999979837, -0.1827294312, -0.9831632392, + -0.6523911722, 0.7578824173, -0.4302626911, -0.9027037258, + -0.9985126289, -0.05452091251, -0.01028102172, -0.9999471489, + -0.4946071129, 0.8691166802, -0.2999350194, 0.9539596344, + 0.8165471961, 0.5772786819, 0.2697460475, 0.962931498, + -0.7306287391, -0.6827749597, -0.7590952064, -0.6509796216, + -0.907053853, 0.4210146171, -0.5104861064, -0.8598860013, + 0.8613350597, 0.5080373165, 0.5007881595, -0.8655698812, + -0.654158152, 0.7563577938, -0.8382755311, -0.545246856, + 0.6940070834, 0.7199681717, 0.06950936031, 0.9975812994, + 0.1702942185, -0.9853932612, 0.2695973274, 0.9629731466, + 0.5519612192, -0.8338697815, 0.225657487, -0.9742067022, + 0.4215262855, -0.9068161835, 0.4881873305, -0.8727388672, + -0.3683854996, -0.9296731273, -0.9825390578, 0.1860564427, + 0.81256471, 0.5828709909, 0.3196460933, -0.9475370046, + 0.9570913859, 0.2897862643, -0.6876655497, -0.7260276109, + -0.9988770922, -0.047376731, -0.1250179027, 0.992154486, + -0.8280133617, 0.560708367, 0.9324863769, -0.3612051451, + 0.6394653183, 0.7688199442, -0.01623847064, -0.9998681473, + -0.9955014666, -0.09474613458, -0.81453315, 0.580117012, + 0.4037327978, -0.9148769469, 0.9944263371, 0.1054336766, + -0.1624711654, 0.9867132919, -0.9949487814, -0.100383875, + -0.6995302564, 0.7146029809, 0.5263414922, -0.85027327, + -0.5395221479, 0.841971408, 0.6579370318, 0.7530729462, + 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, +} + +var gradients3D = []float32{ + 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, +} + +var randVecs3D = []float32{ + -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, +} + +// ==================== +// Public API +// ==================== + +// New initializes a new noise generator state with default values. This function must be used +// to create new states. +func New[T Float]() *State[T] { + state := &State[T]{ + Seed: 1337, + Frequency: 0.01, + noiseType: OpenSimplex2, + RotationType3D: RotationNone, + fractalType: FractalNone, + Octaves: 3, + Lacunarity: 2.0, + Gain: 0.5, + WeightedStrength: 0.0, + PingPongStrength: 2.0, + CellularDistanceFunc: CellularDistanceEuclideanSq, + CellularReturnType: CellularReturnDistance, + CellularJitterMod: 1.0, + DomainWarpAmp: 30.0, + DomainWarpType: DomainWarpOpenSimplex2, + } + state.apply() + return state +} + +// apply determines the function to use for generating noise, and caches it to reduce overhead +// each time it GetNoise2D or GetNoise3D is invoked. +func (state *State[T]) apply() { + switch state.fractalType { + case FractalFBm: + state.noise2D = genFractalFBM2D + state.noise3D = genFractalFBM3D + case FractalRidged: + state.noise2D = genFractalRidged2D + state.noise3D = genFractalRidged3D + case FractalPingPong: + state.noise2D = genFractalPingPong2D + state.noise3D = genFractalPingPong3D + default: + switch state.noiseType { + case OpenSimplex2: + state.noise2D = singleSimplex2D + state.noise3D = singleOpenSimplex23D + case OpenSimplex2S: + state.noise2D = singleOpenSimplex2S2D + state.noise3D = singleOpenSimplex2S3D + case Cellular: + state.noise2D = singleCellular2D + state.noise3D = singleCellular3D + case Perlin: + state.noise2D = singlePerlin2D + state.noise3D = singlePerlin3D + case ValueCubic: + state.noise2D = singleValueCubic2D + state.noise3D = singleValueCubic3D + case Value: + state.noise2D = singleValue2D + state.noise3D = singleValue3D + default: + state.noise2D = func(_ *State[T], _ int, _, _ T) T { return 0 } + state.noise3D = func(_ *State[T], _ int, _, _, _ T) T { return 0 } + } + } +} + +// NoiseType specifies the algorithm that will be used with GetNoise2D and GetNoise3D. +// +// Default: OpenSimplex2 +func (state *State[T]) NoiseType(nt NoiseType) { + state.noiseType = nt + state.apply() +} + +// FractalType specifies the method used for combining octaves for all fractal noise types. +// Only effects DomainWarp2D and DomainWarp3D functions. +// +// Default: FractalNone +func (state *State[T]) FractalType(ft FractalType) { + state.fractalType = ft + state.apply() +} + +// GetNoise2D calculates the noise value at the specified 2D position using the current state +// settings. +// +// This is a convenience function for GetNoise2D that accepts integral coordinates. +// Return values are always normalized and in the range of -1.0 and 1.0. +func (state *State[T]) Noise2D(x, y int) T { + fx, fy := state.transformNoiseCoordinate2D(T(x), T(y)) + return state.noise2D(state, state.Seed, fx, fy) +} + +// GetNoise3D calculates the noise value at the specified 3D position using the current state +// settings. +// +// This is a convenience function for GetNoise3D that accepts integral coordinates. +// Return values are always normalized and in the range of -1.0 and 1.0. +func (state *State[T]) Noise3D(x, y, z int) T { + fx, fy, fz := state.transformNoiseCoordinate3D(T(x), T(y), T(z)) + return state.noise3D(state, state.Seed, fx, fy, fz) +} + +// GetNoise2D calculates the noise value at the specified 2D position using the current state +// settings. +// +// Return values are always normalized and in the range of -1.0 and 1.0. +func (state *State[T]) GetNoise2D(x, y T) T { + x, y = state.transformNoiseCoordinate2D(x, y) + return state.noise2D(state, state.Seed, x, y) +} + +// GetNoise3D calculates the noise value at the specified 3D position using the current state +// settings. +// +// Return values are always normalized and in the range of -1.0 and 1.0. +func (state *State[T]) GetNoise3D(x, y, z T) T { + x, y, z = state.transformNoiseCoordinate3D(x, y, z) + return state.noise3D(state, state.Seed, x, y, z) +} + +// DomainWarp2D warps the input position using current domain warp settings. +func (state *State[T]) DomainWarp2D(x, y T) (T, T) { + xx := x + yy := y + switch state.fractalType { + default: + domainWarpSingle2D(state, &xx, &yy) + case FractalDomainWarpProgressive: + domainWarpFractalProgressive2D(state, &xx, &yy) + case FractalDomainWarpIndependent: + domainWarpFractalIndependent2D(state, &xx, &yy) + } + return xx, yy +} + +// DomainWarp2D warps the input position using current domain warp settings. +func (state *State[T]) DomainWarp3D(x, y, z T) (T, T, T) { + xx := x + yy := y + zz := z + switch state.fractalType { + default: + domainWarpSingle3D(state, &xx, &yy, &zz) + case FractalDomainWarpProgressive: + domainWarpFractalProgressive3D(state, &xx, &yy, &zz) + case FractalDomainWarpIndependent: + domainWarpFractalIndependent3D(state, &xx, &yy, &zz) + } + return xx, yy, zz +} + +// ==================== +// Private/implemenation +// ==================== + +// Utilities + +func fastMin[T Float](x, y T) T { + if x < y { + return x + } + return y +} + +func fastMax[T Float](x, y T) T { + if x > y { + return x + } + return y +} + +func fastAbs[T Float](f T) T { + if f < 0 { + return -f + } + return f +} + +func fastSqrt[T Float](a T) T { + // Benchmarks using Quake's famous "inverse square root" were actually slightly slower than + // using the built-in math library. + return T(math.Sqrt(float64(a))) +} + +func fastFloor[T Float](f T) int { + if f >= 0 { + return int(f) + } + return int(f) - 1 +} + +func fastRound[T Float](f T) int { + if f >= 0 { + return int(f + 0.5) + } + return int(f - 0.5) +} + +func lerp[T Float](a, b, t T) T { + return a + t*(b-a) +} + +func interpHermite[T Float](t T) T { + return t * t * (3 - 2*t) +} + +func interpQuintic[T Float](t T) T { + return t * t * t * (t*(t*6-15) + 10) +} + +func cubicLerp[T Float](a, b, c, d, t T) T { + var p T = (d - c) - (a - b) + return t*t*t*p + t*t*((a-b)-p) + t*(c-a) + b +} + +func pingPong[T Float](t T) T { + t -= T(int(t*0.5)) * 2 + if t < 1 { + return t + } + return 2 - t +} + +func calculateFractalBounding[T Float](state *State[T]) T { + gain := fastAbs(state.Gain) + amp := gain + var ampFractal T = 1.0 + for i := 1; i < state.Octaves; i++ { + ampFractal += amp + amp *= gain + } + return 1.0 / ampFractal +} + +// Hashing + +const ( + primeX int = 501125321 + primeY int = 1136930381 + primeZ int = 1720413743 + + primeX2 = primeX << 1 + primeY2 = -2021106534 + primeZ2 = -854139810 +) + +func hash2D(seed, xPrimed, yPrimed int) uint32 { + hash := seed ^ xPrimed ^ yPrimed + return uint32(hash) * 0x27d4eb2d +} + +func hash3D(seed, xPrimed, yPrimed, zPrimed int) uint32 { + hash := seed ^ xPrimed ^ yPrimed ^ zPrimed + return uint32(hash) * 0x27d4eb2d +} + +func valCoord2D[T Float](seed, xPrimed, yPrimed int) T { + hash := hash2D(seed, xPrimed, yPrimed) + hash *= hash + hash ^= hash << 19 + return T(int32(hash)) * (1 / 2147483648.0) +} + +func valCoord3D[T Float](seed, xPrimed, yPrimed, zPrimed int) T { + hash := hash3D(seed, xPrimed, yPrimed, zPrimed) + hash *= hash + hash ^= hash << 19 + return T(int32(hash)) * (1 / 2147483648.0) +} + +func gradCoord2D[T Float](seed, xPrimed, yPrimed int, xd, yd T) T { + hash := hash2D(seed, xPrimed, yPrimed) + hash ^= hash >> 15 + hash &= 127 << 1 + return xd*T(gradients2D[hash]) + yd*T(gradients2D[hash|1]) +} + +func gradCoord3D[T Float](seed, xPrimed, yPrimed, zPrimed int, xd, yd, zd T) T { + hash := hash3D(seed, xPrimed, yPrimed, zPrimed) + hash ^= hash >> 15 + hash &= 63 << 2 + return xd*T(gradients3D[hash]) + yd*T(gradients3D[hash|1]) + zd*T(gradients3D[hash|2]) +} + +func gradCoordOut2D[T Float](seed, xPrimed, yPrimed int, xo, yo *T) { + hash := hash2D(seed, xPrimed, yPrimed) & (255 << 1) + *xo = T(randVecs2D[hash]) + *yo = T(randVecs2D[hash|1]) +} + +func gradCoordOut3D[T Float](seed, xPrimed, yPrimed, zPrimed int, xo, yo, zo *T) { + hash := hash3D(seed, xPrimed, yPrimed, zPrimed) & (255 << 2) + *xo = T(randVecs3D[hash]) + *yo = T(randVecs3D[hash|1]) + *zo = T(randVecs3D[hash|2]) +} + +func gradCoordDual2D[T Float](seed, xPrimed, yPrimed int, xd, yd T, xo, yo *T) { + hash := hash2D(seed, xPrimed, yPrimed) + index1 := hash & (127 << 1) + index2 := (hash >> 7) & (255 << 1) + + xg := T(gradients2D[index1]) + yg := T(gradients2D[index1|1]) + value := xd*xg + yd*yg + + xgo := T(randVecs2D[index2]) + ygo := T(randVecs2D[index2|1]) + + *xo = value * xgo + *yo = value * ygo +} + +func gradCoordDual3D[T Float](seed, xPrimed, yPrimed, zPrimed int, xd, yd, zd T, xo, yo, zo *T) { + hash := hash3D(seed, xPrimed, yPrimed, zPrimed) + index1 := hash & (63 << 2) + index2 := (hash >> 6) & (255 << 2) + + xg := T(gradients3D[index1]) + yg := T(gradients3D[index1|1]) + zg := T(gradients3D[index1|2]) + value := xd*xg + yd*yg + zd*zg + + xgo := T(randVecs3D[index2]) + ygo := T(randVecs3D[index2|1]) + zgo := T(randVecs3D[index2|2]) + + *xo = value * xgo + *yo = value * ygo + *zo = value * zgo +} + +func genNoiseSingle2D[T Float](state *State[T], seed int, x, y T) T { + switch state.noiseType { + case OpenSimplex2: + return singleSimplex2D(state, seed, x, y) + case OpenSimplex2S: + return singleOpenSimplex2S2D(state, seed, x, y) + case Cellular: + return singleCellular2D(state, seed, x, y) + case Perlin: + return singlePerlin2D(state, seed, x, y) + case ValueCubic: + return singleValueCubic2D(state, seed, x, y) + case Value: + return singleValue2D(state, seed, x, y) + default: + return 0 + } +} + +func genNoiseSingle3D[T Float](state *State[T], seed int, x, y, z T) T { + switch state.noiseType { + case OpenSimplex2: + return singleOpenSimplex23D(state, seed, x, y, z) + case OpenSimplex2S: + return singleOpenSimplex2S3D(state, seed, x, y, z) + case Cellular: + return singleCellular3D(state, seed, x, y, z) + case Perlin: + return singlePerlin3D(state, seed, x, y, z) + case ValueCubic: + return singleValueCubic3D(state, seed, x, y, z) + case Value: + return singleValue3D(state, seed, x, y, z) + default: + return 0 + } +} + +// Noise Coordinate Transforms (frequency, and possible skew or rotation) + +func (state *State[T]) transformNoiseCoordinate2D(x, y T) (T, T) { + tx := x * state.Frequency + ty := y * state.Frequency + + switch state.noiseType { + case OpenSimplex2, OpenSimplex2S: + const SQRT3 float64 = 1.7320508075688772935274463415059 + const F2 float64 = 0.5 * (SQRT3 - 1) + t := (tx + ty) * T(F2) + tx += t + ty += t + } + return tx, ty +} + +func (state *State[T]) transformNoiseCoordinate3D(x, y, z T) (T, T, T) { + tx := x * state.Frequency + ty := y * state.Frequency + tz := z * state.Frequency + + switch state.RotationType3D { + case RotationImproveXYPlanes: + xy := tx + ty + s2 := xy * -0.211324865405187 + tz *= 0.577350269189626 + tx += s2 - tz + ty = ty + s2 - tz + tz += xy * 0.577350269189626 + case RotationImproveXZPlanes: + xz := tx + tz + s2 := xz * -0.211324865405187 + ty *= 0.577350269189626 + tx += s2 - ty + tz += s2 - ty + ty += xz * 0.577350269189626 + default: + switch state.noiseType { + case OpenSimplex2, OpenSimplex2S: + const R3 float64 = 2.0 / 3.0 + r := (tx + ty + tz) * T(R3) // Rotation, not skew + tx = r - tx + ty = r - ty + tz = r - tz + } + } + return tx, ty, tz +} + +// Domain Warp Coordinate Transforms + +func transformDomainWarpCoordinate2D[T Float](state *State[T], x, y *T) { + switch state.DomainWarpType { + case DomainWarpOpenSimplex2, DomainWarpOpenSimplex2Reduced: + const SQRT3 float64 = 1.7320508075688772935274463415059 + const F2 float64 = 0.5 * (SQRT3 - 1) + t := (*x + *y) * T(F2) + *x += t + *y += t + } +} + +func transformDomainWarpCoordinate3D[T Float](state *State[T], x, y, z *T) { + switch state.RotationType3D { + case RotationImproveXYPlanes: + xy := *x + *y + s2 := xy * -0.211324865405187 + *z *= 0.577350269189626 + *x += s2 - *z + *y = *y + s2 - *z + *z += xy * 0.577350269189626 + case RotationImproveXZPlanes: + xz := *x + *z + s2 := xz * -0.211324865405187 + *y *= 0.577350269189626 + *x += s2 - *y + *z += s2 - *y + *y += xz * 0.577350269189626 + default: + switch state.DomainWarpType { + case DomainWarpOpenSimplex2, DomainWarpOpenSimplex2Reduced: + const R3 float64 = 2.0 / 3.0 + r := (*x + *y + *z) * T(R3) // Rotation, not skew + *x = r - *x + *y = r - *y + *z = r - *z + } + } +} + +// Fractal FBm +func genFractalFBM2D[T Float](state *State[T], seed int, x, y T) (sum T) { + amp := calculateFractalBounding(state) + + for i := 0; i < state.Octaves; i++ { + noise := genNoiseSingle2D(state, seed, x, y) + seed++ + sum += noise * amp + amp *= lerp(1.0, fastMin(noise+1, 2)*0.5, state.WeightedStrength) + + x *= state.Lacunarity + y *= state.Lacunarity + amp *= state.Gain + } + + return +} + +func genFractalFBM3D[T Float](state *State[T], seed int, x, y, z T) (sum T) { + amp := calculateFractalBounding(state) + + for i := 0; i < state.Octaves; i++ { + noise := genNoiseSingle3D(state, seed, x, y, z) + seed++ + sum += noise * amp + amp *= lerp(1.0, (noise+1)*0.5, state.WeightedStrength) + + x *= state.Lacunarity + y *= state.Lacunarity + z *= state.Lacunarity + amp *= state.Gain + } + + return +} + +// Fractal Ridged + +func genFractalRidged2D[T Float](state *State[T], seed int, x, y T) (sum T) { + amp := calculateFractalBounding(state) + + for i := 0; i < state.Octaves; i++ { + noise := fastAbs(genNoiseSingle2D(state, seed, x, y)) + seed++ + sum += (noise*-2 + 1) * amp + amp *= lerp(1.0, 1-noise, state.WeightedStrength) + + x *= state.Lacunarity + y *= state.Lacunarity + amp *= state.Gain + } + + return +} + +func genFractalRidged3D[T Float](state *State[T], seed int, x, y, z T) (sum T) { + amp := calculateFractalBounding(state) + + for i := 0; i < state.Octaves; i++ { + noise := fastAbs(genNoiseSingle3D(state, seed, x, y, z)) + seed++ + sum += (noise*-2 + 1) * amp + amp *= lerp(1.0, 1-noise, state.WeightedStrength) + + x *= state.Lacunarity + y *= state.Lacunarity + z *= state.Lacunarity + amp *= state.Gain + } + + return +} + +// Fractal PingPong + +func genFractalPingPong2D[T Float](state *State[T], seed int, x, y T) (sum T) { + amp := calculateFractalBounding(state) + + for i := 0; i < state.Octaves; i++ { + noise := pingPong((genNoiseSingle2D(state, seed, x, y) + 1) * state.PingPongStrength) + seed++ + sum += (noise - 0.5) * 2 * amp + amp *= lerp(1.0, noise, state.WeightedStrength) + + x *= state.Lacunarity + y *= state.Lacunarity + amp *= state.Gain + } + + return +} + +func genFractalPingPong3D[T Float](state *State[T], seed int, x, y, z T) (sum T) { + amp := calculateFractalBounding(state) + + for i := 0; i < state.Octaves; i++ { + noise := pingPong((genNoiseSingle3D(state, seed, x, y, z) + 1) * state.PingPongStrength) + seed++ + sum += (noise - 0.5) * 2 * amp + amp *= lerp(1.0, noise, state.WeightedStrength) + + x *= state.Lacunarity + y *= state.Lacunarity + z *= state.Lacunarity + amp *= state.Gain + } + + return +} + +// Simplex/OpenSimplex2 Noise + +func singleSimplex2D[T Float](state *State[T], seed int, x, y T) T { + // 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex. + + const SQRT3 float64 = 1.7320508075688772935274463415059 + const G2 float64 = (3 - SQRT3) / 6 + + i := fastFloor(x) + j := fastFloor(y) + xi := x - T(i) + yi := y - T(j) + + t := (xi + yi) * T(G2) + x0 := xi - t + y0 := yi - t + + i *= primeX + j *= primeY + + var n0, n1, n2 T + a := 0.5 - x0*x0 - y0*y0 + if a <= 0 { + n0 = 0 + } else { + n0 = (a * a) * (a * a) * gradCoord2D(seed, i, j, x0, y0) + } + + c := T(2*(1-2*G2)*(1/G2-2))*t + (T(-2*(1-2*G2)*(1-2*G2)) + a) + if c <= 0 { + n2 = 0 + } else { + x2 := x0 + (2*T(G2) - 1) + y2 := y0 + (2*T(G2) - 1) + n2 = (c * c) * (c * c) * gradCoord2D(seed, i+primeX, j+primeY, x2, y2) + } + + if y0 > x0 { + x1 := x0 + T(G2) + y1 := y0 + (T(G2) - 1) + b := 0.5 - x1*x1 - y1*y1 + if b <= 0 { + n1 = 0 + } else { + n1 = (b * b) * (b * b) * gradCoord2D(seed, i, j+primeY, x1, y1) + } + } else { + x1 := x0 + (T(G2) - 1) + y1 := y0 + T(G2) + b := 0.5 - x1*x1 - y1*y1 + if b <= 0 { + n1 = 0 + } else { + n1 = (b * b) * (b * b) * gradCoord2D(seed, i+primeX, j, x1, y1) + } + } + + return (n0 + n1 + n2) * 99.83685446303647 +} + +func singleOpenSimplex23D[T Float](state *State[T], seed int, x, y, z T) T { + // 3D OpenSimplex2 case uses two offset rotated cube grids. + + i := fastRound(x) + j := fastRound(y) + k := fastRound(z) + x0 := x - T(i) + y0 := y - T(j) + z0 := z - T(k) + + xNSign := int(-x0-1.0) | 1 + yNSign := int(-y0-1.0) | 1 + zNSign := int(-z0-1.0) | 1 + + ax0 := T(xNSign) * -x0 + ay0 := T(yNSign) * -y0 + az0 := T(zNSign) * -z0 + + i *= primeX + j *= primeY + k *= primeZ + + var value T + a := (0.6 - x0*x0) - (y0*y0 + z0*z0) + + for l := 0; true; l++ { + if a > 0 { + value += (a * a) * (a * a) * gradCoord3D(seed, i, j, k, x0, y0, z0) + } + + b := a + 1 + i1 := i + j1 := j + k1 := k + x1 := x0 + y1 := y0 + z1 := z0 + if ax0 >= ay0 && ax0 >= az0 { + x1 += T(xNSign) + b -= T(xNSign) * 2 * x1 + i1 -= xNSign * primeX + } else if ay0 > ax0 && ay0 >= az0 { + y1 += T(yNSign) + b -= T(yNSign) * 2 * y1 + j1 -= yNSign * primeY + } else { + z1 += T(zNSign) + b -= T(zNSign) * 2 * z1 + k1 -= zNSign * primeZ + } + + if b > 0 { + value += (b * b) * (b * b) * gradCoord3D(seed, i1, j1, k1, x1, y1, z1) + } + + if l == 1 { + break + } + + ax0 := 0.5 - ax0 + ay0 := 0.5 - ay0 + az0 := 0.5 - az0 + + x0 = T(xNSign) * ax0 + y0 = T(yNSign) * ay0 + z0 = T(zNSign) * az0 + + a += (0.75 - 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.69428253173828125 +} + +// OpenSimplex2S Noise + +func singleOpenSimplex2S2D[T Float](state *State[T], seed int, x, y T) T { + // 2D OpenSimplex2S case is a modified 2D simplex noise. + + const SQRT3 float64 = 1.7320508075688772935274463415059 + const G2 float64 = (3 - SQRT3) / 6 + + i := fastFloor(x) + j := fastFloor(y) + xi := x - T(i) + yi := y - T(j) + + i *= primeX + j *= primeY + i1 := i + primeX + j1 := j + primeY + + t := (xi + yi) * T(G2) + x0 := xi - t + y0 := yi - t + + a0 := (2.0 / 3.0) - x0*x0 - y0*y0 + value := (a0 * a0) * (a0 * a0) * gradCoord2D(seed, i, j, x0, y0) + + a1 := T(2*(1-2*G2)*(1/G2-2))*t + (T(-2*(1-2*G2)*(1-2*G2)) + a0) + x1 := x0 - T(1-2*G2) + y1 := y0 - T(1-2*G2) + value += (a1 * a1) * (a1 * a1) * gradCoord2D(seed, i1, j1, x1, y1) + + // Nested conditionals were faster than compact bit logic/arithmetic. + xmyi := xi - yi + if t > T(G2) { + if xi+xmyi > 1 { + x2 := x0 + T(3*G2-2) + y2 := y0 + T(3*G2-1) + a2 := (2.0 / 3.0) - x2*x2 - y2*y2 + if a2 > 0 { + value += (a2 * a2) * (a2 * a2) * gradCoord2D(seed, i+(primeX2), j+primeY, x2, y2) + } + } else { + x2 := x0 + T(G2) + y2 := y0 + T(G2-1) + a2 := (2.0 / 3.0) - x2*x2 - y2*y2 + if a2 > 0 { + value += (a2 * a2) * (a2 * a2) * gradCoord2D(seed, i, j+primeY, x2, y2) + } + } + + if yi-xmyi > 1 { + x3 := x0 + T(3*G2-1) + y3 := y0 + T(3*G2-2) + a3 := (2.0 / 3.0) - x3*x3 - y3*y3 + if a3 > 0 { + value += (a3 * a3) * (a3 * a3) * gradCoord2D(seed, i+primeX, j+(primeY2), x3, y3) + } + } else { + x3 := x0 + T(G2-1) + y3 := y0 + T(G2) + a3 := (2.0 / 3.0) - x3*x3 - y3*y3 + if a3 > 0 { + value += (a3 * a3) * (a3 * a3) * gradCoord2D(seed, i+primeX, j, x3, y3) + } + } + } else { + if xi+xmyi < 0 { + x2 := x0 + T(1-G2) + y2 := y0 - T(G2) + a2 := (2.0 / 3.0) - x2*x2 - y2*y2 + if a2 > 0 { + value += (a2 * a2) * (a2 * a2) * gradCoord2D(seed, i-primeX, j, x2, y2) + } + } else { + x2 := x0 + T(G2-1) + y2 := y0 + T(G2) + a2 := (2.0 / 3.0) - x2*x2 - y2*y2 + if a2 > 0 { + value += (a2 * a2) * (a2 * a2) * gradCoord2D(seed, i+primeX, j, x2, y2) + } + } + + if yi < xmyi { + x2 := x0 - T(G2) + y2 := y0 - T(G2-1) + a2 := (2.0 / 3.0) - x2*x2 - y2*y2 + if a2 > 0 { + value += (a2 * a2) * (a2 * a2) * gradCoord2D(seed, i, j-primeY, x2, y2) + } + } else { + x2 := x0 + T(G2) + y2 := y0 + T(G2-1) + a2 := (2.0 / 3.0) - x2*x2 - y2*y2 + if a2 > 0 { + value += (a2 * a2) * (a2 * a2) * gradCoord2D(seed, i, j+primeY, x2, y2) + } + } + } + + return value * 18.24196194486065 +} + +func singleOpenSimplex2S3D[T Float](state *State[T], seed int, x, y, z T) T { + // 3D OpenSimplex2S case uses two offset rotated cube grids. + + i := fastFloor(x) + j := fastFloor(y) + k := fastFloor(z) + xi := x - T(i) + yi := y - T(j) + zi := z - T(k) + + i *= primeX + j *= primeY + k *= primeZ + + seed2 := seed + 1293373 + + xNMask := int(-0.5 - xi) + yNMask := int(-0.5 - yi) + zNMask := int(-0.5 - zi) + + x0 := xi + T(xNMask) + y0 := yi + T(yNMask) + z0 := zi + T(zNMask) + a0 := 0.75 - x0*x0 - y0*y0 - z0*z0 + value := (a0 * a0) * (a0 * a0) * gradCoord3D(seed, i+(xNMask&primeX), j+(yNMask&primeY), k+(zNMask&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 + value += (a1 * a1) * (a1 * a1) * gradCoord3D(seed2, i+primeX, j+primeY, k+primeZ, x1, y1, z1) + + xAFlipMask0 := T((xNMask|1)<<1) * x1 + yAFlipMask0 := T((yNMask|1)<<1) * y1 + zAFlipMask0 := T((zNMask|1)<<1) * z1 + xAFlipMask1 := T(-2-(xNMask<<2))*x1 - 1.0 + yAFlipMask1 := T(-2-(yNMask<<2))*y1 - 1.0 + zAFlipMask1 := T(-2-(zNMask<<2))*z1 - 1.0 + + skip5 := false + a2 := T(xAFlipMask0) + a0 + if a2 > 0 { + x2 := x0 - T(xNMask|1) + y2 := y0 + z2 := z0 + value += (a2 * a2) * (a2 * a2) * gradCoord3D(seed, i+(^xNMask&primeX), j+(yNMask&primeY), k+(zNMask&primeZ), x2, y2, z2) + } else { + a3 := yAFlipMask0 + zAFlipMask0 + a0 + if a3 > 0 { + x3 := x0 + y3 := y0 - T(yNMask|1) + z3 := z0 - T(zNMask|1) + value += (a3 * a3) * (a3 * a3) * gradCoord3D(seed, i+(xNMask&primeX), j+(^yNMask&primeY), k+(^zNMask&primeZ), x3, y3, z3) + } + + a4 := T(xAFlipMask1) + a1 + if a4 > 0 { + x4 := T(xNMask|1) + x1 + y4 := y1 + z4 := z1 + value += (a4 * a4) * (a4 * a4) * gradCoord3D(seed2, i+(xNMask&(primeX2)), j+primeY, k+primeZ, x4, y4, z4) + skip5 = true + } + } + + skip9 := false + a6 := T(yAFlipMask0) + a0 + if a6 > 0 { + x6 := x0 + y6 := y0 - T(yNMask|1) + z6 := z0 + value += (a6 * a6) * (a6 * a6) * gradCoord3D(seed, i+(xNMask&primeX), j+(^yNMask&primeY), k+(zNMask&primeZ), x6, y6, z6) + } else { + a7 := T(xAFlipMask0+zAFlipMask0) + a0 + if a7 > 0 { + x7 := x0 - T(xNMask|1) + y7 := y0 + z7 := z0 - T(zNMask|1) + value += (a7 * a7) * (a7 * a7) * gradCoord3D(seed, i+(^xNMask&primeX), j+(yNMask&primeY), k+(^zNMask&primeZ), x7, y7, z7) + } + + a8 := T(yAFlipMask1) + a1 + if a8 > 0 { + x8 := x1 + y8 := T(yNMask|1) + y1 + z8 := z1 + value += (a8 * a8) * (a8 * a8) * gradCoord3D(seed2, i+primeX, j+(yNMask&(primeY2)), k+primeZ, x8, y8, z8) + skip9 = true + } + } + + skipD := false + aA := T(zAFlipMask0) + a0 + if aA > 0 { + xA := x0 + yA := y0 + zA := z0 - T(zNMask|1) + value += (aA * aA) * (aA * aA) * gradCoord3D(seed, i+(xNMask&primeX), j+(yNMask&primeY), k+(^zNMask&primeZ), xA, yA, zA) + } else { + aB := T(xAFlipMask0+yAFlipMask0) + a0 + if aB > 0 { + xB := x0 - T(xNMask|1) + yB := y0 - T(yNMask|1) + zB := z0 + value += (aB * aB) * (aB * aB) * gradCoord3D(seed, i+(^xNMask&primeX), j+(^yNMask&primeY), k+(zNMask&primeZ), xB, yB, zB) + } + + aC := T(zAFlipMask1) + a1 + if aC > 0 { + xC := x1 + yC := y1 + zC := T(zNMask|1) + z1 + value += (aC * aC) * (aC * aC) * gradCoord3D(seed2, i+primeX, j+primeY, k+(zNMask&(primeZ2)), xC, yC, zC) + skipD = true + } + } + + if !skip5 { + a5 := T(yAFlipMask1+zAFlipMask1) + a1 + if a5 > 0 { + x5 := x1 + y5 := T(yNMask|1) + y1 + z5 := T(zNMask|1) + z1 + value += (a5 * a5) * (a5 * a5) * gradCoord3D(seed2, i+primeX, j+(yNMask&(primeY2)), k+(zNMask&(primeZ2)), x5, y5, z5) + } + } + + if !skip9 { + a9 := T(xAFlipMask1+zAFlipMask1) + a1 + if a9 > 0 { + x9 := T(xNMask|1) + x1 + y9 := y1 + z9 := T(zNMask|1) + z1 + value += (a9 * a9) * (a9 * a9) * gradCoord3D(seed2, i+(xNMask&(primeX2)), j+primeY, k+(zNMask&(primeZ2)), x9, y9, z9) + } + } + + if !skipD { + aD := T(xAFlipMask1+yAFlipMask1) + a1 + if aD > 0 { + xD := T(xNMask|1) + x1 + yD := T(yNMask|1) + y1 + zD := z1 + value += (aD * aD) * (aD * aD) * gradCoord3D(seed2, i+(xNMask&(primeX2)), j+(yNMask&(primeY2)), k+primeZ, xD, yD, zD) + } + } + + return value * 9.046026385208288 +} + +// Cellular Noise + +func singleCellular2D[T Float](state *State[T], seed int, x, y T) T { + xr := fastRound(x) + yr := fastRound(y) + + // One of the more painful aspects of Go generics.. + var dist0, dist1 T + switch dptr := any(&dist0).(type) { + case *float32: + *dptr = math.MaxFloat32 + case *float64: + *dptr = math.MaxFloat64 + } + dist1 = dist0 + + var closestHash uint32 + // jitter := 0.5 * state.CellularJitterMod + jitter := 0.43701595 * state.CellularJitterMod + + xPrimed := (xr - 1) * primeX + yPrimedBase := (yr - 1) * primeY + + switch state.CellularDistanceFunc { + default: + for xi := xr - 1; xi <= xr+1; xi++ { + yPrimed := yPrimedBase + + for yi := yr - 1; yi <= yr+1; yi++ { + hash := hash2D(seed, xPrimed, yPrimed) + idx := hash & (255 << 1) + + vecX := (T(xi) - x) + T(randVecs2D[idx])*jitter + vecY := (T(yi) - y) + T(randVecs2D[idx|1])*jitter + + newDistance := vecX*vecX + vecY*vecY + + dist1 = fastMax(fastMin(dist1, newDistance), dist0) + if newDistance < dist0 { + dist0 = newDistance + closestHash = hash + } + yPrimed += primeY + } + xPrimed += primeX + } + case CellularDistanceManhattan: + for xi := xr - 1; xi <= xr+1; xi++ { + yPrimed := yPrimedBase + + for yi := yr - 1; yi <= yr+1; yi++ { + hash := hash2D(seed, xPrimed, yPrimed) + idx := hash & (255 << 1) + + vecX := (T(xi) - x) + T(randVecs2D[idx])*jitter + vecY := (T(yi) - y) + T(randVecs2D[idx|1])*jitter + newDistance := fastAbs(vecX) + fastAbs(vecY) + + dist1 = fastMax(fastMin(dist1, newDistance), dist0) + if newDistance < dist0 { + dist0 = newDistance + closestHash = hash + } + yPrimed += primeY + } + xPrimed += primeX + } + case CellularDistanceHybrid: + for xi := xr - 1; xi <= xr+1; xi++ { + yPrimed := yPrimedBase + for yi := yr - 1; yi <= yr+1; yi++ { + hash := hash2D(seed, xPrimed, yPrimed) + idx := hash & (255 << 1) + + vecX := (T(xi) - x) + T(randVecs2D[idx])*jitter + vecY := (T(yi) - y) + T(randVecs2D[idx|1])*jitter + + newDistance := (fastAbs(vecX) + fastAbs(vecY)) + (vecX*vecX + vecY*vecY) + + dist1 = fastMax(fastMin(dist1, newDistance), dist0) + if newDistance < dist0 { + dist0 = newDistance + closestHash = hash + } + yPrimed += primeY + } + xPrimed += primeX + } + } + + if state.CellularDistanceFunc == CellularDistanceEuclidean && state.CellularReturnType >= CellularReturnDistance { + dist0 = fastSqrt(dist0) + if state.CellularReturnType >= CellularReturnDistance2 { + dist1 = fastSqrt(dist1) + } + } + + switch state.CellularReturnType { + case CellularReturnCellValue: + return T(closestHash) * (1 / 2147483648.0) + case CellularReturnDistance: + return dist0 - 1 + case CellularReturnDistance2: + return dist1 - 1 + case CellularReturnDistance2Add: + return (dist1+dist0)*0.5 - 1 + case CellularReturnDistance2Sub: + return dist1 - dist0 - 1 + case CellularReturnDistance2Mul: + return dist1*dist0*0.5 - 1 + case CellularReturnDistance2Div: + return dist0/dist1 - 1 + default: + return 0 + } +} + +func singleCellular3D[T Float](state *State[T], seed int, x, y, z T) T { + xr := fastRound(x) + yr := fastRound(y) + zr := fastRound(z) + + var dist0, dist1 T + switch dptr := any(&dist0).(type) { + case *float32: + *dptr = math.MaxFloat32 + case *float64: + *dptr = math.MaxFloat64 + } + dist1 = dist0 + + var closestHash uint32 + jitter := 0.39614353 * state.CellularJitterMod + + xPrimed := (xr - 1) * primeX + yPrimedBase := (yr - 1) * primeY + zPrimedBase := (zr - 1) * primeZ + + switch state.CellularDistanceFunc { + default: + for xi := xr - 1; xi <= xr+1; xi++ { + yPrimed := yPrimedBase + + for yi := yr - 1; yi <= yr+1; yi++ { + zPrimed := zPrimedBase + + for zi := zr - 1; zi <= zr+1; zi++ { + hash := hash3D(seed, xPrimed, yPrimed, zPrimed) + idx := hash & (255 << 2) + + vecX := (T(xi) - x) + T(randVecs3D[idx])*jitter + vecY := (T(yi) - y) + T(randVecs3D[idx|1])*jitter + vecZ := (T(zi) - z) + T(randVecs3D[idx|2])*jitter + + newDistance := vecX*vecX + vecY*vecY + vecZ*vecZ + + dist1 = fastMax(fastMin(dist1, newDistance), dist0) + if newDistance < dist0 { + dist0 = newDistance + closestHash = hash + } + zPrimed += primeZ + } + yPrimed += primeY + } + xPrimed += primeX + } + case CellularDistanceManhattan: + for xi := xr - 1; xi <= xr+1; xi++ { + yPrimed := yPrimedBase + + for yi := yr - 1; yi <= yr+1; yi++ { + zPrimed := zPrimedBase + + for zi := zr - 1; zi <= zr+1; zi++ { + hash := hash3D(seed, xPrimed, yPrimed, zPrimed) + idx := hash & (255 << 2) + + vecX := (T(xi) - x) + T(randVecs3D[idx])*jitter + vecY := (T(yi) - y) + T(randVecs3D[idx|1])*jitter + vecZ := (T(zi) - z) + T(randVecs3D[idx|2])*jitter + + newDistance := fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ) + + dist1 = fastMax(fastMin(dist1, newDistance), dist0) + if newDistance < dist0 { + dist0 = newDistance + closestHash = hash + } + zPrimed += primeZ + } + yPrimed += primeY + } + xPrimed += primeX + } + case CellularDistanceHybrid: + for xi := xr - 1; xi <= xr+1; xi++ { + yPrimed := yPrimedBase + + for yi := yr - 1; yi <= yr+1; yi++ { + zPrimed := zPrimedBase + + for zi := zr - 1; zi <= zr+1; zi++ { + hash := hash3D(seed, xPrimed, yPrimed, zPrimed) + idx := hash & (255 << 2) + + vecX := (T(xi) - x) + T(randVecs3D[idx])*jitter + vecY := (T(yi) - y) + T(randVecs3D[idx|1])*jitter + vecZ := (T(zi) - z) + T(randVecs3D[idx|2])*jitter + + newDistance := (fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ)) + (vecX*vecX + vecY*vecY + vecZ*vecZ) + + dist1 = fastMax(fastMin(dist1, newDistance), dist0) + if newDistance < dist0 { + dist0 = newDistance + closestHash = hash + } + zPrimed += primeZ + } + yPrimed += primeY + } + xPrimed += primeX + } + } + + if state.CellularDistanceFunc == CellularDistanceEuclidean && state.CellularReturnType >= CellularReturnDistance { + dist0 = fastSqrt(dist0) + if state.CellularReturnType >= CellularReturnDistance2 { + dist1 = fastSqrt(dist1) + } + } + + switch state.CellularReturnType { + case CellularReturnCellValue: + return T(closestHash) * (1 / 2147483648.0) + case CellularReturnDistance: + return dist0 - 1 + case CellularReturnDistance2: + return dist1 - 1 + case CellularReturnDistance2Add: + return (dist1+dist0)*0.5 - 1 + case CellularReturnDistance2Sub: + return dist1 - dist0 - 1 + case CellularReturnDistance2Mul: + return dist1*dist0*0.5 - 1 + case CellularReturnDistance2Div: + return dist0/dist1 - 1 + default: + return 0 + } +} + +// Perlin Noise + +func singlePerlin2D[T Float](state *State[T], seed int, x, y T) T { + x0 := fastFloor(x) + y0 := fastFloor(y) + + xd0 := x - T(x0) + yd0 := y - T(y0) + xd1 := xd0 - 1 + yd1 := yd0 - 1 + + xs := interpQuintic(xd0) + ys := interpQuintic(yd0) + + x0 *= primeX + y0 *= primeY + x1 := x0 + primeX + y1 := y0 + primeY + + xf0 := lerp(gradCoord2D(seed, x0, y0, xd0, yd0), gradCoord2D(seed, x1, y0, xd1, yd0), xs) + xf1 := lerp(gradCoord2D(seed, x0, y1, xd0, yd1), gradCoord2D(seed, x1, y1, xd1, yd1), xs) + + return lerp(xf0, xf1, ys) * 1.4247691104677813 +} + +func singlePerlin3D[T Float](state *State[T], seed int, x, y, z T) T { + x0 := fastFloor(x) + y0 := fastFloor(y) + z0 := fastFloor(z) + + xd0 := x - T(x0) + yd0 := y - T(y0) + zd0 := z - T(z0) + xd1 := xd0 - 1 + yd1 := yd0 - 1 + zd1 := zd0 - 1 + + xs := interpQuintic(xd0) + ys := interpQuintic(yd0) + zs := interpQuintic(zd0) + + x0 *= primeX + y0 *= primeY + z0 *= primeZ + x1 := x0 + primeX + y1 := y0 + primeY + z1 := z0 + primeZ + + xf00 := lerp(gradCoord3D(seed, x0, y0, z0, xd0, yd0, zd0), gradCoord3D(seed, x1, y0, z0, xd1, yd0, zd0), xs) + xf10 := lerp(gradCoord3D(seed, x0, y1, z0, xd0, yd1, zd0), gradCoord3D(seed, x1, y1, z0, xd1, yd1, zd0), xs) + xf01 := lerp(gradCoord3D(seed, x0, y0, z1, xd0, yd0, zd1), gradCoord3D(seed, x1, y0, z1, xd1, yd0, zd1), xs) + xf11 := lerp(gradCoord3D(seed, x0, y1, z1, xd0, yd1, zd1), gradCoord3D(seed, x1, y1, z1, xd1, yd1, zd1), xs) + + yf0 := lerp(xf00, xf10, ys) + yf1 := lerp(xf01, xf11, ys) + + return lerp(yf0, yf1, zs) * 0.964921414852142333984375 +} + +// Value Cubic + +func singleValueCubic2D[T Float](state *State[T], seed int, x, y T) T { + x1 := fastFloor(x) + y1 := fastFloor(y) + + xs := x - T(x1) + ys := y - T(y1) + + x1 *= primeX + y1 *= primeY + + x0 := x1 - primeX + y0 := y1 - primeY + x2 := x1 + primeX + y2 := y1 + primeY + x3 := x1 + primeX2 + y3 := y1 + primeY2 + + return cubicLerp( + cubicLerp(valCoord2D[T](seed, x0, y0), valCoord2D[T](seed, x1, y0), valCoord2D[T](seed, x2, y0), valCoord2D[T](seed, x3, y0), xs), + cubicLerp(valCoord2D[T](seed, x0, y1), valCoord2D[T](seed, x1, y1), valCoord2D[T](seed, x2, y1), valCoord2D[T](seed, x3, y1), xs), + cubicLerp(valCoord2D[T](seed, x0, y2), valCoord2D[T](seed, x1, y2), valCoord2D[T](seed, x2, y2), valCoord2D[T](seed, x3, y2), xs), + cubicLerp(valCoord2D[T](seed, x0, y3), valCoord2D[T](seed, x1, y3), valCoord2D[T](seed, x2, y3), valCoord2D[T](seed, x3, y3), xs), ys) * (1 / (1.5 * 1.5)) +} + +func singleValueCubic3D[T Float](state *State[T], seed int, x, y, z T) T { + x1 := fastFloor(x) + y1 := fastFloor(y) + z1 := fastFloor(z) + + xs := x - T(x1) + ys := y - T(y1) + zs := z - T(z1) + + x1 *= primeX + y1 *= primeY + z1 *= primeZ + + x0 := x1 - primeX + y0 := y1 - primeY + z0 := z1 - primeZ + x2 := x1 + primeX + y2 := y1 + primeY + z2 := z1 + primeZ + x3 := x1 + primeX2 + y3 := y1 + primeY2 + z3 := z1 + primeZ2 + + return cubicLerp( + cubicLerp( + cubicLerp(valCoord3D[T](seed, x0, y0, z0), valCoord3D[T](seed, x1, y0, z0), valCoord3D[T](seed, x2, y0, z0), valCoord3D[T](seed, x3, y0, z0), xs), + cubicLerp(valCoord3D[T](seed, x0, y1, z0), valCoord3D[T](seed, x1, y1, z0), valCoord3D[T](seed, x2, y1, z0), valCoord3D[T](seed, x3, y1, z0), xs), + cubicLerp(valCoord3D[T](seed, x0, y2, z0), valCoord3D[T](seed, x1, y2, z0), valCoord3D[T](seed, x2, y2, z0), valCoord3D[T](seed, x3, y2, z0), xs), + cubicLerp(valCoord3D[T](seed, x0, y3, z0), valCoord3D[T](seed, x1, y3, z0), valCoord3D[T](seed, x2, y3, z0), valCoord3D[T](seed, x3, y3, z0), xs), + ys), + cubicLerp( + cubicLerp(valCoord3D[T](seed, x0, y0, z1), valCoord3D[T](seed, x1, y0, z1), valCoord3D[T](seed, x2, y0, z1), valCoord3D[T](seed, x3, y0, z1), xs), + cubicLerp(valCoord3D[T](seed, x0, y1, z1), valCoord3D[T](seed, x1, y1, z1), valCoord3D[T](seed, x2, y1, z1), valCoord3D[T](seed, x3, y1, z1), xs), + cubicLerp(valCoord3D[T](seed, x0, y2, z1), valCoord3D[T](seed, x1, y2, z1), valCoord3D[T](seed, x2, y2, z1), valCoord3D[T](seed, x3, y2, z1), xs), + cubicLerp(valCoord3D[T](seed, x0, y3, z1), valCoord3D[T](seed, x1, y3, z1), valCoord3D[T](seed, x2, y3, z1), valCoord3D[T](seed, x3, y3, z1), xs), + ys), + cubicLerp( + cubicLerp(valCoord3D[T](seed, x0, y0, z2), valCoord3D[T](seed, x1, y0, z2), valCoord3D[T](seed, x2, y0, z2), valCoord3D[T](seed, x3, y0, z2), xs), + cubicLerp(valCoord3D[T](seed, x0, y1, z2), valCoord3D[T](seed, x1, y1, z2), valCoord3D[T](seed, x2, y1, z2), valCoord3D[T](seed, x3, y1, z2), xs), + cubicLerp(valCoord3D[T](seed, x0, y2, z2), valCoord3D[T](seed, x1, y2, z2), valCoord3D[T](seed, x2, y2, z2), valCoord3D[T](seed, x3, y2, z2), xs), + cubicLerp(valCoord3D[T](seed, x0, y3, z2), valCoord3D[T](seed, x1, y3, z2), valCoord3D[T](seed, x2, y3, z2), valCoord3D[T](seed, x3, y3, z2), xs), + ys), + cubicLerp( + cubicLerp(valCoord3D[T](seed, x0, y0, z3), valCoord3D[T](seed, x1, y0, z3), valCoord3D[T](seed, x2, y0, z3), valCoord3D[T](seed, x3, y0, z3), xs), + cubicLerp(valCoord3D[T](seed, x0, y1, z3), valCoord3D[T](seed, x1, y1, z3), valCoord3D[T](seed, x2, y1, z3), valCoord3D[T](seed, x3, y1, z3), xs), + cubicLerp(valCoord3D[T](seed, x0, y2, z3), valCoord3D[T](seed, x1, y2, z3), valCoord3D[T](seed, x2, y2, z3), valCoord3D[T](seed, x3, y2, z3), xs), + cubicLerp(valCoord3D[T](seed, x0, y3, z3), valCoord3D[T](seed, x1, y3, z3), valCoord3D[T](seed, x2, y3, z3), valCoord3D[T](seed, x3, y3, z3), xs), + ys), + zs) * (1 / (1.5 * 1.5 * 1.5)) +} + +// Value noise + +func singleValue2D[T Float](state *State[T], seed int, x, y T) T { + x0 := fastFloor(x) + y0 := fastFloor(y) + + xs := interpHermite(x - T(x0)) + ys := interpHermite(y - T(y0)) + + x0 *= primeX + y0 *= primeY + x1 := x0 + primeX + y1 := y0 + primeY + + xf0 := lerp(valCoord2D[T](seed, x0, y0), valCoord2D[T](seed, x1, y0), xs) + xf1 := lerp(valCoord2D[T](seed, x0, y1), valCoord2D[T](seed, x1, y1), xs) + + return lerp(xf0, xf1, ys) +} + +func singleValue3D[T Float](state *State[T], seed int, x, y, z T) T { + x0 := fastFloor(x) + y0 := fastFloor(y) + z0 := fastFloor(z) + + xs := interpHermite(x - T(x0)) + ys := interpHermite(y - T(y0)) + zs := interpHermite(z - T(z0)) + + x0 *= primeX + y0 *= primeY + z0 *= primeZ + x1 := x0 + primeX + y1 := y0 + primeY + z1 := z0 + primeZ + + xf00 := lerp(valCoord3D[T](seed, x0, y0, z0), valCoord3D[T](seed, x1, y0, z0), xs) + xf10 := lerp(valCoord3D[T](seed, x0, y1, z0), valCoord3D[T](seed, x1, y1, z0), xs) + xf01 := lerp(valCoord3D[T](seed, x0, y0, z1), valCoord3D[T](seed, x1, y0, z1), xs) + xf11 := lerp(valCoord3D[T](seed, x0, y1, z1), valCoord3D[T](seed, x1, y1, z1), xs) + + yf0 := lerp(xf00, xf10, ys) + yf1 := lerp(xf01, xf11, ys) + + return lerp(yf0, yf1, zs) +} + +// Domain Warp + +func doSingleDomainWarp2D[T Float](state *State[T], seed int, amp, freq, x, y T, xp, yp *T) { + switch state.DomainWarpType { + case DomainWarpOpenSimplex2: + singleDomainWarpSimplexGradient(seed, amp*38.283687591552734375, freq, x, y, xp, yp, false) + case DomainWarpOpenSimplex2Reduced: + singleDomainWarpSimplexGradient(seed, amp*16.0, freq, x, y, xp, yp, true) + case DomainWarpBasicGrid: + singleDomainWarpBasicGrid2D(seed, amp, freq, x, y, xp, yp) + } +} + +func doSingleDomainWarp3D[T Float](state *State[T], seed int, amp, freq, x, y, z T, xp, yp, zp *T) { + switch state.DomainWarpType { + case DomainWarpOpenSimplex2: + singleDomainWarpOpenSimplex2Gradient(seed, amp*32.69428253173828125, freq, x, y, z, xp, yp, zp, false) + case DomainWarpOpenSimplex2Reduced: + singleDomainWarpOpenSimplex2Gradient(seed, amp*7.71604938271605, freq, x, y, z, xp, yp, zp, true) + case DomainWarpBasicGrid: + singleDomainWarpBasicGrid3D(seed, amp, freq, x, y, z, xp, yp, zp) + } +} + +// Domain Warp Single Wrapper + +func domainWarpSingle2D[T Float](state *State[T], x, y *T) { + seed := state.Seed + amp := state.DomainWarpAmp * calculateFractalBounding(state) + freq := state.Frequency + + xs := *x + ys := *y + transformDomainWarpCoordinate2D(state, &xs, &ys) + + doSingleDomainWarp2D(state, seed, amp, freq, xs, ys, x, y) +} + +func domainWarpSingle3D[T Float](state *State[T], x, y, z *T) { + seed := state.Seed + amp := state.DomainWarpAmp * calculateFractalBounding(state) + freq := state.Frequency + + xs := *x + ys := *y + zs := *z + transformDomainWarpCoordinate3D(state, &xs, &ys, &zs) + + doSingleDomainWarp3D(state, seed, amp, freq, xs, ys, zs, x, y, z) +} + +// Domain Warp Fractal Progressive + +func domainWarpFractalProgressive2D[T Float](state *State[T], x, y *T) { + seed := state.Seed + amp := state.DomainWarpAmp * calculateFractalBounding(state) + freq := state.Frequency + + for i := 0; i < state.Octaves; i++ { + xs := *x + ys := *y + transformDomainWarpCoordinate2D(state, &xs, &ys) + + doSingleDomainWarp2D(state, seed, amp, freq, xs, ys, x, y) + + seed++ + amp *= state.Gain + freq *= state.Lacunarity + } +} + +func domainWarpFractalProgressive3D[T Float](state *State[T], x, y, z *T) { + seed := state.Seed + amp := state.DomainWarpAmp * calculateFractalBounding(state) + freq := state.Frequency + + for i := 0; i < state.Octaves; i++ { + xs := *x + ys := *y + zs := *z + transformDomainWarpCoordinate3D(state, &xs, &ys, &zs) + + doSingleDomainWarp3D(state, seed, amp, freq, xs, ys, zs, x, y, z) + + seed++ + amp *= state.Gain + freq *= state.Lacunarity + } +} + +// Domain Warp Fractal Independent + +func domainWarpFractalIndependent2D[T Float](state *State[T], x, y *T) { + xs := *x + ys := *y + transformDomainWarpCoordinate2D(state, &xs, &ys) + + seed := state.Seed + amp := state.DomainWarpAmp * calculateFractalBounding(state) + freq := state.Frequency + + for i := 0; i < state.Octaves; i++ { + doSingleDomainWarp2D(state, seed, amp, freq, xs, ys, x, y) + + seed++ + amp *= state.Gain + freq *= state.Lacunarity + } +} + +func domainWarpFractalIndependent3D[T Float](state *State[T], x, y, z *T) { + xs := *x + ys := *y + zs := *z + transformDomainWarpCoordinate3D(state, &xs, &ys, &zs) + + seed := state.Seed + amp := state.DomainWarpAmp * calculateFractalBounding(state) + freq := state.Frequency + + for i := 0; i < state.Octaves; i++ { + doSingleDomainWarp3D(state, seed, amp, freq, xs, ys, zs, x, y, z) + + seed++ + amp *= state.Gain + freq *= state.Lacunarity + } +} + +// Domain Warp Basic Grid + +func singleDomainWarpBasicGrid2D[T Float](seed int, warpAmp, frequency, x, y T, xp, yp *T) { + xf := x * frequency + yf := y * frequency + + x0 := fastFloor(xf) + y0 := fastFloor(yf) + + xs := interpHermite(xf - T(x0)) + ys := interpHermite(yf - T(y0)) + + x0 *= primeX + y0 *= primeY + x1 := x0 + primeX + y1 := y0 + primeY + + idx0 := hash2D(seed, x0, y0) & (255 << 1) + idx1 := hash2D(seed, x1, y0) & (255 << 1) + + lx0x := lerp(T(randVecs2D[idx0]), T(randVecs2D[idx1]), xs) + ly0x := lerp(T(randVecs2D[idx0|1]), T(randVecs2D[idx1|1]), xs) + + idx0 = hash2D(seed, x0, y1) & (255 << 1) + idx1 = hash2D(seed, x1, y1) & (255 << 1) + + lx1x := lerp(T(randVecs2D[idx0]), T(randVecs2D[idx1]), xs) + ly1x := lerp(T(randVecs2D[idx0|1]), T(randVecs2D[idx1|1]), xs) + + *xp += lerp(lx0x, lx1x, ys) * warpAmp + *yp += lerp(ly0x, ly1x, ys) * warpAmp +} + +func singleDomainWarpBasicGrid3D[T Float](seed int, warpAmp, frequency, x, y, z T, xp, yp, zp *T) { + xf := x * frequency + yf := y * frequency + zf := z * frequency + + x0 := fastFloor(xf) + y0 := fastFloor(yf) + z0 := fastFloor(zf) + + xs := interpHermite(xf - T(x0)) + ys := interpHermite(yf - T(y0)) + zs := interpHermite(zf - T(z0)) + + x0 *= primeX + y0 *= primeY + z0 *= primeZ + x1 := x0 + primeX + y1 := y0 + primeY + z1 := z0 + primeZ + + idx0 := hash3D(seed, x0, y0, z0) & (255 << 2) + idx1 := hash3D(seed, x1, y0, z0) & (255 << 2) + + lx0x := lerp(T(randVecs3D[idx0]), T(randVecs3D[idx1]), xs) + ly0x := lerp(T(randVecs3D[idx0|1]), T(randVecs3D[idx1|1]), xs) + lz0x := lerp(T(randVecs3D[idx0|2]), T(randVecs3D[idx1|2]), xs) + + idx0 = hash3D(seed, x0, y1, z0) & (255 << 2) + idx1 = hash3D(seed, x1, y1, z0) & (255 << 2) + + lx1x := lerp(T(randVecs3D[idx0]), T(randVecs3D[idx1]), xs) + ly1x := lerp(T(randVecs3D[idx0|1]), T(randVecs3D[idx1|1]), xs) + lz1x := lerp(T(randVecs3D[idx0|2]), T(randVecs3D[idx1|2]), xs) + + lx0y := lerp(lx0x, lx1x, ys) + ly0y := lerp(ly0x, ly1x, ys) + lz0y := lerp(lz0x, lz1x, ys) + + idx0 = hash3D(seed, x0, y0, z1) & (255 << 2) + idx1 = hash3D(seed, x1, y0, z1) & (255 << 2) + + lx0x = lerp(T(randVecs3D[idx0]), T(randVecs3D[idx1]), xs) + ly0x = lerp(T(randVecs3D[idx0|1]), T(randVecs3D[idx1|1]), xs) + lz0x = lerp(T(randVecs3D[idx0|2]), T(randVecs3D[idx1|2]), xs) + + idx0 = hash3D(seed, x0, y1, z1) & (255 << 2) + idx1 = hash3D(seed, x1, y1, z1) & (255 << 2) + + lx1x = lerp(T(randVecs3D[idx0]), T(randVecs3D[idx1]), xs) + ly1x = lerp(T(randVecs3D[idx0|1]), T(randVecs3D[idx1|1]), xs) + lz1x = lerp(T(randVecs3D[idx0|2]), T(randVecs3D[idx1|2]), xs) + + *xp += lerp(lx0y, lerp(lx0x, lx1x, ys), zs) * warpAmp + *yp += lerp(ly0y, lerp(ly0x, ly1x, ys), zs) * warpAmp + *zp += lerp(lz0y, lerp(lz0x, lz1x, ys), zs) * warpAmp +} + +// Domain Warp Simplex/OpenSimplex2 + +func singleDomainWarpSimplexGradient[T Float](seed int, warpAmp, frequency, x, y T, xr, yr *T, outGradOnly bool) { + const SQRT3 float64 = 1.7320508075688772935274463415059 + const G2 float64 = (3 - SQRT3) / 6 + + x *= frequency + y *= frequency + + i := fastFloor(x) + j := fastFloor(y) + xi := x - T(i) + yi := y - T(j) + + t := T(xi+yi) * T(G2) + x0 := xi - t + y0 := yi - t + + i *= primeX + j *= primeY + + var vx, vy T + a := 0.5 - x0*x0 - y0*y0 + if a > 0 { + aaaa := (a * a) * (a * a) + var xo, yo T + if outGradOnly { + gradCoordOut2D(seed, i, j, &xo, &yo) + } else { + gradCoordDual2D(seed, i, j, x0, y0, &xo, &yo) + } + vx += aaaa * xo + vy += aaaa * yo + } + + c := T(2*(1-2*G2)*(1/G2-2))*t + (T(-2*(1-2*G2)*(1-2*G2)) + a) + if c > 0 { + x2 := x0 + (2*T(G2) - 1) + y2 := y0 + (2*T(G2) - 1) + cccc := (c * c) * (c * c) + var xo, yo T + if outGradOnly { + gradCoordOut2D(seed, i+primeX, j+primeY, &xo, &yo) + } else { + gradCoordDual2D(seed, i+primeX, j+primeY, x2, y2, &xo, &yo) + } + vx += cccc * xo + vy += cccc * yo + } + + if y0 > x0 { + x1 := x0 + T(G2) + y1 := y0 + T(G2-1) + b := 0.5 - x1*x1 - y1*y1 + if b > 0 { + bbbb := (b * b) * (b * b) + var xo, yo T + if outGradOnly { + gradCoordOut2D(seed, i, j+primeY, &xo, &yo) + } else { + gradCoordDual2D(seed, i, j+primeY, x1, y1, &xo, &yo) + } + vx += bbbb * xo + vy += bbbb * yo + } + } else { + x1 := x0 + T(G2-1) + y1 := y0 + T(G2) + b := 0.5 - x1*x1 - y1*y1 + if b > 0 { + bbbb := (b * b) * (b * b) + var xo, yo T + if outGradOnly { + gradCoordOut2D(seed, i+primeX, j, &xo, &yo) + } else { + gradCoordDual2D(seed, i+primeX, j, x1, y1, &xo, &yo) + } + vx += bbbb * xo + vy += bbbb * yo + } + } + + *xr += vx * warpAmp + *yr += vy * warpAmp +} + +func singleDomainWarpOpenSimplex2Gradient[T Float](seed int, warpAmp, frequency, x, y, z T, xr, yr, zr *T, outGradOnly bool) { + x *= frequency + y *= frequency + z *= frequency + + i := fastRound(x) + j := fastRound(y) + k := fastRound(z) + x0 := x - T(i) + y0 := y - T(j) + z0 := z - T(k) + + xNSign := int(-x0-1.0) | 1 + yNSign := int(-y0-1.0) | 1 + zNSign := int(-z0-1.0) | 1 + + ax0 := T(xNSign) * -x0 + ay0 := T(yNSign) * -y0 + az0 := T(zNSign) * -z0 + + i *= primeX + j *= primeY + k *= primeZ + + var vx, vy, vz T + a := (0.6 - x0*x0) - (y0*y0 + z0*z0) + for l := 0; l < 2; l++ { + if a > 0 { + aaaa := (a * a) * (a * a) + var xo, yo, zo T + if outGradOnly { + gradCoordOut3D(seed, i, j, k, &xo, &yo, &zo) + } else { + gradCoordDual3D(seed, i, j, k, x0, y0, z0, &xo, &yo, &zo) + } + vx += aaaa * xo + vy += aaaa * yo + vz += aaaa * zo + } + + b := a + 1 + i1 := i + j1 := j + k1 := k + x1 := x0 + y1 := y0 + z1 := z0 + if ax0 >= ay0 && ax0 >= az0 { + x1 += T(xNSign) + b -= T(xNSign) * 2 * x1 + i1 -= xNSign * primeX + } else if ay0 > ax0 && ay0 >= az0 { + y1 += T(yNSign) + b -= T(yNSign) * 2 * y1 + j1 -= yNSign * primeY + } else { + z1 += T(zNSign) + b -= T(zNSign) * 2 * z1 + k1 -= zNSign * primeZ + } + + if b > 0 { + bbbb := (b * b) * (b * b) + var xo, yo, zo T + if outGradOnly { + gradCoordOut3D(seed, i1, j1, k1, &xo, &yo, &zo) + } else { + gradCoordDual3D(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.5 - ax0 + ay0 = 0.5 - ay0 + az0 = 0.5 - az0 + + x0 = T(xNSign) * ax0 + y0 = T(yNSign) * ay0 + z0 = T(zNSign) * az0 + + a += (0.75 - 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 +} + +// vim: ts=4 diff --git a/HLSL/FastNoiseLite.hlsl b/HLSL/FastNoiseLite.hlsl index a2884fd..27a2493 100644 --- a/HLSL/FastNoiseLite.hlsl +++ b/HLSL/FastNoiseLite.hlsl @@ -45,7 +45,7 @@ // ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX // // VERSION: 1.0.1 -// https://github.com/Auburn/FastNoise +// https://github.com/Auburn/FastNoiseLite // Switch between using floats or doubles for input position typedef float FNLfloat; diff --git a/Java/FastNoiseLite.java b/Java/FastNoiseLite.java index 39e2f32..ef074ce 100644 --- a/Java/FastNoiseLite.java +++ b/Java/FastNoiseLite.java @@ -45,7 +45,7 @@ // ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX // // VERSION: 1.0.1 -// https://github.com/Auburn/FastNoise +// https://github.com/Auburn/FastNoiseLite // To switch between using floats or doubles for input position, // perform a file-wide replace on the following strings (including /*FNLfloat*/) diff --git a/JavaScript/FastNoiseLite.js b/JavaScript/FastNoiseLite.js index d136d64..45bcdf3 100644 --- a/JavaScript/FastNoiseLite.js +++ b/JavaScript/FastNoiseLite.js @@ -49,8 +49,8 @@ // https://www.npmjs.com/package/fastnoise-lite // https://discord.gg/SHVaVfV // -// Ported to Javascript by storm (Patrick U): -// Discord: storm#8888 (prefered) | Email: storm1surge@gmail.com | Github: stormy482 (https://github.com/stormy482) +// Ported to JavaScript by Stormy482 (Patrick U): +// Discord: dev_storm (preferred) | Email: storm1surge@gmail.com | GitHub: stormy482 (https://github.com/stormy482) // diff --git a/JavaScript/README.md b/JavaScript/README.md index d4dcad0..7f57fa4 100644 --- a/JavaScript/README.md +++ b/JavaScript/README.md @@ -48,12 +48,12 @@ for (let y = 0; y < 128; y++) { Since JavaScript does not support method overloading it has been simulated to make the user experience more continuous between language versions. -Some of the code has been changed to use switch statments since it provided a minor preformance boost in some small +Some of the code has been changed to use switch statements since it provided a minor performance boost in some small frequently used places eg the _Hash methods. Here is a template for the method overloading: -```javascript +```js class FastNoiseLite { /** * JSdoc @@ -77,7 +77,6 @@ class FastNoiseLite { } } - ``` -### DM storm#8888 on discord or email w/ any questions or need any support or ask someone in our discord :D \ No newline at end of file +### DM dev_storm on discord or email w/ any questions or need any support or ask someone in our discord :D diff --git a/JavaScript/package.json b/JavaScript/package.json index 133c3d4..238acaf 100644 --- a/JavaScript/package.json +++ b/JavaScript/package.json @@ -2,7 +2,7 @@ "name": "fastnoise-lite", "type": "module", "version": "1.0.1", - "description": "an extremely portable open source noise generation library with a large selection of noise algorithms", + "description": "FastNoiseLite Lite is an extremely portable open source noise generation library with a large selection of noise algorithms", "main": "FastNoiseLite.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" @@ -32,7 +32,7 @@ "random", "generative" ], - "author": "Patrick U & Jordan Peck", + "contributors": ["Patrick U", "Jordan Peck"], "license": "MIT", "bugs": { "url": "https://github.com/Auburn/FastNoiseLite/issues" diff --git a/PreviewApp/FastNoiseLiteGUI.cs b/PreviewApp/FastNoiseLiteGUI.cs index e8798ef..900146f 100644 --- a/PreviewApp/FastNoiseLiteGUI.cs +++ b/PreviewApp/FastNoiseLiteGUI.cs @@ -377,7 +377,7 @@ public FastNoiseLiteGUI() stack.Items.Add(new StackLayoutItem(save)); var github = new Button { Text = "GitHub" }; - github.Click += (sender, e) => { Process.Start(new ProcessStartInfo("https://github.com/Auburn/FastNoise") { UseShellExecute = true }); }; + github.Click += (sender, e) => { Process.Start(new ProcessStartInfo("https://github.com/Auburn/FastNoiseLite") { UseShellExecute = true }); }; stack.Items.Add(new StackLayoutItem(github)); controlPanel.Items.Add(stack); diff --git a/README.md b/README.md index 48b5d55..241ca5c 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,10 @@ -[![discord](https://img.shields.io/discord/703636892901441577?style=flat-square&logo=discord "Discord")](https://discord.gg/SHVaVfV) -[![npm](https://img.shields.io/npm/v/fastnoise-lite)](https://www.npmjs.com/package/fastnoise-lite) +[![discord](https://img.shields.io/discord/703636892901441577?logo=discord "Discord")](https://discord.gg/SHVaVfV) # FastNoise Lite FastNoise Lite is an extremely portable open source noise generation library with a large selection of noise algorithms. This library focuses on high performance while avoiding platform/language specific features, allowing for easy ports to as many possible languages. -This project is an evolution of the [original FastNoise](https://github.com/Auburn/FastNoise/tree/FastNoise-Legacy) library and shares the same goal: An easy to use library that can quickly be integrated into a project and provides performant modern noise generation. See a breakdown of changes from the transition to FastNoise Lite [here](https://github.com/Auburn/FastNoise/pull/49) +This project is an evolution of the [original FastNoise](https://github.com/Auburn/FastNoiseLite/tree/FastNoise-Legacy) library and shares the same goal: An easy to use library that can quickly be integrated into a project and provides performant modern noise generation. See a breakdown of changes from the transition to FastNoise Lite [here](https://github.com/Auburn/FastNoiseLite/pull/49) If you are looking for a more extensive noise generation library consider using [FastNoise2](https://github.com/Auburn/FastNoise2). It provides large performance gains thanks to SIMD and uses a node graph structure to allow complex noise configurations with lots of flexibility. @@ -28,10 +27,14 @@ If you are looking for a more extensive noise generation library consider using - [C#](/CSharp/) - [C++98](/Cpp/) - [C99](/C/) -- [Java](/Java/) -- [JavaScript](/JavaScript/) - [HLSL](/HLSL/) - [GLSL](/GLSL/) +- [Go](/Go/) +- [Java](/Java/) +- [JavaScript](/JavaScript/) + [![npm](https://img.shields.io/npm/v/fastnoise-lite?logo=npm "npm")](https://www.npmjs.com/package/fastnoise-lite) +- [Rust](/Rust/) + [![crates.io](https://img.shields.io/crates/v/fastnoise-lite?logo=rust "crates.io")](https://crates.io/crates/fastnoise-lite) ### [Getting Started](https://github.com/Auburn/FastNoiseLite/wiki#getting-started) ### [Documentation](https://github.com/Auburn/FastNoiseLite/wiki/Documentation) @@ -71,11 +74,13 @@ Million points of noise generated per second (higher = better) ## Credits: - [OpenSimplex2](https://github.com/KdotJPG/OpenSimplex2) for the OpenSimplex2 noise algorithm -- [@KdotJPG](https://github.com/KdotJPG) for implementing all the OpenSimplex alogrithms and the Java port +- [@KdotJPG](https://github.com/KdotJPG) for implementing all the OpenSimplex algorithms and the Java port - [CubicNoise](https://github.com/jobtalle/CubicNoise) for the Value (Cubic) noise algorithm - [@Rover656](https://github.com/Rover656) for creating the preview GUI and porting FastNoise Lite to C and HLSL. -- [@Stormy482](https://github.com/stormy482) for creating the Javascript port. +- [@Stormy482](https://github.com/stormy482) for creating the JavaScript port. - [@dotlogix](https://github.com/dotlogix) for creating the GLSL port. +- [@ForeverZer0](https://github.com/ForeverZer0) for creating the Go port. +- [@Keavon](https://github.com/stormy482) for creating the Rust port. # Examples diff --git a/Rust/Cargo.lock b/Rust/Cargo.lock new file mode 100644 index 0000000..1ca2513 --- /dev/null +++ b/Rust/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "fastnoise-lite" +version = "1.0.1" diff --git a/Rust/Cargo.toml b/Rust/Cargo.toml new file mode 100644 index 0000000..59a2784 --- /dev/null +++ b/Rust/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "fastnoise-lite" +version = "1.0.1" +edition = "2021" +license = "MIT" +description = "FastNoiseLite Lite is an extremely portable open source noise generation library with a large selection of noise algorithms" +repository = "https://github.com/Auburn/FastNoiseLite" +readme = "README.md" +authors = ["Jordan Peck", "Keavon Chambers"] + +[features] +f64 = [] diff --git a/Rust/README.md b/Rust/README.md new file mode 100644 index 0000000..b2ede5e --- /dev/null +++ b/Rust/README.md @@ -0,0 +1,50 @@ +[crates.io](https://crates.io/crates/fastnoise-lite) • [docs.rs](https://docs.rs/fastnoise-lite/latest/bezier_rs/) • [repo](https://github.com/GraphiteEditor/Graphite/tree/master/libraries/fastnoise-lite) + +# FastNoise Lite + +FastNoise Lite is an extremely portable open source noise generation library with a large selection of noise algorithms. This library focuses on high performance while avoiding platform/language specific features, allowing for easy ports to as many possible languages. + +## Features + +- 2D & 3D +- OpenSimplex2 Noise +- OpenSimplex2S Noise +- Cellular (Voronoi) Noise +- Perlin Noise +- Value Noise +- Value Cubic Noise +- OpenSimplex2-based Domain Warp +- Basic Grid Gradient Domain Warp +- Multiple fractal options for all of the above +- Supports floats and/or doubles + - Switch from `f32` to `f64` position inputs with the `"f64"` feature flag in your `Cargo.toml` + +## Getting Started + +Below is an example for creating a 128x128 array of OpenSimplex2 noise. + +Additional documentation is available at [docs.rs](https://docs.rs/fastnoise-lite/latest/bezier_rs/) and the project's [Getting Started](https://github.com/Auburn/FastNoiseLite/wiki#getting-started) and [Documentation](https://github.com/Auburn/FastNoiseLite/wiki/Documentation) pages from its GitHub wiki. + +```rs +use fastnoise_lite::*; + +// Create and configure FastNoise object +let mut noise = FastNoiseLite::new(); +noise.SetNoiseType(NoiseType::OpenSimplex2); + +// Gather noise data +const WIDTH: usize = 128; +const HEIGHT: usize = 128; + +let mut noise_data = [0.; WIDTH * HEIGHT]; + +for y in 0..HEIGHT { + for x in 0..WIDTH { + // Enable `features = ["f64"]` in Cargo.toml to pass f64 values here instead of f32. + // Use `noise.get_noise_3d(x, y, z)` for 3D noise instead of 2D. + noise_data[WIDTH * y + x] = noise.get_noise_2d(x as f32, y as f32); + } +} + +// Do something with this data... +``` diff --git a/Rust/src/lib.rs b/Rust/src/lib.rs new file mode 100644 index 0000000..5a8b24f --- /dev/null +++ b/Rust/src/lib.rs @@ -0,0 +1,2963 @@ +// MIT License +// +// Copyright(c) 2020 Jordan Peck (jordan.me2@gmail.com) +// Copyright(c) 2020 Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files(the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions : +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +// .'',;:cldxkO00KKXXNNWWWNNXKOkxdollcc::::::;:::ccllloooolllllllllooollc:,'... ...........',;cldxkO000Okxdlc::;;;,,;;;::cclllllll +// ..',;:ldxO0KXXNNNNNNNNXXK0kxdolcc::::::;;;,,,,,,;;;;;;;;;;:::cclllllc:;'.... ...........',;:ldxO0KXXXK0Okxdolc::;;;;::cllodddddo +// ...',:loxO0KXNNNNNXXKK0Okxdolc::;::::::::;;;,,'''''.....''',;:clllllc:;,'............''''''''',;:loxO0KXNNNNNXK0Okxdollccccllodxxxxxxd +// ....';:ldkO0KXXXKK00Okxdolcc:;;;;;::cclllcc:;;,''..... ....',;clooddolcc:;;;;,,;;;;;::::;;;;;;:cloxk0KXNWWWWWWNXKK0Okxddoooddxxkkkkkxx +// .....';:ldxkOOOOOkxxdolcc:;;;,,,;;:cllooooolcc:;'... ..,:codxkkkxddooollloooooooollcc:::::clodkO0KXNWWWWWWNNXK00Okxxxxxxxxkkkkxxx +// . ....';:cloddddo___________,,,,;;:clooddddoolc:,... ..,:ldx__00OOOkkk___kkkkkkxxdollc::::cclodkO0KXXNNNNNNXXK0OOkxxxxxxxxxxxxddd +// .......',;:cccc:| |,,,;;:cclooddddoll:;'.. ..';cox| \KKK000| |KK00OOkxdocc___;::clldxxkO0KKKKK00Okkxdddddddddddddddoo +// .......'',,,,,''| ________|',,;;::cclloooooolc:;'......___:ldk| \KK000| |XKKK0Okxolc| |;;::cclodxxkkkkxxdoolllcclllooodddooooo +// ''......''''....| | ....'',,,,;;;::cclloooollc:;,''.'| |oxk| \OOO0| |KKK00Oxdoll|___|;;;;;::ccllllllcc::;;,,;;;:cclloooooooo +// ;;,''.......... | |_____',,;;;____:___cllo________.___| |___| \xkk| |KK_______ool___:::;________;;;_______...'',;;:ccclllloo +// c:;,''......... | |:::/ ' |lo/ | | \dx| |0/ \d| |cc/ |'/ \......',,;;:ccllo +// ol:;,'..........| _____|ll/ __ |o/ ______|____ ___| | \o| |/ ___ \| |o/ ______|/ ___ \ .......'',;:clo +// dlc;,...........| |::clooo| / | |x\___ \KXKKK0| |dol| |\ \| | | | | |d\___ \..| | / / ....',:cl +// xoc;'... .....'| |llodddd| \__| |_____\ \KKK0O| |lc:| |'\ | |___| | |_____\ \.| |_/___/... ...',;:c +// dlc;'... ....',;| |oddddddo\ | |Okkx| |::;| |..\ |\ /| | | \ |... ....',;:c +// ol:,'.......',:c|___|xxxddollc\_____,___|_________/ddoll|___|,,,|___|...\_____|:\ ______/l|___|_________/...\________|'........',;::cc +// c:;'.......';:codxxkkkkxxolc::;::clodxkOO0OOkkxdollc::;;,,''''',,,,''''''''''',,'''''',;:loxkkOOkxol:;,'''',,;:ccllcc:;,'''''',;::ccll +// ;,'.......',:codxkOO0OOkxdlc:;,,;;:cldxxkkxxdolc:;;,,''.....'',;;:::;;,,,'''''........,;cldkO0KK0Okdoc::;;::cloodddoolc:;;;;;::ccllooo +// .........',;:lodxOO0000Okdoc:,,',,;:clloddoolc:;,''.......'',;:clooollc:;;,,''.......',:ldkOKXNNXX0Oxdolllloddxxxxxxdolccccccllooodddd +// . .....';:cldxkO0000Okxol:;,''',,;::cccc:;,,'.......'',;:cldxxkkxxdolc:;;,'.......';coxOKXNWWWNXKOkxddddxxkkkkkkxdoollllooddxxxxkkk +// ....',;:codxkO000OOxdoc:;,''',,,;;;;,''.......',,;:clodkO00000Okxolc::;,,''..',;:ldxOKXNWWWNNK0OkkkkkkkkkkkxxddooooodxxkOOOOO000 +// ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX +// +// VERSION: 1.0.1 +// https://github.com/Auburn/FastNoiseLite +// https://crates.io/crates/fastnoise-lite +// https://discord.gg/SHVaVfV +// +// Ported to Rust by Keavon Chambers: +// Discord: Keavon (preferred) | Email: see for the address | GitHub: Keavon (https://github.com/Keavon) + +#![allow(clippy::excessive_precision)] + +// Switch between using floats or doubles for input position +#[cfg(not(feature = "f64"))] +type Float = f32; +#[cfg(feature = "f64")] +type Float = f64; + +#[derive(Copy, Clone, Debug, PartialEq)] +pub enum NoiseType { + OpenSimplex2, + OpenSimplex2S, + Cellular, + Perlin, + ValueCubic, + Value, +} + +#[derive(Copy, Clone, Debug, PartialEq)] +pub enum RotationType3D { + None, + ImproveXYPlanes, + ImproveXZPlanes, +} + +#[derive(Copy, Clone, Debug, PartialEq)] +pub enum FractalType { + None, + FBm, + Ridged, + PingPong, + DomainWarpProgressive, + DomainWarpIndependent, +} + +#[derive(Copy, Clone, Debug, PartialEq)] +pub enum CellularDistanceFunction { + Euclidean, + EuclideanSq, + Manhattan, + Hybrid, +} + +#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)] +pub enum CellularReturnType { + CellValue = 0, + Distance = 1, + Distance2 = 2, + Distance2Add = 3, + Distance2Sub = 4, + Distance2Mul = 5, + Distance2Div = 6, +} + +#[derive(Copy, Clone, Debug, PartialEq)] +pub enum DomainWarpType { + OpenSimplex2, + OpenSimplex2Reduced, + BasicGrid, +} + +#[derive(Copy, Clone, Debug, PartialEq)] +pub enum TransformType3D { + None, + ImproveXYPlanes, + ImproveXZPlanes, + DefaultOpenSimplex2, +} + +pub struct FastNoiseLite { + pub seed: i32, + pub frequency: f32, + pub noise_type: NoiseType, + pub rotation_type_3d: RotationType3D, + transform_type_3d: TransformType3D, + + pub fractal_type: FractalType, + pub octaves: i32, + pub lacunarity: f32, + pub gain: f32, + pub weighted_strength: f32, + pub ping_pong_strength: f32, + + fractal_bounding: f32, + + pub cellular_distance_function: CellularDistanceFunction, + pub cellular_return_type: CellularReturnType, + pub cellular_jitter_modifier: f32, + + pub domain_warp_type: DomainWarpType, + warp_transform_type_3d: TransformType3D, + pub domain_warp_amp: f32, +} + +impl Default for FastNoiseLite { + fn default() -> Self { + Self { + seed: 1337, + frequency: 0.01, + noise_type: NoiseType::OpenSimplex2, + rotation_type_3d: RotationType3D::None, + transform_type_3d: TransformType3D::DefaultOpenSimplex2, + + fractal_type: FractalType::None, + octaves: 3, + lacunarity: 2., + gain: 0.5, + weighted_strength: 0., + ping_pong_strength: 2., + + fractal_bounding: 1. / 1.75, + + cellular_distance_function: CellularDistanceFunction::EuclideanSq, + cellular_return_type: CellularReturnType::Distance, + cellular_jitter_modifier: 1., + + domain_warp_type: DomainWarpType::OpenSimplex2, + warp_transform_type_3d: TransformType3D::DefaultOpenSimplex2, + domain_warp_amp: 1., + } + } +} + +impl FastNoiseLite { + /// Create new FastNoise object with optional seed + pub fn new() -> Self { + Self::default() + } + + /// Create new FastNoise object with optional seed + pub fn with_seed(seed: i32) -> Self { + let mut fnl = Self::default(); + fnl.set_seed(Some(seed)); + fnl + } + + /// Sets seed used for all noise types + /// + /// Default: 1337 + pub fn set_seed(&mut self, seed: Option) { + self.seed = seed.unwrap_or(1337); + } + + /// Sets frequency for all noise types + /// + /// Default: 0.01 + pub fn set_frequency(&mut self, frequency: Option) { + self.frequency = frequency.unwrap_or(0.01); + } + + /// Sets noise algorithm used for get_noise_2d(...)/get_noise_3d(...) + /// + /// Default: OpenSimplex2 + pub fn set_noise_type(&mut self, noise_type: Option) { + self.noise_type = noise_type.unwrap_or(NoiseType::OpenSimplex2); + self.update_transform_type_3d(); + } + + /// 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 + pub fn set_rotation_type_3d(&mut self, rotation_type_3d: Option) { + self.rotation_type_3d = rotation_type_3d.unwrap_or(RotationType3D::None); + self.update_transform_type_3d(); + self.update_warp_transform_type_3d(); + } + + /// Sets method for combining octaves in all fractal noise types + /// + /// Default: None + /// Note: FractalType::DomainWarp... only affects domain_warp(...) + pub fn set_fractal_type(&mut self, fractal_type: Option) { + self.fractal_type = fractal_type.unwrap_or(FractalType::None); + } + + /// Sets octave count for all fractal noise types + /// + /// Default: 3 + pub fn set_fractal_octaves(&mut self, octaves: Option) { + self.octaves = octaves.unwrap_or(3); + self.calculate_fractal_bounding(); + } + + /// Sets octave lacunarity for all fractal noise types + /// + /// Default: 2.0 + pub fn set_fractal_lacunarity(&mut self, lacunarity: Option) { + self.lacunarity = lacunarity.unwrap_or(2.); + } + + /// Sets octave gain for all fractal noise types + /// + /// Default: 0.5 + pub fn set_fractal_gain(&mut self, gain: Option) { + self.gain = gain.unwrap_or(0.5); + self.calculate_fractal_bounding(); + } + + /// Sets octave weighting for all none DomainWarp fratal types + /// + /// Default: 0.0 + /// Note: Keep between 0...1 to maintain -1...1 output bounding + pub fn set_fractal_weighted_strength(&mut self, weighted_strength: Option) { + self.weighted_strength = weighted_strength.unwrap_or(0.); + } + + /// Sets strength of the fractal ping pong effect + /// + /// Default: 2.0 + pub fn set_fractal_ping_pong_strength(&mut self, ping_pong_strength: Option) { + self.ping_pong_strength = ping_pong_strength.unwrap_or(2.); + } + + /// Sets distance function used in cellular noise calculations + /// + /// Default: EuclideanSq + pub fn set_cellular_distance_function( + &mut self, + cellular_distance_function: Option, + ) { + self.cellular_distance_function = + cellular_distance_function.unwrap_or(CellularDistanceFunction::EuclideanSq); + } + + /// Sets return type from cellular noise calculations + /// + /// Default: Distance + pub fn set_cellular_return_type(&mut self, cellular_return_type: Option) { + self.cellular_return_type = cellular_return_type.unwrap_or(CellularReturnType::Distance); + } + + /// 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 + pub fn set_cellular_jitter(&mut self, cellular_jitter: Option) { + self.cellular_jitter_modifier = cellular_jitter.unwrap_or(1.); + } + + /// Sets the warp algorithm when using domain_warp(...) + /// + /// Default: OpenSimplex2 + pub fn set_domain_warp_type(&mut self, domain_warp_type: Option) { + self.domain_warp_type = domain_warp_type.unwrap_or(DomainWarpType::OpenSimplex2); + self.update_warp_transform_type_3d(); + } + + /// Sets the maximum warp distance from original position when using domain_warp(...) + /// + /// Default: 1.0 + pub fn set_domain_warp_amp(&mut self, domain_warp_amp: Option) { + self.domain_warp_amp = domain_warp_amp.unwrap_or(1.); + } + + /// 2D noise at given position using current settings. Use [`get_noise_3d`] for 3D noise. + /// + /// Noise output bounded between -1...1 + pub fn get_noise_2d(&mut self, x: Float, y: Float) -> f32 { + let (x, y) = self.transform_noise_coordinate_2d(x, y); + + match self.fractal_type { + FractalType::FBm => self.gen_fractal_fbm_2d(x, y), + FractalType::Ridged => self.gen_fractal_ridged_2d(x, y), + FractalType::PingPong => self.gen_fractal_ping_pong_2d(x, y), + _ => self.gen_noise_single_2d(self.seed, x, y), + } + } + + /// 3D noise at given position using current settings. Use [`get_noise_2d`] for 2D noise. + /// + /// Noise output bounded between -1...1 + pub fn get_noise_3d(&mut self, x: Float, y: Float, z: Float) -> f32 { + let (x, y, z) = self.transform_noise_coordinate_3d(x, y, z); + + match self.fractal_type { + FractalType::FBm => self.gen_fractal_fbm_3d(x, y, z), + FractalType::Ridged => self.gen_fractal_ridged_3d(x, y, z), + FractalType::PingPong => self.gen_fractal_ping_pong_3d(x, y, z), + _ => self.gen_noise_single_3d(self.seed, x, y, z), + } + } + + /// 2D warps the input position using current domain warp settings. Use [`domain_warp_3d`] for 3D domain warp. + /// + /// Example usage with get_noise_2d + /// ``` + /// let (x, y) = domain_warp_2d(x, y); + /// let noise = get_noise_2d(x, y); + /// ``` + pub fn domain_warp(&mut self, x: Float, y: Float) -> (Float, Float) { + match self.fractal_type { + FractalType::DomainWarpProgressive => self.domain_warp_fractal_progressive_2d(x, y), + FractalType::DomainWarpIndependent => self.domain_warp_fractal_independent_2d(x, y), + _ => self.domain_warp_single_2d(x, y), + } + } + + /// 3D warps the input position using current domain warp settings. Use [`domain_warp`] for 2D domain warp. + /// + /// Example usage with get_noise_3d + /// ``` + /// let (x, y, z) = domain_warp_3d(x, y, z); + /// let noise = get_noise_3d(x, y, z); + /// ``` + pub fn domain_warp_3d(&mut self, x: Float, y: Float, z: Float) -> (Float, Float, Float) { + match self.fractal_type { + FractalType::DomainWarpProgressive => self.domain_warp_fractal_progressive_3d(x, y, z), + FractalType::DomainWarpIndependent => self.domain_warp_fractal_independent_3d(x, y, z), + _ => self.domain_warp_single_3d(x, y, z), + } + } + + #[rustfmt::skip] + const GRADIENTS_2D: [f32; 256] = [ + 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, + -0.130526192220052, -0.99144486137381, -0.38268343236509, -0.923879532511287, -0.608761429008721, -0.793353340291235, -0.793353340291235, -0.608761429008721, + -0.923879532511287, -0.38268343236509, -0.99144486137381, -0.130526192220052, -0.99144486137381, 0.130526192220051, -0.923879532511287, 0.38268343236509, + -0.793353340291235, 0.608761429008721, -0.608761429008721, 0.793353340291235, -0.38268343236509, 0.923879532511287, -0.130526192220052, 0.99144486137381, + 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, + -0.130526192220052, -0.99144486137381, -0.38268343236509, -0.923879532511287, -0.608761429008721, -0.793353340291235, -0.793353340291235, -0.608761429008721, + -0.923879532511287, -0.38268343236509, -0.99144486137381, -0.130526192220052, -0.99144486137381, 0.130526192220051, -0.923879532511287, 0.38268343236509, + -0.793353340291235, 0.608761429008721, -0.608761429008721, 0.793353340291235, -0.38268343236509, 0.923879532511287, -0.130526192220052, 0.99144486137381, + 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, + -0.130526192220052, -0.99144486137381, -0.38268343236509, -0.923879532511287, -0.608761429008721, -0.793353340291235, -0.793353340291235, -0.608761429008721, + -0.923879532511287, -0.38268343236509, -0.99144486137381, -0.130526192220052, -0.99144486137381, 0.130526192220051, -0.923879532511287, 0.38268343236509, + -0.793353340291235, 0.608761429008721, -0.608761429008721, 0.793353340291235, -0.38268343236509, 0.923879532511287, -0.130526192220052, 0.99144486137381, + 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, + -0.130526192220052, -0.99144486137381, -0.38268343236509, -0.923879532511287, -0.608761429008721, -0.793353340291235, -0.793353340291235, -0.608761429008721, + -0.923879532511287, -0.38268343236509, -0.99144486137381, -0.130526192220052, -0.99144486137381, 0.130526192220051, -0.923879532511287, 0.38268343236509, + -0.793353340291235, 0.608761429008721, -0.608761429008721, 0.793353340291235, -0.38268343236509, 0.923879532511287, -0.130526192220052, 0.99144486137381, + 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, + -0.130526192220052, -0.99144486137381, -0.38268343236509, -0.923879532511287, -0.608761429008721, -0.793353340291235, -0.793353340291235, -0.608761429008721, + -0.923879532511287, -0.38268343236509, -0.99144486137381, -0.130526192220052, -0.99144486137381, 0.130526192220051, -0.923879532511287, 0.38268343236509, + -0.793353340291235, 0.608761429008721, -0.608761429008721, 0.793353340291235, -0.38268343236509, 0.923879532511287, -0.130526192220052, 0.99144486137381, + 0.38268343236509, 0.923879532511287, 0.923879532511287, 0.38268343236509, 0.923879532511287, -0.38268343236509, 0.38268343236509, -0.923879532511287, + -0.38268343236509, -0.923879532511287, -0.923879532511287, -0.38268343236509, -0.923879532511287, 0.38268343236509, -0.38268343236509, 0.923879532511287, + ]; + + #[rustfmt::skip] + const RAND_VECS_2D: [f32; 512] = [ + -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, -0.9951650832, 0.0982163789, 0.7724397808, -0.6350880136, 0.7573283322, -0.6530343002, -0.9928004525, -0.119780055, + -0.0532665713, 0.9985803285, 0.9754253726, -0.2203300762, -0.7665018163, 0.6422421394, 0.991636706, 0.1290606184, -0.994696838, 0.1028503788, -0.5379205513, -0.84299554, 0.5022815471, -0.8647041387, 0.4559821461, -0.8899889226, + -0.8659131224, -0.5001944266, 0.0879458407, -0.9961252577, -0.5051684983, 0.8630207346, 0.7753185226, -0.6315704146, -0.6921944612, 0.7217110418, -0.5191659449, -0.8546734591, 0.8978622882, -0.4402764035, -0.1706774107, 0.9853269617, + -0.9353430106, -0.3537420705, -0.9992404798, 0.03896746794, -0.2882064021, -0.9575683108, -0.9663811329, 0.2571137995, -0.8759714238, -0.4823630009, -0.8303123018, -0.5572983775, 0.05110133755, -0.9986934731, -0.8558373281, -0.5172450752, + 0.09887025282, 0.9951003332, 0.9189016087, 0.3944867976, -0.2439375892, -0.9697909324, -0.8121409387, -0.5834613061, -0.9910431363, 0.1335421355, 0.8492423985, -0.5280031709, -0.9717838994, -0.2358729591, 0.9949457207, 0.1004142068, + 0.6241065508, -0.7813392434, 0.662910307, 0.7486988212, -0.7197418176, 0.6942418282, -0.8143370775, -0.5803922158, 0.104521054, -0.9945226741, -0.1065926113, -0.9943027784, 0.445799684, -0.8951327509, 0.105547406, 0.9944142724, + -0.992790267, 0.1198644477, -0.8334366408, 0.552615025, 0.9115561563, -0.4111755999, 0.8285544909, -0.5599084351, 0.7217097654, -0.6921957921, 0.4940492677, -0.8694339084, -0.3652321272, -0.9309164803, -0.9696606758, 0.2444548501, + 0.08925509731, -0.996008799, 0.5354071276, -0.8445941083, -0.1053576186, 0.9944343981, -0.9890284586, 0.1477251101, 0.004856104961, 0.9999882091, 0.9885598478, 0.1508291331, 0.9286129562, -0.3710498316, -0.5832393863, -0.8123003252, + 0.3015207509, 0.9534596146, -0.9575110528, 0.2883965738, 0.9715802154, -0.2367105511, 0.229981792, 0.9731949318, 0.955763816, -0.2941352207, 0.740956116, 0.6715534485, -0.9971513787, -0.07542630764, 0.6905710663, -0.7232645452, + -0.290713703, -0.9568100872, 0.5912777791, -0.8064679708, -0.9454592212, -0.325740481, 0.6664455681, 0.74555369, 0.6236134912, 0.7817328275, 0.9126993851, -0.4086316587, -0.8191762011, 0.5735419353, -0.8812745759, -0.4726046147, + 0.9953313627, 0.09651672651, 0.9855650846, -0.1692969699, -0.8495980887, 0.5274306472, 0.6174853946, -0.7865823463, 0.8508156371, 0.52546432, 0.9985032451, -0.05469249926, 0.1971371563, -0.9803759185, 0.6607855748, -0.7505747292, + -0.03097494063, 0.9995201614, -0.6731660801, 0.739491331, -0.7195018362, -0.6944905383, 0.9727511689, 0.2318515979, 0.9997059088, -0.0242506907, 0.4421787429, -0.8969269532, 0.9981350961, -0.061043673, -0.9173660799, -0.3980445648, + -0.8150056635, -0.5794529907, -0.8789331304, 0.4769450202, 0.0158605829, 0.999874213, -0.8095464474, 0.5870558317, -0.9165898907, -0.3998286786, -0.8023542565, 0.5968480938, -0.5176737917, 0.8555780767, -0.8154407307, -0.5788405779, + 0.4022010347, -0.9155513791, -0.9052556868, -0.4248672045, 0.7317445619, 0.6815789728, -0.5647632201, -0.8252529947, -0.8403276335, -0.5420788397, -0.9314281527, 0.363925262, 0.5238198472, 0.8518290719, 0.7432803869, -0.6689800195, + -0.985371561, -0.1704197369, 0.4601468731, 0.88784281, 0.825855404, 0.5638819483, 0.6182366099, 0.7859920446, 0.8331502863, -0.553046653, 0.1500307506, 0.9886813308, -0.662330369, -0.7492119075, -0.668598664, 0.743623444, + 0.7025606278, 0.7116238924, -0.5419389763, -0.8404178401, -0.3388616456, 0.9408362159, 0.8331530315, 0.5530425174, -0.2989720662, -0.9542618632, 0.2638522993, 0.9645630949, 0.124108739, -0.9922686234, -0.7282649308, -0.6852956957, + 0.6962500149, 0.7177993569, -0.9183535368, 0.3957610156, -0.6326102274, -0.7744703352, -0.9331891859, -0.359385508, -0.1153779357, -0.9933216659, 0.9514974788, -0.3076565421, -0.08987977445, -0.9959526224, 0.6678496916, 0.7442961705, + 0.7952400393, -0.6062947138, -0.6462007402, -0.7631674805, -0.2733598753, 0.9619118351, 0.9669590226, -0.254931851, -0.9792894595, 0.2024651934, -0.5369502995, -0.8436138784, -0.270036471, -0.9628500944, -0.6400277131, 0.7683518247, + -0.7854537493, -0.6189203566, 0.06005905383, -0.9981948257, -0.02455770378, 0.9996984141, -0.65983623, 0.751409442, -0.6253894466, -0.7803127835, -0.6210408851, -0.7837781695, 0.8348888491, 0.5504185768, -0.1592275245, 0.9872419133, + 0.8367622488, 0.5475663786, -0.8675753916, -0.4973056806, -0.2022662628, -0.9793305667, 0.9399189937, 0.3413975472, 0.9877404807, -0.1561049093, -0.9034455656, 0.4287028224, 0.1269804218, -0.9919052235, -0.3819600854, 0.924178821, + 0.9754625894, 0.2201652486, -0.3204015856, -0.9472818081, -0.9874760884, 0.1577687387, 0.02535348474, -0.9996785487, 0.4835130794, -0.8753371362, -0.2850799925, -0.9585037287, -0.06805516006, -0.99768156, -0.7885244045, -0.6150034663, + 0.3185392127, -0.9479096845, 0.8880043089, 0.4598351306, 0.6476921488, -0.7619021462, 0.9820241299, 0.1887554194, 0.9357275128, -0.3527237187, -0.8894895414, 0.4569555293, 0.7922791302, 0.6101588153, 0.7483818261, 0.6632681526, + -0.7288929755, -0.6846276581, 0.8729032783, -0.4878932944, 0.8288345784, 0.5594937369, 0.08074567077, 0.9967347374, 0.9799148216, -0.1994165048, -0.580730673, -0.8140957471, -0.4700049791, -0.8826637636, 0.2409492979, 0.9705377045, + 0.9437816757, -0.3305694308, -0.8927998638, -0.4504535528, -0.8069622304, 0.5906030467, 0.06258973166, 0.9980393407, -0.9312597469, 0.3643559849, 0.5777449785, 0.8162173362, -0.3360095855, -0.941858566, 0.697932075, -0.7161639607, + -0.002008157227, -0.9999979837, -0.1827294312, -0.9831632392, -0.6523911722, 0.7578824173, -0.4302626911, -0.9027037258, -0.9985126289, -0.05452091251, -0.01028102172, -0.9999471489, -0.4946071129, 0.8691166802, -0.2999350194, 0.9539596344, + 0.8165471961, 0.5772786819, 0.2697460475, 0.962931498, -0.7306287391, -0.6827749597, -0.7590952064, -0.6509796216, -0.907053853, 0.4210146171, -0.5104861064, -0.8598860013, 0.8613350597, 0.5080373165, 0.5007881595, -0.8655698812, + -0.654158152, 0.7563577938, -0.8382755311, -0.545246856, 0.6940070834, 0.7199681717, 0.06950936031, 0.9975812994, 0.1702942185, -0.9853932612, 0.2695973274, 0.9629731466, 0.5519612192, -0.8338697815, 0.225657487, -0.9742067022, + 0.4215262855, -0.9068161835, 0.4881873305, -0.8727388672, -0.3683854996, -0.9296731273, -0.9825390578, 0.1860564427, 0.81256471, 0.5828709909, 0.3196460933, -0.9475370046, 0.9570913859, 0.2897862643, -0.6876655497, -0.7260276109, + -0.9988770922, -0.047376731, -0.1250179027, 0.992154486, -0.8280133617, 0.560708367, 0.9324863769, -0.3612051451, 0.6394653183, 0.7688199442, -0.01623847064, -0.9998681473, -0.9955014666, -0.09474613458, -0.81453315, 0.580117012, + 0.4037327978, -0.9148769469, 0.9944263371, 0.1054336766, -0.1624711654, 0.9867132919, -0.9949487814, -0.100383875, -0.6995302564, 0.7146029809, 0.5263414922, -0.85027327, -0.5395221479, 0.841971408, 0.6579370318, 0.7530729462, + 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, + ]; + + #[rustfmt::skip] + const GRADIENTS_3D: [f32; 256] = [ + 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., + ]; + + #[rustfmt::skip] + const RAND_VECS_3D: [f32; 1024] = [ + -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., + ]; + + #[inline(always)] + fn fast_floor(f: Float) -> i32 { + if f >= 0. { + f as i32 + } else { + f as i32 - 1 + } + } + + #[inline(always)] + fn fast_round(f: Float) -> i32 { + if f >= 0. { + (f + 0.5) as i32 + } else { + (f - 0.5) as i32 + } + } + + #[inline(always)] + fn lerp(a: f32, b: f32, t: f32) -> f32 { + a + t * (b - a) + } + + #[inline(always)] + fn interp_hermite(t: f32) -> f32 { + t * t * (t * -2. + 3.) + } + + #[inline(always)] + fn interp_quintic(t: f32) -> f32 { + t * t * t * (t * (t * 6. - 15.) + 10.) + } + + #[inline(always)] + fn cubic_lerp(a: f32, b: f32, c: f32, d: f32, t: f32) -> f32 { + let p = (d - c) - (a - b); + t * t * t * p + t * t * ((a - b) - p) + t * (c - a) + b + } + + #[inline(always)] + fn ping_pong(t: f32) -> f32 { + let t = t - (t * 0.5).trunc() * 2.; + if t < 1. { + t + } else { + 2. - t + } + } + + fn calculate_fractal_bounding(&mut self) { + let gain = self.gain.abs(); + let mut amp = gain; + let mut amp_fractal = 1.; + for _ in 1..self.octaves { + amp_fractal += amp; + amp *= gain; + } + self.fractal_bounding = 1. / amp_fractal; + } + + // Hashing + const PRIME_X: i32 = 501125321; + const PRIME_Y: i32 = 1136930381; + const PRIME_Z: i32 = 1720413743; + const PRIME_X_2: i32 = Self::PRIME_X.wrapping_mul(2); + const PRIME_Y_2: i32 = Self::PRIME_Y.wrapping_mul(2); + const PRIME_Z_2: i32 = Self::PRIME_Z.wrapping_mul(2); + + #[inline(always)] + fn hash_2d(seed: i32, x_primed: i32, y_primed: i32) -> i32 { + let hash = seed ^ x_primed ^ y_primed; + hash.wrapping_mul(0x27d4eb2d) + } + + #[inline(always)] + fn hash_3d(seed: i32, x_primed: i32, y_primed: i32, z_primed: i32) -> i32 { + let hash = seed ^ x_primed ^ y_primed ^ z_primed; + hash.wrapping_mul(0x27d4eb2d) + } + + #[inline(always)] + fn val_coord_2d(seed: i32, x_primed: i32, y_primed: i32) -> f32 { + let hash = Self::hash_2d(seed, x_primed, y_primed); + let hash = hash.wrapping_mul(hash); + let hash = hash ^ (hash << 19); + hash as f32 * (1. / 2147483648.) + } + + #[inline(always)] + fn val_coord_3d(seed: i32, x_primed: i32, y_primed: i32, z_primed: i32) -> f32 { + let hash = Self::hash_3d(seed, x_primed, y_primed, z_primed); + + let hash = hash.wrapping_mul(hash); + let hash = hash ^ (hash << 19); + hash as f32 * (1. / 2147483648.) + } + + #[inline(always)] + fn grad_coord_2d(seed: i32, x_primed: i32, y_primed: i32, xd: f32, yd: f32) -> f32 { + let hash = Self::hash_2d(seed, x_primed, y_primed); + let hash = hash ^ (hash >> 15); + let hash = hash & (127 << 1); + + let xg = Self::GRADIENTS_2D[hash as usize]; + let yg = Self::GRADIENTS_2D[(hash | 1) as usize]; + + xd * xg + yd * yg + } + + #[inline(always)] + fn grad_coord_3d( + seed: i32, + x_primed: i32, + y_primed: i32, + z_primed: i32, + xd: f32, + yd: f32, + zd: f32, + ) -> f32 { + let hash = Self::hash_3d(seed, x_primed, y_primed, z_primed); + let hash = hash ^ (hash >> 15); + let hash = hash & (63 << 2); + + let xg = Self::GRADIENTS_3D[hash as usize]; + let yg = Self::GRADIENTS_3D[(hash | 1) as usize]; + let zg = Self::GRADIENTS_3D[(hash | 2) as usize]; + + xd * xg + yd * yg + zd * zg + } + + #[inline(always)] + fn grad_coord_out_2d(seed: i32, x_primed: i32, y_primed: i32) -> (f32, f32) { + let hash = Self::hash_2d(seed, x_primed, y_primed) & (255 << 1); + + let xo = Self::RAND_VECS_2D[hash as usize]; + let yo = Self::RAND_VECS_2D[(hash | 1) as usize]; + + (xo, yo) + } + + #[inline(always)] + fn grad_coord_out_3d( + seed: i32, + x_primed: i32, + y_primed: i32, + z_primed: i32, + ) -> (f32, f32, f32) { + let hash = Self::hash_3d(seed, x_primed, y_primed, z_primed) & (255 << 2); + + let xo = Self::RAND_VECS_3D[hash as usize]; + let yo = Self::RAND_VECS_3D[(hash | 1) as usize]; + let zo = Self::RAND_VECS_3D[(hash | 2) as usize]; + + (xo, yo, zo) + } + + #[inline(always)] + fn grad_coord_dual_2d(seed: i32, x_primed: i32, y_primed: i32, xd: f32, yd: f32) -> (f32, f32) { + let hash = Self::hash_2d(seed, x_primed, y_primed); + let index1 = hash & (127 << 1); + let index2 = (hash >> 7) & (255 << 1); + + let xg = Self::GRADIENTS_2D[index1 as usize]; + let yg = Self::GRADIENTS_2D[(index1 | 1) as usize]; + let value = xd * xg + yd * yg; + + let xgo = Self::RAND_VECS_2D[index2 as usize]; + let ygo = Self::RAND_VECS_2D[(index2 | 1) as usize]; + + let xo = value * xgo; + let yo = value * ygo; + + (xo, yo) + } + + #[inline(always)] + fn grad_coord_dual_3d( + seed: i32, + x_primed: i32, + y_primed: i32, + z_primed: i32, + xd: f32, + yd: f32, + zd: f32, + ) -> (f32, f32, f32) { + let hash = Self::hash_3d(seed, x_primed, y_primed, z_primed); + let index1 = hash & (63 << 2); + let index2 = (hash >> 6) & (255 << 2); + + let xg = Self::GRADIENTS_3D[index1 as usize]; + let yg = Self::GRADIENTS_3D[(index1 | 1) as usize]; + let zg = Self::GRADIENTS_3D[(index1 | 2) as usize]; + let value = xd * xg + yd * yg + zd * zg; + + let xgo = Self::RAND_VECS_3D[index2 as usize]; + let ygo = Self::RAND_VECS_3D[(index2 | 1) as usize]; + let zgo = Self::RAND_VECS_3D[(index2 | 2) as usize]; + + let xo = value * xgo; + let yo = value * ygo; + let zo = value * zgo; + + (xo, yo, zo) + } + + // Generic noise gen + + fn gen_noise_single_2d(&self, seed: i32, x: Float, y: Float) -> f32 { + match self.noise_type { + NoiseType::OpenSimplex2 => self.single_simplex_2d(seed, x, y), + NoiseType::OpenSimplex2S => self.single_open_simplex_2s_2d(seed, x, y), + NoiseType::Cellular => self.single_cellular_2d(seed, x, y), + NoiseType::Perlin => self.single_perlin_2d(seed, x, y), + NoiseType::ValueCubic => self.single_value_cubic_2d(seed, x, y), + NoiseType::Value => self.single_value_2d(seed, x, y), + } + } + + fn gen_noise_single_3d(&self, seed: i32, x: Float, y: Float, z: Float) -> f32 { + match self.noise_type { + NoiseType::OpenSimplex2 => self.single_open_simplex_2(seed, x, y, z), + NoiseType::OpenSimplex2S => self.single_open_simplex_2s_3d(seed, x, y, z), + NoiseType::Cellular => self.single_cellular_3d(seed, x, y, z), + NoiseType::Perlin => self.single_perlin_3d(seed, x, y, z), + NoiseType::ValueCubic => self.single_value_cubic_3d(seed, x, y, z), + NoiseType::Value => self.single_value_3d(seed, x, y, z), + } + } + + // Noise Coordinate Transforms (frequency, and possible skew or rotation) + + #[inline(always)] + fn transform_noise_coordinate_2d(&self, x: Float, y: Float) -> (Float, Float) { + let mut x = x * self.frequency as Float; + let mut y = y * self.frequency as Float; + + match self.noise_type { + NoiseType::OpenSimplex2 | NoiseType::OpenSimplex2S => { + let sqrt3 = 1.7320508075688772935274463415059; + let f2 = 0.5 * (sqrt3 - 1.); + let t = (x + y) * f2; + + x += t; + y += t; + } + _ => {} + } + + (x, y) + } + + #[inline(always)] + fn transform_noise_coordinate_3d(&self, x: Float, y: Float, z: Float) -> (Float, Float, Float) { + let mut x = x * self.frequency as Float; + let mut y = y * self.frequency as Float; + let mut z = z * self.frequency as Float; + + match self.transform_type_3d { + TransformType3D::ImproveXYPlanes => { + let xy = x + y; + let s2 = xy * -0.211324865405187; + z *= 0.577350269189626; + x += s2 - z; + y = y + s2 - z; + z += xy * 0.577350269189626; + } + TransformType3D::ImproveXZPlanes => { + let xz = x + z; + let s2 = xz * -0.211324865405187; + y *= 0.577350269189626; + x += s2 - y; + z += s2 - y; + y += xz * 0.577350269189626; + } + TransformType3D::DefaultOpenSimplex2 => { + let r3 = 2. / 3.; + let r = (x + y + z) * r3; // Rotation, not skew + x = r - x; + y = r - y; + z = r - z; + } + _ => {} + } + + (x, y, z) + } + + fn update_transform_type_3d(&mut self) { + match self.rotation_type_3d { + RotationType3D::ImproveXYPlanes => { + self.transform_type_3d = TransformType3D::ImproveXYPlanes; + } + RotationType3D::ImproveXZPlanes => { + self.transform_type_3d = TransformType3D::ImproveXZPlanes; + } + _ => match self.noise_type { + NoiseType::OpenSimplex2 | NoiseType::OpenSimplex2S => { + self.transform_type_3d = TransformType3D::DefaultOpenSimplex2; + } + _ => { + self.transform_type_3d = TransformType3D::None; + } + }, + } + } + + // Domain Warp Coordinate Transforms + + #[inline(always)] + fn transform_domain_warp_coordinate_2d(&self, x: Float, y: Float) -> (Float, Float) { + let mut x = x; + let mut y = y; + + match self.domain_warp_type { + DomainWarpType::OpenSimplex2 | DomainWarpType::OpenSimplex2Reduced => { + let sqrt3 = 1.7320508075688772935274463415059; + let f2 = 0.5 * (sqrt3 - 1.); + let t = (x + y) * f2; + + x += t; + y += t; + } + _ => {} + } + + (x, y) + } + + #[inline(always)] + fn transform_domain_warp_coordinate_3d( + &self, + x: Float, + y: Float, + z: Float, + ) -> (Float, Float, Float) { + let mut x = x; + let mut y = y; + let mut z = z; + + match self.warp_transform_type_3d { + TransformType3D::ImproveXYPlanes => { + let xy = x + y; + let s2 = xy * -0.211324865405187; + z *= 0.577350269189626; + x += s2 - z; + y = y + s2 - z; + z += xy * 0.577350269189626; + } + TransformType3D::ImproveXZPlanes => { + let xz = x + z; + let s2 = xz * -0.211324865405187; + y *= 0.577350269189626; + x += s2 - y; + z += s2 - y; + y += xz * 0.577350269189626; + } + TransformType3D::DefaultOpenSimplex2 => { + let r3 = 2. / 3.; + let r = (x + y + z) * r3; // Rotation, not skew + x = r - x; + y = r - y; + z = r - z; + } + _ => {} + } + + (x, y, z) + } + + fn update_warp_transform_type_3d(&mut self) { + match self.rotation_type_3d { + RotationType3D::ImproveXYPlanes => { + self.warp_transform_type_3d = TransformType3D::ImproveXYPlanes; + } + RotationType3D::ImproveXZPlanes => { + self.warp_transform_type_3d = TransformType3D::ImproveXZPlanes; + } + _ => match self.domain_warp_type { + DomainWarpType::OpenSimplex2 | DomainWarpType::OpenSimplex2Reduced => { + self.warp_transform_type_3d = TransformType3D::DefaultOpenSimplex2; + } + _ => { + self.warp_transform_type_3d = TransformType3D::None; + } + }, + } + } + + // Fractal FBm + + fn gen_fractal_fbm_2d(&mut self, x: Float, y: Float) -> f32 { + let mut x = x; + let mut y = y; + + let mut seed = self.seed; + let mut sum = 0.; + let mut amp = self.fractal_bounding; + + for _ in 0..self.octaves { + let noise = self.gen_noise_single_2d(seed, x, y); + + seed += 1; + sum += noise * amp; + amp *= Self::lerp(1., (noise + 1.).min(2.) * 0.5, self.weighted_strength); + + x *= self.lacunarity as Float; + y *= self.lacunarity as Float; + amp *= self.gain; + } + + sum + } + + fn gen_fractal_fbm_3d(&self, x: Float, y: Float, z: Float) -> f32 { + let mut x = x; + let mut y = y; + let mut z = z; + + let mut seed = self.seed; + let mut sum = 0.; + let mut amp = self.fractal_bounding; + + for _ in 0..self.octaves { + let noise = self.gen_noise_single_3d(seed, x, y, z); + + seed += 1; + sum += noise * amp; + amp *= Self::lerp(1., (noise + 1.) * 0.5, self.weighted_strength); + + x *= self.lacunarity as Float; + y *= self.lacunarity as Float; + z *= self.lacunarity as Float; + amp *= self.gain; + } + + sum + } + + // Fractal Ridged + + fn gen_fractal_ridged_2d(&self, x: Float, y: Float) -> f32 { + let mut x = x; + let mut y = y; + + let mut seed = self.seed; + let mut sum = 0.; + let mut amp = self.fractal_bounding; + + for _ in 0..self.octaves { + let noise = self.gen_noise_single_2d(seed, x, y).abs(); + seed += 1; + + sum += (noise * -2. + 1.) * amp; + amp *= Self::lerp(1., 1. - noise, self.weighted_strength); + + x *= self.lacunarity as Float; + y *= self.lacunarity as Float; + amp *= self.gain; + } + + sum + } + + fn gen_fractal_ridged_3d(&self, x: Float, y: Float, z: Float) -> f32 { + let mut x = x; + let mut y = y; + let mut z = z; + + let mut seed = self.seed; + let mut sum = 0.; + let mut amp = self.fractal_bounding; + + for _ in 0..self.octaves { + let noise = self.gen_noise_single_3d(seed, x, y, z).abs(); + seed += 1; + + sum += (noise * -2. + 1.) * amp; + amp *= Self::lerp(1., 1. - noise, self.weighted_strength); + + x *= self.lacunarity as Float; + y *= self.lacunarity as Float; + z *= self.lacunarity as Float; + amp *= self.gain; + } + + sum + } + + // Fractal PingPong + + fn gen_fractal_ping_pong_2d(&self, x: Float, y: Float) -> f32 { + let mut x = x; + let mut y = y; + + let mut seed = self.seed; + let mut sum = 0.; + let mut amp = self.fractal_bounding; // DEBUG: This is 0.400000006, should be 0.4 + + for _ in 0..self.octaves { + let noise = Self::ping_pong( + (self.gen_noise_single_2d(seed, x, y) + 1.) * self.ping_pong_strength, + ); + seed += 1; + + sum += (noise - 0.5) * 2. * amp; + amp *= Self::lerp(1., noise, self.weighted_strength); + + x *= self.lacunarity as Float; + y *= self.lacunarity as Float; + amp *= self.gain; + } + + sum + } + + fn gen_fractal_ping_pong_3d(&self, x: Float, y: Float, z: Float) -> f32 { + let mut x = x; + let mut y = y; + let mut z = z; + + let mut seed = self.seed; + let mut sum = 0.; + let mut amp = self.fractal_bounding; + + for _ in 0..self.octaves { + let noise = Self::ping_pong( + (self.gen_noise_single_3d(seed, x, y, z) + 1.) * self.ping_pong_strength, + ); + seed += 1; + + sum += (noise - 0.5) * 2. * amp; + amp *= Self::lerp(1., noise, self.weighted_strength); + + x *= self.lacunarity as Float; + y *= self.lacunarity as Float; + z *= self.lacunarity as Float; + amp *= self.gain; + } + + sum + } + + // Simplex/OpenSimplex2 Noise + + fn single_simplex_2d(&self, seed: i32, x: Float, y: Float) -> f32 { + // 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex. + + let sqrt3 = 1.7320508075688772935274463415059; + let g2 = (3. - sqrt3) / 6.; + + /* + * --- Skew moved to TransformNoiseCoordinateXY method --- + * let f2 = 0.5 * (sqrt3 - 1.); + * let s = (x + y) * f2; + * x += s; y += s; + */ + + let i = Self::fast_floor(x); + let j = Self::fast_floor(y); + #[allow(clippy::unnecessary_cast)] + let xi = (x - i as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let yi = (y - j as Float) as f32; + + let t = (xi + yi) * g2; + let x0 = xi - t; + let y0 = yi - t; + + let i = i.wrapping_mul(Self::PRIME_X); + let j = j.wrapping_mul(Self::PRIME_Y); + + let a = 0.5 - x0 * x0 - y0 * y0; + let n0 = if a <= 0. { + 0. + } else { + (a * a) * (a * a) * Self::grad_coord_2d(seed, i, j, x0, y0) + }; + + let c = (2. * (1. - 2. * g2) * (1. / g2 - 2.)) * t + + ((-2. * (1. - 2. * g2) * (1. - 2. * g2)) + a); + let n2 = if c <= 0. { + 0. + } else { + let x2 = x0 + (2. * g2 - 1.); + let y2 = y0 + (2. * g2 - 1.); + + (c * c) + * (c * c) + * Self::grad_coord_2d( + seed, + i.wrapping_add(Self::PRIME_X), + j.wrapping_add(Self::PRIME_Y), + x2, + y2, + ) + }; + + let n1 = if y0 > x0 { + let x1 = x0 + g2; + let y1 = y0 + (g2 - 1.); + let b = 0.5 - x1 * x1 - y1 * y1; + + if b <= 0. { + 0. + } else { + (b * b) + * (b * b) + * Self::grad_coord_2d(seed, i, j.wrapping_add(Self::PRIME_Y), x1, y1) + } + } else { + let x1 = x0 + (g2 - 1.); + let y1 = y0 + g2; + let b = 0.5 - x1 * x1 - y1 * y1; + + if b <= 0. { + 0. + } else { + (b * b) + * (b * b) + * Self::grad_coord_2d(seed, i.wrapping_add(Self::PRIME_X), j, x1, y1) + } + }; + + (n0 + n1 + n2) * 99.83685446303647 + } + + fn single_open_simplex_2(&self, seed: i32, x: Float, y: Float, z: Float) -> f32 { + // 3D OpenSimplex2 case uses two offset rotated cube grids. + + /* + * --- Rotation moved to TransformNoiseCoordinateXYZ method --- + * let r3 = 2. / 3.; + * let r = (x + y + z) * r3; // Rotation, not skew + * x = r - x; y = r - y; z = r - z; + */ + + let mut seed = seed; + + let i = Self::fast_round(x); + let j = Self::fast_round(y); + let k = Self::fast_round(z); + #[allow(clippy::unnecessary_cast)] + let mut x0 = (x - i as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let mut y0 = (y - j as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let mut z0 = (z - k as Float) as f32; + + let mut x_n_sign = (-1. - x0) as i32 | 1; + let mut y_n_sign = (-1. - y0) as i32 | 1; + let mut z_n_sign = (-1. - z0) as i32 | 1; + + let mut ax0 = x_n_sign as f32 * -x0; + let mut ay0 = y_n_sign as f32 * -y0; + let mut az0 = z_n_sign as f32 * -z0; + + let mut i = i.wrapping_mul(Self::PRIME_X); + let mut j = j.wrapping_mul(Self::PRIME_Y); + let mut k = k.wrapping_mul(Self::PRIME_Z); + + let mut value = 0.; + let mut a = (0.6 - x0 * x0) - (y0 * y0 + z0 * z0); + + let mut l = 0; + loop { + if a > 0. { + value += (a * a) * (a * a) * Self::grad_coord_3d(seed, i, j, k, x0, y0, z0); + } + + if ax0 >= ay0 && ax0 >= az0 { + let b = a + ax0 + ax0; + if b > 1. { + let b = b - 1.; + value += (b * b) + * (b * b) + * Self::grad_coord_3d( + seed, + i.wrapping_sub(x_n_sign.wrapping_mul(Self::PRIME_X)), + j, + k, + x0 + x_n_sign as f32, + y0, + z0, + ); + } + } else if ay0 > ax0 && ay0 >= az0 { + let b = a + ay0 + ay0; + if b > 1. { + let b = b - 1.; + value += (b * b) + * (b * b) + * Self::grad_coord_3d( + seed, + i, + j.wrapping_sub(y_n_sign.wrapping_mul(Self::PRIME_Y)), + k, + x0, + y0 + y_n_sign as f32, + z0, + ); + } + } else { + let b = a + az0 + az0; + if b > 1. { + let b = b - 1.; + value += (b * b) + * (b * b) + * Self::grad_coord_3d( + seed, + i, + j, + k.wrapping_sub(z_n_sign.wrapping_mul(Self::PRIME_Z)), + x0, + y0, + z0 + z_n_sign as f32, + ); + } + } + + if l == 1 { + break; + } + + ax0 = 0.5 - ax0; + ay0 = 0.5 - ay0; + az0 = 0.5 - az0; + + x0 = x_n_sign as f32 * ax0; + y0 = y_n_sign as f32 * ay0; + z0 = z_n_sign as f32 * az0; + + a = a + (0.75 - ax0) - (ay0 + az0); + + i = i.wrapping_add((x_n_sign >> 1) & Self::PRIME_X); + j = j.wrapping_add((y_n_sign >> 1) & Self::PRIME_Y); + k = k.wrapping_add((z_n_sign >> 1) & Self::PRIME_Z); + + x_n_sign = -x_n_sign; + y_n_sign = -y_n_sign; + z_n_sign = -z_n_sign; + + seed = !seed; + + l += 1; + } + + value * 32.69428253173828125 + } + + // OpenSimplex2S Noise + + fn single_open_simplex_2s_2d(&self, seed: i32, x: Float, y: Float) -> f32 { + // 2D OpenSimplex2S case is a modified 2D simplex noise. + + let sqrt3 = 1.7320508075688772935274463415059; + let g2 = (3. - sqrt3) / 6.; + + /* + * --- Skew moved to TransformNoiseCoordinateXY method --- + * let f2 = 0.5 * (sqrt3 - 1); + * let s = (x + y) * f2; + * x += s; y += s; + */ + + let i = Self::fast_floor(x); + let j = Self::fast_floor(y); + #[allow(clippy::unnecessary_cast)] + let xi = (x - i as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let yi = (y - j as Float) as f32; + + let i = i.wrapping_mul(Self::PRIME_X); + let j = j.wrapping_mul(Self::PRIME_Y); + let i1 = i.wrapping_add(Self::PRIME_X); + let j1 = j.wrapping_add(Self::PRIME_Y); + + let t = (xi + yi) * g2; + let x0 = xi - t; + let y0 = yi - t; + + let a0 = (2. / 3.) - x0 * x0 - y0 * y0; + let mut value = (a0 * a0) * (a0 * a0) * Self::grad_coord_2d(seed, i, j, x0, y0); + + let a1 = (2. * (1. - 2. * g2) * (1. / g2 - 2.)) * t + + ((-2. * (1. - 2. * g2) * (1. - 2. * g2)) + a0); + let x1 = x0 - (1. - 2. * g2); + let y1 = y0 - (1. - 2. * g2); + value += (a1 * a1) * (a1 * a1) * Self::grad_coord_2d(seed, i1, j1, x1, y1); + + // Nested conditionals were faster than compact bit logic/arithmetic. + let xmyi = xi - yi; + if t > g2 { + if xi + xmyi > 1. { + let x2 = x0 + (3. * g2 - 2.); + let y2 = y0 + (3. * g2 - 1.); + let a2 = (2. / 3.) - x2 * x2 - y2 * y2; + if a2 > 0. { + value += (a2 * a2) + * (a2 * a2) + * Self::grad_coord_2d( + seed, + i.wrapping_add(Self::PRIME_X << 1), + j.wrapping_add(Self::PRIME_Y), + x2, + y2, + ) + } + } else { + let x2 = x0 + g2; + let y2 = y0 + (g2 - 1.); + let a2 = (2. / 3.) - x2 * x2 - y2 * y2; + if a2 > 0. { + value += (a2 * a2) + * (a2 * a2) + * Self::grad_coord_2d(seed, i, j.wrapping_add(Self::PRIME_Y), x2, y2) + } + } + + if yi - xmyi > 1. { + let x3 = x0 + (3. * g2 - 1.); + let y3 = y0 + (3. * g2 - 2.); + let a3 = (2. / 3.) - x3 * x3 - y3 * y3; + if a3 > 0. { + value += (a3 * a3) + * (a3 * a3) + * Self::grad_coord_2d( + seed, + i.wrapping_add(Self::PRIME_X), + j.wrapping_add(Self::PRIME_Y << 1), + x3, + y3, + ) + } + } else { + let x3 = x0 + (g2 - 1.); + let y3 = y0 + g2; + let a3 = (2. / 3.) - x3 * x3 - y3 * y3; + if a3 > 0. { + value += (a3 * a3) + * (a3 * a3) + * Self::grad_coord_2d(seed, i.wrapping_add(Self::PRIME_X), j, x3, y3) + } + } + } else { + if xi + xmyi < 0. { + let x2 = x0 + (1. - g2); + let y2 = y0 - g2; + let a2 = (2. / 3.) - x2 * x2 - y2 * y2; + if a2 > 0. { + value += (a2 * a2) + * (a2 * a2) + * Self::grad_coord_2d(seed, i.wrapping_sub(Self::PRIME_X), j, x2, y2) + } + } else { + let x2 = x0 + (g2 - 1.); + let y2 = y0 + g2; + let a2 = (2. / 3.) - x2 * x2 - y2 * y2; + if a2 > 0. { + value += (a2 * a2) + * (a2 * a2) + * Self::grad_coord_2d(seed, i.wrapping_add(Self::PRIME_X), j, x2, y2) + } + } + + if yi < xmyi { + let x2 = x0 - g2; + let y2 = y0 - (g2 - 1.); + let a2 = (2. / 3.) - x2 * x2 - y2 * y2; + if a2 > 0. { + value += (a2 * a2) + * (a2 * a2) + * Self::grad_coord_2d(seed, i, j.wrapping_sub(Self::PRIME_Y), x2, y2) + } + } else { + let x2 = x0 + g2; + let y2 = y0 + (g2 - 1.); + let a2 = (2. / 3.) - x2 * x2 - y2 * y2; + if a2 > 0. { + value += (a2 * a2) + * (a2 * a2) + * Self::grad_coord_2d(seed, i, j.wrapping_add(Self::PRIME_Y), x2, y2) + } + } + } + + value * 18.24196194486065 + } + + fn single_open_simplex_2s_3d(&self, seed: i32, x: Float, y: Float, z: Float) -> f32 { + // 3D OpenSimplex2S case uses two offset rotated cube grids. + + /* + * --- Rotation moved to TransformNoiseCoordinateXYZ method --- + * let R3 = 2. / 3.; + * let r = (x + y + z) * R3; // Rotation, not skew + * x = r - x; y = r - y; z = r - z; + */ + + let i = Self::fast_floor(x); + let j = Self::fast_floor(y); + let k = Self::fast_floor(z); + #[allow(clippy::unnecessary_cast)] + let xi = (x - i as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let yi = (y - j as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let zi = (z - k as Float) as f32; + + let i = i.wrapping_mul(Self::PRIME_X); + let j = j.wrapping_mul(Self::PRIME_Y); + let k = k.wrapping_mul(Self::PRIME_Z); + let seed2 = seed + 1293373; + + let x_n_mask = (-0.5 - xi) as i32; + let y_n_mask = (-0.5 - yi) as i32; + let z_n_mask = (-0.5 - zi) as i32; + + let x0 = xi + x_n_mask as f32; + let y0 = yi + y_n_mask as f32; + let z0 = zi + z_n_mask as f32; + let a0 = 0.75 - x0 * x0 - y0 * y0 - z0 * z0; + let mut value = (a0 * a0) + * (a0 * a0) + * Self::grad_coord_3d( + seed, + i.wrapping_add(x_n_mask & Self::PRIME_X), + j.wrapping_add(y_n_mask & Self::PRIME_Y), + k.wrapping_add(z_n_mask & Self::PRIME_Z), + x0, + y0, + z0, + ); + + let x1 = xi - 0.5; + let y1 = yi - 0.5; + let z1 = zi - 0.5; + let a1 = 0.75 - x1 * x1 - y1 * y1 - z1 * z1; + value += (a1 * a1) + * (a1 * a1) + * Self::grad_coord_3d( + seed2, + i.wrapping_add(Self::PRIME_X), + j.wrapping_add(Self::PRIME_Y), + k.wrapping_add(Self::PRIME_Z), + x1, + y1, + z1, + ); + + let x_a_flip_mask_0 = ((x_n_mask | 1) << 1) as f32 * x1; + let y_a_flip_mask_0 = ((y_n_mask | 1) << 1) as f32 * y1; + let z_a_flip_mask_0 = ((z_n_mask | 1) << 1) as f32 * z1; + let x_a_flip_mask_1 = (-2 - (x_n_mask << 2)) as f32 * x1 - 1.; + let y_a_flip_mask_1 = (-2 - (y_n_mask << 2)) as f32 * y1 - 1.; + let z_a_flip_mask_1 = (-2 - (z_n_mask << 2)) as f32 * z1 - 1.; + + let mut skip_5 = false; + let a2 = x_a_flip_mask_0 + a0; + if a2 > 0. { + let x2 = x0 - (x_n_mask | 1) as f32; + let y2 = y0; + let z2 = z0; + value += (a2 * a2) + * (a2 * a2) + * Self::grad_coord_3d( + seed, + i.wrapping_add(!x_n_mask & Self::PRIME_X), + j.wrapping_add(y_n_mask & Self::PRIME_Y), + k.wrapping_add(z_n_mask & Self::PRIME_Z), + x2, + y2, + z2, + ); + } else { + let a3 = y_a_flip_mask_0 + z_a_flip_mask_0 + a0; + if a3 > 0. { + let x3 = x0; + let y3 = y0 - (y_n_mask | 1) as f32; + let z3 = z0 - (z_n_mask | 1) as f32; + value += (a3 * a3) + * (a3 * a3) + * Self::grad_coord_3d( + seed, + i.wrapping_add(x_n_mask & Self::PRIME_X), + j.wrapping_add(!y_n_mask & Self::PRIME_Y), + k.wrapping_add(!z_n_mask & Self::PRIME_Z), + x3, + y3, + z3, + ); + } + + let a4 = x_a_flip_mask_1 + a1; + if a4 > 0. { + let x4 = (x_n_mask | 1) as f32 + x1; + let y4 = y1; + let z4 = z1; + value += (a4 * a4) + * (a4 * a4) + * Self::grad_coord_3d( + seed2, + i.wrapping_add(x_n_mask & Self::PRIME_X_2), + j.wrapping_add(Self::PRIME_Y), + k.wrapping_add(Self::PRIME_Z), + x4, + y4, + z4, + ); + skip_5 = true; + } + } + + let mut skip_9 = false; + let a6 = y_a_flip_mask_0 + a0; + if a6 > 0. { + let x6 = x0; + let y6 = y0 - (y_n_mask | 1) as f32; + let z6 = z0; + value += (a6 * a6) + * (a6 * a6) + * Self::grad_coord_3d( + seed, + i.wrapping_add(x_n_mask & Self::PRIME_X), + j.wrapping_add(!y_n_mask & Self::PRIME_Y), + k.wrapping_add(z_n_mask & Self::PRIME_Z), + x6, + y6, + z6, + ); + } else { + let a7 = x_a_flip_mask_0 + z_a_flip_mask_0 + a0; + if a7 > 0. { + let x7 = x0 - (x_n_mask | 1) as f32; + let y7 = y0; + let z7 = z0 - (z_n_mask | 1) as f32; + value += (a7 * a7) + * (a7 * a7) + * Self::grad_coord_3d( + seed, + i.wrapping_add(!x_n_mask & Self::PRIME_X), + j.wrapping_add(y_n_mask & Self::PRIME_Y), + k.wrapping_add(!z_n_mask & Self::PRIME_Z), + x7, + y7, + z7, + ); + } + + let a8 = y_a_flip_mask_1 + a1; + if a8 > 0. { + let x8 = x1; + let y8 = (y_n_mask | 1) as f32 + y1; + let z8 = z1; + value += (a8 * a8) + * (a8 * a8) + * Self::grad_coord_3d( + seed2, + i.wrapping_add(Self::PRIME_X), + j.wrapping_add(y_n_mask & (Self::PRIME_Y << 1)), + k.wrapping_add(Self::PRIME_Z), + x8, + y8, + z8, + ); + skip_9 = true; + } + } + + let mut skip_d = false; + let a_a = z_a_flip_mask_0 + a0; + if a_a > 0. { + let x_a = x0; + let y_a = y0; + let z_a = z0 - (z_n_mask | 1) as f32; + value += (a_a * a_a) + * (a_a * a_a) + * Self::grad_coord_3d( + seed, + i.wrapping_add(x_n_mask & Self::PRIME_X), + j.wrapping_add(y_n_mask & Self::PRIME_Y), + k.wrapping_add(!z_n_mask & Self::PRIME_Z), + x_a, + y_a, + z_a, + ); + } else { + let a_b = x_a_flip_mask_0 + y_a_flip_mask_0 + a0; + if a_b > 0. { + let x_b = x0 - (x_n_mask | 1) as f32; + let y_b = y0 - (y_n_mask | 1) as f32; + let z_b = z0; + value += (a_b * a_b) + * (a_b * a_b) + * Self::grad_coord_3d( + seed, + i.wrapping_add(!x_n_mask & Self::PRIME_X), + j.wrapping_add(!y_n_mask & Self::PRIME_Y), + k.wrapping_add(z_n_mask & Self::PRIME_Z), + x_b, + y_b, + z_b, + ); + } + + let a_c = z_a_flip_mask_1 + a1; + if a_c > 0. { + let x_c = x1; + let y_c = y1; + let z_c = (z_n_mask | 1) as f32 + z1; + value += (a_c * a_c) + * (a_c * a_c) + * Self::grad_coord_3d( + seed2, + i.wrapping_add(Self::PRIME_X), + j.wrapping_add(Self::PRIME_Y), + k.wrapping_add(z_n_mask & (Self::PRIME_Z << 1)), + x_c, + y_c, + z_c, + ); + skip_d = true; + } + } + + if !skip_5 { + let a5 = y_a_flip_mask_1 + z_a_flip_mask_1 + a1; + if a5 > 0. { + let x5 = x1; + let y5 = (y_n_mask | 1) as f32 + y1; + let z5 = (z_n_mask | 1) as f32 + z1; + value += (a5 * a5) + * (a5 * a5) + * Self::grad_coord_3d( + seed2, + i.wrapping_add(Self::PRIME_X), + j.wrapping_add(y_n_mask & (Self::PRIME_Y << 1)), + k.wrapping_add(z_n_mask & (Self::PRIME_Z << 1)), + x5, + y5, + z5, + ); + } + } + + if !skip_9 { + let a9 = x_a_flip_mask_1 + z_a_flip_mask_1 + a1; + if a9 > 0. { + let x9 = (x_n_mask | 1) as f32 + x1; + let y9 = y1; + let z9 = (z_n_mask | 1) as f32 + z1; + value += (a9 * a9) + * (a9 * a9) + * Self::grad_coord_3d( + seed2, + i.wrapping_add(x_n_mask & Self::PRIME_X_2), + j.wrapping_add(Self::PRIME_Y), + k.wrapping_add(z_n_mask & (Self::PRIME_Z << 1)), + x9, + y9, + z9, + ); + } + } + + if !skip_d { + let a_d = x_a_flip_mask_1 + y_a_flip_mask_1 + a1; + if a_d > 0. { + let x_d = (x_n_mask | 1) as f32 + x1; + let y_d = (y_n_mask | 1) as f32 + y1; + let z_d = z1; + value += (a_d * a_d) + * (a_d * a_d) + * Self::grad_coord_3d( + seed2, + i.wrapping_add(x_n_mask & (Self::PRIME_X << 1)), + j.wrapping_add(y_n_mask & (Self::PRIME_Y << 1)), + k.wrapping_add(Self::PRIME_Z), + x_d, + y_d, + z_d, + ); + } + } + + value * 9.046026385208288 + } + + // Cellular Noise + + fn single_cellular_2d(&self, seed: i32, x: Float, y: Float) -> f32 { + let xr = Self::fast_round(x); + let yr = Self::fast_round(y); + + let mut distance0 = f32::MAX; + let mut distance1 = f32::MAX; + let mut closest_hash = 0; + + let cellular_jitter = 0.43701595 * self.cellular_jitter_modifier; + + let mut x_primed = (xr - 1).wrapping_mul(Self::PRIME_X); + let y_primed_base = (yr - 1).wrapping_mul(Self::PRIME_Y); + + match self.cellular_distance_function { + CellularDistanceFunction::Euclidean | CellularDistanceFunction::EuclideanSq => { + for xi in xr - 1..=xr + 1 { + let mut y_primed = y_primed_base; + + for yi in yr - 1..=yr + 1 { + let hash = Self::hash_2d(seed, x_primed, y_primed); + let idx = hash & (255 << 1); + + #[allow(clippy::unnecessary_cast)] + let vec_x = (xi as Float - x) as f32 + + Self::RAND_VECS_2D[idx as usize] * cellular_jitter; + #[allow(clippy::unnecessary_cast)] + let vec_y = (yi as Float - y) as f32 + + Self::RAND_VECS_2D[(idx | 1) as usize] * cellular_jitter; + + let new_distance = vec_x * vec_x + vec_y * vec_y; + + distance1 = distance1.min(new_distance).max(distance0); + if new_distance < distance0 { + distance0 = new_distance; + closest_hash = hash; + } + y_primed = y_primed.wrapping_add(Self::PRIME_Y); + } + x_primed = x_primed.wrapping_add(Self::PRIME_X); + } + } + CellularDistanceFunction::Manhattan => { + for xi in xr - 1..=xr + 1 { + let mut y_primed = y_primed_base; + + for yi in yr - 1..=yr + 1 { + let hash = Self::hash_2d(seed, x_primed, y_primed); + let idx = hash & (255 << 1); + + #[allow(clippy::unnecessary_cast)] + let vec_x = (xi as Float - x) as f32 + + Self::RAND_VECS_2D[idx as usize] * cellular_jitter; + #[allow(clippy::unnecessary_cast)] + let vec_y = (yi as Float - y) as f32 + + Self::RAND_VECS_2D[(idx | 1) as usize] * cellular_jitter; + + let new_distance = vec_x.abs() + vec_y.abs(); + + distance1 = distance1.min(new_distance).max(distance0); + if new_distance < distance0 { + distance0 = new_distance; + closest_hash = hash; + } + y_primed = y_primed.wrapping_add(Self::PRIME_Y); + } + x_primed = x_primed.wrapping_add(Self::PRIME_X); + } + } + CellularDistanceFunction::Hybrid => { + for xi in xr - 1..=xr + 1 { + let mut y_primed = y_primed_base; + + for yi in yr - 1..=yr + 1 { + let hash = Self::hash_2d(seed, x_primed, y_primed); + let idx = hash & (255 << 1); + + #[allow(clippy::unnecessary_cast)] + let vec_x = (xi as Float - x) as f32 + + Self::RAND_VECS_2D[idx as usize] * cellular_jitter; + #[allow(clippy::unnecessary_cast)] + let vec_y = (yi as Float - y) as f32 + + Self::RAND_VECS_2D[(idx | 1) as usize] * cellular_jitter; + + let new_distance = + (vec_x.abs() + vec_y.abs()) + (vec_x * vec_x + vec_y * vec_y); + + distance1 = distance1.min(new_distance).max(distance0); + if new_distance < distance0 { + distance0 = new_distance; + closest_hash = hash; + } + y_primed = y_primed.wrapping_add(Self::PRIME_Y); + } + x_primed = x_primed.wrapping_add(Self::PRIME_X); + } + } + } + + if self.cellular_distance_function == CellularDistanceFunction::Euclidean + && self.cellular_return_type >= CellularReturnType::Distance + { + distance0 = distance0.sqrt(); + + if self.cellular_return_type >= CellularReturnType::Distance2 { + distance1 = distance1.sqrt(); + } + } + + match self.cellular_return_type { + CellularReturnType::CellValue => closest_hash as f32 * (1. / 2147483648.), + CellularReturnType::Distance => distance0 - 1., + CellularReturnType::Distance2 => distance1 - 1., + CellularReturnType::Distance2Add => (distance1 + distance0) * 0.5 - 1., + CellularReturnType::Distance2Sub => distance1 - distance0 - 1., + CellularReturnType::Distance2Mul => distance1 * distance0 * 0.5 - 1., + CellularReturnType::Distance2Div => distance0 / distance1 - 1., + } + } + + fn single_cellular_3d(&self, seed: i32, x: Float, y: Float, z: Float) -> f32 { + let xr = Self::fast_round(x); + let yr = Self::fast_round(y); + let zr = Self::fast_round(z); + + let mut distance0 = f32::MAX; + let mut distance1 = f32::MAX; + let mut closest_hash = 0; + + let cellular_jitter = 0.39614353 * self.cellular_jitter_modifier; + + let mut x_primed = (xr - 1).wrapping_mul(Self::PRIME_X); + let y_primed_base = (yr - 1).wrapping_mul(Self::PRIME_Y); + let z_primed_base = (zr - 1).wrapping_mul(Self::PRIME_Z); + + match self.cellular_distance_function { + CellularDistanceFunction::Euclidean | CellularDistanceFunction::EuclideanSq => { + for xi in xr - 1..=xr + 1 { + let mut y_primed = y_primed_base; + + for yi in yr - 1..=yr + 1 { + let mut z_primed = z_primed_base; + + for zi in zr - 1..=zr + 1 { + let hash = Self::hash_3d(seed, x_primed, y_primed, z_primed); + let idx = hash & (255 << 2); + + #[allow(clippy::unnecessary_cast)] + let vec_x = (xi as Float - x) as f32 + + Self::RAND_VECS_3D[idx as usize] * cellular_jitter; + #[allow(clippy::unnecessary_cast)] + let vec_y = (yi as Float - y) as f32 + + Self::RAND_VECS_3D[(idx | 1) as usize] * cellular_jitter; + #[allow(clippy::unnecessary_cast)] + let vec_z = (zi as Float - z) as f32 + + Self::RAND_VECS_3D[(idx | 2) as usize] * cellular_jitter; + + let new_distance = vec_x * vec_x + vec_y * vec_y + vec_z * vec_z; + + distance1 = distance1.min(new_distance).max(distance0); + if new_distance < distance0 { + distance0 = new_distance; + closest_hash = hash; + } + z_primed = z_primed.wrapping_add(Self::PRIME_Z); + } + y_primed = y_primed.wrapping_add(Self::PRIME_Y); + } + x_primed = x_primed.wrapping_add(Self::PRIME_X); + } + } + CellularDistanceFunction::Manhattan => { + for xi in xr - 1..=xr + 1 { + let mut y_primed = y_primed_base; + + for yi in yr - 1..=yr + 1 { + let mut z_primed = z_primed_base; + + for zi in zr - 1..=zr + 1 { + let hash = Self::hash_3d(seed, x_primed, y_primed, z_primed); + let idx = hash & (255 << 2); + + #[allow(clippy::unnecessary_cast)] + let vec_x = (xi as Float - x) as f32 + + Self::RAND_VECS_3D[idx as usize] * cellular_jitter; + #[allow(clippy::unnecessary_cast)] + let vec_y = (yi as Float - y) as f32 + + Self::RAND_VECS_3D[(idx | 1) as usize] * cellular_jitter; + #[allow(clippy::unnecessary_cast)] + let vec_z = (zi as Float - z) as f32 + + Self::RAND_VECS_3D[(idx | 2) as usize] * cellular_jitter; + + let new_distance = vec_x.abs() + vec_y.abs() + vec_z.abs(); + + distance1 = distance1.min(new_distance).max(distance0); + if new_distance < distance0 { + distance0 = new_distance; + closest_hash = hash; + } + z_primed = z_primed.wrapping_add(Self::PRIME_Z); + } + y_primed = y_primed.wrapping_add(Self::PRIME_Y); + } + x_primed = x_primed.wrapping_add(Self::PRIME_X); + } + } + CellularDistanceFunction::Hybrid => { + for xi in xr - 1..=xr + 1 { + let mut y_primed = y_primed_base; + + for yi in yr - 1..=yr + 1 { + let mut z_primed = z_primed_base; + + for zi in zr - 1..=zr + 1 { + let hash = Self::hash_3d(seed, x_primed, y_primed, z_primed); + let idx = hash & (255 << 2); + + #[allow(clippy::unnecessary_cast)] + let vec_x = (xi as Float - x) as f32 + + Self::RAND_VECS_3D[idx as usize] * cellular_jitter; + #[allow(clippy::unnecessary_cast)] + let vec_y = (yi as Float - y) as f32 + + Self::RAND_VECS_3D[(idx | 1) as usize] * cellular_jitter; + #[allow(clippy::unnecessary_cast)] + let vec_z = (zi as Float - z) as f32 + + Self::RAND_VECS_3D[(idx | 2) as usize] * cellular_jitter; + + let new_distance = (vec_x.abs() + vec_y.abs() + vec_z.abs()) + + (vec_x * vec_x + vec_y * vec_y + vec_z * vec_z); + + distance1 = distance1.min(new_distance).max(distance0); + if new_distance < distance0 { + distance0 = new_distance; + closest_hash = hash; + } + z_primed = z_primed.wrapping_add(Self::PRIME_Z); + } + y_primed = y_primed.wrapping_add(Self::PRIME_Y); + } + x_primed = x_primed.wrapping_add(Self::PRIME_X); + } + } + } + + if self.cellular_distance_function == CellularDistanceFunction::Euclidean + && self.cellular_return_type >= CellularReturnType::Distance + { + distance0 = distance0.sqrt(); + + if self.cellular_return_type >= CellularReturnType::Distance2 { + distance1 = distance1.sqrt(); + } + } + + match self.cellular_return_type { + CellularReturnType::CellValue => closest_hash as f32 * (1. / 2147483648.), + CellularReturnType::Distance => distance0 - 1., + CellularReturnType::Distance2 => distance1 - 1., + CellularReturnType::Distance2Add => (distance1 + distance0) * 0.5 - 1., + CellularReturnType::Distance2Sub => distance1 - distance0 - 1., + CellularReturnType::Distance2Mul => distance1 * distance0 * 0.5 - 1., + CellularReturnType::Distance2Div => distance0 / distance1 - 1., + } + } + + // Perlin Noise + + fn single_perlin_2d(&self, seed: i32, x: Float, y: Float) -> f32 { + let x0 = Self::fast_floor(x); + let y0 = Self::fast_floor(y); + + #[allow(clippy::unnecessary_cast)] + let xd0 = (x - x0 as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let yd0 = (y - y0 as Float) as f32; + let xd1 = xd0 - 1.; + let yd1 = yd0 - 1.; + + let xs = Self::interp_quintic(xd0); + let ys = Self::interp_quintic(yd0); + + let x0 = x0.wrapping_mul(Self::PRIME_X); + let y0 = y0.wrapping_mul(Self::PRIME_Y); + let x1 = x0.wrapping_add(Self::PRIME_X); + let y1 = y0.wrapping_add(Self::PRIME_Y); + + let xf0 = Self::lerp( + Self::grad_coord_2d(seed, x0, y0, xd0, yd0), + Self::grad_coord_2d(seed, x1, y0, xd1, yd0), + xs, + ); + let xf1 = Self::lerp( + Self::grad_coord_2d(seed, x0, y1, xd0, yd1), + Self::grad_coord_2d(seed, x1, y1, xd1, yd1), + xs, + ); + + Self::lerp(xf0, xf1, ys) * 1.4247691104677813 + } + + fn single_perlin_3d(&self, seed: i32, x: Float, y: Float, z: Float) -> f32 { + let x0 = Self::fast_floor(x); + let y0 = Self::fast_floor(y); + let z0 = Self::fast_floor(z); + + #[allow(clippy::unnecessary_cast)] + let xd0 = (x - x0 as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let yd0 = (y - y0 as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let zd0 = (z - z0 as Float) as f32; + let xd1 = xd0 - 1.; + let yd1 = yd0 - 1.; + let zd1 = zd0 - 1.; + + let xs = Self::interp_quintic(xd0); + let ys = Self::interp_quintic(yd0); + let zs = Self::interp_quintic(zd0); + + let x0 = x0.wrapping_mul(Self::PRIME_X); + let y0 = y0.wrapping_mul(Self::PRIME_Y); + let z0 = z0.wrapping_mul(Self::PRIME_Z); + let x1 = x0.wrapping_add(Self::PRIME_X); + let y1 = y0.wrapping_add(Self::PRIME_Y); + let z1 = z0.wrapping_add(Self::PRIME_Z); + + let xf00 = Self::lerp( + Self::grad_coord_3d(seed, x0, y0, z0, xd0, yd0, zd0), + Self::grad_coord_3d(seed, x1, y0, z0, xd1, yd0, zd0), + xs, + ); + let xf10 = Self::lerp( + Self::grad_coord_3d(seed, x0, y1, z0, xd0, yd1, zd0), + Self::grad_coord_3d(seed, x1, y1, z0, xd1, yd1, zd0), + xs, + ); + let xf01 = Self::lerp( + Self::grad_coord_3d(seed, x0, y0, z1, xd0, yd0, zd1), + Self::grad_coord_3d(seed, x1, y0, z1, xd1, yd0, zd1), + xs, + ); + let xf11 = Self::lerp( + Self::grad_coord_3d(seed, x0, y1, z1, xd0, yd1, zd1), + Self::grad_coord_3d(seed, x1, y1, z1, xd1, yd1, zd1), + xs, + ); + + let yf0 = Self::lerp(xf00, xf10, ys); + let yf1 = Self::lerp(xf01, xf11, ys); + + Self::lerp(yf0, yf1, zs) * 0.964921414852142333984375 + } + + // Value Cubic Noise + + fn single_value_cubic_2d(&self, seed: i32, x: Float, y: Float) -> f32 { + let x1 = Self::fast_floor(x); + let y1 = Self::fast_floor(y); + + #[allow(clippy::unnecessary_cast)] + let xs = (x - x1 as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let ys = (y - y1 as Float) as f32; + + let x1 = x1.wrapping_mul(Self::PRIME_X); + let y1 = y1.wrapping_mul(Self::PRIME_Y); + let x0 = x1.wrapping_sub(Self::PRIME_X); + let y0 = y1.wrapping_sub(Self::PRIME_Y); + let x2 = x1.wrapping_add(Self::PRIME_X); + let y2 = y1.wrapping_add(Self::PRIME_Y); + let x3 = x1.wrapping_add(Self::PRIME_X_2); + let y3 = y1.wrapping_add(Self::PRIME_Y_2); + + Self::cubic_lerp( + Self::cubic_lerp( + Self::val_coord_2d(seed, x0, y0), + Self::val_coord_2d(seed, x1, y0), + Self::val_coord_2d(seed, x2, y0), + Self::val_coord_2d(seed, x3, y0), + xs, + ), + Self::cubic_lerp( + Self::val_coord_2d(seed, x0, y1), + Self::val_coord_2d(seed, x1, y1), + Self::val_coord_2d(seed, x2, y1), + Self::val_coord_2d(seed, x3, y1), + xs, + ), + Self::cubic_lerp( + Self::val_coord_2d(seed, x0, y2), + Self::val_coord_2d(seed, x1, y2), + Self::val_coord_2d(seed, x2, y2), + Self::val_coord_2d(seed, x3, y2), + xs, + ), + Self::cubic_lerp( + Self::val_coord_2d(seed, x0, y3), + Self::val_coord_2d(seed, x1, y3), + Self::val_coord_2d(seed, x2, y3), + Self::val_coord_2d(seed, x3, y3), + xs, + ), + ys, + ) * (1. / (1.5 * 1.5)) + } + + fn single_value_cubic_3d(&self, seed: i32, x: Float, y: Float, z: Float) -> f32 { + let x1 = Self::fast_floor(x); + let y1 = Self::fast_floor(y); + let z1 = Self::fast_floor(z); + + #[allow(clippy::unnecessary_cast)] + let xs = (x - x1 as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let ys = (y - y1 as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let zs = (z - z1 as Float) as f32; + + let x1 = x1.wrapping_mul(Self::PRIME_X); + let y1 = y1.wrapping_mul(Self::PRIME_Y); + let z1 = z1.wrapping_mul(Self::PRIME_Z); + + let x0 = x1.wrapping_sub(Self::PRIME_X); + let y0 = y1.wrapping_sub(Self::PRIME_Y); + let z0 = z1.wrapping_sub(Self::PRIME_Z); + let x2 = x1.wrapping_add(Self::PRIME_X); + let y2 = y1.wrapping_add(Self::PRIME_Y); + let z2 = z1.wrapping_add(Self::PRIME_Z); + let x3 = x1.wrapping_add(Self::PRIME_X_2); + let y3 = y1.wrapping_add(Self::PRIME_Y_2); + let z3 = z1.wrapping_add(Self::PRIME_Z_2); + + Self::cubic_lerp( + Self::cubic_lerp( + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y0, z0), + Self::val_coord_3d(seed, x1, y0, z0), + Self::val_coord_3d(seed, x2, y0, z0), + Self::val_coord_3d(seed, x3, y0, z0), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y1, z0), + Self::val_coord_3d(seed, x1, y1, z0), + Self::val_coord_3d(seed, x2, y1, z0), + Self::val_coord_3d(seed, x3, y1, z0), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y2, z0), + Self::val_coord_3d(seed, x1, y2, z0), + Self::val_coord_3d(seed, x2, y2, z0), + Self::val_coord_3d(seed, x3, y2, z0), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y3, z0), + Self::val_coord_3d(seed, x1, y3, z0), + Self::val_coord_3d(seed, x2, y3, z0), + Self::val_coord_3d(seed, x3, y3, z0), + xs, + ), + ys, + ), + Self::cubic_lerp( + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y0, z1), + Self::val_coord_3d(seed, x1, y0, z1), + Self::val_coord_3d(seed, x2, y0, z1), + Self::val_coord_3d(seed, x3, y0, z1), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y1, z1), + Self::val_coord_3d(seed, x1, y1, z1), + Self::val_coord_3d(seed, x2, y1, z1), + Self::val_coord_3d(seed, x3, y1, z1), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y2, z1), + Self::val_coord_3d(seed, x1, y2, z1), + Self::val_coord_3d(seed, x2, y2, z1), + Self::val_coord_3d(seed, x3, y2, z1), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y3, z1), + Self::val_coord_3d(seed, x1, y3, z1), + Self::val_coord_3d(seed, x2, y3, z1), + Self::val_coord_3d(seed, x3, y3, z1), + xs, + ), + ys, + ), + Self::cubic_lerp( + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y0, z2), + Self::val_coord_3d(seed, x1, y0, z2), + Self::val_coord_3d(seed, x2, y0, z2), + Self::val_coord_3d(seed, x3, y0, z2), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y1, z2), + Self::val_coord_3d(seed, x1, y1, z2), + Self::val_coord_3d(seed, x2, y1, z2), + Self::val_coord_3d(seed, x3, y1, z2), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y2, z2), + Self::val_coord_3d(seed, x1, y2, z2), + Self::val_coord_3d(seed, x2, y2, z2), + Self::val_coord_3d(seed, x3, y2, z2), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y3, z2), + Self::val_coord_3d(seed, x1, y3, z2), + Self::val_coord_3d(seed, x2, y3, z2), + Self::val_coord_3d(seed, x3, y3, z2), + xs, + ), + ys, + ), + Self::cubic_lerp( + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y0, z3), + Self::val_coord_3d(seed, x1, y0, z3), + Self::val_coord_3d(seed, x2, y0, z3), + Self::val_coord_3d(seed, x3, y0, z3), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y1, z3), + Self::val_coord_3d(seed, x1, y1, z3), + Self::val_coord_3d(seed, x2, y1, z3), + Self::val_coord_3d(seed, x3, y1, z3), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y2, z3), + Self::val_coord_3d(seed, x1, y2, z3), + Self::val_coord_3d(seed, x2, y2, z3), + Self::val_coord_3d(seed, x3, y2, z3), + xs, + ), + Self::cubic_lerp( + Self::val_coord_3d(seed, x0, y3, z3), + Self::val_coord_3d(seed, x1, y3, z3), + Self::val_coord_3d(seed, x2, y3, z3), + Self::val_coord_3d(seed, x3, y3, z3), + xs, + ), + ys, + ), + zs, + ) * (1. / (1.5 * 1.5 * 1.5)) + } + + // Value Noise + + fn single_value_2d(&self, seed: i32, x: Float, y: Float) -> f32 { + let x0 = Self::fast_floor(x); + let y0 = Self::fast_floor(y); + + #[allow(clippy::unnecessary_cast)] + let xs = Self::interp_hermite((x - x0 as Float) as f32); + #[allow(clippy::unnecessary_cast)] + let ys = Self::interp_hermite((y - y0 as Float) as f32); + + let x0 = x0.wrapping_mul(Self::PRIME_X); + let y0 = y0.wrapping_mul(Self::PRIME_Y); + let x1 = x0.wrapping_add(Self::PRIME_X); + let y1 = y0.wrapping_add(Self::PRIME_Y); + + let xf0 = Self::lerp( + Self::val_coord_2d(seed, x0, y0), + Self::val_coord_2d(seed, x1, y0), + xs, + ); + let xf1 = Self::lerp( + Self::val_coord_2d(seed, x0, y1), + Self::val_coord_2d(seed, x1, y1), + xs, + ); + + Self::lerp(xf0, xf1, ys) + } + + fn single_value_3d(&self, seed: i32, x: Float, y: Float, z: Float) -> f32 { + let x0 = Self::fast_floor(x); + let y0 = Self::fast_floor(y); + let z0 = Self::fast_floor(z); + + #[allow(clippy::unnecessary_cast)] + let xs = Self::interp_hermite((x - x0 as Float) as f32); + #[allow(clippy::unnecessary_cast)] + let ys = Self::interp_hermite((y - y0 as Float) as f32); + #[allow(clippy::unnecessary_cast)] + let zs = Self::interp_hermite((z - z0 as Float) as f32); + + let x0 = x0.wrapping_mul(Self::PRIME_X); + let y0 = y0.wrapping_mul(Self::PRIME_Y); + let z0 = z0.wrapping_mul(Self::PRIME_Z); + let x1 = x0.wrapping_add(Self::PRIME_X); + let y1 = y0.wrapping_add(Self::PRIME_Y); + let z1 = z0.wrapping_add(Self::PRIME_Z); + + let xf00 = Self::lerp( + Self::val_coord_3d(seed, x0, y0, z0), + Self::val_coord_3d(seed, x1, y0, z0), + xs, + ); + let xf10 = Self::lerp( + Self::val_coord_3d(seed, x0, y1, z0), + Self::val_coord_3d(seed, x1, y1, z0), + xs, + ); + let xf01 = Self::lerp( + Self::val_coord_3d(seed, x0, y0, z1), + Self::val_coord_3d(seed, x1, y0, z1), + xs, + ); + let xf11 = Self::lerp( + Self::val_coord_3d(seed, x0, y1, z1), + Self::val_coord_3d(seed, x1, y1, z1), + xs, + ); + + let yf0 = Self::lerp(xf00, xf10, ys); + let yf1 = Self::lerp(xf01, xf11, ys); + + Self::lerp(yf0, yf1, zs) + } + + // Domain Warp + + #[allow(clippy::too_many_arguments)] + fn do_single_domain_warp_2d( + &self, + seed: i32, + amp: f32, + freq: f32, + x: Float, + y: Float, + xr: Float, + yr: Float, + ) -> (Float, Float) { + match self.domain_warp_type { + DomainWarpType::OpenSimplex2 => self.single_domain_warp_simplex_gradient_2d( + seed, + amp * 38.283687591552734375, + freq, + x, + y, + xr, + yr, + false, + ), + DomainWarpType::OpenSimplex2Reduced => self.single_domain_warp_simplex_gradient_2d( + seed, + amp * 16., + freq, + x, + y, + xr, + yr, + true, + ), + DomainWarpType::BasicGrid => { + self.single_domain_warp_basic_grid_2d(seed, amp, freq, x, y, xr, yr) + } + } + } + + #[allow(clippy::too_many_arguments)] + fn do_single_domain_warp_3d( + &self, + seed: i32, + amp: f32, + freq: f32, + x: Float, + y: Float, + z: Float, + xr: Float, + yr: Float, + zr: Float, + ) -> (Float, Float, Float) { + match self.domain_warp_type { + DomainWarpType::OpenSimplex2 => self.single_domain_warp_open_simplex_2_gradient( + seed, + amp * 32.69428253173828125, + freq, + x, + y, + z, + xr, + yr, + zr, + false, + ), + DomainWarpType::OpenSimplex2Reduced => self.single_domain_warp_open_simplex_2_gradient( + seed, + amp * 7.71604938271605, + freq, + x, + y, + z, + xr, + yr, + zr, + true, + ), + DomainWarpType::BasicGrid => { + self.single_domain_warp_basic_grid_3d(seed, amp, freq, x, y, z, xr, yr, zr) + } + } + } + + // Domain Warp Single Wrapper + + fn domain_warp_single_2d(&self, x: Float, y: Float) -> (Float, Float) { + let seed = self.seed; + let amp = self.domain_warp_amp * self.fractal_bounding; + let freq = self.frequency; + + let (xs, ys) = self.transform_domain_warp_coordinate_2d(x, y); + + self.do_single_domain_warp_2d(seed, amp, freq, xs, ys, x, y) + } + + fn domain_warp_single_3d(&self, x: Float, y: Float, z: Float) -> (Float, Float, Float) { + let seed = self.seed; + let amp = self.domain_warp_amp * self.fractal_bounding; + let freq = self.frequency; + + let (xs, ys, zs) = self.transform_domain_warp_coordinate_3d(x, y, z); + + self.do_single_domain_warp_3d(seed, amp, freq, xs, ys, zs, x, y, z) + } + + // Domain Warp Fractal Progressive + + fn domain_warp_fractal_progressive_2d(&self, x: Float, y: Float) -> (Float, Float) { + let mut x = x; + let mut y = y; + + let mut seed = self.seed; + let mut amp = self.domain_warp_amp * self.fractal_bounding; + let mut freq = self.frequency; + + for _ in 0..self.octaves { + let (xs, ys) = self.transform_domain_warp_coordinate_2d(x, y); + + (x, y) = self.do_single_domain_warp_2d(seed, amp, freq, xs, ys, x, y); + + seed += 1; + amp *= self.gain; + freq *= self.lacunarity; + } + + (x, y) + } + + fn domain_warp_fractal_progressive_3d( + &self, + x: Float, + y: Float, + z: Float, + ) -> (Float, Float, Float) { + let mut x = x; + let mut y = y; + let mut z = z; + + let mut seed = self.seed; + let mut amp = self.domain_warp_amp * self.fractal_bounding; + let mut freq = self.frequency; + + for _ in 0..self.octaves { + let (xs, ys, zs) = self.transform_domain_warp_coordinate_3d(x, y, z); + + (x, y, z) = self.do_single_domain_warp_3d(seed, amp, freq, xs, ys, zs, x, y, z); + + seed += 1; + amp *= self.gain; + freq *= self.lacunarity; + } + + (x, y, z) + } + + // Domain Warp Fractal Independant + fn domain_warp_fractal_independent_2d(&self, x: Float, y: Float) -> (Float, Float) { + let mut x = x; + let mut y = y; + + let (xs, ys) = self.transform_domain_warp_coordinate_2d(x, y); + + let mut seed = self.seed; + let mut amp = self.domain_warp_amp * self.fractal_bounding; + let mut freq = self.frequency; + + for _ in 0..self.octaves { + (x, y) = self.do_single_domain_warp_2d(seed, amp, freq, xs, ys, x, y); + + seed += 1; + amp *= self.gain; + freq *= self.lacunarity; + } + + (x, y) + } + + fn domain_warp_fractal_independent_3d( + &self, + x: Float, + y: Float, + z: Float, + ) -> (Float, Float, Float) { + let mut x = x; + let mut y = y; + let mut z = z; + + let (xs, ys, zs) = self.transform_domain_warp_coordinate_3d(x, y, z); + + let mut seed = self.seed; + let mut amp = self.domain_warp_amp * self.fractal_bounding; + let mut freq = self.frequency; + + for _ in 0..self.octaves { + (x, y, z) = self.do_single_domain_warp_3d(seed, amp, freq, xs, ys, zs, x, y, z); + + seed += 1; + amp *= self.gain; + freq *= self.lacunarity; + } + + (x, y, z) + } + + // Domain Warp Basic Grid + + #[allow(clippy::too_many_arguments)] + fn single_domain_warp_basic_grid_2d( + &self, + seed: i32, + warp_amp: f32, + frequency: f32, + x: Float, + y: Float, + xr: Float, + yr: Float, + ) -> (Float, Float) { + let xf = x * frequency as Float; + let yf = y * frequency as Float; + + let x0 = Self::fast_floor(xf); + let y0 = Self::fast_floor(yf); + + #[allow(clippy::unnecessary_cast)] + let xs = Self::interp_hermite((xf - x0 as Float) as f32); + #[allow(clippy::unnecessary_cast)] + let ys = Self::interp_hermite((yf - y0 as Float) as f32); + + let x0 = x0.wrapping_mul(Self::PRIME_X); + let y0 = y0.wrapping_mul(Self::PRIME_Y); + let x1 = x0.wrapping_add(Self::PRIME_X); + let y1 = y0.wrapping_add(Self::PRIME_Y); + + let hash0 = Self::hash_2d(seed, x0, y0) & (255 << 1); + let hash1 = Self::hash_2d(seed, x1, y0) & (255 << 1); + + let lx0x = Self::lerp( + Self::RAND_VECS_2D[hash0 as usize], + Self::RAND_VECS_2D[hash1 as usize], + xs, + ); + let ly0x = Self::lerp( + Self::RAND_VECS_2D[(hash0 | 1) as usize], + Self::RAND_VECS_2D[(hash1 | 1) as usize], + xs, + ); + + let hash0 = Self::hash_2d(seed, x0, y1) & (255 << 1); + let hash1 = Self::hash_2d(seed, x1, y1) & (255 << 1); + + let lx1x = Self::lerp( + Self::RAND_VECS_2D[hash0 as usize], + Self::RAND_VECS_2D[hash1 as usize], + xs, + ); + let ly1x = Self::lerp( + Self::RAND_VECS_2D[(hash0 | 1) as usize], + Self::RAND_VECS_2D[(hash1 | 1) as usize], + xs, + ); + + let xr = xr + (Self::lerp(lx0x, lx1x, ys) * warp_amp) as Float; + let yr = yr + (Self::lerp(ly0x, ly1x, ys) * warp_amp) as Float; + + (xr, yr) + } + + #[allow(clippy::too_many_arguments)] + fn single_domain_warp_basic_grid_3d( + &self, + seed: i32, + warp_amp: f32, + frequency: f32, + x: Float, + y: Float, + z: Float, + xr: Float, + yr: Float, + zr: Float, + ) -> (Float, Float, Float) { + let xf = x * frequency as Float; + let yf = y * frequency as Float; + let zf = z * frequency as Float; + + let x0 = Self::fast_floor(xf); + let y0 = Self::fast_floor(yf); + let z0 = Self::fast_floor(zf); + + #[allow(clippy::unnecessary_cast)] + let xs = Self::interp_hermite((xf - x0 as Float) as f32); + #[allow(clippy::unnecessary_cast)] + let ys = Self::interp_hermite((yf - y0 as Float) as f32); + #[allow(clippy::unnecessary_cast)] + let zs = Self::interp_hermite((zf - z0 as Float) as f32); + + let x0 = x0.wrapping_mul(Self::PRIME_X); + let y0 = y0.wrapping_mul(Self::PRIME_Y); + let z0 = z0.wrapping_mul(Self::PRIME_Z); + let x1 = x0.wrapping_add(Self::PRIME_X); + let y1 = y0.wrapping_add(Self::PRIME_Y); + let z1 = z0.wrapping_add(Self::PRIME_Z); + + let hash0 = Self::hash_3d(seed, x0, y0, z0) & (255 << 2); + let hash1 = Self::hash_3d(seed, x1, y0, z0) & (255 << 2); + + let lx0x = Self::lerp( + Self::RAND_VECS_3D[hash0 as usize], + Self::RAND_VECS_3D[hash1 as usize], + xs, + ); + let ly0x = Self::lerp( + Self::RAND_VECS_3D[(hash0 | 1) as usize], + Self::RAND_VECS_3D[(hash1 | 1) as usize], + xs, + ); + let lz0x = Self::lerp( + Self::RAND_VECS_3D[(hash0 | 2) as usize], + Self::RAND_VECS_3D[(hash1 | 2) as usize], + xs, + ); + + let hash0 = Self::hash_3d(seed, x0, y1, z0) & (255 << 2); + let hash1 = Self::hash_3d(seed, x1, y1, z0) & (255 << 2); + + let lx1x = Self::lerp( + Self::RAND_VECS_3D[hash0 as usize], + Self::RAND_VECS_3D[hash1 as usize], + xs, + ); + let ly1x = Self::lerp( + Self::RAND_VECS_3D[(hash0 | 1) as usize], + Self::RAND_VECS_3D[(hash1 | 1) as usize], + xs, + ); + let lz1x = Self::lerp( + Self::RAND_VECS_3D[(hash0 | 2) as usize], + Self::RAND_VECS_3D[(hash1 | 2) as usize], + xs, + ); + + let lx0y = Self::lerp(lx0x, lx1x, ys); + let ly0y = Self::lerp(ly0x, ly1x, ys); + let lz0y = Self::lerp(lz0x, lz1x, ys); + + let hash0 = Self::hash_3d(seed, x0, y0, z1) & (255 << 2); + let hash1 = Self::hash_3d(seed, x1, y0, z1) & (255 << 2); + + let lx0x = Self::lerp( + Self::RAND_VECS_3D[hash0 as usize], + Self::RAND_VECS_3D[hash1 as usize], + xs, + ); + let ly0x = Self::lerp( + Self::RAND_VECS_3D[(hash0 | 1) as usize], + Self::RAND_VECS_3D[(hash1 | 1) as usize], + xs, + ); + let lz0x = Self::lerp( + Self::RAND_VECS_3D[(hash0 | 2) as usize], + Self::RAND_VECS_3D[(hash1 | 2) as usize], + xs, + ); + + let hash0 = Self::hash_3d(seed, x0, y1, z1) & (255 << 2); + let hash1 = Self::hash_3d(seed, x1, y1, z1) & (255 << 2); + + let lx1x = Self::lerp( + Self::RAND_VECS_3D[hash0 as usize], + Self::RAND_VECS_3D[hash1 as usize], + xs, + ); + let ly1x = Self::lerp( + Self::RAND_VECS_3D[(hash0 | 1) as usize], + Self::RAND_VECS_3D[(hash1 | 1) as usize], + xs, + ); + let lz1x = Self::lerp( + Self::RAND_VECS_3D[(hash0 | 2) as usize], + Self::RAND_VECS_3D[(hash1 | 2) as usize], + xs, + ); + + let xr = xr + (Self::lerp(lx0y, Self::lerp(lx0x, lx1x, ys), zs) * warp_amp) as Float; + let yr = yr + (Self::lerp(ly0y, Self::lerp(ly0x, ly1x, ys), zs) * warp_amp) as Float; + let zr = zr + (Self::lerp(lz0y, Self::lerp(lz0x, lz1x, ys), zs) * warp_amp) as Float; + + (xr, yr, zr) + } + + // Domain Warp Simplex/OpenSimplex2 + #[allow(clippy::too_many_arguments)] + fn single_domain_warp_simplex_gradient_2d( + &self, + seed: i32, + warp_amp: f32, + frequency: f32, + x: Float, + y: Float, + xr: Float, + yr: Float, + out_frad_only: bool, + ) -> (Float, Float) { + const SQRT3: f32 = 1.7320508075688772935274463415059; + const G2: f32 = (3. - SQRT3) / 6.; + + let x = x * frequency as Float; + let y = y * frequency as Float; + + /* + * --- Skew moved to TransformNoiseCoordinateXY method --- + * let f2 = 0.5 * (sqrt3 - 1); + * let s = (x + y) * f2; + * x += s; y += s; + */ + + let i = Self::fast_floor(x); + let j = Self::fast_floor(y); + #[allow(clippy::unnecessary_cast)] + let xi = (x - i as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let yi = (y - j as Float) as f32; + + let t = (xi + yi) * G2; + let x0 = xi - t; + let y0 = yi - t; + + let i = i.wrapping_mul(Self::PRIME_X); + let j = j.wrapping_mul(Self::PRIME_Y); + + let mut vx = 0.; + let mut vy = 0.; + + let a = 0.5 - x0 * x0 - y0 * y0; + if a > 0. { + let aaaa = (a * a) * (a * a); + let (xo, yo) = if out_frad_only { + Self::grad_coord_out_2d(seed, i, j) + } else { + Self::grad_coord_dual_2d(seed, i, j, x0, y0) + }; + vx += aaaa * xo; + vy += aaaa * yo; + } + + let c = (2. * (1. - 2. * G2) * (1. / G2 - 2.)) * t + + ((-2. * (1. - 2. * G2) * (1. - 2. * G2)) + a); + if c > 0. { + let x2 = x0 + (2. * G2 - 1.); + let y2 = y0 + (2. * G2 - 1.); + let cccc = (c * c) * (c * c); + let (xo, yo) = if out_frad_only { + Self::grad_coord_out_2d( + seed, + i.wrapping_add(Self::PRIME_X), + j.wrapping_add(Self::PRIME_Y), + ) + } else { + Self::grad_coord_dual_2d( + seed, + i.wrapping_add(Self::PRIME_X), + j.wrapping_add(Self::PRIME_Y), + x2, + y2, + ) + }; + vx += cccc * xo; + vy += cccc * yo; + } + + if y0 > x0 { + let x1 = x0 + G2; + let y1 = y0 + (G2 - 1.); + let b = 0.5 - x1 * x1 - y1 * y1; + if b > 0. { + let bbbb = (b * b) * (b * b); + let (xo, yo) = if out_frad_only { + Self::grad_coord_out_2d(seed, i, j.wrapping_add(Self::PRIME_Y)) + } else { + Self::grad_coord_dual_2d(seed, i, j.wrapping_add(Self::PRIME_Y), x1, y1) + }; + vx += bbbb * xo; + vy += bbbb * yo; + } + } else { + let x1 = x0 + (G2 - 1.); + let y1 = y0 + G2; + let b = 0.5 - x1 * x1 - y1 * y1; + if b > 0. { + let bbbb = (b * b) * (b * b); + let (xo, yo) = if out_frad_only { + Self::grad_coord_out_2d(seed, i.wrapping_add(Self::PRIME_X), j) + } else { + Self::grad_coord_dual_2d(seed, i.wrapping_add(Self::PRIME_X), j, x1, y1) + }; + vx += bbbb * xo; + vy += bbbb * yo; + } + } + + let xr = xr + (vx * warp_amp) as Float; + let yr = yr + (vy * warp_amp) as Float; + + (xr, yr) + } + + #[allow(clippy::too_many_arguments)] + fn single_domain_warp_open_simplex_2_gradient( + &self, + seed: i32, + warp_amp: f32, + frequency: f32, + x: Float, + y: Float, + z: Float, + xr: Float, + yr: Float, + zr: Float, + out_grad_only: bool, + ) -> (Float, Float, Float) { + let mut seed = seed; + + let x = x * frequency as Float; + let y = y * frequency as Float; + let z = z * frequency as Float; + + /* + * --- Rotation moved to TransformDomainWarpCoordinate method --- + * let r3 = 2. / 3.; + * let r = (x + y + z) * r3; // Rotation, not skew + * x = r - x; y = r - y; z = r - z; + */ + + let i = Self::fast_round(x); + let j = Self::fast_round(y); + let k = Self::fast_round(z); + #[allow(clippy::unnecessary_cast)] + let mut x0 = (x - i as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let mut y0 = (y - j as Float) as f32; + #[allow(clippy::unnecessary_cast)] + let mut z0 = (z - k as Float) as f32; + + let mut x_n_sign = (-x0 - 1.) as i32 | 1; + let mut y_n_sign = (-y0 - 1.) as i32 | 1; + let mut z_n_sign = (-z0 - 1.) as i32 | 1; + + let mut ax0 = x_n_sign as f32 * -x0; + let mut ay0 = y_n_sign as f32 * -y0; + let mut az0 = z_n_sign as f32 * -z0; + + let mut i = i.wrapping_mul(Self::PRIME_X); + let mut j = j.wrapping_mul(Self::PRIME_Y); + let mut k = k.wrapping_mul(Self::PRIME_Z); + + let mut vx = 0.; + let mut vy = 0.; + let mut vz = 0.; + + let mut a = (0.6 - x0 * x0) - (y0 * y0 + z0 * z0); + let mut l = 0; + loop { + if a > 0. { + let aaaa = (a * a) * (a * a); + let (xo, yo, zo) = if out_grad_only { + Self::grad_coord_out_3d(seed, i, j, k) + } else { + Self::grad_coord_dual_3d(seed, i, j, k, x0, y0, z0) + }; + vx += aaaa * xo; + vy += aaaa * yo; + vz += aaaa * zo; + } + + let mut b = a; + let mut i1 = i; + let mut j1 = j; + let mut k1 = k; + let mut x1 = x0; + let mut y1 = y0; + let mut z1 = z0; + + if ax0 >= ay0 && ax0 >= az0 { + x1 += x_n_sign as f32; + b = b + ax0 + ax0; + i1 = i1.wrapping_sub(x_n_sign.wrapping_mul(Self::PRIME_X)); + } else if ay0 > ax0 && ay0 >= az0 { + y1 += y_n_sign as f32; + b = b + ay0 + ay0; + j1 = j1.wrapping_sub(y_n_sign.wrapping_mul(Self::PRIME_Y)); + } else { + z1 += z_n_sign as f32; + b = b + az0 + az0; + k1 = k1.wrapping_sub(z_n_sign.wrapping_mul(Self::PRIME_Z)); + } + + if b > 1. { + b -= 1.; + let bbbb = (b * b) * (b * b); + let (xo, yo, zo) = if out_grad_only { + Self::grad_coord_out_3d(seed, i1, j1, k1) + } else { + Self::grad_coord_dual_3d(seed, i1, j1, k1, x1, y1, z1) + }; + vx += bbbb * xo; + vy += bbbb * yo; + vz += bbbb * zo; + } + + if l == 1 { + break; + } + + ax0 = 0.5 - ax0; + ay0 = 0.5 - ay0; + az0 = 0.5 - az0; + + x0 = x_n_sign as f32 * ax0; + y0 = y_n_sign as f32 * ay0; + z0 = z_n_sign as f32 * az0; + + a += (0.75 - ax0) - (ay0 + az0); + + i = i.wrapping_add((x_n_sign >> 1) & Self::PRIME_X); + j = j.wrapping_add((y_n_sign >> 1) & Self::PRIME_Y); + k = k.wrapping_add((z_n_sign >> 1) & Self::PRIME_Z); + + x_n_sign = -x_n_sign; + y_n_sign = -y_n_sign; + z_n_sign = -z_n_sign; + + seed += 1293373; + + l += 1; + } + + let xr = xr + (vx * warp_amp) as Float; + let yr = yr + (vy * warp_amp) as Float; + let zr = zr + (vz * warp_amp) as Float; + + (xr, yr, zr) + } +}