Add flake node implementations

documents/Specification/MaterialX.StandardNodes.md

@@ -512,6 +512,43 @@ A single node supporting 3D Perlin, Cell, Worley or Fractal noise in a unified i
 |`style`      |The output style                                                                           |integer|0        |0 (Distance), 1 (Solid)|
 |`out`        |Output: the computed noise value                                                           |float  |0.0      |                       |
 
+<a id="node-flake2d"> </a>
+
+### `flake2d`
+Generates a procedural flake pattern in 2D space, suitable for simulating metallic flakes in materials such as car paint.
+
+|Port         |Description                                                                                        |Type   |Default |
+|-------------|---------------------------------------------------------------------------------------------------|-------|--------|
+|`texcoord`   |The 2D texture coordinate at which the flake pattern is evaluated                                  |vector2|_UV0_   |
+|`size`       |The size of individual flakes, with smaller values producing larger flakes                         |float  |0.01    |
+|`roughness`  |The surface roughness of individual flakes, controlling the variation in normal                    |float  |0.1     |
+|`coverage`   |The density of flakes in the pattern, ranging from 0.0 (no flakes) to 1.0 (maximum)                |float  |0.5     |
+|`normal`     |The surface normal vector used as the base for flake normal perturbations                          |vector3|_Nworld_|
+|`tangent`    |The surface tangent vector, used to construct the tangent space                                    |vector3|_Tworld_|
+|`bitangent`  |The surface bitangent vector, used to construct the tangent space                                  |vector3|_Bworld_|
+|`id`         |Output: unique identifier for each flake. 0 for no flake                                           |integer|0       |
+|`rand`       |Output: random value per flake for additional variation. 0.0 for no flake                          |float  |0.0     |
+|`presence`   |Output: presence per flake; a depth-like value (higher is closer to the surface). 0.0 for no flake.|float  |0.0     |
+|`flakenormal`|Output: the computed flake normal. Base normal if no flake present                                 |vector3|_Nworld_|
+
+<a id="node-flake3d"> </a>
+
+### `flake3d`
+Generates a procedural flake pattern in 3D space, suitable for simulating metallic flakes in materials such as car paint.
+
+|Port         |Description                                                                                        |Type   |Default  |
+|-------------|---------------------------------------------------------------------------------------------------|-------|---------|
+|`position`   |The 3D position at which the flake pattern is evaluated                                            |vector3|_Pobject_|
+|`size`       |The size of individual flakes, with smaller values producing larger flakes                         |float  |0.01     |
+|`roughness`  |The surface roughness of individual flakes, controlling the variation in normal                    |float  |0.1      |
+|`coverage`   |The density of flakes in the pattern, ranging from 0.0 (no flakes) to 1.0 (maximum)                |float  |0.5      |
+|`normal`     |The surface normal vector used as the base for flake normal perturbations                          |vector3|_Nworld_ |
+|`tangent`    |The surface tangent vector, used to construct the tangent space                                    |vector3|_Tworld_ |
+|`bitangent`  |The surface bitangent vector, used to construct the tangent space                                  |vector3|_Bworld_ |
+|`id`         |Output: unique identifier for each flake. 0 for no flake                                           |integer|0        |
+|`rand`       |Output: random value per flake for additional variation. 0.0 for no flake                          |float  |0.0      |
+|`presence`   |Output: presence per flake; a depth-like value (higher is closer to the surface). 0.0 for no flake.|float  |0.0      |
+|`flakenormal`|Output: the computed flake normal. Base normal if no flake present                                 |vector3|_Nworld_ |
 
 ### Noise Node Notes
 

libraries/stdlib/genglsl/lib/mx_flake.glsl

@@ -0,0 +1,158 @@
+uint mx_flake_hash(uint seed, uint i)
+{
+    return (i ^ seed) * 1075385539u; 
+}
+
+uint mx_flake_init_seed(ivec3 i)
+{
+    return mx_flake_hash(mx_flake_hash(mx_flake_hash(0, i.x), i.y), i.z);
+}
+
+uint mx_flake_xorshift32(uint seed)
+{
+    seed ^= seed << 13;
+    seed ^= seed >> 17;
+    seed ^= seed << 5;
+    return seed;
+}
+
+float mx_uint_to_01(uint x)
+{
+    return float(x) / float(0xffffffffu);  // scale to [0, 1)
+}
+
+// "Fast Random Rotation Matrices" by James Arvo, Graphics Gems3 P.117
+vec3 mx_rotate_flake(vec3 p, vec3 i)
+{
+    float theta = M_PI * 2.0 * i.x;
+    float phi = M_PI * 2.0 * i.y;
+    float z = i.z * 2.0;
+
+    float r = sqrt(z);
+    float vx = sin(phi) * r;
+    float vy = cos(phi) * r;
+    float vz = sqrt(2.0 - z);
+
+    float s_theta = sin(theta);
+    float c_theta = cos(theta);
+    float sx = vx * s_theta - vy * s_theta;
+    float sy = vx * c_theta + vy * c_theta;
+
+    mat3 m = mat3(
+        vx * sx - s_theta, vx * sy - s_theta, vx * vz,
+        vy * sx + c_theta, vy * sy - c_theta, vy * vz,
+        vz * sx          , vz * sy          , 1.0 - z
+    );
+
+    return m * p;
+}
+
+// compute a flake probability for a given flake coverage density x
+float mx_flake_density_to_probability(float x)
+{
+    // constants for numerical fitted curve to observed flake noise density behavior
+    const vec4 abcd = vec4(-26.19771808f, 26.39663835f, 85.53857017f, -102.35069432f);
+    const vec2 ef = vec2(-101.42634862f, 118.45082288f);
+    float xx = x * x;
+
+    return (abcd.x * xx + abcd.y * x) / (abcd.z * xx * x + abcd.w * xx  + ef.x * x + ef.y);
+}
+
+void mx_flake(
+    float size,
+    float roughness,
+    float coverage,
+    vec3 position,
+    vec3 normal,
+    vec3 tangent,
+    vec3 bitangent,
+    out int id,
+    out float rand,
+    out float presence,
+    out vec3 flakenormal
+)
+{
+    float probability = mx_flake_density_to_probability(clamp(coverage, 0.0, 1.0));
+    const float flake_diameter = 1.5 / sqrt(3.0);
+
+    vec3 P = position / vec3(size);
+    vec3 base_P = floor(P);
+    ivec3 base_P_int = ivec3(base_P);
+
+    // flake priority in [0..1], 0: no flake, flakes with higher priority shadow flakes "below" them
+    float flake_priority = 0.0;
+    uint flake_seed = 0;
+
+    // Examine the 3×3×3 lattice neighborhood around the sample cell. Flakes are seeded at cell
+    // centers but can overlap adjacent cells by up to flake_diameter, so neighbors may contribute
+    // at the sample position. For each neighbor we deterministically generate a seed, reject it
+    // by the density probability, compute a per-flake priority, and test the rotated, centered
+    // flake position for overlap. The highest-priority overlapping flake is selected.
+    for (int i = -1; i < 2; ++i)
+    {
+        for (int j = -1; j < 2; ++j)
+        {
+            for (int k = -1; k < 2; ++k)
+            {
+                uint seed = mx_flake_init_seed(base_P_int + ivec3(i, j, k));
+
+                seed = mx_flake_xorshift32(seed);
+                if (mx_uint_to_01(seed) > probability)
+                    continue;
+
+                seed = mx_flake_xorshift32(seed);
+                float priority = mx_uint_to_01(seed);
+                if (priority < flake_priority)
+                    continue;
+
+                vec3 flake_P = base_P + vec3(i, j, k) + vec3(0.5);
+                vec3 PP = P - flake_P;
+                if (dot(PP, PP) >= flake_diameter * flake_diameter * 4.0)
+                    continue;
+
+                vec3 rot;
+                seed = mx_flake_xorshift32(seed); rot.x = mx_uint_to_01(seed);
+                seed = mx_flake_xorshift32(seed); rot.y = mx_uint_to_01(seed);
+                seed = mx_flake_xorshift32(seed); rot.z = mx_uint_to_01(seed);
+                PP = mx_rotate_flake(PP, rot);
+
+                if (abs(PP.x) <= flake_diameter &&
+                    abs(PP.y) <= flake_diameter &&
+                    abs(PP.z) <= flake_diameter)
+                {
+                    flake_priority = priority;
+                    flake_seed = seed;
+                }
+            }
+        }
+    }
+
+    if (flake_priority <= 0.0)
+    {
+        // no flake
+        id = 0;
+        rand = 0.0;
+        presence = 0.0;
+        flakenormal = normal;
+        return;
+    }
+
+    // create a flake normal by importance sampling a microfacet distribution with given roughness
+    uint seed = flake_seed;
+    float xi0 = mx_uint_to_01(seed); seed = mx_flake_xorshift32(seed);
+    float xi1 = mx_uint_to_01(seed); seed = mx_flake_xorshift32(seed);
+
+    id = int(seed);  // not ideal but MaterialX does not support unsigned integer type
+    rand = mx_uint_to_01(seed);
+    presence = flake_priority;
+
+    float phi = M_PI * 2.0 * xi0;
+    float tan_theta = roughness * roughness * sqrt(xi1) / sqrt(1.0 - xi1);  // GGX
+    float sin_theta = tan_theta / sqrt(1.0 + tan_theta * tan_theta);
+    float cos_theta = sqrt(1.0 - sin_theta * sin_theta);
+
+    flakenormal = tangent * cos(phi) * sin_theta +
+                  bitangent * sin(phi) * sin_theta +
+                  normal * cos_theta;
+    flakenormal = normalize(flakenormal);
+}

libraries/stdlib/genglsl/lib/mx_math.glsl

@@ -1,4 +1,5 @@
 #define M_FLOAT_EPS 1e-8
+#define M_PI 3.1415926535897932
 
 #define mx_mod mod
 #define mx_inverse inverse

libraries/stdlib/genglsl/mx_flake2d.glsl

@@ -0,0 +1,20 @@
+#include "lib/mx_flake.glsl"
+
+void mx_flake2d(
+    float size,
+    float roughness,
+    float coverage,
+    vec2 texcoord,
+    vec3 normal,
+    vec3 tangent,
+    vec3 bitangent,
+    out int id,
+    out float rand,
+    out float presence,
+    out vec3 flakenormal
+)
+{
+    // reuse the 3d flake implementation. this could be optimized by using a 2d flake implementation
+    vec3 position = vec3(texcoord.x, texcoord.y, 0.0);
+    mx_flake(size, roughness, coverage, position, normal, tangent, bitangent, id, rand, presence, flakenormal);
+}

libraries/stdlib/genglsl/mx_flake3d.glsl

@@ -0,0 +1,18 @@
+#include "lib/mx_flake.glsl"
+
+void mx_flake3d(
+    float size,
+    float roughness,
+    float coverage,
+    vec3 position,
+    vec3 normal,
+    vec3 tangent,
+    vec3 bitangent,
+    out int id,
+    out float rand,
+    out float presence,
+    out vec3 flakenormal
+)
+{
+    mx_flake(size, roughness, coverage, position, normal, tangent, bitangent, id, rand, presence, flakenormal);
+}

libraries/stdlib/genglsl/stdlib_genglsl_impl.mtlx

@@ -148,6 +148,12 @@
   <implementation name="IM_worleynoise3d_vector2_genglsl" nodedef="ND_worleynoise3d_vector2" file="mx_worleynoise3d_vector2.glsl" function="mx_worleynoise3d_vector2" target="genglsl" />
   <implementation name="IM_worleynoise3d_vector3_genglsl" nodedef="ND_worleynoise3d_vector3" file="mx_worleynoise3d_vector3.glsl" function="mx_worleynoise3d_vector3" target="genglsl" />
 
+  <!-- <flake2d> -->
+  <implementation name="IM_flake2d_genglsl" nodedef="ND_flake2d" file="mx_flake2d.glsl" function="mx_flake2d" target="genglsl" />
+
+  <!-- <flake3d> -->
+  <implementation name="IM_flake3d_genglsl" nodedef="ND_flake3d" file="mx_flake3d.glsl" function="mx_flake3d" target="genglsl" />
+
   <!-- ======================================================================== -->
   <!-- Geometric nodes                                                          -->
   <!-- ======================================================================== -->

libraries/stdlib/genmdl/stdlib_genmdl_impl.mtlx

@@ -150,6 +150,12 @@
   <implementation name="IM_worleynoise3d_vector2_genmdl" nodedef="ND_worleynoise3d_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_worleynoise3d_float2(mxp_position:{{position}}, mxp_jitter:{{jitter}})" target="genmdl" />
   <implementation name="IM_worleynoise3d_vector3_genmdl" nodedef="ND_worleynoise3d_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_worleynoise3d_float3(mxp_position:{{position}}, mxp_jitter:{{jitter}})" target="genmdl" />
 
+  <!-- <flake2d> -->
+  <implementation name="IM_flake2d_genmdl" nodedef="ND_flake2d" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_flake2d(mxp_size:{{size}}, mxp_roughness:{{roughness}}, mxp_coverage:{{coverage}}, mxp_texcoord:{{texcoord}}, mxp_normal:{{normal}}, mxp_tangent:{{tangent}}, mxp_bitangent:{{bitangent}})" target="genmdl" />
+
+  <!-- <flake3d> -->
+  <implementation name="IM_flake3d_genmdl" nodedef="ND_flake3d" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_flake3d(mxp_size:{{size}}, mxp_roughness:{{roughness}}, mxp_coverage:{{coverage}}, mxp_position:{{position}}, mxp_normal:{{normal}}, mxp_tangent:{{tangent}}, mxp_bitangent:{{bitangent}})" target="genmdl" />
+
   <!-- ======================================================================== -->
   <!-- Geometric nodes                                                          -->
   <!-- ======================================================================== -->

libraries/stdlib/genmsl/lib/mx_math.metal

@@ -1,4 +1,5 @@
 #define M_FLOAT_EPS 1e-8
+#define M_PI M_PI_F
 
 #define mx_sin metal::sin
 #define mx_cos metal::cos

libraries/stdlib/stdlib_defs.mtlx

@@ -1237,6 +1237,42 @@
     <output name="out" type="float" default="0.0" />
   </nodedef>
 
+  <!--
+    Node: <flake2d>
+    3D flake pattern generator.
+  -->
+  <nodedef name="ND_flake2d" node="flake2d" nodegroup="procedural2d">
+    <input name="size" type="float" value="0.01" doc="Size of individual flakes." />
+    <input name="roughness" type="float" value="0.1" doc="Roughness of the flake normal distribution." />
+    <input name="coverage" type="float" value="0.5" doc="Density of flake coverage (0 = no flakes, 1 = full coverage)." />
+    <input name="texcoord" type="vector2" defaultgeomprop="UV0" doc="The input 2d space. Default is the first texture coordinates." />
+    <input name="normal" type="vector3" defaultgeomprop="Nworld" doc="Surface normal; defaults to the current world-space normal." />
+    <input name="tangent" type="vector3" defaultgeomprop="Tworld" doc="Surface tangent vector, defaults to the current world-space tangent vector." />
+    <input name="bitangent" type="vector3" defaultgeomprop="Bworld" doc="Surface bitangent vector, defaults to the current world-space bitangent vector." />
+    <output name="id" type="integer" default="0" doc="Unique identifier for each flake (0 for no flake)." />
+    <output name="rand" type="float" default="0.0" doc="Random value per flake for additional variation (0 for no flake)." />
+    <output name="presence" type="float" default="0.0" doc="Depth-based presence value per flake for additional variation (0 for no flake)." />
+    <output name="flakenormal" type="vector3" default="Nworld" doc="The computed flake normal (base normal if no flake present)." />
+  </nodedef>
+
+  <!--
+    Node: <flake3d>
+    2D flake pattern generator.
+  -->
+  <nodedef name="ND_flake3d" node="flake3d" nodegroup="procedural3d">
+    <input name="size" type="float" value="0.01" doc="Size of individual flakes." />
+    <input name="roughness" type="float" value="0.1" doc="Roughness of the flake normal distribution." />
+    <input name="coverage" type="float" value="0.5" doc="Density of flake coverage (0 = no flakes, 1 = full coverage)." />
+    <input name="position" type="vector3" defaultgeomprop="Pobject" doc="The input 3d space. Default is position in object-space." />
+    <input name="normal" type="vector3" defaultgeomprop="Nworld" doc="Surface normal; defaults to the current world-space normal." />
+    <input name="tangent" type="vector3" defaultgeomprop="Tworld" doc="Surface tangent vector, defaults to the current world-space tangent vector." />
+    <input name="bitangent" type="vector3" defaultgeomprop="Bworld" doc="Surface bitangent vector, defaults to the current world-space bitangent vector." />
+    <output name="id" type="integer" default="0" doc="Unique identifier for each flake (0 for no flake)." />
+    <output name="rand" type="float" default="0.0" doc="Random value per flake for additional variation (0 for no flake)." />
+    <output name="presence" type="float" default="0.0" doc="Depth-based presence value per flake for additional variation (0 for no flake)." />
+    <output name="flakenormal" type="vector3" default="Nworld" doc="The computed flake normal (base normal if no flake present)." />
+  </nodedef>
+
   <!--
     Node: <randomfloat>
     Produces a randomized float, based on an 'input' signal and 'seed' value.

resources/Materials/TestSuite/pbrlib/surfaceshader/flake_surfaceshader.mtlx

@@ -0,0 +1,44 @@
+<?xml version="1.0"?>
+<materialx version="1.39">
+  <surfacematerial name="flake_surfaceshader" type="material">
+    <input name="surfaceshader" type="surfaceshader" nodename="standard_surface_surfaceshader" />
+  </surfacematerial>
+  <standard_surface name="standard_surface_surfaceshader" type="surfaceshader">
+    <input name="normal" type="vector3" output="flakenormal" nodename="flake3d" />
+    <input name="metalness" type="float" value="1" />
+    <input name="coat" type="float" value="1" />
+    <input name="specular_roughness" type="float" value="0.1" />
+    <input name="coat_roughness" type="float" value="0" />
+    <input name="specular" type="float" value="1" />
+    <input name="base_color" type="color3" nodename="multiply_color3FA" />
+    <input name="base" type="float" value="1" />
+  </standard_surface>
+  <flake3d name="flake3d" type="multioutput">
+    <input name="coverage" type="float" value="1" />
+    <input name="roughness" type="float" value="0.2" />
+    <input name="size" type="float" value="0.002" />
+    <output name="id" type="integer" />
+    <output name="presence" type="float" />
+    <output name="flakenormal" type="vector3" />
+  </flake3d>
+  <randomcolor name="randomcolor_float" type="color3">
+    <input name="seed" type="integer" output="id" nodename="flake3d" />
+    <output name="out" type="color3" />
+    <input name="saturationhigh" type="float" value="0" />
+    <input name="saturationlow" type="float" value="0.5" />
+  </randomcolor>
+  <multiply name="multiply_color3" type="color3">
+    <input name="in2" type="color3" nodename="randomcolor_float" />
+    <output name="out" type="color3" />
+    <input name="in1" type="color3" value="0.399894, 0.0183279, 0.530191" />
+  </multiply>
+  <multiply name="multiply_color3FA" type="color3">
+    <input name="in2" type="float" nodename="safepower_float" />
+    <input name="in1" type="color3" nodename="multiply_color3" />
+    <output name="out" type="color3" />
+  </multiply>
+  <safepower name="safepower_float" type="float">
+    <input name="in1" type="float" output="presence" nodename="flake3d" />
+    <input name="in2" type="float" value="8" />
+  </safepower>
+</materialx>