archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Activity

BLI: expose more noise hash functions in header

Browse Source 
This is a follow up of the previous commit.
These functions are useful for other areas of Blender as well.
This commit is contained in:
Jacques Lucke
2021-09-24 11:24:15 +02:00
parent bc27bafa54
commit d8a5b768f0
2 changed files with 97 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
source/blender/blenlib/BLI_noise.hh
View File

@@ -22,43 +22,66 @@
namespace blender::noise {
/* Create a randomized hash from the given inputs. Contrary to hash functions in `BLI_hash.hh`
* these functions produce better randomness but are more expensive to compute. */
/* --------------------------------------------------------------------
* Hash functions.
* Create a randomized hash from the given inputs. Contrary to hash functions in `BLI_hash.hh`
* these functions produce better randomness but are more expensive to compute.
*/
/* Hash integers to `uint32_t`. */
uint32_t hash(uint32_t kx);
uint32_t hash(uint32_t kx, uint32_t ky);
uint32_t hash(uint32_t kx, uint32_t ky, uint32_t kz);
uint32_t hash(uint32_t kx, uint32_t ky, uint32_t kz, uint32_t kw);
/* Perlin noise in the range [-1, 1]. */
/* Hash floats to `uint32_t`. */
uint32_t hash_float(float kx);
uint32_t hash_float(float2 k);
uint32_t hash_float(float3 k);
uint32_t hash_float(float4 k);
/* Hash integers to `float` between 0 and 1. */
float hash_to_float(uint32_t kx);
float hash_to_float(uint32_t kx, uint32_t ky);
float hash_to_float(uint32_t kx, uint32_t ky, uint32_t kz);
float hash_to_float(uint32_t kx, uint32_t ky, uint32_t kz, uint32_t kw);
/* Hash floats to `float` between 0 and 1. */
float hash_float_to_float(float k);
float hash_float_to_float(float2 k);
float hash_float_to_float(float3 k);
float hash_float_to_float(float4 k);
/* --------------------------------------------------------------------
* Perlin noise.
*/
/* Perlin noise in the range [-1, 1]. */
float perlin_signed(float position);
float perlin_signed(float2 position);
float perlin_signed(float3 position);
float perlin_signed(float4 position);
/* Perlin noise in the range [0, 1]. */
float perlin(float position);
float perlin(float2 position);
float perlin(float3 position);
float perlin(float4 position);
/* Fractal perlin noise in the range [0, 1]. */
float perlin_fractal(float position, float octaves, float roughness);
float perlin_fractal(float2 position, float octaves, float roughness);
float perlin_fractal(float3 position, float octaves, float roughness);
float perlin_fractal(float4 position, float octaves, float roughness);
/* Positive distorted fractal perlin noise. */
float perlin_fractal_distorted(float position, float octaves, float roughness, float distortion);
float perlin_fractal_distorted(float2 position, float octaves, float roughness, float distortion);
float perlin_fractal_distorted(float3 position, float octaves, float roughness, float distortion);
float perlin_fractal_distorted(float4 position, float octaves, float roughness, float distortion);
/* Positive distorted fractal perlin noise that outputs a float3. */
float3 perlin_float3_fractal_distorted(float position,
float octaves,
float roughness,

110
source/blender/blenlib/intern/noise.cc
View File

@@ -161,30 +161,6 @@ uint32_t hash(uint32_t kx, uint32_t ky, uint32_t kz, uint32_t kw)
return c;
}
/* Hashing a number of uint32_t into a float in the range [0, 1]. */
BLI_INLINE float hash_to_float(uint32_t kx)
{
return static_cast<float>(hash(kx)) / static_cast<float>(0xFFFFFFFFu);
}
BLI_INLINE float hash_to_float(uint32_t kx, uint32_t ky)
{
return static_cast<float>(hash(kx, ky)) / static_cast<float>(0xFFFFFFFFu);
}
BLI_INLINE float hash_to_float(uint32_t kx, uint32_t ky, uint32_t kz)
{
return static_cast<float>(hash(kx, ky, kz)) / static_cast<float>(0xFFFFFFFFu);
}
BLI_INLINE float hash_to_float(uint32_t kx, uint32_t ky, uint32_t kz, uint32_t kw)
{
return static_cast<float>(hash(kx, ky, kz, kw)) / static_cast<float>(0xFFFFFFFFu);
}
/* Hashing a number of floats into a float in the range [0, 1]. */
BLI_INLINE uint32_t float_as_uint(float f)
{
union {
@@ -195,25 +171,73 @@ BLI_INLINE uint32_t float_as_uint(float f)
return u.i;
}
BLI_INLINE float hash_to_float(float k)
uint32_t hash_float(float kx)
{
return hash_to_float(float_as_uint(k));
return hash(float_as_uint(kx));
}
BLI_INLINE float hash_to_float(float2 k)
uint32_t hash_float(float2 k)
{
return hash_to_float(float_as_uint(k.x), float_as_uint(k.y));
return hash(float_as_uint(k.x), float_as_uint(k.y));
}
BLI_INLINE float hash_to_float(float3 k)
uint32_t hash_float(float3 k)
{
return hash_to_float(float_as_uint(k.x), float_as_uint(k.y), float_as_uint(k.z));
return hash(float_as_uint(k.x), float_as_uint(k.y), float_as_uint(k.z));
}
BLI_INLINE float hash_to_float(float4 k)
uint32_t hash_float(float4 k)
{
return hash_to_float(
float_as_uint(k.x), float_as_uint(k.y), float_as_uint(k.z), float_as_uint(k.w));
return hash(float_as_uint(k.x), float_as_uint(k.y), float_as_uint(k.z), float_as_uint(k.w));
}
/* Hashing a number of uint32_t into a float in the range [0, 1]. */
BLI_INLINE float uint_to_float_01(uint32_t k)
{
return static_cast<float>(k) / static_cast<float>(0xFFFFFFFFu);
}
float hash_to_float(uint32_t kx)
{
return uint_to_float_01(hash(kx));
}
float hash_to_float(uint32_t kx, uint32_t ky)
{
return uint_to_float_01(hash(kx, ky));
}
float hash_to_float(uint32_t kx, uint32_t ky, uint32_t kz)
{
return uint_to_float_01(hash(kx, ky, kz));
}
float hash_to_float(uint32_t kx, uint32_t ky, uint32_t kz, uint32_t kw)
{
return uint_to_float_01(hash(kx, ky, kz, kw));
}
/* Hashing a number of floats into a float in the range [0, 1]. */
float hash_float_to_float(float k)
{
return hash_to_float(hash_float(k));
}
float hash_float_to_float(float2 k)
{
return hash_to_float(hash_float(k));
}
float hash_float_to_float(float3 k)
{
return hash_to_float(hash_float(k));
}
float hash_float_to_float(float4 k)
{
return hash_to_float(hash_float(k));
}
/* ------------
@@ -565,28 +589,28 @@ float perlin_fractal(float4 position, float octaves, float roughness)
BLI_INLINE float random_float_offset(float seed)
{
return 100.0f + hash_to_float(seed) * 100.0f;
return 100.0f + hash_float_to_float(seed) * 100.0f;
}
BLI_INLINE float2 random_float2_offset(float seed)
{
return float2(100.0f + hash_to_float(float2(seed, 0.0f)) * 100.0f,
100.0f + hash_to_float(float2(seed, 1.0f)) * 100.0f);
return float2(100.0f + hash_float_to_float(float2(seed, 0.0f)) * 100.0f,
100.0f + hash_float_to_float(float2(seed, 1.0f)) * 100.0f);
}
BLI_INLINE float3 random_float3_offset(float seed)
{
return float3(100.0f + hash_to_float(float2(seed, 0.0f)) * 100.0f,
100.0f + hash_to_float(float2(seed, 1.0f)) * 100.0f,
100.0f + hash_to_float(float2(seed, 2.0f)) * 100.0f);
return float3(100.0f + hash_float_to_float(float2(seed, 0.0f)) * 100.0f,
100.0f + hash_float_to_float(float2(seed, 1.0f)) * 100.0f,
100.0f + hash_float_to_float(float2(seed, 2.0f)) * 100.0f);
}
BLI_INLINE float4 random_float4_offset(float seed)
{
return float4(100.0f + hash_to_float(float2(seed, 0.0f)) * 100.0f,
100.0f + hash_to_float(float2(seed, 1.0f)) * 100.0f,
100.0f + hash_to_float(float2(seed, 2.0f)) * 100.0f,
100.0f + hash_to_float(float2(seed, 3.0f)) * 100.0f);
return float4(100.0f + hash_float_to_float(float2(seed, 0.0f)) * 100.0f,
100.0f + hash_float_to_float(float2(seed, 1.0f)) * 100.0f,
100.0f + hash_float_to_float(float2(seed, 2.0f)) * 100.0f,
100.0f + hash_float_to_float(float2(seed, 3.0f)) * 100.0f);
}
/* Perlin noises to be added to the position to distort other noises. */