Node: Gabor Noise Texture

This patch adds procedural Gabor noise.

This has implementations for Shading (Cycles, Eevee, OSL) and GN.

The noise works by splatting kernels over grid cells similar to Voronoi.

The node has controls for fractal layering and kernel shape variance.

The noise is similar to Voronoi for expense.

Shadertoy test version:
https://www.shadertoy.com/view/NtdfRj

Devtalk feedback thread:
https://devtalk.blender.org/t/gabor-procedural-texture-node/25934

Based on these patches and OSL:
https://archive.blender.org/developer/D3495
https://archive.blender.org/developer/D287

Adapted from Open Shading Language
Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
All Rights Reserved.

Gabor noise originally based on:
Lagae, A. and Drettakis, G. 2011. Filtering Solid Gabor Noise.

@@ -0,0 +13,4 @@
+                         floatBitsToUint(floor(cell.y)),
+                         floatBitsToUint(floor(cell.z)),
+                         floatBitsToUint(float(seed))));
+  if (chash == 0)

@@ -0,0 +18,4 @@
+  return chash * 1519588931;
+}
+
+float gabor_rng_uniform(inout int rng)

@@ -0,0 +92,4 @@
+  float ovar = M_PI * (orand * 2.0 - 1.0);
+  float omega_t = ovar * gp.variance - gp.rotation;
+
+  if (gp.anisotropic == 1) { /* ANISO */

@@ -0,0 +110,4 @@
+  return gp;  // workaround gpu_codegen parser
+}
+
+vec3 gabor_fractal(GaborParams gp, float dv, inout vec3 omega, float phi, vec3 kernel_position)

@@ -0,0 +264,4 @@
+                  int anisotropic,
+                  int periodic)
+{
+  if (impulses == 0.0) {

@@ -1560,3 +1681,3 @@
   SOCKET_IN_FLOAT(detail_scale, "Detail Scale", 0.0f);
   SOCKET_IN_FLOAT(detail_roughness, "Detail Roughness", 0.5f);
-  SOCKET_IN_FLOAT(phase, "Phase Offset", 0.0f);
+  SOCKET_IN_FLOAT(phase, "Phase Randomness", 0.0f);

@@ -0,0 +242,4 @@
+  float maxamp = 0.0f;
+  float sum = 0.0f;
+  float octaves = gp.octaves;
+  if (gp.roughness == 0.0f || gp.scl_lacunarity == 0.0f) {

@@ -0,0 +242,4 @@
+  float maxamp = 0.0f;
+  float sum = 0.0f;
+  float octaves = gp.octaves;
+  if (gp.roughness == 0.0f) {

@@ -0,0 +280,4 @@
+    return mix(sum, sum2, rmd) / maxamp * gp.bandwidth;
+  }
+  else {
+    return sum / maxamp * gp.bandwidth;

@@ -0,0 +75,4 @@
+/* Calculate impulses per cell. Performance is optimised when impulses are set to whole numbers.
+ * Uniform distribution is faster than running a poisson for calculating impulses for remaining
+ * fractional part. */
+int impulses_per_cell(int seed, vec3 cell, float impulses)

@@ -0,0 +87,4 @@
+}
+
+/* Calculates the kernel shape that is multiplied by the gaussian envelope.  */
+vec3 gabor_kernel(GaborParams gp, float freq, vec3 omega, float phi, vec3 position, float g)

@@ -0,0 +113,4 @@
+    h = cos(freq * dot(omega, position) + phi);
+  }
+
+  return vec3(g * h);

@@ -0,0 +155,4 @@
+  vec3 sum = vec3(0.0);
+  for (int i = 0; i < num_impulses; ++i) {
+    vec3 rand_position = vec3(0.0);
+    if (gp.cell_randomness > 0.0) {

@@ -0,0 +168,4 @@
+    if (dv <= 1.0) {
+      vec3 omega;
+      float phi;
+      vec3 rand_values = hash_vec4_to_vec3(vec4(cell, float(seed + (num_impulses + i) * 1259)));

@@ -0,0 +172,4 @@
+
+      gabor_sample(
+          gp, cell, rand_position, rand_values.x, rand_values.y, rand_values.z, omega, phi);
+      const float g = (1.0 + M_EPI) * (exp(-M_PI * dv) - M_EPI);

@@ -0,0 +430,4 @@
+  /* Normalise height of noise by the number of impulses. This is empircal as there is no easy way
+   * to analytically determine the scaling factor for the sum of impulses. */
+  float g = gabor_fractal_noise(gp, co, scale, int(dimensions), int(periodic));
+  float impulse_scale = impulses < 1.0 ? (1.2613446229 * sqrt(gp.impulses)) :

@@ -0,0 +436,4 @@
+
+  /* Normalise and clamp noise to [0.1] range. */
+  if (int(use_normalize) == 1) {
+    g = clamp(0.5 * g + 0.5, 0.0, 1.0);

@@ -0,0 +42,4 @@
+ */
+
+#ifndef M_EPI
+#  define M_EPI 0.0432139182637722

@@ -0,0 +157,4 @@
+  float pvar = mix(0.0, rand_values.z * 2.0 - 1.0, gp.phase_variance);
+  phi = M_2PI * pvar + gp.phase;
+
+  /* Anisotropic direction. */

@@ -0,0 +181,4 @@
+  int num_impulses = impulses_per_cell(seed, cell, gp.impulses);
+  vec3 sum = vec3(0.0);
+  for (int i = 0; i < num_impulses; ++i) {
+    vec3 rand_position = vec3(0.0);

@@ -0,0 +465,4 @@
+  if (gp.mode == SHD_GABOR_MODE_GABOR || gp.mode == SHD_GABOR_MODE_RING ||
+      gp.mode == SHD_GABOR_MODE_CROSS || gp.mode == SHD_GABOR_MODE_SQUARE)
+  {
+    float impulse_scale = impulses > 1.0 ? 1.2613446229 * sqrt(gp.impulses) : 1.2613446229;