Struct ImprovedNoise 

pub struct ImprovedNoise {
    p: [u8; 256],
    pub xo: f64,
    pub yo: f64,
    pub zo: f64,
    yo_floor: i32,
    yo_fraction: f64,
    zo_floor: i32,
    zo_fraction: f64,
}

Improved Perlin noise generator.

This implements the improved Perlin noise algorithm as used in Minecraft. Each instance has a permutation table and offset values initialized from a random source.

Fields

p: [u8; 256]

Permutation table (256 bytes)

xo: f64

X offset for the noise coordinates

yo: f64

Y offset for the noise coordinates

zo: f64

Z offset for the noise coordinates

yo_floor: i32

yo_fraction: f64

zo_floor: i32

zo_fraction: f64

Implementations

impl ImprovedNoise

pub fn new<R: Random>(random: &mut R) -> Self

Creates a new ImprovedNoise from a random source.

Initializes the permutation table using Fisher-Yates shuffle and sets random offsets.

pub fn noise(&self, x: f64, y: f64, z: f64) -> f64

Sample noise at the given coordinates.

This is the standard 3D Perlin noise sampling without Y scaling.

pub fn noise_simd<F, const N: usize>( &self, x: Simd<F, N>, y: Simd<F, N>, z: Simd<F, N>, ) -> Simd<F, N>

where F: SimdElement + SimdCast, Simd<F, N>: SimdFloat<Cast<i32> = Simd<i32, N>> + SimdPartialOrd + SimdPartialEq<Mask = Mask<<F as SimdElement>::Mask, N>> + Add<Output = Simd<F, N>> + Sub<Output = Simd<F, N>> + Mul<Output = Simd<F, N>> + Neg<Output = Simd<F, N>>,

Calculate Perlin noise using SIMD vectors.

pub fn noise_xz(&self, x: f64, z: f64) -> f64

Sample noise at (x, 0.0, z).

pub fn noise_xy(&self, x: f64, y: f64) -> f64

Sample noise at (x, y, 0.0).

pub fn noise_with_derivative( &self, x: f64, y: f64, z: f64, derivative_out: &mut [f64; 3], ) -> f64

Sample noise at the given coordinates, accumulating partial derivatives.

Returns the noise value and adds the partial derivatives (dx, dy, dz) into derivative_out. Used by BlendedNoise for terrain generation.

pub fn noise_with_y_scale( &self, x: f64, y: f64, z: f64, y_scale: f64, y_fudge: f64, ) -> f64

Sample noise with Y scale and fudge parameters.

The y_scale and y_fudge parameters are used for terrain generation where vertical noise needs special handling.

Arguments

• x, y, z - The coordinates to sample
• y_scale - Y scaling factor (0.0 to disable)
• y_fudge - Y fudge factor for floor snapping

fn sample_and_lerp( &self, x: i32, y: i32, z: i32, xr: f64, yr: f64, zr: f64, yr_original: f64, ) -> f64

Sample noise at grid point and interpolate.

The 8 corner gradient-dot products are evaluated as 2 × f64x4 so the per-lane math stays identical to the scalar path (((gx*xr) + (gy*yr)) + (gz*zr)), which preserves bit-identical output. Inspired by C2ME’s c2me-opts-math flat-gradient SIMD form.

fn p_simd<const N: usize>(&self, idx: Simd<u8, N>) -> Simd<u8, N>

fn sample_and_lerp_simd<F, const N: usize>( &self, x: Simd<i32, N>, y: Simd<i32, N>, z: Simd<i32, N>, xr: Simd<F, N>, yr: Simd<F, N>, zr: Simd<F, N>, yr_original: Simd<F, N>, ) -> Simd<F, N>

where F: SimdElement + SimdCast, Simd<F, N>: Mul<Output = Simd<F, N>> + Add<Output = Simd<F, N>> + Sub<Output = Simd<F, N>> + Neg<Output = Simd<F, N>>,

Sample noise at grid point and interpolate.

pub fn noise_with_y_scale_simd<const N: usize>( &self, x: f64, ys: Simd<f64, N>, z: f64, y_scale: f64, y_fudges: Simd<f64, N>, ) -> Simd<f64, N>

Generic N-lane form of [Self::noise_with_y_scale_4x]. Each lane runs the exact per-lane math of the scalar Self::noise_with_y_scale, so any supported lane width yields bit-identical per-lane results — only the SIMD batch size changes. f64x4 ≡ noise_with_y_scale_simd::<4>.

fn sample_and_lerp_y_simd<const N: usize>( &self, xf: i32, zf: i32, xr: f64, zr: f64, ys_floor: Simd<i32, N>, yrs: Simd<f64, N>, yrs_original: Simd<f64, N>, ) -> Simd<f64, N>

Vectorized sample-and-lerp for N Y values sharing x/z grid position. Generic counterpart of [Self::sample_and_lerp_4x].

fn sample_with_derivative( &self, x: i32, y: i32, z: i32, xr: f64, yr: f64, zr: f64, derivative_out: &mut [f64; 3], ) -> f64

Sample noise at grid point, interpolate, and accumulate derivatives.

Trait Implementations

impl Clone for ImprovedNoise

fn clone(&self) -> ImprovedNoise

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ImprovedNoise

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.