@@ -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;