BLI: expose more noise hash functions in header

This is a follow up of the previous commit.
These functions are useful for other areas of Blender as well.

2 files changed, 90 insertions, 43 deletions

diff --git a/source/blender/blenlib/BLI_noise.hh b/source/blender/blenlib/BLI_noise.hh
index b5a06b2b020..7e1655f7864 100644
--- a/source/blender/blenlib/BLI_noise.hh
+++ b/source/blender/blenlib/BLI_noise.hh
@@ -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,
diff --git a/source/blender/blenlib/intern/noise.cc b/source/blender/blenlib/intern/noise.cc
index 0f80fa0f294..e80975f618c 100644
--- a/source/blender/blenlib/intern/noise.cc
+++ b/source/blender/blenlib/intern/noise.cc
@@ -161,59 +161,83 @@ 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 uint32_t float_as_uint(float f)
+{
+  union {
+    uint32_t i;
+    float f;
+  } u;
+  u.f = f;
+  return u.i;
+}
 
-BLI_INLINE float hash_to_float(uint32_t kx)
+uint32_t hash_float(float kx)
 {
-  return static_cast<float>(hash(kx)) / static_cast<float>(0xFFFFFFFFu);
+  return hash(float_as_uint(kx));
 }
 
-BLI_INLINE float hash_to_float(uint32_t kx, uint32_t ky)
+uint32_t hash_float(float2 k)
 {
-  return static_cast<float>(hash(kx, ky)) / static_cast<float>(0xFFFFFFFFu);
+  return hash(float_as_uint(k.x), float_as_uint(k.y));
 }
 
-BLI_INLINE float hash_to_float(uint32_t kx, uint32_t ky, uint32_t kz)
+uint32_t hash_float(float3 k)
 {
-  return static_cast<float>(hash(kx, ky, kz)) / static_cast<float>(0xFFFFFFFFu);
+  return hash(float_as_uint(k.x), float_as_uint(k.y), float_as_uint(k.z));
 }
 
-BLI_INLINE float hash_to_float(uint32_t kx, uint32_t ky, uint32_t kz, uint32_t kw)
+uint32_t hash_float(float4 k)
 {
-  return static_cast<float>(hash(kx, ky, kz, kw)) / static_cast<float>(0xFFFFFFFFu);
+  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 floats into a float in the range [0, 1]. */
+/* Hashing a number of uint32_t into a float in the range [0, 1]. */
 
-BLI_INLINE uint32_t float_as_uint(float f)
+BLI_INLINE float uint_to_float_01(uint32_t k)
 {
-  union {
-    uint32_t i;
-    float f;
-  } u;
-  u.f = f;
-  return u.i;
+  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));
 }
 
-BLI_INLINE float hash_to_float(float k)
+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(float_as_uint(k));
+  return hash_to_float(hash_float(k));
 }
 
-BLI_INLINE float hash_to_float(float2 k)
+float hash_float_to_float(float2 k)
 {
-  return hash_to_float(float_as_uint(k.x), float_as_uint(k.y));
+  return hash_to_float(hash_float(k));
 }
 
-BLI_INLINE float hash_to_float(float3 k)
+float hash_float_to_float(float3 k)
 {
-  return hash_to_float(float_as_uint(k.x), float_as_uint(k.y), float_as_uint(k.z));
+  return hash_to_float(hash_float(k));
 }
 
-BLI_INLINE float hash_to_float(float4 k)
+float hash_float_to_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_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. */