simdnoise 3.0.0

SIMD accelerate noise library with runtime feature detection
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

<img align="left" width="120" src="https://raw.githubusercontent.com/jackmott/rust-simd-noise/master/logo.jpg"/>

# SIMDNoise
Super fast SIMD noise library for Rust. PRs welcome!  
Available on [crates.io](https://crates.io/crates/simdnoise).  
See above crates.io link for Docs.

## Features

* Gradient Noise (Simplex aka Perlin) 1D,2D,3D,4D
* Fractal Brownian Motion, Ridge, and Turbulence 
* Cellular Noise (aka Voroni) 2D, 3D 
* SSE2, SSE41, and AVX2 instruction sets, along with non SIMD fallback
* AVX2 version also leverages FMA3
* Runtime detection picks the best available instruction set

## Benchmarks
*Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz*
*Single Threaded*
*using Criterion.rs*

### 2D 4k (3840 × 2160)  Fbm Noise, 3 Octaves

| SIMD Set | Time |
|----------|------|
| scalar|  888 ms|
| sse2  |  225 ms|
| sse41 |  186 ms|
| avx2  |  108 ms|

### 3D 128 × 128 x 128  Cell Noise

| SIMD Set | Time |
|----------|------|
| scalar|  1,400 ms|
| sse2  |    128 ms|
| sse41 |     94 ms|
| avx2  |     47 ms|


## Todo

* AVX512 support
* ARM NEON support
* Other noise types

## Get a block of noise with runtime SIMD detection

The library will, at runtime, pick the fastest available options between SSE2, SSE41, and AVX2

```rust
use simdnoise::*;

// Get a block of 2d fbm noise with default settings, 100 x 100, with values scaled to the range [0,1]
let noise =  NoiseBuilder::fbm_2d(100, 100).generate_scaled(0.0,1.0);

// Get a block of 3d ridge noise, custom settings, 32x32x32 unscaled
let (noise,min,max) =  NoiseBuilder::ridge_3d(32,32,32) 
        .with_freq(0.05)
        .with_octaves(5)
        .with_gain(2.0)
        .with_lacunarity(0.5)
        .generate();

``

## Call noise functions directly
Sometimes you need something other than a block, like the points on the surface of a sphere.
Sometimes you may want to use SSE41 even with AVX2 is available

```rust
let noise_setting =  NoiseBuilder::ridge_3d(32,32,32) 
        .with_freq(0.05)
        .with_octaves(5)
        .with_gain(2.0)
        .with_lacunarity(0.5)
        .wrap();
 
// get a block of noise with the sse41 version, using the above settings
let (noise,min,max) = unsafe { simdnoise::sse41::get_2d_noise(&noise_setting); }

// send your own SIMD x,y values to the noise functions directly
unsafe {
  // sse2 simplex noise
  let x = _mm_set1_ps(5.0);
  let y = _mm_set1_ps(10.0);
  let f : __m128 = simdnoise::sse2::simplex_2d(x,y);
  
  // avx2 turbulence
  let x = _mm256_set1_ps(5.0);
  let y = _mm256_set1_ps(10.0);
  let freq = _mm_256_set1_ps(1.0);
  let lacunarity = _mm256_set1_ps(0.5);
  let gain = _mm256_set1_ps(2.0);
  let octaves = 3;
  let f_turbulence : __m256 = simdnoise::avx2::turbulence_2d(x,y,lacunarity,gain,octaves);
    
}
```