Ajout du projet Depths sur Git

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/lib/mx_hsv.glsl

@@ -0,0 +1,91 @@
+/*
+Color transform functions.
+
+These funcions are modified versions of the color operators found in Open Shading Language:
+github.com/imageworks/OpenShadingLanguage/blob/master/src/liboslexec/opcolor.cpp
+
+It contains the subset of color operators needed to implement the MaterialX
+standard library. The modifications are for conversions from C++ to GLSL.
+
+Original copyright notice:
+------------------------------------------------------------------------
+Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
+All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of Sony Pictures Imageworks nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+------------------------------------------------------------------------
+*/
+
+vec3 mx_hsvtorgb(vec3 hsv)
+{
+    // Reference for this technique: Foley & van Dam
+    float h = hsv.x; float s = hsv.y; float v = hsv.z;
+    if (s < 0.0001f) {
+      return vec3 (v, v, v);
+    } else {
+        h = 6.0f * (h - floor(h));  // expand to [0..6)
+        int hi = int(trunc(h));
+        float f = h - float(hi);
+        float p = v * (1.0f-s);
+        float q = v * (1.0f-s*f);
+        float t = v * (1.0f-s*(1.0f-f));
+        if (hi == 0)
+            return vec3 (v, t, p);
+        else if (hi == 1)
+            return vec3 (q, v, p);
+        else if (hi == 2)
+            return vec3 (p, v, t);
+        else if (hi == 3)
+            return vec3 (p, q, v);
+        else if (hi == 4)
+            return vec3 (t, p, v);
+        return vec3 (v, p, q);
+    }
+}
+
+
+vec3 mx_rgbtohsv(vec3 c)
+{
+    // See Foley & van Dam
+    float r = c.x; float g = c.y; float b = c.z;
+    float mincomp = min (r, min(g, b));
+    float maxcomp = max (r, max(g, b));
+    float delta = maxcomp - mincomp;  // chroma
+    float h, s, v;
+    v = maxcomp;
+    if (maxcomp > 0.0f)
+        s = delta / maxcomp;
+    else s = 0.0f;
+    if (s <= 0.0f)
+        h = 0.0f;
+    else {
+        if      (r >= maxcomp) h = (g-b) / delta;
+        else if (g >= maxcomp) h = 2.0f + (b-r) / delta;
+        else                   h = 4.0f + (r-g) / delta;
+        h *= (1.0f/6.0f);
+        if (h < 0.0f)
+            h += 1.0f;
+    }
+    return vec3(h, s, v);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/lib/mx_math.glsl

@@ -0,0 +1,16 @@
+#define M_FLOAT_EPS 1e-8
+
+float mx_square(float x)
+{
+    return x*x;
+}
+
+vec2 mx_square(vec2 x)
+{
+    return x*x;
+}
+
+vec3 mx_square(vec3 x)
+{
+    return x*x;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/lib/mx_noise.glsl

@@ -0,0 +1,636 @@
+/*
+Noise Library.
+
+This library is a modified version of the noise library found in
+Open Shading Language:
+github.com/imageworks/OpenShadingLanguage/blob/master/src/include/OSL/oslnoise.h
+
+It contains the subset of noise types needed to implement the MaterialX
+standard library. The modifications are mainly conversions from C++ to GLSL.
+Produced results should be identical to the OSL noise functions.
+
+Original copyright notice:
+------------------------------------------------------------------------
+Copyright (c) 2009-2010 Sony Pictures Imageworks Inc., et al.
+All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of Sony Pictures Imageworks nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+------------------------------------------------------------------------
+*/
+
+float mx_select(bool b, float t, float f)
+{
+    return b ? t : f;
+}
+
+float mx_negate_if(float val, bool b)
+{
+    return b ? -val : val;
+}
+
+int mx_floor(float x)
+{
+    return int(floor(x));
+}
+
+// return mx_floor as well as the fractional remainder
+float mx_floorfrac(float x, out int i)
+{
+    i = mx_floor(x);
+    return x - float(i);
+}
+
+float mx_bilerp(float v0, float v1, float v2, float v3, float s, float t)
+{
+    float s1 = 1.0 - s;
+    return (1.0 - t) * (v0*s1 + v1*s) + t * (v2*s1 + v3*s);
+}
+vec3 mx_bilerp(vec3 v0, vec3 v1, vec3 v2, vec3 v3, float s, float t)
+{
+    float s1 = 1.0 - s;
+    return (1.0 - t) * (v0*s1 + v1*s) + t * (v2*s1 + v3*s);
+}
+float mx_trilerp(float v0, float v1, float v2, float v3, float v4, float v5, float v6, float v7, float s, float t, float r)
+{
+    float s1 = 1.0 - s;
+    float t1 = 1.0 - t;
+    float r1 = 1.0 - r;
+    return (r1*(t1*(v0*s1 + v1*s) + t*(v2*s1 + v3*s)) +
+            r*(t1*(v4*s1 + v5*s) + t*(v6*s1 + v7*s)));
+}
+vec3 mx_trilerp(vec3 v0, vec3 v1, vec3 v2, vec3 v3, vec3 v4, vec3 v5, vec3 v6, vec3 v7, float s, float t, float r)
+{
+    float s1 = 1.0 - s;
+    float t1 = 1.0 - t;
+    float r1 = 1.0 - r;
+    return (r1*(t1*(v0*s1 + v1*s) + t*(v2*s1 + v3*s)) +
+            r*(t1*(v4*s1 + v5*s) + t*(v6*s1 + v7*s)));
+}
+
+// 2 and 3 dimensional gradient functions - perform a dot product against a
+// randomly chosen vector. Note that the gradient vector is not normalized, but
+// this only affects the overal "scale" of the result, so we simply account for
+// the scale by multiplying in the corresponding "perlin" function.
+float mx_gradient_float(uint hash, float x, float y)
+{
+    // 8 possible directions (+-1,+-2) and (+-2,+-1)
+    uint h = hash & 7u;
+    float u = mx_select(h<4u, x, y);
+    float v = 2.0 * mx_select(h<4u, y, x);
+    // compute the dot product with (x,y).
+    return mx_negate_if(u, bool(h&1u)) + mx_negate_if(v, bool(h&2u));
+}
+float mx_gradient_float(uint hash, float x, float y, float z)
+{
+    // use vectors pointing to the edges of the cube
+    uint h = hash & 15u;
+    float u = mx_select(h<8u, x, y);
+    float v = mx_select(h<4u, y, mx_select((h==12u)||(h==14u), x, z));
+    return mx_negate_if(u, bool(h&1u)) + mx_negate_if(v, bool(h&2u));
+}
+vec3 mx_gradient_vec3(uvec3 hash, float x, float y)
+{
+    return vec3(mx_gradient_float(hash.x, x, y), mx_gradient_float(hash.y, x, y), mx_gradient_float(hash.z, x, y));
+}
+vec3 mx_gradient_vec3(uvec3 hash, float x, float y, float z)
+{
+    return vec3(mx_gradient_float(hash.x, x, y, z), mx_gradient_float(hash.y, x, y, z), mx_gradient_float(hash.z, x, y, z));
+}
+// Scaling factors to normalize the result of gradients above.
+// These factors were experimentally calculated to be:
+//    2D:   0.6616
+//    3D:   0.9820
+float mx_gradient_scale2d(float v) { return 0.6616 * v; }
+float mx_gradient_scale3d(float v) { return 0.9820 * v; }
+vec3 mx_gradient_scale2d(vec3 v) { return 0.6616 * v; }
+vec3 mx_gradient_scale3d(vec3 v) { return 0.9820 * v; }
+
+/// Bitwise circular rotation left by k bits (for 32 bit unsigned integers)
+uint mx_rotl32(uint x, int k)
+{
+    return (x<<k) | (x>>(32-k));
+}
+
+void mx_bjmix(inout uint a, inout uint b, inout uint c)
+{
+    a -= c; a ^= mx_rotl32(c, 4); c += b;
+    b -= a; b ^= mx_rotl32(a, 6); a += c;
+    c -= b; c ^= mx_rotl32(b, 8); b += a;
+    a -= c; a ^= mx_rotl32(c,16); c += b;
+    b -= a; b ^= mx_rotl32(a,19); a += c;
+    c -= b; c ^= mx_rotl32(b, 4); b += a;
+}
+
+// Mix up and combine the bits of a, b, and c (doesn't change them, but
+// returns a hash of those three original values).
+uint mx_bjfinal(uint a, uint b, uint c)
+{
+    c ^= b; c -= mx_rotl32(b,14);
+    a ^= c; a -= mx_rotl32(c,11);
+    b ^= a; b -= mx_rotl32(a,25);
+    c ^= b; c -= mx_rotl32(b,16);
+    a ^= c; a -= mx_rotl32(c,4);
+    b ^= a; b -= mx_rotl32(a,14);
+    c ^= b; c -= mx_rotl32(b,24);
+    return c;
+}
+
+// Convert a 32 bit integer into a floating point number in [0,1]
+float mx_bits_to_01(uint bits)
+{
+    return float(bits) / float(uint(0xffffffff));
+}
+
+float mx_fade(float t)
+{
+   return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
+}
+
+uint mx_hash_int(int x)
+{
+    uint len = 1u;
+    uint seed = uint(0xdeadbeef) + (len << 2u) + 13u;
+    return mx_bjfinal(seed+uint(x), seed, seed);
+}
+
+uint mx_hash_int(int x, int y)
+{
+    uint len = 2u;
+    uint a, b, c;
+    a = b = c = uint(0xdeadbeef) + (len << 2u) + 13u;
+    a += uint(x);
+    b += uint(y);
+    return mx_bjfinal(a, b, c);
+}
+
+uint mx_hash_int(int x, int y, int z)
+{
+    uint len = 3u;
+    uint a, b, c;
+    a = b = c = uint(0xdeadbeef) + (len << 2u) + 13u;
+    a += uint(x);
+    b += uint(y);
+    c += uint(z);
+    return mx_bjfinal(a, b, c);
+}
+
+uint mx_hash_int(int x, int y, int z, int xx)
+{
+    uint len = 4u;
+    uint a, b, c;
+    a = b = c = uint(0xdeadbeef) + (len << 2u) + 13u;
+    a += uint(x);
+    b += uint(y);
+    c += uint(z);
+    mx_bjmix(a, b, c);
+    a += uint(xx);
+    return mx_bjfinal(a, b, c);
+}
+
+uint mx_hash_int(int x, int y, int z, int xx, int yy)
+{
+    uint len = 5u;
+    uint a, b, c;
+    a = b = c = uint(0xdeadbeef) + (len << 2u) + 13u;
+    a += uint(x);
+    b += uint(y);
+    c += uint(z);
+    mx_bjmix(a, b, c);
+    a += uint(xx);
+    b += uint(yy);
+    return mx_bjfinal(a, b, c);
+}
+
+uvec3 mx_hash_vec3(int x, int y)
+{
+    uint h = mx_hash_int(x, y);
+    // we only need the low-order bits to be random, so split out
+    // the 32 bit result into 3 parts for each channel
+    uvec3 result;
+    result.x = (h      ) & 0xFFu;
+    result.y = (h >> 8 ) & 0xFFu;
+    result.z = (h >> 16) & 0xFFu;
+    return result;
+}
+
+uvec3 mx_hash_vec3(int x, int y, int z)
+{
+    uint h = mx_hash_int(x, y, z);
+    // we only need the low-order bits to be random, so split out
+    // the 32 bit result into 3 parts for each channel
+    uvec3 result;
+    result.x = (h      ) & 0xFFu;
+    result.y = (h >> 8 ) & 0xFFu;
+    result.z = (h >> 16) & 0xFFu;
+    return result;
+}
+
+float mx_perlin_noise_float(vec2 p)
+{
+    int X, Y;
+    float fx = mx_floorfrac(p.x, X);
+    float fy = mx_floorfrac(p.y, Y);
+    float u = mx_fade(fx);
+    float v = mx_fade(fy);
+    float result = mx_bilerp(
+        mx_gradient_float(mx_hash_int(X  , Y  ), fx    , fy     ),
+        mx_gradient_float(mx_hash_int(X+1, Y  ), fx-1.0, fy     ),
+        mx_gradient_float(mx_hash_int(X  , Y+1), fx    , fy-1.0),
+        mx_gradient_float(mx_hash_int(X+1, Y+1), fx-1.0, fy-1.0),
+        u, v);
+    return mx_gradient_scale2d(result);
+}
+
+float mx_perlin_noise_float(vec3 p)
+{
+    int X, Y, Z;
+    float fx = mx_floorfrac(p.x, X);
+    float fy = mx_floorfrac(p.y, Y);
+    float fz = mx_floorfrac(p.z, Z);
+    float u = mx_fade(fx);
+    float v = mx_fade(fy);
+    float w = mx_fade(fz);
+    float result = mx_trilerp(
+        mx_gradient_float(mx_hash_int(X  , Y  , Z  ), fx    , fy    , fz     ),
+        mx_gradient_float(mx_hash_int(X+1, Y  , Z  ), fx-1.0, fy    , fz     ),
+        mx_gradient_float(mx_hash_int(X  , Y+1, Z  ), fx    , fy-1.0, fz     ),
+        mx_gradient_float(mx_hash_int(X+1, Y+1, Z  ), fx-1.0, fy-1.0, fz     ),
+        mx_gradient_float(mx_hash_int(X  , Y  , Z+1), fx    , fy    , fz-1.0),
+        mx_gradient_float(mx_hash_int(X+1, Y  , Z+1), fx-1.0, fy    , fz-1.0),
+        mx_gradient_float(mx_hash_int(X  , Y+1, Z+1), fx    , fy-1.0, fz-1.0),
+        mx_gradient_float(mx_hash_int(X+1, Y+1, Z+1), fx-1.0, fy-1.0, fz-1.0),
+        u, v, w);
+    return mx_gradient_scale3d(result);
+}
+
+vec3 mx_perlin_noise_vec3(vec2 p)
+{
+    int X, Y;
+    float fx = mx_floorfrac(p.x, X);
+    float fy = mx_floorfrac(p.y, Y);
+    float u = mx_fade(fx);
+    float v = mx_fade(fy);
+    vec3 result = mx_bilerp(
+        mx_gradient_vec3(mx_hash_vec3(X  , Y  ), fx    , fy     ),
+        mx_gradient_vec3(mx_hash_vec3(X+1, Y  ), fx-1.0, fy     ),
+        mx_gradient_vec3(mx_hash_vec3(X  , Y+1), fx    , fy-1.0),
+        mx_gradient_vec3(mx_hash_vec3(X+1, Y+1), fx-1.0, fy-1.0),
+        u, v);
+    return mx_gradient_scale2d(result);
+}
+
+vec3 mx_perlin_noise_vec3(vec3 p)
+{
+    int X, Y, Z;
+    float fx = mx_floorfrac(p.x, X);
+    float fy = mx_floorfrac(p.y, Y);
+    float fz = mx_floorfrac(p.z, Z);
+    float u = mx_fade(fx);
+    float v = mx_fade(fy);
+    float w = mx_fade(fz);
+    vec3 result = mx_trilerp(
+        mx_gradient_vec3(mx_hash_vec3(X  , Y  , Z  ), fx    , fy    , fz     ),
+        mx_gradient_vec3(mx_hash_vec3(X+1, Y  , Z  ), fx-1.0, fy    , fz     ),
+        mx_gradient_vec3(mx_hash_vec3(X  , Y+1, Z  ), fx    , fy-1.0, fz     ),
+        mx_gradient_vec3(mx_hash_vec3(X+1, Y+1, Z  ), fx-1.0, fy-1.0, fz     ),
+        mx_gradient_vec3(mx_hash_vec3(X  , Y  , Z+1), fx    , fy    , fz-1.0),
+        mx_gradient_vec3(mx_hash_vec3(X+1, Y  , Z+1), fx-1.0, fy    , fz-1.0),
+        mx_gradient_vec3(mx_hash_vec3(X  , Y+1, Z+1), fx    , fy-1.0, fz-1.0),
+        mx_gradient_vec3(mx_hash_vec3(X+1, Y+1, Z+1), fx-1.0, fy-1.0, fz-1.0),
+        u, v, w);
+    return mx_gradient_scale3d(result);
+}
+
+float mx_cell_noise_float(float p)
+{
+    int ix = mx_floor(p);
+    return mx_bits_to_01(mx_hash_int(ix));
+}
+
+float mx_cell_noise_float(vec2 p)
+{
+    int ix = mx_floor(p.x);
+    int iy = mx_floor(p.y);
+    return mx_bits_to_01(mx_hash_int(ix, iy));
+}
+
+float mx_cell_noise_float(vec3 p)
+{
+    int ix = mx_floor(p.x);
+    int iy = mx_floor(p.y);
+    int iz = mx_floor(p.z);
+    return mx_bits_to_01(mx_hash_int(ix, iy, iz));
+}
+
+float mx_cell_noise_float(vec4 p)
+{
+    int ix = mx_floor(p.x);
+    int iy = mx_floor(p.y);
+    int iz = mx_floor(p.z);
+    int iw = mx_floor(p.w);
+    return mx_bits_to_01(mx_hash_int(ix, iy, iz, iw));
+}
+
+vec3 mx_cell_noise_vec3(float p)
+{
+    int ix = mx_floor(p);
+    return vec3(
+            mx_bits_to_01(mx_hash_int(ix, 0)),
+            mx_bits_to_01(mx_hash_int(ix, 1)),
+            mx_bits_to_01(mx_hash_int(ix, 2))
+    );
+}
+
+vec3 mx_cell_noise_vec3(vec2 p)
+{
+    int ix = mx_floor(p.x);
+    int iy = mx_floor(p.y);
+    return vec3(
+            mx_bits_to_01(mx_hash_int(ix, iy, 0)),
+            mx_bits_to_01(mx_hash_int(ix, iy, 1)),
+            mx_bits_to_01(mx_hash_int(ix, iy, 2))
+    );
+}
+
+vec3 mx_cell_noise_vec3(vec3 p)
+{
+    int ix = mx_floor(p.x);
+    int iy = mx_floor(p.y);
+    int iz = mx_floor(p.z);
+    return vec3(
+            mx_bits_to_01(mx_hash_int(ix, iy, iz, 0)),
+            mx_bits_to_01(mx_hash_int(ix, iy, iz, 1)),
+            mx_bits_to_01(mx_hash_int(ix, iy, iz, 2))
+    );
+}
+
+vec3 mx_cell_noise_vec3(vec4 p)
+{
+    int ix = mx_floor(p.x);
+    int iy = mx_floor(p.y);
+    int iz = mx_floor(p.z);
+    int iw = mx_floor(p.w);
+    return vec3(
+            mx_bits_to_01(mx_hash_int(ix, iy, iz, iw, 0)),
+            mx_bits_to_01(mx_hash_int(ix, iy, iz, iw, 1)),
+            mx_bits_to_01(mx_hash_int(ix, iy, iz, iw, 2))
+    );
+}
+
+float mx_fractal_noise_float(vec3 p, int octaves, float lacunarity, float diminish)
+{
+    float result = 0.0;
+    float amplitude = 1.0;
+    for (int i = 0;  i < octaves; ++i)
+    {
+        result += amplitude * mx_perlin_noise_float(p);
+        amplitude *= diminish;
+        p *= lacunarity;
+    }
+    return result;
+}
+
+vec3 mx_fractal_noise_vec3(vec3 p, int octaves, float lacunarity, float diminish)
+{
+    vec3 result = vec3(0.0);
+    float amplitude = 1.0;
+    for (int i = 0;  i < octaves; ++i)
+    {
+        result += amplitude * mx_perlin_noise_vec3(p);
+        amplitude *= diminish;
+        p *= lacunarity;
+    }
+    return result;
+}
+
+vec2 mx_fractal_noise_vec2(vec3 p, int octaves, float lacunarity, float diminish)
+{
+    return vec2(mx_fractal_noise_float(p, octaves, lacunarity, diminish),
+                mx_fractal_noise_float(p+vec3(19, 193, 17), octaves, lacunarity, diminish));
+}
+
+vec4 mx_fractal_noise_vec4(vec3 p, int octaves, float lacunarity, float diminish)
+{
+    vec3  c = mx_fractal_noise_vec3(p, octaves, lacunarity, diminish);
+    float f = mx_fractal_noise_float(p+vec3(19, 193, 17), octaves, lacunarity, diminish);
+    return vec4(c, f);
+}
+
+float mx_worley_distance(vec2 p, int x, int y, int xoff, int yoff, float jitter, int metric)
+{
+    vec3  tmp = mx_cell_noise_vec3(vec2(x+xoff, y+yoff));
+    vec2  off = vec2(tmp.x, tmp.y);
+
+    off -= 0.5f;
+    off *= jitter;
+    off += 0.5f;
+
+    vec2 cellpos = vec2(float(x), float(y)) + off;
+    vec2 diff = cellpos - p;
+    if (metric == 2)
+        return abs(diff.x) + abs(diff.y);       // Manhattan distance
+    if (metric == 3)
+        return max(abs(diff.x), abs(diff.y));   // Chebyshev distance
+    // Either Euclidian or Distance^2
+    return dot(diff, diff);
+}
+
+float mx_worley_distance(vec3 p, int x, int y, int z, int xoff, int yoff, int zoff, float jitter, int metric)
+{
+    vec3  off = mx_cell_noise_vec3(vec3(x+xoff, y+yoff, z+zoff));
+
+    off -= 0.5f;
+    off *= jitter;
+    off += 0.5f;
+
+    vec3 cellpos = vec3(float(x), float(y), float(z)) + off;
+    vec3 diff = cellpos - p;
+    if (metric == 2)
+        return abs(diff.x) + abs(diff.y) + abs(diff.z); // Manhattan distance
+    if (metric == 3)
+        return max(max(abs(diff.x), abs(diff.y)), abs(diff.z)); // Chebyshev distance
+    // Either Euclidian or Distance^2
+    return dot(diff, diff);
+}
+
+float mx_worley_noise_float(vec2 p, float jitter, int metric)
+{
+    int X, Y;
+    vec2 localpos = vec2(mx_floorfrac(p.x, X), mx_floorfrac(p.y, Y));
+    float sqdist = 1e6f;        // Some big number for jitter > 1 (not all GPUs may be IEEE)
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            float dist = mx_worley_distance(localpos, x, y, X, Y, jitter, metric);
+            sqdist = min(sqdist, dist);
+        }
+    }
+    if (metric == 0)
+        sqdist = sqrt(sqdist);
+    return sqdist;
+}
+
+vec2 mx_worley_noise_vec2(vec2 p, float jitter, int metric)
+{
+    int X, Y;
+    vec2 localpos = vec2(mx_floorfrac(p.x, X), mx_floorfrac(p.y, Y));
+    vec2 sqdist = vec2(1e6f, 1e6f);
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            float dist = mx_worley_distance(localpos, x, y, X, Y, jitter, metric);
+            if (dist < sqdist.x)
+            {
+                sqdist.y = sqdist.x;
+                sqdist.x = dist;
+            }
+            else if (dist < sqdist.y)
+            {
+                sqdist.y = dist;
+            }
+        }
+    }
+    if (metric == 0)
+        sqdist = sqrt(sqdist);
+    return sqdist;
+}
+
+vec3 mx_worley_noise_vec3(vec2 p, float jitter, int metric)
+{
+    int X, Y;
+    vec2 localpos = vec2(mx_floorfrac(p.x, X), mx_floorfrac(p.y, Y));
+    vec3 sqdist = vec3(1e6f, 1e6f, 1e6f);
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            float dist = mx_worley_distance(localpos, x, y, X, Y, jitter, metric);
+            if (dist < sqdist.x)
+            {
+                sqdist.z = sqdist.y;
+                sqdist.y = sqdist.x;
+                sqdist.x = dist;
+            }
+            else if (dist < sqdist.y)
+            {
+                sqdist.z = sqdist.y;
+                sqdist.y = dist;
+            }
+            else if (dist < sqdist.z)
+            {
+                sqdist.z = dist;
+            }
+        }
+    }
+    if (metric == 0)
+        sqdist = sqrt(sqdist);
+    return sqdist;
+}
+
+float mx_worley_noise_float(vec3 p, float jitter, int metric)
+{
+    int X, Y, Z;
+    vec3 localpos = vec3(mx_floorfrac(p.x, X), mx_floorfrac(p.y, Y), mx_floorfrac(p.z, Z));
+    float sqdist = 1e6f;
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            for (int z = -1; z <= 1; ++z)
+            {
+                float dist = mx_worley_distance(localpos, x, y, z, X, Y, Z, jitter, metric);
+                sqdist = min(sqdist, dist);
+            }
+        }
+    }
+    if (metric == 0)
+        sqdist = sqrt(sqdist);
+    return sqdist;
+}
+
+vec2 mx_worley_noise_vec2(vec3 p, float jitter, int metric)
+{
+    int X, Y, Z;
+    vec3 localpos = vec3(mx_floorfrac(p.x, X), mx_floorfrac(p.y, Y), mx_floorfrac(p.z, Z));
+    vec2 sqdist = vec2(1e6f, 1e6f);
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            for (int z = -1; z <= 1; ++z)
+            {
+                float dist = mx_worley_distance(localpos, x, y, z, X, Y, Z, jitter, metric);
+                if (dist < sqdist.x)
+                {
+                    sqdist.y = sqdist.x;
+                    sqdist.x = dist;
+                }
+                else if (dist < sqdist.y)
+                {
+                    sqdist.y = dist;
+                }
+            }
+        }
+    }
+    if (metric == 0)
+        sqdist = sqrt(sqdist);
+    return sqdist;
+}
+
+vec3 mx_worley_noise_vec3(vec3 p, float jitter, int metric)
+{
+    int X, Y, Z;
+    vec3 localpos = vec3(mx_floorfrac(p.x, X), mx_floorfrac(p.y, Y), mx_floorfrac(p.z, Z));
+    vec3 sqdist = vec3(1e6f, 1e6f, 1e6f);
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            for (int z = -1; z <= 1; ++z)
+            {
+                float dist = mx_worley_distance(localpos, x, y, z, X, Y, Z, jitter, metric);
+                if (dist < sqdist.x)
+                {
+                    sqdist.z = sqdist.y;
+                    sqdist.y = sqdist.x;
+                    sqdist.x = dist;
+                }
+                else if (dist < sqdist.y)
+                {
+                    sqdist.z = sqdist.y;
+                    sqdist.y = dist;
+                }
+                else if (dist < sqdist.z)
+                {
+                    sqdist.z = dist;
+                }
+            }
+        }
+    }
+    if (metric == 0)
+        sqdist = sqrt(sqdist);
+    return sqdist;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/lib/mx_sampling.glsl

@@ -0,0 +1,91 @@
+// Restrict to 7x7 kernel size for performance reasons
+#define MX_MAX_SAMPLE_COUNT 49
+// Size of all weights for all levels (including level 1)
+#define MX_WEIGHT_ARRAY_SIZE 84
+
+//
+// Function to compute the sample size relative to a texture coordinate
+//
+vec2 mx_compute_sample_size_uv(vec2 uv, float filterSize, float filterOffset)
+{
+   vec2 derivUVx = dFdx(uv) * 0.5f;
+   vec2 derivUVy = dFdy(uv) * 0.5f;
+   float derivX = abs(derivUVx.x) + abs(derivUVy.x);
+   float derivY = abs(derivUVx.y) + abs(derivUVy.y);
+   float sampleSizeU = 2.0f * filterSize * derivX + filterOffset;
+   if (sampleSizeU < 1.0E-05f)
+       sampleSizeU = 1.0E-05f;
+   float sampleSizeV = 2.0f * filterSize * derivY + filterOffset;
+   if (sampleSizeV < 1.0E-05f)
+       sampleSizeV = 1.0E-05f;
+   return vec2(sampleSizeU, sampleSizeV);
+}
+
+//
+// Compute a normal mapped to 0..1 space based on a set of input
+// samples using a Sobel filter.
+//
+vec3 mx_normal_from_samples_sobel(float S[9], float _scale)
+{
+    float nx = S[0] - S[2] + (2.0*S[3]) - (2.0*S[5]) + S[6] - S[8];
+    float ny = S[0] + (2.0*S[1]) + S[2] - S[6] - (2.0*S[7]) - S[8];
+    float nz = max(_scale, M_FLOAT_EPS) * sqrt(max(1.0 - nx * nx - ny * ny, M_FLOAT_EPS));
+    vec3 norm = normalize(vec3(nx, ny, nz));
+    return (norm + 1.0) * 0.5;
+}
+
+//
+// Apply filter for float samples S, using weights W.
+// sampleCount should be a square of a odd number in the range { 1, 3, 5, 7 }
+//
+float mx_convolution_float(float S[MX_MAX_SAMPLE_COUNT], float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    float result = 0.0;
+    for (int i = 0;  i < sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}
+
+//
+// Apply filter for vec2 samples S, using weights W.
+// sampleCount should be a square of a odd number in the range { 1, 3, 5, 7 }
+//
+vec2 mx_convolution_vec2(vec2 S[MX_MAX_SAMPLE_COUNT], float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    vec2 result = vec2(0.0);
+    for (int i=0;  i<sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}
+
+//
+// Apply filter for vec3 samples S, using weights W.
+// sampleCount should be a square of a odd number in the range { 1, 3, 5, 7 }
+//
+vec3 mx_convolution_vec3(vec3 S[MX_MAX_SAMPLE_COUNT], float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    vec3 result = vec3(0.0);
+    for (int i=0;  i<sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}
+
+//
+// Apply filter for vec4 samples S, using weights W.
+// sampleCount should be a square of a odd number { 1, 3, 5, 7 }
+//
+vec4 mx_convolution_vec4(vec4 S[MX_MAX_SAMPLE_COUNT], float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    vec4 result = vec4(0.0);
+    for (int i=0;  i<sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/lib/mx_transform_uv.glsl

@@ -0,0 +1,5 @@
+vec2 mx_transform_uv(vec2 uv, vec2 uv_scale, vec2 uv_offset)
+{
+    uv = uv * uv_scale + uv_offset;
+    return uv;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/lib/mx_transform_uv_vflip.glsl

@@ -0,0 +1,5 @@
+vec2 mx_transform_uv(vec2 uv, vec2 uv_scale, vec2 uv_offset)
+{
+    uv = uv * uv_scale + uv_offset;
+    return vec2(uv.x, 1.0 - uv.y);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_aastep.glsl

@@ -0,0 +1,5 @@
+float mx_aastep(float threshold, float value)
+{
+    float afwidth = length(vec2(dFdx(value), dFdy(value))) * 0.70710678118654757;
+    return smoothstep(threshold-afwidth, threshold+afwidth, value);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_burn_color3.glsl

@@ -0,0 +1,8 @@
+#include "mx_burn_float.glsl"
+
+void mx_burn_color3(vec3 fg, vec3 bg, float mixval, out vec3 result)
+{
+    mx_burn_float(fg.x, bg.x, mixval, result.x);
+    mx_burn_float(fg.y, bg.y, mixval, result.y);
+    mx_burn_float(fg.z, bg.z, mixval, result.z);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_burn_color4.glsl

@@ -0,0 +1,9 @@
+#include "mx_burn_float.glsl"
+
+void mx_burn_color4(vec4 fg, vec4 bg, float mixval, out vec4 result)
+{
+    mx_burn_float(fg.x, bg.x, mixval, result.x);
+    mx_burn_float(fg.y, bg.y, mixval, result.y);
+    mx_burn_float(fg.z, bg.z, mixval, result.z);
+    mx_burn_float(fg.w, bg.w, mixval, result.w);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_burn_float.glsl

@@ -0,0 +1,9 @@
+void mx_burn_float(float fg, float bg, float mixval, out float result)
+{
+    if (abs(fg) < M_FLOAT_EPS)
+    {
+        result = 0.0;
+        return;
+    }
+    result = mixval*(1.0 - ((1.0 - bg) / fg)) + ((1.0-mixval)*bg);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_cellnoise2d_float.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_noise.glsl"
+
+void mx_cellnoise2d_float(vec2 texcoord, out float result)
+{
+    result = mx_cell_noise_float(texcoord);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_cellnoise3d_float.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_noise.glsl"
+
+void mx_cellnoise3d_float(vec3 position, out float result)
+{
+    result = mx_cell_noise_float(position);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_creatematrix_vector3_matrix33.glsl

@@ -0,0 +1,6 @@
+void mx_creatematrix_vector3_matrix33(vec3 in1, vec3 in2, vec3 in3, out mat3 result)
+{
+    result = mat3(in1.x, in1.y, in1.z,
+                  in2.x, in2.y, in2.z,
+                  in3.x, in3.y, in3.z);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_creatematrix_vector3_matrix44.glsl

@@ -0,0 +1,7 @@
+void mx_creatematrix_vector3_matrix44(vec3 in1, vec3 in2, vec3 in3, vec3 in4, out mat4 result)
+{
+    result = mat4(in1.x, in1.y, in1.z, 0.0,
+                  in2.x, in2.y, in2.z, 0.0,
+                  in3.x, in3.y, in3.z, 0.0,
+                  in4.x, in4.y, in4.z, 1.0);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_creatematrix_vector4_matrix44.glsl

@@ -0,0 +1,7 @@
+void mx_creatematrix_vector4_matrix44(vec4 in1, vec4 in2, vec4 in3, vec4 in4, out mat4 result)
+{
+    result = mat4(in1.x, in1.y, in1.z, in1.w,
+                  in2.x, in2.y, in2.z, in2.w,
+                  in3.x, in3.y, in3.z, in3.w,
+                  in4.x, in4.y, in4.z, in4.w);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_disjointover_color4.glsl

@@ -0,0 +1,25 @@
+void mx_disjointover_color4(vec4 fg, vec4 bg, float mixval, out vec4 result)
+{
+    float summedAlpha = fg.w + bg.w;
+
+    if (summedAlpha <= 1.0)
+    {
+        result.xyz = fg.xyz + bg.xyz;
+    }
+    else
+    {
+        if (abs(bg.w) < M_FLOAT_EPS)
+        {
+            result.xyz = vec3(0.0);
+        }
+        else
+        {
+            float x = (1.0 - fg.w) / bg.w;
+            result.xyz = fg.xyz + bg.xyz * x;
+        }
+    }
+    result.w = min(summedAlpha, 1.0);
+
+    result.xyz = result.xyz * mixval + (1.0 - mixval) * bg.xyz;
+    result.w = result.w * mixval + (1.0 - mixval) * bg.w;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_dodge_color3.glsl

@@ -0,0 +1,8 @@
+#include "mx_dodge_float.glsl"
+
+void mx_dodge_color3(vec3 fg, vec3 bg, float mixval, out vec3 result)
+{
+    mx_dodge_float(fg.x, bg.x, mixval, result.x);
+    mx_dodge_float(fg.y, bg.y, mixval, result.y);
+    mx_dodge_float(fg.z, bg.z, mixval, result.z);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_dodge_color4.glsl

@@ -0,0 +1,9 @@
+#include "mx_dodge_float.glsl"
+
+void mx_dodge_color4(vec4 fg , vec4 bg , float mixval, out vec4 result)
+{
+    mx_dodge_float(fg.x, bg.x, mixval, result.x);
+    mx_dodge_float(fg.y, bg.y, mixval, result.y);
+    mx_dodge_float(fg.z, bg.z, mixval, result.z);
+    mx_dodge_float(fg.w, bg.w, mixval, result.w);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_dodge_float.glsl

@@ -0,0 +1,9 @@
+void mx_dodge_float(float fg, float bg, float mixval, out float result)
+{
+    if (abs(1.0 - fg) < M_FLOAT_EPS)
+    {
+        result = 0.0;
+        return;
+    }
+    result = mixval*(bg / (1.0 - fg)) + ((1.0-mixval)*bg);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_fractal3d_float.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_noise.glsl"
+
+void mx_fractal3d_float(float amplitude, int octaves, float lacunarity, float diminish, vec3 position, out float result)
+{
+    float value = mx_fractal_noise_float(position, octaves, lacunarity, diminish);
+    result = value * amplitude;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_fractal3d_vector2.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_noise.glsl"
+
+void mx_fractal3d_vector2(vec2 amplitude, int octaves, float lacunarity, float diminish, vec3 position, out vec2 result)
+{
+    vec2 value = mx_fractal_noise_vec2(position, octaves, lacunarity, diminish);
+    result = value * amplitude;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_fractal3d_vector3.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_noise.glsl"
+
+void mx_fractal3d_vector3(vec3 amplitude, int octaves, float lacunarity, float diminish, vec3 position, out vec3 result)
+{
+    vec3 value = mx_fractal_noise_vec3(position, octaves, lacunarity, diminish);
+    result = value * amplitude;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_fractal3d_vector4.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_noise.glsl"
+
+void mx_fractal3d_vector4(vec4 amplitude, int octaves, float lacunarity, float diminish, vec3 position, out vec4 result)
+{
+    vec4 value = mx_fractal_noise_vec4(position, octaves, lacunarity, diminish);
+    result = value * amplitude;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_hsvtorgb_color3.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_hsv.glsl"
+
+void mx_hsvtorgb_color3(vec3 _in, out vec3 result)
+{
+    result = mx_hsvtorgb(_in);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_hsvtorgb_color4.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_hsv.glsl"
+
+void mx_hsvtorgb_color4(vec4 _in, out vec4 result)
+{
+    result = vec4(mx_hsvtorgb(_in.rgb), 1.0);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_image_color3.glsl

@@ -0,0 +1,7 @@
+#include "lib/$fileTransformUv"
+
+void mx_image_color3(sampler2D tex_sampler, int layer, vec3 defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out vec3 result)
+{
+    vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset);
+    result = texture(tex_sampler, uv).rgb;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_image_color4.glsl

@@ -0,0 +1,7 @@
+#include "lib/$fileTransformUv"
+
+void mx_image_color4(sampler2D tex_sampler, int layer, vec4 defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out vec4 result)
+{
+    vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset);
+    result = texture(tex_sampler, uv);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_image_float.glsl

@@ -0,0 +1,7 @@
+#include "lib/$fileTransformUv"
+
+void mx_image_float(sampler2D tex_sampler, int layer, float defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out float result)
+{
+    vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset);
+    result = texture(tex_sampler, uv).r;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_image_vector2.glsl

@@ -0,0 +1,7 @@
+#include "lib/$fileTransformUv"
+
+void mx_image_vector2(sampler2D tex_sampler, int layer, vec2 defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out vec2 result)
+{
+    vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset);
+    result = texture(tex_sampler, uv).rg;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_image_vector3.glsl

@@ -0,0 +1,7 @@
+#include "lib/$fileTransformUv"
+
+void mx_image_vector3(sampler2D tex_sampler, int layer, vec3 defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out vec3 result)
+{
+    vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset);
+    result = texture(tex_sampler, uv).rgb;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_image_vector4.glsl

@@ -0,0 +1,7 @@
+#include "lib/$fileTransformUv"
+
+void mx_image_vector4(sampler2D tex_sampler, int layer, vec4 defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out vec4 result)
+{
+    vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset);
+    result = texture(tex_sampler, uv);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_luminance_color3.glsl

@@ -0,0 +1,4 @@
+void mx_luminance_color3(vec3 _in, vec3 lumacoeffs, out vec3 result)
+{
+    result = vec3(dot(_in, lumacoeffs));
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_luminance_color4.glsl

@@ -0,0 +1,4 @@
+void mx_luminance_color4(vec4 _in, vec3 lumacoeffs, out vec4 result)
+{
+    result = vec4(vec3(dot(_in.rgb, lumacoeffs)), _in.a);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_mix_surfaceshader.glsl

@@ -0,0 +1,5 @@
+void mx_mix_surfaceshader(surfaceshader fg, surfaceshader bg, float w, out surfaceshader returnshader)
+{
+    returnshader.color = mix(bg.color, fg.color, w);
+    returnshader.transparency = mix(bg.transparency, fg.transparency, w);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_noise2d_float.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_noise.glsl"
+
+void mx_noise2d_float(float amplitude, float pivot, vec2 texcoord, out float result)
+{
+    float value = mx_perlin_noise_float(texcoord);
+    result = value * amplitude + pivot;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_noise2d_vector2.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_noise.glsl"
+
+void mx_noise2d_vector2(vec2 amplitude, float pivot, vec2 texcoord, out vec2 result)
+{
+    vec3 value = mx_perlin_noise_vec3(texcoord);
+    result = value.xy * amplitude + pivot;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_noise2d_vector3.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_noise.glsl"
+
+void mx_noise2d_vector3(vec3 amplitude, float pivot, vec2 texcoord, out vec3 result)
+{
+    vec3 value = mx_perlin_noise_vec3(texcoord);
+    result = value * amplitude + pivot;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_noise2d_vector4.glsl

@@ -0,0 +1,8 @@
+#include "lib/mx_noise.glsl"
+
+void mx_noise2d_vector4(vec4 amplitude, float pivot, vec2 texcoord, out vec4 result)
+{
+    vec3 xyz = mx_perlin_noise_vec3(texcoord);
+    float w = mx_perlin_noise_float(texcoord + vec2(19, 73));
+    result = vec4(xyz, w) * amplitude + pivot;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_noise3d_float.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_noise.glsl"
+
+void mx_noise3d_float(float amplitude, float pivot, vec3 position, out float result)
+{
+    float value = mx_perlin_noise_float(position);
+    result = value * amplitude + pivot;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_noise3d_vector2.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_noise.glsl"
+
+void mx_noise3d_vector2(vec2 amplitude, float pivot, vec3 position, out vec2 result)
+{
+    vec3 value = mx_perlin_noise_vec3(position);
+    result = value.xy * amplitude + pivot;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_noise3d_vector3.glsl

@@ -0,0 +1,7 @@
+#include "lib/mx_noise.glsl"
+
+void mx_noise3d_vector3(vec3 amplitude, float pivot, vec3 position, out vec3 result)
+{
+    vec3 value = mx_perlin_noise_vec3(position);
+    result = value * amplitude + pivot;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_noise3d_vector4.glsl

@@ -0,0 +1,8 @@
+#include "lib/mx_noise.glsl"
+
+void mx_noise3d_vector4(vec4 amplitude, float pivot, vec3 position, out vec4 result)
+{
+    vec3 xyz = mx_perlin_noise_vec3(position);
+    float w = mx_perlin_noise_float(position + vec3(19, 73, 29));
+    result = vec4(xyz, w) * amplitude + pivot;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_normalmap.glsl

@@ -0,0 +1,21 @@
+void mx_normalmap_vector2(vec3 value, int map_space, vec2 normal_scale, vec3 N, vec3 T,  out vec3 result)
+{
+    // Decode the normal map.
+    value = (value == vec3(0.0f)) ? vec3(0.0, 0.0, 1.0) : value * 2.0 - 1.0;
+
+    // Transform from tangent space if needed.
+    if (map_space == 0)
+    {
+        vec3 B = normalize(cross(N, T));
+        value.xy *= normal_scale;
+        value = T * value.x + B * value.y + N * value.z;
+    }
+
+    // Normalize the result.
+    result = normalize(value);
+}
+
+void mx_normalmap_float(vec3 value, int map_space, float normal_scale, vec3 N, vec3 T,  out vec3 result)
+{
+    mx_normalmap_vector2(value, map_space, vec2(normal_scale), N, T, result);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_premult_color4.glsl

@@ -0,0 +1,4 @@
+void mx_premult_color4(vec4 _in, out vec4 result)
+{
+    result = vec4(_in.rgb * _in.a, _in.a);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_ramplr_float.glsl

@@ -0,0 +1,4 @@
+void mx_ramplr_float(float valuel, float valuer, vec2 texcoord, out float result)
+{
+    result = mix (valuel, valuer, clamp(texcoord.x, 0.0, 1.0) );
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_ramplr_vector2.glsl

@@ -0,0 +1,4 @@
+void mx_ramplr_vector2(vec2 valuel, vec2 valuer, vec2 texcoord, out vec2 result)
+{
+    result = mix (valuel, valuer, clamp(texcoord.x, 0.0, 1.0) );
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_ramplr_vector3.glsl

@@ -0,0 +1,4 @@
+void mx_ramplr_vector3(vec3 valuel, vec3 valuer, vec2 texcoord, out vec3 result)
+{
+    result = mix (valuel, valuer, clamp(texcoord.x, 0.0, 1.0) );
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_ramplr_vector4.glsl

@@ -0,0 +1,4 @@
+void mx_ramplr_vector4(vec4 valuel, vec4 valuer, vec2 texcoord, out vec4 result)
+{
+    result = mix (valuel, valuer, clamp(texcoord.x, 0.0, 1.0) );
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_ramptb_float.glsl

@@ -0,0 +1,4 @@
+void mx_ramptb_float(float valuet, float valueb, vec2 texcoord, out float result)
+{
+    result = mix (valuet, valueb, clamp(texcoord.y, 0.0, 1.0) );
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_ramptb_vector2.glsl

@@ -0,0 +1,4 @@
+void mx_ramptb_vector2(vec2 valuet, vec2 valueb, vec2 texcoord, out vec2 result)
+{
+    result = mix (valuet, valueb, clamp(texcoord.y, 0.0, 1.0) );
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_ramptb_vector3.glsl

@@ -0,0 +1,4 @@
+void mx_ramptb_vector3(vec3 valuet, vec3 valueb, vec2 texcoord, out vec3 result)
+{
+    result = mix (valuet, valueb, clamp(texcoord.y, 0.0, 1.0) );
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_ramptb_vector4.glsl

@@ -0,0 +1,4 @@
+void mx_ramptb_vector4(vec4 valuet, vec4 valueb, vec2 texcoord, out vec4 result)
+{
+    result = mix (valuet, valueb, clamp(texcoord.y, 0.0, 1.0) );
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_rgbtohsv_color3.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_hsv.glsl"
+
+void mx_rgbtohsv_color3(vec3 _in, out vec3 result)
+{
+    result = mx_rgbtohsv(_in);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_rgbtohsv_color4.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_hsv.glsl"
+
+void mx_rgbtohsv_color4(vec4 _in, out vec4 result)
+{
+    result = vec4(mx_rgbtohsv(_in.rgb), 1.0);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_rotate_vector2.glsl

@@ -0,0 +1,7 @@
+void mx_rotate_vector2(vec2 _in, float amount, out vec2 result)
+{
+    float rotationRadians = radians(amount);
+    float sa = sin(rotationRadians);
+    float ca = cos(rotationRadians);
+    result = vec2(ca*_in.x + sa*_in.y, -sa*_in.x + ca*_in.y);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_rotate_vector3.glsl

@@ -0,0 +1,19 @@
+mat4 mx_rotationMatrix(vec3 axis, float angle)
+{
+    axis = normalize(axis);
+    float s = sin(angle);
+    float c = cos(angle);
+    float oc = 1.0 - c;
+
+    return mat4(oc * axis.x * axis.x + c,           oc * axis.x * axis.y - axis.z * s,  oc * axis.z * axis.x + axis.y * s,  0.0,
+                oc * axis.x * axis.y + axis.z * s,  oc * axis.y * axis.y + c,           oc * axis.y * axis.z - axis.x * s,  0.0,
+                oc * axis.z * axis.x - axis.y * s,  oc * axis.y * axis.z + axis.x * s,  oc * axis.z * axis.z + c,           0.0,
+                0.0,                                0.0,                                0.0,                                1.0);
+}
+
+void mx_rotate_vector3(vec3 _in, float amount, vec3 axis, out vec3 result)
+{
+    float rotationRadians = radians(amount);
+    mat4 m = mx_rotationMatrix(axis, rotationRadians);
+    result = (m * vec4(_in, 1.0)).xyz;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_smoothstep_float.glsl

@@ -0,0 +1,9 @@
+void mx_smoothstep_float(float val, float low, float high, out float result)
+{
+    if (val <= low)
+        result = 0.0;
+    else if (val >= high)
+        result = 1.0;
+    else
+        result = smoothstep(low, high, val);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_smoothstep_vector2.glsl

@@ -0,0 +1,7 @@
+#include "mx_smoothstep_float.glsl"
+
+void mx_smoothstep_vector2(vec2 val, vec2 low, vec2 high, out vec2 result)
+{
+    mx_smoothstep_float(val.x, low.x, high.x, result.x);
+    mx_smoothstep_float(val.y, low.y, high.y, result.y);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_smoothstep_vector3.glsl

@@ -0,0 +1,8 @@
+#include "mx_smoothstep_float.glsl"
+
+void mx_smoothstep_vector3(vec3 val, vec3 low, vec3 high, out vec3 result)
+{
+    mx_smoothstep_float(val.x, low.x, high.x, result.x);
+    mx_smoothstep_float(val.y, low.y, high.y, result.y);
+    mx_smoothstep_float(val.z, low.z, high.z, result.z);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_smoothstep_vector4.glsl

@@ -0,0 +1,9 @@
+#include "mx_smoothstep_float.glsl"
+
+void mx_smoothstep_vector4(vec4 val, vec4 low, vec4 high, out vec4 result)
+{
+    mx_smoothstep_float(val.x, low.x, high.x, result.x);
+    mx_smoothstep_float(val.y, low.y, high.y, result.y);
+    mx_smoothstep_float(val.z, low.z, high.z, result.z);
+    mx_smoothstep_float(val.w, low.w, high.w, result.w);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_splitlr_float.glsl

@@ -0,0 +1,6 @@
+#include "mx_aastep.glsl"
+
+void mx_splitlr_float(float valuel, float valuer, float center, vec2 texcoord, out float result)
+{
+    result = mix(valuel, valuer, mx_aastep(center, texcoord.x));
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_splitlr_vector2.glsl

@@ -0,0 +1,6 @@
+#include "mx_aastep.glsl"
+
+void mx_splitlr_vector2(vec2 valuel, vec2 valuer, float center, vec2 texcoord, out vec2 result)
+{
+    result = mix(valuel, valuer, mx_aastep(center, texcoord.x));
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_splitlr_vector3.glsl

@@ -0,0 +1,6 @@
+#include "mx_aastep.glsl"
+
+void mx_splitlr_vector3(vec3 valuel, vec3 valuer, float center, vec2 texcoord, out vec3 result)
+{
+    result = mix(valuel, valuer, mx_aastep(center, texcoord.x));
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_splitlr_vector4.glsl

@@ -0,0 +1,6 @@
+#include "mx_aastep.glsl"
+
+void mx_splitlr_vector4(vec4 valuel, vec4 valuer, float center, vec2 texcoord, out vec4 result)
+{
+    result = mix(valuel, valuer, mx_aastep(center, texcoord.x));
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_splittb_float.glsl

@@ -0,0 +1,6 @@
+#include "mx_aastep.glsl"
+
+void mx_splittb_float(float valuet, float valueb, float center, vec2 texcoord, out float result)
+{
+    result = mix(valuet, valueb, mx_aastep(center, texcoord.y));
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_splittb_vector2.glsl

@@ -0,0 +1,6 @@
+#include "mx_aastep.glsl"
+
+void mx_splittb_vector2(vec2 valuet, vec2 valueb, float center, vec2 texcoord, out vec2 result)
+{
+    result = mix(valuet, valueb, mx_aastep(center, texcoord.y));
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_splittb_vector3.glsl

@@ -0,0 +1,6 @@
+#include "mx_aastep.glsl"
+
+void mx_splittb_vector3(vec3 valuet, vec3 valueb, float center, vec2 texcoord, out vec3 result)
+{
+    result = mix(valuet, valueb, mx_aastep(center, texcoord.y));
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_splittb_vector4.glsl

@@ -0,0 +1,6 @@
+#include "mx_aastep.glsl"
+
+void mx_splittb_vector4(vec4 valuet, vec4 valueb, float center, vec2 texcoord, out vec4 result)
+{
+    result = mix(valuet, valueb, mx_aastep(center, texcoord.y));
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_transformmatrix_vector2M3.glsl

@@ -0,0 +1,5 @@
+void mx_transformmatrix_vector2M3(vec2 val, mat3 transform, out vec2 result)
+{
+  vec3 res = transform * vec3(val, 1.0);
+  result = res.xy;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_transformmatrix_vector3M4.glsl

@@ -0,0 +1,5 @@
+void mx_transformmatrix_vector3M4(vec3 val, mat4 transform, out vec3 result)
+{
+  vec4 res = transform * vec4(val, 1.0);
+  result = res.xyz;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_unpremult_color4.glsl

@@ -0,0 +1,4 @@
+void mx_unpremult_color4(vec4 _in, out vec4 result)
+{
+    result = vec4(_in.rgb / _in.a, _in.a);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_worleynoise2d_float.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_noise.glsl"
+
+void mx_worleynoise2d_float(vec2 texcoord, float jitter, out float result)
+{
+    result = mx_worley_noise_float(texcoord, jitter, 0);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_worleynoise2d_vector2.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_noise.glsl"
+
+void mx_worleynoise2d_vector2(vec2 texcoord, float jitter, out vec2 result)
+{
+    result = mx_worley_noise_vec2(texcoord, jitter, 0);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_worleynoise2d_vector3.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_noise.glsl"
+
+void mx_worleynoise2d_vector3(vec2 texcoord, float jitter, out vec3 result)
+{
+    result = mx_worley_noise_vec3(texcoord, jitter, 0);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_worleynoise3d_float.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_noise.glsl"
+
+void mx_worleynoise3d_float(vec3 position, float jitter, out float result)
+{
+    result = mx_worley_noise_float(position, jitter, 0);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_worleynoise3d_vector2.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_noise.glsl"
+
+void mx_worleynoise3d_vector2(vec3 position, float jitter, out vec2 result)
+{
+    result = mx_worley_noise_vec2(position, jitter, 0);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/mx_worleynoise3d_vector3.glsl

@@ -0,0 +1,6 @@
+#include "lib/mx_noise.glsl"
+
+void mx_worleynoise3d_vector3(vec3 position, float jitter, out vec3 result)
+{
+    result = mx_worley_noise_vec3(position, jitter, 0);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genglsl/stdlib_genglsl_impl.mtlx

@@ -0,0 +1,775 @@
+<?xml version="1.0"?>
+<materialx version="1.38">
+  <!--
+    Copyright Contributors to the MaterialX Project
+    SPDX-License-Identifier: Apache-2.0
+
+    Declarations for glsl implementations of standard nodes included in the MaterialX specification.
+  -->
+
+  <!-- ======================================================================== -->
+  <!-- Shader nodes                                                             -->
+  <!-- ======================================================================== -->
+
+  <!-- <surfacematerial> -->
+  <implementation name="IM_surfacematerial_genglsl" nodedef="ND_surfacematerial" target="genglsl" />
+
+  <!-- <surface_unlit> -->
+  <implementation name="IM_surface_unlit_genglsl" nodedef="ND_surface_unlit" target="genglsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Texture nodes                                                            -->
+  <!-- ======================================================================== -->
+
+  <!-- <image> -->
+  <implementation name="IM_image_float_genglsl" nodedef="ND_image_float" file="mx_image_float.glsl" function="mx_image_float" target="genglsl">
+    <input name="default" type="float" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_color3_genglsl" nodedef="ND_image_color3" file="mx_image_color3.glsl" function="mx_image_color3" target="genglsl">
+    <input name="default" type="color3" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_color4_genglsl" nodedef="ND_image_color4" file="mx_image_color4.glsl" function="mx_image_color4" target="genglsl">
+    <input name="default" type="color4" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_vector2_genglsl" nodedef="ND_image_vector2" file="mx_image_vector2.glsl" function="mx_image_vector2" target="genglsl">
+    <input name="default" type="vector2" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_vector3_genglsl" nodedef="ND_image_vector3" file="mx_image_vector3.glsl" function="mx_image_vector3" target="genglsl">
+    <input name="default" type="vector3" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_vector4_genglsl" nodedef="ND_image_vector4" file="mx_image_vector4.glsl" function="mx_image_vector4" target="genglsl">
+    <input name="default" type="vector4" implname="default_value" />
+  </implementation>
+
+  <!-- <normalmap> -->
+  <implementation name="IM_normalmap_float_genglsl" nodedef="ND_normalmap" file="mx_normalmap.glsl" function="mx_normalmap_float" target="genglsl" />
+  <implementation name="IM_normalmap_vector2_genglsl" nodedef="ND_normalmap_vector2" file="mx_normalmap.glsl" function="mx_normalmap_vector2" target="genglsl" />
+
+
+  <!-- ======================================================================== -->
+  <!-- Procedural nodes                                                         -->
+  <!-- ======================================================================== -->
+
+  <!-- <constant> -->
+  <implementation name="IM_constant_float_genglsl" nodedef="ND_constant_float" target="genglsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_color3_genglsl" nodedef="ND_constant_color3" target="genglsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_color4_genglsl" nodedef="ND_constant_color4" target="genglsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_vector2_genglsl" nodedef="ND_constant_vector2" target="genglsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_vector3_genglsl" nodedef="ND_constant_vector3" target="genglsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_vector4_genglsl" nodedef="ND_constant_vector4" target="genglsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_boolean_genglsl" nodedef="ND_constant_boolean" target="genglsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_integer_genglsl" nodedef="ND_constant_integer" target="genglsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_matrix33_genglsl" nodedef="ND_constant_matrix33" target="genglsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_matrix44_genglsl" nodedef="ND_constant_matrix44" target="genglsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_string_genglsl" nodedef="ND_constant_string" target="genglsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_filename_genglsl" nodedef="ND_constant_filename" target="genglsl" sourcecode="{{value}}" />
+
+  <!-- <ramplr> -->
+  <implementation name="IM_ramplr_float_genglsl" nodedef="ND_ramplr_float" file="mx_ramplr_float.glsl" function="mx_ramplr_float" target="genglsl" />
+  <implementation name="IM_ramplr_color3_genglsl" nodedef="ND_ramplr_color3" file="mx_ramplr_vector3.glsl" function="mx_ramplr_vector3" target="genglsl" />
+  <implementation name="IM_ramplr_color4_genglsl" nodedef="ND_ramplr_color4" file="mx_ramplr_vector4.glsl" function="mx_ramplr_vector4" target="genglsl" />
+  <implementation name="IM_ramplr_vector2_genglsl" nodedef="ND_ramplr_vector2" file="mx_ramplr_vector2.glsl" function="mx_ramplr_vector2" target="genglsl" />
+  <implementation name="IM_ramplr_vector3_genglsl" nodedef="ND_ramplr_vector3" file="mx_ramplr_vector3.glsl" function="mx_ramplr_vector3" target="genglsl" />
+  <implementation name="IM_ramplr_vector4_genglsl" nodedef="ND_ramplr_vector4" file="mx_ramplr_vector4.glsl" function="mx_ramplr_vector4" target="genglsl" />
+
+  <!-- <ramptb> -->
+  <implementation name="IM_ramptb_float_genglsl" nodedef="ND_ramptb_float" file="mx_ramptb_float.glsl" function="mx_ramptb_float" target="genglsl" />
+  <implementation name="IM_ramptb_color3_genglsl" nodedef="ND_ramptb_color3" file="mx_ramptb_vector3.glsl" function="mx_ramptb_vector3" target="genglsl" />
+  <implementation name="IM_ramptb_color4_genglsl" nodedef="ND_ramptb_color4" file="mx_ramptb_vector4.glsl" function="mx_ramptb_vector4" target="genglsl" />
+  <implementation name="IM_ramptb_vector2_genglsl" nodedef="ND_ramptb_vector2" file="mx_ramptb_vector2.glsl" function="mx_ramptb_vector2" target="genglsl" />
+  <implementation name="IM_ramptb_vector3_genglsl" nodedef="ND_ramptb_vector3" file="mx_ramptb_vector3.glsl" function="mx_ramptb_vector3" target="genglsl" />
+  <implementation name="IM_ramptb_vector4_genglsl" nodedef="ND_ramptb_vector4" file="mx_ramptb_vector4.glsl" function="mx_ramptb_vector4" target="genglsl" />
+
+  <!-- <splitlr> -->
+  <implementation name="IM_splitlr_float_genglsl" nodedef="ND_splitlr_float" file="mx_splitlr_float.glsl" function="mx_splitlr_float" target="genglsl" />
+  <implementation name="IM_splitlr_color3_genglsl" nodedef="ND_splitlr_color3" file="mx_splitlr_vector3.glsl" function="mx_splitlr_vector3" target="genglsl" />
+  <implementation name="IM_splitlr_color4_genglsl" nodedef="ND_splitlr_color4" file="mx_splitlr_vector4.glsl" function="mx_splitlr_vector4" target="genglsl" />
+  <implementation name="IM_splitlr_vector2_genglsl" nodedef="ND_splitlr_vector2" file="mx_splitlr_vector2.glsl" function="mx_splitlr_vector2" target="genglsl" />
+  <implementation name="IM_splitlr_vector3_genglsl" nodedef="ND_splitlr_vector3" file="mx_splitlr_vector3.glsl" function="mx_splitlr_vector3" target="genglsl" />
+  <implementation name="IM_splitlr_vector4_genglsl" nodedef="ND_splitlr_vector4" file="mx_splitlr_vector4.glsl" function="mx_splitlr_vector4" target="genglsl" />
+
+  <!-- <splittb> -->
+  <implementation name="IM_splittb_float_genglsl" nodedef="ND_splittb_float" file="mx_splittb_float.glsl" function="mx_splittb_float" target="genglsl" />
+  <implementation name="IM_splittb_color3_genglsl" nodedef="ND_splittb_color3" file="mx_splittb_vector3.glsl" function="mx_splittb_vector3" target="genglsl" />
+  <implementation name="IM_splittb_color4_genglsl" nodedef="ND_splittb_color4" file="mx_splittb_vector4.glsl" function="mx_splittb_vector4" target="genglsl" />
+  <implementation name="IM_splittb_vector2_genglsl" nodedef="ND_splittb_vector2" file="mx_splittb_vector2.glsl" function="mx_splittb_vector2" target="genglsl" />
+  <implementation name="IM_splittb_vector3_genglsl" nodedef="ND_splittb_vector3" file="mx_splittb_vector3.glsl" function="mx_splittb_vector3" target="genglsl" />
+  <implementation name="IM_splittb_vector4_genglsl" nodedef="ND_splittb_vector4" file="mx_splittb_vector4.glsl" function="mx_splittb_vector4" target="genglsl" />
+
+  <!-- <noise2d> -->
+  <implementation name="IM_noise2d_float_genglsl" nodedef="ND_noise2d_float" file="mx_noise2d_float.glsl" function="mx_noise2d_float" target="genglsl" />
+  <implementation name="IM_noise2d_vector2_genglsl" nodedef="ND_noise2d_vector2" file="mx_noise2d_vector2.glsl" function="mx_noise2d_vector2" target="genglsl" />
+  <implementation name="IM_noise2d_vector3_genglsl" nodedef="ND_noise2d_vector3" file="mx_noise2d_vector3.glsl" function="mx_noise2d_vector3" target="genglsl" />
+  <implementation name="IM_noise2d_vector4_genglsl" nodedef="ND_noise2d_vector4" file="mx_noise2d_vector4.glsl" function="mx_noise2d_vector4" target="genglsl" />
+
+  <!-- <noise3d> -->
+  <implementation name="IM_noise3d_float_genglsl" nodedef="ND_noise3d_float" file="mx_noise3d_float.glsl" function="mx_noise3d_float" target="genglsl" />
+  <implementation name="IM_noise3d_vector2_genglsl" nodedef="ND_noise3d_vector2" file="mx_noise3d_vector2.glsl" function="mx_noise3d_vector2" target="genglsl" />
+  <implementation name="IM_noise3d_vector3_genglsl" nodedef="ND_noise3d_vector3" file="mx_noise3d_vector3.glsl" function="mx_noise3d_vector3" target="genglsl" />
+  <implementation name="IM_noise3d_vector4_genglsl" nodedef="ND_noise3d_vector4" file="mx_noise3d_vector4.glsl" function="mx_noise3d_vector4" target="genglsl" />
+
+  <!-- <fractal3d> -->
+  <implementation name="IM_fractal3d_float_genglsl" nodedef="ND_fractal3d_float" file="mx_fractal3d_float.glsl" function="mx_fractal3d_float" target="genglsl" />
+  <implementation name="IM_fractal3d_vector2_genglsl" nodedef="ND_fractal3d_vector2" file="mx_fractal3d_vector2.glsl" function="mx_fractal3d_vector2" target="genglsl" />
+  <implementation name="IM_fractal3d_vector3_genglsl" nodedef="ND_fractal3d_vector3" file="mx_fractal3d_vector3.glsl" function="mx_fractal3d_vector3" target="genglsl" />
+  <implementation name="IM_fractal3d_vector4_genglsl" nodedef="ND_fractal3d_vector4" file="mx_fractal3d_vector4.glsl" function="mx_fractal3d_vector4" target="genglsl" />
+
+  <!-- <cellnoise2d> -->
+  <implementation name="IM_cellnoise2d_float_genglsl" nodedef="ND_cellnoise2d_float" file="mx_cellnoise2d_float.glsl" function="mx_cellnoise2d_float" target="genglsl" />
+
+  <!-- <cellnoise3d> -->
+  <implementation name="IM_cellnoise3d_float_genglsl" nodedef="ND_cellnoise3d_float" file="mx_cellnoise3d_float.glsl" function="mx_cellnoise3d_float" target="genglsl" />
+
+  <!-- <worleynoise2d> -->
+  <implementation name="IM_worleynoise2d_float_genglsl" nodedef="ND_worleynoise2d_float" file="mx_worleynoise2d_float.glsl" function="mx_worleynoise2d_float" target="genglsl" />
+  <implementation name="IM_worleynoise2d_vector2_genglsl" nodedef="ND_worleynoise2d_vector2" file="mx_worleynoise2d_vector2.glsl" function="mx_worleynoise2d_vector2" target="genglsl" />
+  <implementation name="IM_worleynoise2d_vector3_genglsl" nodedef="ND_worleynoise2d_vector3" file="mx_worleynoise2d_vector3.glsl" function="mx_worleynoise2d_vector3" target="genglsl" />
+
+  <!-- <worleynoise3d> -->
+  <implementation name="IM_worleynoise3d_float_genglsl" nodedef="ND_worleynoise3d_float" file="mx_worleynoise3d_float.glsl" function="mx_worleynoise3d_float" target="genglsl" />
+  <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" />
+
+  <!-- ======================================================================== -->
+  <!-- Global nodes                                                             -->
+  <!-- ======================================================================== -->
+
+  <!-- <ambientocclusion> -->
+
+  <!-- ======================================================================== -->
+  <!-- Geometric nodes                                                          -->
+  <!-- ======================================================================== -->
+
+  <!-- <position> -->
+  <implementation name="IM_position_vector3_genglsl" nodedef="ND_position_vector3" target="genglsl" />
+
+  <!-- <normal> -->
+  <implementation name="IM_normal_vector3_genglsl" nodedef="ND_normal_vector3" target="genglsl" />
+
+  <!-- <tangent> -->
+  <implementation name="IM_tangent_vector3_genglsl" nodedef="ND_tangent_vector3" target="genglsl" />
+
+  <!-- <bitangent> -->
+  <implementation name="IM_bitangent_vector3_genglsl" nodedef="ND_bitangent_vector3" target="genglsl" />
+
+  <!-- <texcoord> -->
+  <implementation name="IM_texcoord_vector2_genglsl" nodedef="ND_texcoord_vector2" target="genglsl" />
+  <implementation name="IM_texcoord_vector3_genglsl" nodedef="ND_texcoord_vector3" target="genglsl" />
+
+  <!-- <geomcolor> -->
+  <implementation name="IM_geomcolor_float_genglsl" nodedef="ND_geomcolor_float" target="genglsl" />
+  <implementation name="IM_geomcolor_color3_genglsl" nodedef="ND_geomcolor_color3" target="genglsl" />
+  <implementation name="IM_geomcolor_color4_genglsl" nodedef="ND_geomcolor_color4" target="genglsl" />
+
+  <!-- <geompropvalue> -->
+  <implementation name="IM_geompropvalue_integer_genglsl" nodedef="ND_geompropvalue_integer" function="mx_geompropvalue_int" target="genglsl" />
+  <implementation name="IM_geompropvalue_boolean_genglsl" nodedef="ND_geompropvalue_boolean" function="mx_geompropvalue_bool" target="genglsl" />
+  <implementation name="IM_geompropvalue_string_genglsl" nodedef="ND_geompropvalue_string" function="mx_geompropvalue_string" target="genglsl" />
+  <implementation name="IM_geompropvalue_float_genglsl" nodedef="ND_geompropvalue_float" function="mx_geompropvalue_float" target="genglsl" />
+  <implementation name="IM_geompropvalue_color3_genglsl" nodedef="ND_geompropvalue_color3" function="mx_geompropvalue_color" target="genglsl" />
+  <implementation name="IM_geompropvalue_color4_genglsl" nodedef="ND_geompropvalue_color4" function="mx_geompropvalue_color4" target="genglsl" />
+  <implementation name="IM_geompropvalue_vector2_genglsl" nodedef="ND_geompropvalue_vector2" function="mx_geompropvalue_vector2" target="genglsl" />
+  <implementation name="IM_geompropvalue_vector3_genglsl" nodedef="ND_geompropvalue_vector3" function="mx_geompropvalue_vector" target="genglsl" />
+  <implementation name="IM_geompropvalue_vector4_genglsl" nodedef="ND_geompropvalue_vector4" function="mx_geompropvalue_vector4" target="genglsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Application nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <frame> -->
+  <implementation name="IM_frame_float_genglsl" nodedef="ND_frame_float" function="mx_frame_float" target="genglsl" />
+
+  <!-- <time> -->
+  <implementation name="IM_time_float_genglsl" nodedef="ND_time_float" function="mx_time_float" target="genglsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Math nodes                                                               -->
+  <!-- ======================================================================== -->
+
+  <!-- <add> -->
+  <implementation name="IM_add_float_genglsl" nodedef="ND_add_float" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_color3_genglsl" nodedef="ND_add_color3" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_color3FA_genglsl" nodedef="ND_add_color3FA" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_color4_genglsl" nodedef="ND_add_color4" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_color4FA_genglsl" nodedef="ND_add_color4FA" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector2_genglsl" nodedef="ND_add_vector2" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector2FA_genglsl" nodedef="ND_add_vector2FA" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector3_genglsl" nodedef="ND_add_vector3" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector3FA_genglsl" nodedef="ND_add_vector3FA" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector4_genglsl" nodedef="ND_add_vector4" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector4FA_genglsl" nodedef="ND_add_vector4FA" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_matrix33_genglsl" nodedef="ND_add_matrix33" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_matrix33FA_genglsl" nodedef="ND_add_matrix33FA" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_matrix44_genglsl" nodedef="ND_add_matrix44" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_matrix44FA_genglsl" nodedef="ND_add_matrix44FA" target="genglsl" sourcecode="{{in1}} + {{in2}}" />
+
+  <!-- <subtract> -->
+  <implementation name="IM_subtract_float_genglsl" nodedef="ND_subtract_float" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_color3_genglsl" nodedef="ND_subtract_color3" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_color3FA_genglsl" nodedef="ND_subtract_color3FA" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_color4_genglsl" nodedef="ND_subtract_color4" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_color4FA_genglsl" nodedef="ND_subtract_color4FA" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector2_genglsl" nodedef="ND_subtract_vector2" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector2FA_genglsl" nodedef="ND_subtract_vector2FA" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector3_genglsl" nodedef="ND_subtract_vector3" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector3FA_genglsl" nodedef="ND_subtract_vector3FA" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector4_genglsl" nodedef="ND_subtract_vector4" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector4FA_genglsl" nodedef="ND_subtract_vector4FA" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_matrix33_genglsl" nodedef="ND_subtract_matrix33" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_matrix33FA_genglsl" nodedef="ND_subtract_matrix33FA" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_matrix44_genglsl" nodedef="ND_subtract_matrix44" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_matrix44FA_genglsl" nodedef="ND_subtract_matrix44FA" target="genglsl" sourcecode="{{in1}} - {{in2}}" />
+
+  <!-- <multiply> -->
+  <implementation name="IM_multiply_float_genglsl" nodedef="ND_multiply_float" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_color3_genglsl" nodedef="ND_multiply_color3" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_color3FA_genglsl" nodedef="ND_multiply_color3FA" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_color4_genglsl" nodedef="ND_multiply_color4" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_color4FA_genglsl" nodedef="ND_multiply_color4FA" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector2_genglsl" nodedef="ND_multiply_vector2" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector2FA_genglsl" nodedef="ND_multiply_vector2FA" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector3_genglsl" nodedef="ND_multiply_vector3" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector3FA_genglsl" nodedef="ND_multiply_vector3FA" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector4_genglsl" nodedef="ND_multiply_vector4" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector4FA_genglsl" nodedef="ND_multiply_vector4FA" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_matrix33_genglsl" nodedef="ND_multiply_matrix33" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_matrix44_genglsl" nodedef="ND_multiply_matrix44" target="genglsl" sourcecode="{{in1}} * {{in2}}" />
+
+  <!-- <divide> -->
+  <implementation name="IM_divide_float_genglsl" nodedef="ND_divide_float" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_color3_genglsl" nodedef="ND_divide_color3" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_color3FA_genglsl" nodedef="ND_divide_color3FA" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_color4_genglsl" nodedef="ND_divide_color4" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_color4FA_genglsl" nodedef="ND_divide_color4FA" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector2_genglsl" nodedef="ND_divide_vector2" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector2FA_genglsl" nodedef="ND_divide_vector2FA" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector3_genglsl" nodedef="ND_divide_vector3" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector3FA_genglsl" nodedef="ND_divide_vector3FA" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector4_genglsl" nodedef="ND_divide_vector4" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector4FA_genglsl" nodedef="ND_divide_vector4FA" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_matrix33_genglsl" nodedef="ND_divide_matrix33" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_matrix44_genglsl" nodedef="ND_divide_matrix44" target="genglsl" sourcecode="{{in1}} / {{in2}}" />
+
+  <!-- <modulo> -->
+  <implementation name="IM_modulo_float_genglsl" nodedef="ND_modulo_float" target="genglsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_color3_genglsl" nodedef="ND_modulo_color3" target="genglsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_color3FA_genglsl" nodedef="ND_modulo_color3FA" target="genglsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_color4_genglsl" nodedef="ND_modulo_color4" target="genglsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_color4FA_genglsl" nodedef="ND_modulo_color4FA" target="genglsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector2_genglsl" nodedef="ND_modulo_vector2" target="genglsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector2FA_genglsl" nodedef="ND_modulo_vector2FA" target="genglsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector3_genglsl" nodedef="ND_modulo_vector3" target="genglsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector3FA_genglsl" nodedef="ND_modulo_vector3FA" target="genglsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector4_genglsl" nodedef="ND_modulo_vector4" target="genglsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector4FA_genglsl" nodedef="ND_modulo_vector4FA" target="genglsl" sourcecode="mod({{in1}}, {{in2}})" />
+
+  <!-- <invert> -->
+  <implementation name="IM_invert_float_genglsl" nodedef="ND_invert_float" target="genglsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_color3_genglsl" nodedef="ND_invert_color3" target="genglsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_color3FA_genglsl" nodedef="ND_invert_color3FA" target="genglsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_color4_genglsl" nodedef="ND_invert_color4" target="genglsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_color4FA_genglsl" nodedef="ND_invert_color4FA" target="genglsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector2_genglsl" nodedef="ND_invert_vector2" target="genglsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector2FA_genglsl" nodedef="ND_invert_vector2FA" target="genglsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector3_genglsl" nodedef="ND_invert_vector3" target="genglsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector3FA_genglsl" nodedef="ND_invert_vector3FA" target="genglsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector4_genglsl" nodedef="ND_invert_vector4" target="genglsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector4FA_genglsl" nodedef="ND_invert_vector4FA" target="genglsl" sourcecode="{{amount}} - {{in}}" />
+
+  <!-- <absval> -->
+  <implementation name="IM_absval_float_genglsl" nodedef="ND_absval_float" target="genglsl" sourcecode="abs({{in}})" />
+  <implementation name="IM_absval_color3_genglsl" nodedef="ND_absval_color3" target="genglsl" sourcecode="abs({{in}})" />
+  <implementation name="IM_absval_color4_genglsl" nodedef="ND_absval_color4" target="genglsl" sourcecode="abs({{in}})" />
+  <implementation name="IM_absval_vector2_genglsl" nodedef="ND_absval_vector2" target="genglsl" sourcecode="abs({{in}})" />
+  <implementation name="IM_absval_vector3_genglsl" nodedef="ND_absval_vector3" target="genglsl" sourcecode="abs({{in}})" />
+  <implementation name="IM_absval_vector4_genglsl" nodedef="ND_absval_vector4" target="genglsl" sourcecode="abs({{in}})" />
+
+  <!-- <floor> -->
+  <implementation name="IM_floor_float_genglsl" nodedef="ND_floor_float" target="genglsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_color3_genglsl" nodedef="ND_floor_color3" target="genglsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_color4_genglsl" nodedef="ND_floor_color4" target="genglsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_vector2_genglsl" nodedef="ND_floor_vector2" target="genglsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_vector3_genglsl" nodedef="ND_floor_vector3" target="genglsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_vector4_genglsl" nodedef="ND_floor_vector4" target="genglsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_integer_genglsl" nodedef="ND_floor_integer" target="genglsl" sourcecode="int(floor({{in}}))" />
+
+  <!-- <ceil> -->
+  <implementation name="IM_ceil_float_genglsl" nodedef="ND_ceil_float" target="genglsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_color3_genglsl" nodedef="ND_ceil_color3" target="genglsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_color4_genglsl" nodedef="ND_ceil_color4" target="genglsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_vector2_genglsl" nodedef="ND_ceil_vector2" target="genglsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_vector3_genglsl" nodedef="ND_ceil_vector3" target="genglsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_vector4_genglsl" nodedef="ND_ceil_vector4" target="genglsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_integer_genglsl" nodedef="ND_ceil_integer" target="genglsl" sourcecode="int(ceil({{in}}))" />
+
+  <!-- <round> -->
+  <implementation name="IM_round_float_genglsl" nodedef="ND_round_float" target="genglsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_color3_genglsl" nodedef="ND_round_color3" target="genglsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_color4_genglsl" nodedef="ND_round_color4" target="genglsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_vector2_genglsl" nodedef="ND_round_vector2" target="genglsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_vector3_genglsl" nodedef="ND_round_vector3" target="genglsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_vector4_genglsl" nodedef="ND_round_vector4" target="genglsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_integer_genglsl" nodedef="ND_round_integer" target="genglsl" sourcecode="int(round({{in}}))" />
+
+  <!-- <power> -->
+  <implementation name="IM_power_float_genglsl" nodedef="ND_power_float" target="genglsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_color3_genglsl" nodedef="ND_power_color3" target="genglsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_color3FA_genglsl" nodedef="ND_power_color3FA" target="genglsl" sourcecode="pow({{in1}}, vec3({{in2}}))" />
+  <implementation name="IM_power_color4_genglsl" nodedef="ND_power_color4" target="genglsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_color4FA_genglsl" nodedef="ND_power_color4FA" target="genglsl" sourcecode="pow({{in1}}, vec4({{in2}}))" />
+  <implementation name="IM_power_vector2_genglsl" nodedef="ND_power_vector2" target="genglsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_vector2FA_genglsl" nodedef="ND_power_vector2FA" target="genglsl" sourcecode="pow({{in1}}, vec2({{in2}}))" />
+  <implementation name="IM_power_vector3_genglsl" nodedef="ND_power_vector3" target="genglsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_vector3FA_genglsl" nodedef="ND_power_vector3FA" target="genglsl" sourcecode="pow({{in1}}, vec3({{in2}}))" />
+  <implementation name="IM_power_vector4_genglsl" nodedef="ND_power_vector4" target="genglsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_vector4FA_genglsl" nodedef="ND_power_vector4FA" target="genglsl" sourcecode="pow({{in1}}, vec4({{in2}}))" />
+
+  <!-- <sin>, <cos>, <tan>, <asin>, <acos>, <atan2> -->
+  <implementation name="IM_sin_float_genglsl" nodedef="ND_sin_float" target="genglsl" sourcecode="sin({{in}})" />
+  <implementation name="IM_cos_float_genglsl" nodedef="ND_cos_float" target="genglsl" sourcecode="cos({{in}})" />
+  <implementation name="IM_tan_float_genglsl" nodedef="ND_tan_float" target="genglsl" sourcecode="tan({{in}})" />
+  <implementation name="IM_asin_float_genglsl" nodedef="ND_asin_float" target="genglsl" sourcecode="asin({{in}})" />
+  <implementation name="IM_acos_float_genglsl" nodedef="ND_acos_float" target="genglsl" sourcecode="acos({{in}})" />
+  <implementation name="IM_atan2_float_genglsl" nodedef="ND_atan2_float" target="genglsl" sourcecode="atan({{in1}}, {{in2}})" />
+  <implementation name="IM_sin_vector2_genglsl" nodedef="ND_sin_vector2" target="genglsl" sourcecode="sin({{in}})" />
+  <implementation name="IM_cos_vector2_genglsl" nodedef="ND_cos_vector2" target="genglsl" sourcecode="cos({{in}})" />
+  <implementation name="IM_tan_vector2_genglsl" nodedef="ND_tan_vector2" target="genglsl" sourcecode="tan({{in}})" />
+  <implementation name="IM_asin_vector2_genglsl" nodedef="ND_asin_vector2" target="genglsl" sourcecode="asin({{in}})" />
+  <implementation name="IM_acos_vector2_genglsl" nodedef="ND_acos_vector2" target="genglsl" sourcecode="acos({{in}})" />
+  <implementation name="IM_atan2_vector2_genglsl" nodedef="ND_atan2_vector2" target="genglsl" sourcecode="atan({{in1}}, {{in2}})" />
+  <implementation name="IM_sin_vector3_genglsl" nodedef="ND_sin_vector3" target="genglsl" sourcecode="sin({{in}})" />
+  <implementation name="IM_cos_vector3_genglsl" nodedef="ND_cos_vector3" target="genglsl" sourcecode="cos({{in}})" />
+  <implementation name="IM_tan_vector3_genglsl" nodedef="ND_tan_vector3" target="genglsl" sourcecode="tan({{in}})" />
+  <implementation name="IM_asin_vector3_genglsl" nodedef="ND_asin_vector3" target="genglsl" sourcecode="asin({{in}})" />
+  <implementation name="IM_acos_vector3_genglsl" nodedef="ND_acos_vector3" target="genglsl" sourcecode="acos({{in}})" />
+  <implementation name="IM_atan2_vector3_genglsl" nodedef="ND_atan2_vector3" target="genglsl" sourcecode="atan({{in1}}, {{in2}})" />
+  <implementation name="IM_sin_vector4_genglsl" nodedef="ND_sin_vector4" target="genglsl" sourcecode="sin({{in}})" />
+  <implementation name="IM_cos_vector4_genglsl" nodedef="ND_cos_vector4" target="genglsl" sourcecode="cos({{in}})" />
+  <implementation name="IM_tan_vector4_genglsl" nodedef="ND_tan_vector4" target="genglsl" sourcecode="tan({{in}})" />
+  <implementation name="IM_asin_vector4_genglsl" nodedef="ND_asin_vector4" target="genglsl" sourcecode="asin({{in}})" />
+  <implementation name="IM_acos_vector4_genglsl" nodedef="ND_acos_vector4" target="genglsl" sourcecode="acos({{in}})" />
+  <implementation name="IM_atan2_vector4_genglsl" nodedef="ND_atan2_vector4" target="genglsl" sourcecode="atan({{in1}}, {{in2}})" />
+
+  <!-- <sqrt> -->
+  <implementation name="IM_sqrt_float_genglsl" nodedef="ND_sqrt_float" target="genglsl" sourcecode="sqrt({{in}})" />
+  <implementation name="IM_sqrt_vector2_genglsl" nodedef="ND_sqrt_vector2" target="genglsl" sourcecode="sqrt({{in}})" />
+  <implementation name="IM_sqrt_vector3_genglsl" nodedef="ND_sqrt_vector3" target="genglsl" sourcecode="sqrt({{in}})" />
+  <implementation name="IM_sqrt_vector4_genglsl" nodedef="ND_sqrt_vector4" target="genglsl" sourcecode="sqrt({{in}})" />
+
+  <!-- <ln> -->
+  <implementation name="IM_ln_float_genglsl" nodedef="ND_ln_float" target="genglsl" sourcecode="log({{in}})" />
+  <implementation name="IM_ln_vector2_genglsl" nodedef="ND_ln_vector2" target="genglsl" sourcecode="log({{in}})" />
+  <implementation name="IM_ln_vector3_genglsl" nodedef="ND_ln_vector3" target="genglsl" sourcecode="log({{in}})" />
+  <implementation name="IM_ln_vector4_genglsl" nodedef="ND_ln_vector4" target="genglsl" sourcecode="log({{in}})" />
+
+  <!-- <exp> -->
+  <implementation name="IM_exp_float_genglsl" nodedef="ND_exp_float" target="genglsl" sourcecode="exp({{in}})" />
+  <implementation name="IM_exp_vector2_genglsl" nodedef="ND_exp_vector2" target="genglsl" sourcecode="exp({{in}})" />
+  <implementation name="IM_exp_vector3_genglsl" nodedef="ND_exp_vector3" target="genglsl" sourcecode="exp({{in}})" />
+  <implementation name="IM_exp_vector4_genglsl" nodedef="ND_exp_vector4" target="genglsl" sourcecode="exp({{in}})" />
+
+  <!-- sign -->
+  <implementation name="IM_sign_float_genglsl" nodedef="ND_sign_float" target="genglsl" sourcecode="sign({{in}})" />
+  <implementation name="IM_sign_color3_genglsl" nodedef="ND_sign_color3" target="genglsl" sourcecode="sign({{in}})" />
+  <implementation name="IM_sign_color4_genglsl" nodedef="ND_sign_color4" target="genglsl" sourcecode="sign({{in}})" />
+  <implementation name="IM_sign_vector2_genglsl" nodedef="ND_sign_vector2" target="genglsl" sourcecode="sign({{in}})" />
+  <implementation name="IM_sign_vector3_genglsl" nodedef="ND_sign_vector3" target="genglsl" sourcecode="sign({{in}})" />
+  <implementation name="IM_sign_vector4_genglsl" nodedef="ND_sign_vector4" target="genglsl" sourcecode="sign({{in}})" />
+
+  <!-- <clamp> -->
+  <implementation name="IM_clamp_float_genglsl" nodedef="ND_clamp_float" target="genglsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_color3_genglsl" nodedef="ND_clamp_color3" target="genglsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_color3FA_genglsl" nodedef="ND_clamp_color3FA" target="genglsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_color4_genglsl" nodedef="ND_clamp_color4" target="genglsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_color4FA_genglsl" nodedef="ND_clamp_color4FA" target="genglsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector2_genglsl" nodedef="ND_clamp_vector2" target="genglsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector2FA_genglsl" nodedef="ND_clamp_vector2FA" target="genglsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector3_genglsl" nodedef="ND_clamp_vector3" target="genglsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector3FA_genglsl" nodedef="ND_clamp_vector3FA" target="genglsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector4_genglsl" nodedef="ND_clamp_vector4" target="genglsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector4FA_genglsl" nodedef="ND_clamp_vector4FA" target="genglsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+
+  <!-- <min> -->
+  <implementation name="IM_min_float_genglsl" nodedef="ND_min_float" target="genglsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_color3_genglsl" nodedef="ND_min_color3" target="genglsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_color3FA_genglsl" nodedef="ND_min_color3FA" target="genglsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_color4_genglsl" nodedef="ND_min_color4" target="genglsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_color4FA_genglsl" nodedef="ND_min_color4FA" target="genglsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector2_genglsl" nodedef="ND_min_vector2" target="genglsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector2FA_genglsl" nodedef="ND_min_vector2FA" target="genglsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector3_genglsl" nodedef="ND_min_vector3" target="genglsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector3FA_genglsl" nodedef="ND_min_vector3FA" target="genglsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector4_genglsl" nodedef="ND_min_vector4" target="genglsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector4FA_genglsl" nodedef="ND_min_vector4FA" target="genglsl" sourcecode="min({{in1}}, {{in2}})" />
+
+  <!-- <max> -->
+  <implementation name="IM_max_float_genglsl" nodedef="ND_max_float" target="genglsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_color3_genglsl" nodedef="ND_max_color3" target="genglsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_color3FA_genglsl" nodedef="ND_max_color3FA" target="genglsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_color4_genglsl" nodedef="ND_max_color4" target="genglsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_color4FA_genglsl" nodedef="ND_max_color4FA" target="genglsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector2_genglsl" nodedef="ND_max_vector2" target="genglsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector2FA_genglsl" nodedef="ND_max_vector2FA" target="genglsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector3_genglsl" nodedef="ND_max_vector3" target="genglsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector3FA_genglsl" nodedef="ND_max_vector3FA" target="genglsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector4_genglsl" nodedef="ND_max_vector4" target="genglsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector4FA_genglsl" nodedef="ND_max_vector4FA" target="genglsl" sourcecode="max({{in1}}, {{in2}})" />
+
+  <!-- <normalize> -->
+  <implementation name="IM_normalize_vector2_genglsl" nodedef="ND_normalize_vector2" target="genglsl" sourcecode="normalize({{in}})" />
+  <implementation name="IM_normalize_vector3_genglsl" nodedef="ND_normalize_vector3" target="genglsl" sourcecode="normalize({{in}})" />
+  <implementation name="IM_normalize_vector4_genglsl" nodedef="ND_normalize_vector4" target="genglsl" sourcecode="normalize({{in}})" />
+
+  <!-- <magnitude> -->
+  <implementation name="IM_magnitude_vector2_genglsl" nodedef="ND_magnitude_vector2" target="genglsl" sourcecode="length({{in}})" />
+  <implementation name="IM_magnitude_vector3_genglsl" nodedef="ND_magnitude_vector3" target="genglsl" sourcecode="length({{in}})" />
+  <implementation name="IM_magnitude_vector4_genglsl" nodedef="ND_magnitude_vector4" target="genglsl" sourcecode="length({{in}})" />
+
+  <!-- <dotproduct> -->
+  <implementation name="IM_dotproduct_vector2_genglsl" nodedef="ND_dotproduct_vector2" target="genglsl" sourcecode="dot({{in1}}, {{in2}})" />
+  <implementation name="IM_dotproduct_vector3_genglsl" nodedef="ND_dotproduct_vector3" target="genglsl" sourcecode="dot({{in1}}, {{in2}})" />
+  <implementation name="IM_dotproduct_vector4_genglsl" nodedef="ND_dotproduct_vector4" target="genglsl" sourcecode="dot({{in1}}, {{in2}})" />
+
+  <!-- <crossproduct> -->
+  <implementation name="IM_crossproduct_vector3_genglsl" nodedef="ND_crossproduct_vector3" target="genglsl" sourcecode="cross({{in1}}, {{in2}})" />
+
+  <!-- <transformpoint> -->
+  <implementation name="IM_transformpoint_vector3_genglsl" nodedef="ND_transformpoint_vector3" target="genglsl" />
+
+  <!-- <transformvector> -->
+  <implementation name="IM_transformvector_vector3_genglsl" nodedef="ND_transformvector_vector3" target="genglsl" />
+
+  <!-- <transformnormal> -->
+  <implementation name="IM_transformnormal_vector3_genglsl" nodedef="ND_transformnormal_vector3" target="genglsl" />
+
+  <!-- <transformmatrix> -->
+  <implementation name="IM_transformmatrix_vector2M3_genglsl" nodedef="ND_transformmatrix_vector2M3" function="mx_transformmatrix_vector2M3" file="mx_transformmatrix_vector2M3.glsl" target="genglsl" />
+  <implementation name="IM_transformmatrix_vector3_genglsl" nodedef="ND_transformmatrix_vector3" target="genglsl" sourcecode="{{mat}} * {{in}}" />
+  <implementation name="IM_transformmatrix_vector3M4_genglsl" nodedef="ND_transformmatrix_vector3M4" function="mx_transformmatrix_vector3M4" file="mx_transformmatrix_vector3M4.glsl" target="genglsl" />
+  <implementation name="IM_transformmatrix_vector4_genglsl" nodedef="ND_transformmatrix_vector4" target="genglsl" sourcecode="{{mat}} * {{in}}" />
+
+  <!-- <transpose> -->
+  <implementation name="IM_transpose_matrix33_genglsl" nodedef="ND_transpose_matrix33" target="genglsl" sourcecode="transpose({{in}})" />
+  <implementation name="IM_transpose_matrix44_genglsl" nodedef="ND_transpose_matrix44" target="genglsl" sourcecode="transpose({{in}})" />
+
+  <!-- <determinant> -->
+  <implementation name="IM_determinant_matrix33_genglsl" nodedef="ND_determinant_matrix33" target="genglsl" sourcecode="determinant({{in}})" />
+  <implementation name="IM_determinant_matrix44_genglsl" nodedef="ND_determinant_matrix44" target="genglsl" sourcecode="determinant({{in}})" />
+
+  <!-- <invertmatrix> -->
+  <implementation name="IM_invertmatrix_matrix33_genglsl" nodedef="ND_invertmatrix_matrix33" target="genglsl" sourcecode="inverse({{in}})" />
+  <implementation name="IM_invertmatrix_matrix44_genglsl" nodedef="ND_invertmatrix_matrix44" target="genglsl" sourcecode="inverse({{in}})" />
+
+  <!-- <rotate2d> -->
+  <implementation name="IM_rotate2d_vector2_genglsl" nodedef="ND_rotate2d_vector2" file="mx_rotate_vector2.glsl" function="mx_rotate_vector2" target="genglsl" />
+
+  <!-- <rotate3d> -->
+  <implementation name="IM_rotate3d_vector3_genglsl" nodedef="ND_rotate3d_vector3" file="mx_rotate_vector3.glsl" function="mx_rotate_vector3" target="genglsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Adjustment nodes                                                         -->
+  <!-- ======================================================================== -->
+
+  <!-- <contrast> -->
+
+  <!-- <remap> -->
+  <implementation name="IM_remap_float_genglsl" nodedef="ND_remap_float" target="genglsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_color3_genglsl" nodedef="ND_remap_color3" target="genglsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_color3FA_genglsl" nodedef="ND_remap_color3FA" target="genglsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_color4_genglsl" nodedef="ND_remap_color4" target="genglsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_color4FA_genglsl" nodedef="ND_remap_color4FA" target="genglsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector2_genglsl" nodedef="ND_remap_vector2" target="genglsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector2FA_genglsl" nodedef="ND_remap_vector2FA" target="genglsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector3_genglsl" nodedef="ND_remap_vector3" target="genglsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector3FA_genglsl" nodedef="ND_remap_vector3FA" target="genglsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector4_genglsl" nodedef="ND_remap_vector4" target="genglsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector4FA_genglsl" nodedef="ND_remap_vector4FA" target="genglsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+
+  <!-- <smoothstep> -->
+  <implementation name="IM_smoothstep_float_genglsl" nodedef="ND_smoothstep_float" file="mx_smoothstep_float.glsl" function="mx_smoothstep_float" target="genglsl" />
+  <implementation name="IM_smoothstep_vector2_genglsl" nodedef="ND_smoothstep_vector2" file="mx_smoothstep_vector2.glsl" function="mx_smoothstep_vector2" target="genglsl" />
+  <implementation name="IM_smoothstep_vector3_genglsl" nodedef="ND_smoothstep_vector3" file="mx_smoothstep_vector3.glsl" function="mx_smoothstep_vector3" target="genglsl" />
+  <implementation name="IM_smoothstep_vector4_genglsl" nodedef="ND_smoothstep_vector4" file="mx_smoothstep_vector4.glsl" function="mx_smoothstep_vector4" target="genglsl" />
+
+  <!-- <luminance> -->
+  <implementation name="IM_luminance_color3_genglsl" nodedef="ND_luminance_color3" file="mx_luminance_color3.glsl" function="mx_luminance_color3" target="genglsl" />
+  <implementation name="IM_luminance_color4_genglsl" nodedef="ND_luminance_color4" file="mx_luminance_color4.glsl" function="mx_luminance_color4" target="genglsl" />
+
+  <!-- <rgbtohsv> -->
+  <implementation name="IM_rgbtohsv_color3_genglsl" nodedef="ND_rgbtohsv_color3" file="mx_rgbtohsv_color3.glsl" function="mx_rgbtohsv_color3" target="genglsl" />
+  <implementation name="IM_rgbtohsv_color4_genglsl" nodedef="ND_rgbtohsv_color4" file="mx_rgbtohsv_color4.glsl" function="mx_rgbtohsv_color4" target="genglsl" />
+
+  <!-- <hsvtorgb> -->
+  <implementation name="IM_hsvtorgb_color3_genglsl" nodedef="ND_hsvtorgb_color3" file="mx_hsvtorgb_color3.glsl" function="mx_hsvtorgb_color3" target="genglsl" />
+  <implementation name="IM_hsvtorgb_color4_genglsl" nodedef="ND_hsvtorgb_color4" file="mx_hsvtorgb_color4.glsl" function="mx_hsvtorgb_color4" target="genglsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Compositing nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <premult> -->
+  <implementation name="IM_premult_color4_genglsl" nodedef="ND_premult_color4" file="mx_premult_color4.glsl" function="mx_premult_color4" target="genglsl" />
+
+  <!-- <unpremult> -->
+  <implementation name="IM_unpremult_color4_genglsl" nodedef="ND_unpremult_color4" file="mx_unpremult_color4.glsl" function="mx_unpremult_color4" target="genglsl" />
+
+  <!-- <plus> -->
+  <implementation name="IM_plus_float_genglsl" nodedef="ND_plus_float" target="genglsl" sourcecode="({{mix}}*({{bg}} + {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_plus_color3_genglsl" nodedef="ND_plus_color3" target="genglsl" sourcecode="({{mix}}*({{bg}} + {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_plus_color4_genglsl" nodedef="ND_plus_color4" target="genglsl" sourcecode="({{mix}}*({{bg}} + {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+
+  <!-- <minus> -->
+  <implementation name="IM_minus_float_genglsl" nodedef="ND_minus_float" target="genglsl" sourcecode="({{mix}}*({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_minus_color3_genglsl" nodedef="ND_minus_color3" target="genglsl" sourcecode="({{mix}}*({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_minus_color4_genglsl" nodedef="ND_minus_color4" target="genglsl" sourcecode="({{mix}}*({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+
+  <!-- <difference> -->
+  <implementation name="IM_difference_float_genglsl" nodedef="ND_difference_float" target="genglsl" sourcecode="({{mix}}*abs({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_difference_color3_genglsl" nodedef="ND_difference_color3" target="genglsl" sourcecode="({{mix}}*abs({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_difference_color4_genglsl" nodedef="ND_difference_color4" target="genglsl" sourcecode="({{mix}}*abs({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+
+  <!-- <burn> -->
+  <implementation name="IM_burn_float_genglsl" nodedef="ND_burn_float" file="mx_burn_float.glsl" function="mx_burn_float" target="genglsl" />
+  <implementation name="IM_burn_color3_genglsl" nodedef="ND_burn_color3" file="mx_burn_color3.glsl" function="mx_burn_color3" target="genglsl" />
+  <implementation name="IM_burn_color4_genglsl" nodedef="ND_burn_color4" file="mx_burn_color4.glsl" function="mx_burn_color4" target="genglsl" />
+
+  <!-- <dodge> -->
+  <implementation name="IM_dodge_float_genglsl" nodedef="ND_dodge_float" file="mx_dodge_float.glsl" function="mx_dodge_float" target="genglsl" />
+  <implementation name="IM_dodge_color3_genglsl" nodedef="ND_dodge_color3" file="mx_dodge_color3.glsl" function="mx_dodge_color3" target="genglsl" />
+  <implementation name="IM_dodge_color4_genglsl" nodedef="ND_dodge_color4" file="mx_dodge_color4.glsl" function="mx_dodge_color4" target="genglsl" />
+
+  <!-- <screen> -->
+  <implementation name="IM_screen_float_genglsl" nodedef="ND_screen_float" target="genglsl" sourcecode="({{mix}}*((1.0 - (1.0 - {{fg}}) * (1.0 - {{bg}})))) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_screen_color3_genglsl" nodedef="ND_screen_color3" target="genglsl" sourcecode="({{mix}}*((1.0 - (1.0 - {{fg}}) * (1.0 - {{bg}})))) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_screen_color4_genglsl" nodedef="ND_screen_color4" target="genglsl" sourcecode="({{mix}}*((1.0 - (1.0 - {{fg}}) * (1.0 - {{bg}})))) + ((1.0-{{mix}})*{{bg}})" />
+
+  <!-- <disjointover> -->
+  <implementation name="IM_disjointover_color4_genglsl" nodedef="ND_disjointover_color4" file="mx_disjointover_color4.glsl" function="mx_disjointover_color4" target="genglsl" />
+
+  <!-- <in> -->
+  <implementation name="IM_in_color4_genglsl" nodedef="ND_in_color4" target="genglsl" sourcecode="({{fg}}*{{bg}}.a  * {{mix}}) + ({{bg}} * (1.0-{{mix}}));" />
+
+  <!-- <mask> -->
+  <implementation name="IM_mask_color4_genglsl" nodedef="ND_mask_color4" target="genglsl" sourcecode="({{bg}}*{{fg}}.a  * {{mix}}) + ({{bg}} * (1.0-{{mix}}));" />
+
+  <!-- <matte> -->
+  <implementation name="IM_matte_color4_genglsl" nodedef="ND_matte_color4" target="genglsl" sourcecode="vec4( {{fg}}.xyz*{{fg}}.w + {{bg}}.xyz*(1.0-{{fg}}.w), {{fg}}.w + ({{bg}}.w*(1.0-{{fg}}.w)) ) * {{mix}} + ({{bg}} * (1.0-{{mix}}));" />
+
+  <!-- <out> -->
+  <implementation name="IM_out_color4_genglsl" nodedef="ND_out_color4" target="genglsl" sourcecode="({{fg}}*(1.0-{{bg}}.a)  * {{mix}}) + ({{bg}} * (1.0-{{mix}}));" />
+
+  <!-- <over> -->
+  <implementation name="IM_over_color4_genglsl" nodedef="ND_over_color4" target="genglsl" sourcecode="({{fg}} + ({{bg}}*(1.0-{{fg}}[3]))) * {{mix}} + {{bg}} * (1.0-{{mix}})" />
+
+  <!-- <inside> -->
+  <implementation name="IM_inside_float_genglsl" nodedef="ND_inside_float" target="genglsl" sourcecode="{{in}} * {{mask}}" />
+  <implementation name="IM_inside_color3_genglsl" nodedef="ND_inside_color3" target="genglsl" sourcecode="{{in}} * {{mask}}" />
+  <implementation name="IM_inside_color4_genglsl" nodedef="ND_inside_color4" target="genglsl" sourcecode="{{in}} * {{mask}}" />
+
+  <!-- <outside> -->
+  <implementation name="IM_outside_float_genglsl" nodedef="ND_outside_float" target="genglsl" sourcecode="{{in}} * (1.0 - {{mask}})" />
+  <implementation name="IM_outside_color3_genglsl" nodedef="ND_outside_color3" target="genglsl" sourcecode="{{in}} * (1.0 - {{mask}})" />
+  <implementation name="IM_outside_color4_genglsl" nodedef="ND_outside_color4" target="genglsl" sourcecode="{{in}} * (1.0 - {{mask}})" />
+
+  <!-- <mix> -->
+  <implementation name="IM_mix_float_genglsl" nodedef="ND_mix_float" target="genglsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_color3_genglsl" nodedef="ND_mix_color3" target="genglsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_color3_color3_genglsl" nodedef="ND_mix_color3_color3" target="genglsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_color4_genglsl" nodedef="ND_mix_color4" target="genglsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_color4_color4_genglsl" nodedef="ND_mix_color4_color4" target="genglsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector2_genglsl" nodedef="ND_mix_vector2" target="genglsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector2_vector2_genglsl" nodedef="ND_mix_vector2_vector2" target="genglsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector3_genglsl" nodedef="ND_mix_vector3" target="genglsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector3_vector3_genglsl" nodedef="ND_mix_vector3_vector3" target="genglsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector4_genglsl" nodedef="ND_mix_vector4" target="genglsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector4_vector4_genglsl" nodedef="ND_mix_vector4_vector4" target="genglsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_surfaceshader_genglsl" nodedef="ND_mix_surfaceshader" function="mx_mix_surfaceshader" file="mx_mix_surfaceshader.glsl" target="genglsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Conditional nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <ifgreater -->
+  <implementation name="IM_ifgreater_float_genglsl" nodedef="ND_ifgreater_float" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_color3_genglsl" nodedef="ND_ifgreater_color3" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_color4_genglsl" nodedef="ND_ifgreater_color4" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector2_genglsl" nodedef="ND_ifgreater_vector2" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector3_genglsl" nodedef="ND_ifgreater_vector3" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector4_genglsl" nodedef="ND_ifgreater_vector4" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_floatI_genglsl" nodedef="ND_ifgreater_floatI" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_color3I_genglsl" nodedef="ND_ifgreater_color3I" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_color4I_genglsl" nodedef="ND_ifgreater_color4I" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector2I_genglsl" nodedef="ND_ifgreater_vector2I" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector3I_genglsl" nodedef="ND_ifgreater_vector3I" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector4I_genglsl" nodedef="ND_ifgreater_vector4I" target="genglsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+
+  <!-- <ifgreatereq -->
+  <implementation name="IM_ifgreatereq_float_genglsl" nodedef="ND_ifgreatereq_float" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_color3_genglsl" nodedef="ND_ifgreatereq_color3" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_color4_genglsl" nodedef="ND_ifgreatereq_color4" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector2_genglsl" nodedef="ND_ifgreatereq_vector2" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector3_genglsl" nodedef="ND_ifgreatereq_vector3" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector4_genglsl" nodedef="ND_ifgreatereq_vector4" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_floatI_genglsl" nodedef="ND_ifgreatereq_floatI" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_color3I_genglsl" nodedef="ND_ifgreatereq_color3I" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_color4I_genglsl" nodedef="ND_ifgreatereq_color4I" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector2I_genglsl" nodedef="ND_ifgreatereq_vector2I" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector3I_genglsl" nodedef="ND_ifgreatereq_vector3I" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector4I_genglsl" nodedef="ND_ifgreatereq_vector4I" target="genglsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+
+  <!-- <ifequal -->
+  <implementation name="IM_ifequal_float_genglsl" nodedef="ND_ifequal_float" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color3_genglsl" nodedef="ND_ifequal_color3" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color4_genglsl" nodedef="ND_ifequal_color4" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector2_genglsl" nodedef="ND_ifequal_vector2" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector3_genglsl" nodedef="ND_ifequal_vector3" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector4_genglsl" nodedef="ND_ifequal_vector4" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_floatI_genglsl" nodedef="ND_ifequal_floatI" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color3I_genglsl" nodedef="ND_ifequal_color3I" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color4I_genglsl" nodedef="ND_ifequal_color4I" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector2I_genglsl" nodedef="ND_ifequal_vector2I" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector3I_genglsl" nodedef="ND_ifequal_vector3I" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector4I_genglsl" nodedef="ND_ifequal_vector4I" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_floatB_genglsl" nodedef="ND_ifequal_floatB" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color3B_genglsl" nodedef="ND_ifequal_color3B" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color4B_genglsl" nodedef="ND_ifequal_color4B" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector2B_genglsl" nodedef="ND_ifequal_vector2B" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector3B_genglsl" nodedef="ND_ifequal_vector3B" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector4B_genglsl" nodedef="ND_ifequal_vector4B" target="genglsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+
+  <!-- <switch> -->
+
+  <!-- 'which' type : float -->
+  <implementation name="IM_switch_float_genglsl" nodedef="ND_switch_float" target="genglsl" />
+  <implementation name="IM_switch_color3_genglsl" nodedef="ND_switch_color3" target="genglsl" />
+  <implementation name="IM_switch_color4_genglsl" nodedef="ND_switch_color4" target="genglsl" />
+  <implementation name="IM_switch_vector2_genglsl" nodedef="ND_switch_vector2" target="genglsl" />
+  <implementation name="IM_switch_vector3_genglsl" nodedef="ND_switch_vector3" target="genglsl" />
+  <implementation name="IM_switch_vector4_genglsl" nodedef="ND_switch_vector4" target="genglsl" />
+
+  <!-- 'which' type : integer -->
+  <implementation name="IM_switch_floatI_genglsl" nodedef="ND_switch_floatI" target="genglsl" />
+  <implementation name="IM_switch_color3I_genglsl" nodedef="ND_switch_color3I" target="genglsl" />
+  <implementation name="IM_switch_color4I_genglsl" nodedef="ND_switch_color4I" target="genglsl" />
+  <implementation name="IM_switch_vector2I_genglsl" nodedef="ND_switch_vector2I" target="genglsl" />
+  <implementation name="IM_switch_vector3I_genglsl" nodedef="ND_switch_vector3I" target="genglsl" />
+  <implementation name="IM_switch_vector4I_genglsl" nodedef="ND_switch_vector4I" target="genglsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Channel nodes                                                            -->
+  <!-- ======================================================================== -->
+
+  <!-- <convert> -->
+  <implementation name="IM_convert_float_color3_genglsl" nodedef="ND_convert_float_color3" target="genglsl" />
+  <implementation name="IM_convert_float_color4_genglsl" nodedef="ND_convert_float_color4" target="genglsl" />
+  <implementation name="IM_convert_float_vector2_genglsl" nodedef="ND_convert_float_vector2" target="genglsl" />
+  <implementation name="IM_convert_float_vector3_genglsl" nodedef="ND_convert_float_vector3" target="genglsl" />
+  <implementation name="IM_convert_float_vector4_genglsl" nodedef="ND_convert_float_vector4" target="genglsl" />
+  <implementation name="IM_convert_vector2_vector3_genglsl" nodedef="ND_convert_vector2_vector3" target="genglsl" />
+  <implementation name="IM_convert_vector3_vector2_genglsl" nodedef="ND_convert_vector3_vector2" target="genglsl" />
+  <implementation name="IM_convert_vector3_color3_genglsl" nodedef="ND_convert_vector3_color3" target="genglsl" />
+  <implementation name="IM_convert_vector3_vector4_genglsl" nodedef="ND_convert_vector3_vector4" target="genglsl" />
+  <implementation name="IM_convert_vector4_vector3_genglsl" nodedef="ND_convert_vector4_vector3" target="genglsl" />
+  <implementation name="IM_convert_vector4_color4_genglsl" nodedef="ND_convert_vector4_color4" target="genglsl" />
+  <implementation name="IM_convert_color3_vector3_genglsl" nodedef="ND_convert_color3_vector3" target="genglsl" />
+  <implementation name="IM_convert_color4_vector4_genglsl" nodedef="ND_convert_color4_vector4" target="genglsl" />
+  <implementation name="IM_convert_color3_color4_genglsl" nodedef="ND_convert_color3_color4" target="genglsl" />
+  <implementation name="IM_convert_color4_color3_genglsl" nodedef="ND_convert_color4_color3" target="genglsl" />
+  <implementation name="IM_convert_boolean_float_genglsl" nodedef="ND_convert_boolean_float" target="genglsl" />
+  <implementation name="IM_convert_integer_float_genglsl" nodedef="ND_convert_integer_float" target="genglsl" />
+
+  <!-- <swizzle> -->
+  <!-- from type: float -->
+  <implementation name="IM_swizzle_float_color3_genglsl" nodedef="ND_swizzle_float_color3" target="genglsl" />
+  <implementation name="IM_swizzle_float_color4_genglsl" nodedef="ND_swizzle_float_color4" target="genglsl" />
+  <implementation name="IM_swizzle_float_vector2_genglsl" nodedef="ND_swizzle_float_vector2" target="genglsl" />
+  <implementation name="IM_swizzle_float_vector3_genglsl" nodedef="ND_swizzle_float_vector3" target="genglsl" />
+  <implementation name="IM_swizzle_float_vector4_genglsl" nodedef="ND_swizzle_float_vector4" target="genglsl" />
+  <!-- from type: color3 -->
+  <implementation name="IM_swizzle_color3_float_genglsl" nodedef="ND_swizzle_color3_float" target="genglsl" />
+  <implementation name="IM_swizzle_color3_color3_genglsl" nodedef="ND_swizzle_color3_color3" target="genglsl" />
+  <implementation name="IM_swizzle_color3_color4_genglsl" nodedef="ND_swizzle_color3_color4" target="genglsl" />
+  <implementation name="IM_swizzle_color3_vector2_genglsl" nodedef="ND_swizzle_color3_vector2" target="genglsl" />
+  <implementation name="IM_swizzle_color3_vector3_genglsl" nodedef="ND_swizzle_color3_vector3" target="genglsl" />
+  <implementation name="IM_swizzle_color3_vector4_genglsl" nodedef="ND_swizzle_color3_vector4" target="genglsl" />
+  <!-- from type: color4 -->
+  <implementation name="IM_swizzle_color4_float_genglsl" nodedef="ND_swizzle_color4_float" target="genglsl" />
+  <implementation name="IM_swizzle_color4_color3_genglsl" nodedef="ND_swizzle_color4_color3" target="genglsl" />
+  <implementation name="IM_swizzle_color4_color4_genglsl" nodedef="ND_swizzle_color4_color4" target="genglsl" />
+  <implementation name="IM_swizzle_color4_vector2_genglsl" nodedef="ND_swizzle_color4_vector2" target="genglsl" />
+  <implementation name="IM_swizzle_color4_vector3_genglsl" nodedef="ND_swizzle_color4_vector3" target="genglsl" />
+  <implementation name="IM_swizzle_color4_vector4_genglsl" nodedef="ND_swizzle_color4_vector4" target="genglsl" />
+  <!-- from type: vector2 -->
+  <implementation name="IM_swizzle_vector2_float_genglsl" nodedef="ND_swizzle_vector2_float" target="genglsl" />
+  <implementation name="IM_swizzle_vector2_color3_genglsl" nodedef="ND_swizzle_vector2_color3" target="genglsl" />
+  <implementation name="IM_swizzle_vector2_color4_genglsl" nodedef="ND_swizzle_vector2_color4" target="genglsl" />
+  <implementation name="IM_swizzle_vector2_vector2_genglsl" nodedef="ND_swizzle_vector2_vector2" target="genglsl" />
+  <implementation name="IM_swizzle_vector2_vector3_genglsl" nodedef="ND_swizzle_vector2_vector3" target="genglsl" />
+  <implementation name="IM_swizzle_vector2_vector4_genglsl" nodedef="ND_swizzle_vector2_vector4" target="genglsl" />
+  <!-- from type: vector3 -->
+  <implementation name="IM_swizzle_vector3_float_genglsl" nodedef="ND_swizzle_vector3_float" target="genglsl" />
+  <implementation name="IM_swizzle_vector3_color3_genglsl" nodedef="ND_swizzle_vector3_color3" target="genglsl" />
+  <implementation name="IM_swizzle_vector3_color4_genglsl" nodedef="ND_swizzle_vector3_color4" target="genglsl" />
+  <implementation name="IM_swizzle_vector3_vector2_genglsl" nodedef="ND_swizzle_vector3_vector2" target="genglsl" />
+  <implementation name="IM_swizzle_vector3_vector3_genglsl" nodedef="ND_swizzle_vector3_vector3" target="genglsl" />
+  <implementation name="IM_swizzle_vector3_vector4_genglsl" nodedef="ND_swizzle_vector3_vector4" target="genglsl" />
+  <!-- from type: vector4 -->
+  <implementation name="IM_swizzle_vector4_float_genglsl" nodedef="ND_swizzle_vector4_float" target="genglsl" />
+  <implementation name="IM_swizzle_vector4_color3_genglsl" nodedef="ND_swizzle_vector4_color3" target="genglsl" />
+  <implementation name="IM_swizzle_vector4_color4_genglsl" nodedef="ND_swizzle_vector4_color4" target="genglsl" />
+  <implementation name="IM_swizzle_vector4_vector2_genglsl" nodedef="ND_swizzle_vector4_vector2" target="genglsl" />
+  <implementation name="IM_swizzle_vector4_vector3_genglsl" nodedef="ND_swizzle_vector4_vector3" target="genglsl" />
+  <implementation name="IM_swizzle_vector4_vector4_genglsl" nodedef="ND_swizzle_vector4_vector4" target="genglsl" />
+
+  <!-- <combine> -->
+  <implementation name="IM_combine2_vector2_genglsl" nodedef="ND_combine2_vector2" target="genglsl" />
+  <implementation name="IM_combine2_color4CF_genglsl" nodedef="ND_combine2_color4CF" target="genglsl" />
+  <implementation name="IM_combine2_vector4VF_genglsl" nodedef="ND_combine2_vector4VF" target="genglsl" />
+  <implementation name="IM_combine2_vector4VV_genglsl" nodedef="ND_combine2_vector4VV" target="genglsl" />
+  <implementation name="IM_combine3_color3_genglsl" nodedef="ND_combine3_color3" target="genglsl" />
+  <implementation name="IM_combine3_vector3_genglsl" nodedef="ND_combine3_vector3" target="genglsl" />
+  <implementation name="IM_combine4_color4_genglsl" nodedef="ND_combine4_color4" target="genglsl" />
+  <implementation name="IM_combine4_vector4_genglsl" nodedef="ND_combine4_vector4" target="genglsl" />
+
+  <!-- <creatematrix> -->
+  <implementation name="IM_creatematrix_vector3_matrix33_genglsl" nodedef="ND_creatematrix_vector3_matrix33" file="mx_creatematrix_vector3_matrix33.glsl" function="mx_creatematrix_vector3_matrix33" target="genglsl" />
+  <implementation name="IM_creatematrix_vector3_matrix44_genglsl" nodedef="ND_creatematrix_vector3_matrix44" file="mx_creatematrix_vector3_matrix44.glsl" function="mx_creatematrix_vector3_matrix44" target="genglsl" />
+  <implementation name="IM_creatematrix_vector4_matrix44_genglsl" nodedef="ND_creatematrix_vector4_matrix44" file="mx_creatematrix_vector4_matrix44.glsl" function="mx_creatematrix_vector4_matrix44" target="genglsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Convolution nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <blur> -->
+  <implementation name="IM_blur_float_genglsl" nodedef="ND_blur_float" target="genglsl" />
+  <implementation name="IM_blur_color3_genglsl" nodedef="ND_blur_color3" target="genglsl" />
+  <implementation name="IM_blur_color4_genglsl" nodedef="ND_blur_color4" target="genglsl" />
+  <implementation name="IM_blur_vector2_genglsl" nodedef="ND_blur_vector2" target="genglsl" />
+  <implementation name="IM_blur_vector3_genglsl" nodedef="ND_blur_vector3" target="genglsl" />
+  <implementation name="IM_blur_vector4_genglsl" nodedef="ND_blur_vector4" target="genglsl" />
+
+  <!-- <heighttonormal> -->
+  <implementation name="IM_heighttonormal_vector3_genglsl" nodedef="ND_heighttonormal_vector3" target="genglsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Organization nodes                                                       -->
+  <!-- ======================================================================== -->
+
+  <!-- <dot> -->
+  <implementation name="IM_dot_float_genglsl" nodedef="ND_dot_float" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_color3_genglsl" nodedef="ND_dot_color3" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_color4_genglsl" nodedef="ND_dot_color4" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_vector2_genglsl" nodedef="ND_dot_vector2" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_vector3_genglsl" nodedef="ND_dot_vector3" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_vector4_genglsl" nodedef="ND_dot_vector4" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_integer_genglsl" nodedef="ND_dot_integer" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_boolean_genglsl" nodedef="ND_dot_boolean" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_matrix33_genglsl" nodedef="ND_dot_matrix33" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_matrix44_genglsl" nodedef="ND_dot_matrix44" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_string_genglsl" nodedef="ND_dot_string" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_filename_genglsl" nodedef="ND_dot_filename" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_surfaceshader_genglsl" nodedef="ND_dot_surfaceshader" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_displacementshader_genglsl" nodedef="ND_dot_displacementshader" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_volumeshader_genglsl" nodedef="ND_dot_volumeshader" target="genglsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_lightshader_genglsl" nodedef="ND_dot_lightshader" target="genglsl" sourcecode="{{in}}" />
+</materialx>

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmdl/stdlib_genmdl_impl.mtlx

@@ -0,0 +1,781 @@
+<?xml version="1.0"?>
+<materialx version="1.38">
+  <!--
+    Copyright Contributors to the MaterialX Project
+    SPDX-License-Identifier: Apache-2.0
+
+    Declarations for MDL implementations of standard nodes included in the MaterialX specification.
+  -->
+
+  <!-- ======================================================================== -->
+  <!-- Shader nodes                                                             -->
+  <!-- ======================================================================== -->
+
+  <!-- <surfacematerial> -->
+  <implementation name="IM_surfacematerial_genmdl" nodedef="ND_surfacematerial" target="genmdl" />
+
+  <!-- <surface_unlit> -->
+  <implementation name="IM_surface_unlit_genmdl" nodedef="ND_surface_unlit" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_surface_unlit({{emission}}, {{emission_color}}, {{transmission}}, {{transmission_color}}, {{opacity}})" target="genmdl" />
+
+  <!-- ======================================================================== -->
+  <!-- Texture nodes                                                            -->
+  <!-- ======================================================================== -->
+
+  <!-- <image> -->
+  <implementation name="IM_image_float_genmdl" nodedef="ND_image_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_image_float({{file}}, {{layer}}, {{default}}, {{texcoord}}, {{uaddressmode}}, {{vaddressmode}}, {{filtertype}}, {{framerange}}, {{frameoffset}}, {{frameendaction}}, mxp_flip_v:{{flip_v}})" target="genmdl">
+    <input name="default" type="float" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_color3_genmdl" nodedef="ND_image_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_image_color3({{file}}, {{layer}}, {{default}}, {{texcoord}}, {{uaddressmode}}, {{vaddressmode}}, {{filtertype}}, {{framerange}}, {{frameoffset}}, {{frameendaction}}, mxp_flip_v:{{flip_v}})" target="genmdl">
+    <input name="default" type="color3" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_color4_genmdl" nodedef="ND_image_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_image_color4({{file}}, {{layer}}, {{default}}, {{texcoord}}, {{uaddressmode}}, {{vaddressmode}}, {{filtertype}}, {{framerange}}, {{frameoffset}}, {{frameendaction}}, mxp_flip_v:{{flip_v}})" target="genmdl">
+    <input name="default" type="color4" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_vector2_genmdl" nodedef="ND_image_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_image_vector2({{file}}, {{layer}}, {{default}}, {{texcoord}}, {{uaddressmode}}, {{vaddressmode}}, {{filtertype}}, {{framerange}}, {{frameoffset}}, {{frameendaction}}, mxp_flip_v:{{flip_v}})" target="genmdl">
+    <input name="default" type="vector2" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_vector3_genmdl" nodedef="ND_image_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_image_vector3({{file}}, {{layer}}, {{default}}, {{texcoord}}, {{uaddressmode}}, {{vaddressmode}}, {{filtertype}}, {{framerange}}, {{frameoffset}}, {{frameendaction}}, mxp_flip_v:{{flip_v}})" target="genmdl">
+    <input name="default" type="vector3" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_vector4_genmdl" nodedef="ND_image_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_image_vector4({{file}}, {{layer}}, {{default}}, {{texcoord}}, {{uaddressmode}}, {{vaddressmode}}, {{filtertype}}, {{framerange}}, {{frameoffset}}, {{frameendaction}}, mxp_flip_v:{{flip_v}})" target="genmdl">
+    <input name="default" type="vector4" implname="default_value" />
+  </implementation>
+
+  <!-- <triplanarprojection> -->
+
+  <!-- <normalmap> -->
+  <implementation name="IM_normalmap_float_genmdl" nodedef="ND_normalmap" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_normalmap_float(mxp_in:{{in}}, mxp_space:{{space}}, mxp_scale:{{scale}}, mxp_normal:{{normal}}, mxp_tangent:{{tangent}})" target="genmdl" />
+  <implementation name="IM_normalmap_vector2_genmdl" nodedef="ND_normalmap_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_normalmap_vector2(mxp_in:{{in}}, mxp_space:{{space}}, mxp_scale:{{scale}}, mxp_normal:{{normal}}, mxp_tangent:{{tangent}})" target="genmdl" />
+
+  <!-- ======================================================================== -->
+  <!-- Procedural nodes                                                         -->
+  <!-- ======================================================================== -->
+
+  <!-- <constant> -->
+  <implementation name="IM_constant_float_genmdl" nodedef="ND_constant_float" sourcecode="{{value}}" target="genmdl" />
+  <implementation name="IM_constant_color3_genmdl" nodedef="ND_constant_color3" sourcecode="{{value}}" target="genmdl" />
+  <implementation name="IM_constant_color4_genmdl" nodedef="ND_constant_color4" sourcecode="{{value}}" target="genmdl" />
+  <implementation name="IM_constant_vector2_genmdl" nodedef="ND_constant_vector2" sourcecode="{{value}}" target="genmdl" />
+  <implementation name="IM_constant_vector3_genmdl" nodedef="ND_constant_vector3" sourcecode="{{value}}" target="genmdl" />
+  <implementation name="IM_constant_vector4_genmdl" nodedef="ND_constant_vector4" sourcecode="{{value}}" target="genmdl" />
+  <implementation name="IM_constant_boolean_genmdl" nodedef="ND_constant_boolean" sourcecode="{{value}}" target="genmdl" />
+  <implementation name="IM_constant_integer_genmdl" nodedef="ND_constant_integer" sourcecode="{{value}}" target="genmdl" />
+  <implementation name="IM_constant_matrix33_genmdl" nodedef="ND_constant_matrix33" sourcecode="{{value}}" target="genmdl" />
+  <implementation name="IM_constant_matrix44_genmdl" nodedef="ND_constant_matrix44" sourcecode="{{value}}" target="genmdl" />
+  <implementation name="IM_constant_string_genmdl" nodedef="ND_constant_string" sourcecode="{{value}}" target="genmdl" />
+  <implementation name="IM_constant_filename_genmdl" nodedef="ND_constant_filename" sourcecode="{{value}}" target="genmdl" />
+
+  <!-- <ramplr> -->
+  <implementation name="IM_ramplr_float_genmdl" nodedef="ND_ramplr_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramplr_float(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_ramplr_color3_genmdl" nodedef="ND_ramplr_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramplr_color3(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_ramplr_color4_genmdl" nodedef="ND_ramplr_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramplr_color4(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_ramplr_vector2_genmdl" nodedef="ND_ramplr_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramplr_vector2(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_ramplr_vector3_genmdl" nodedef="ND_ramplr_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramplr_vector3(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_ramplr_vector4_genmdl" nodedef="ND_ramplr_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramplr_vector4(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+
+  <!-- <ramptb> -->
+  <implementation name="IM_ramptb_float_genmdl" nodedef="ND_ramptb_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramptb_float(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_ramptb_color3_genmdl" nodedef="ND_ramptb_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramptb_color3(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_ramptb_color4_genmdl" nodedef="ND_ramptb_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramptb_color4(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_ramptb_vector2_genmdl" nodedef="ND_ramptb_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramptb_vector2(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_ramptb_vector3_genmdl" nodedef="ND_ramptb_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramptb_vector3(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_ramptb_vector4_genmdl" nodedef="ND_ramptb_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ramptb_vector4(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+
+  <!-- <splitlr> -->
+  <implementation name="IM_splitlr_float_genmdl" nodedef="ND_splitlr_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splitlr_float(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_splitlr_color3_genmdl" nodedef="ND_splitlr_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splitlr_color3(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_splitlr_color4_genmdl" nodedef="ND_splitlr_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splitlr_color4(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_splitlr_vector2_genmdl" nodedef="ND_splitlr_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splitlr_vector2(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_splitlr_vector3_genmdl" nodedef="ND_splitlr_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splitlr_vector3(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_splitlr_vector4_genmdl" nodedef="ND_splitlr_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splitlr_vector4(mxp_valuel:{{valuel}}, mxp_valuer:{{valuer}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+
+  <!-- <splittb> -->
+  <implementation name="IM_splittb_float_genmdl" nodedef="ND_splittb_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splittb_float(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_splittb_color3_genmdl" nodedef="ND_splittb_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splittb_color3(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_splittb_color4_genmdl" nodedef="ND_splittb_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splittb_color4(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_splittb_vector2_genmdl" nodedef="ND_splittb_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splittb_vector2(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_splittb_vector3_genmdl" nodedef="ND_splittb_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splittb_vector3(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_splittb_vector4_genmdl" nodedef="ND_splittb_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_splittb_vector4(mxp_valuet:{{valuet}}, mxp_valueb:{{valueb}}, mxp_center:{{center}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+
+  <!-- <noise2d> -->
+  <implementation name="IM_noise2d_float_genmdl" nodedef="ND_noise2d_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_noise2d_float(mxp_amplitude:{{amplitude}}, mxp_pivot:{{pivot}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_noise2d_vector2_genmdl" nodedef="ND_noise2d_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_noise2d_float2(mxp_amplitude:{{amplitude}}, mxp_pivot:{{pivot}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_noise2d_vector3_genmdl" nodedef="ND_noise2d_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_noise2d_float3(mxp_amplitude:{{amplitude}}, mxp_pivot:{{pivot}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+  <implementation name="IM_noise2d_vector4_genmdl" nodedef="ND_noise2d_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_noise2d_float4(mxp_amplitude:{{amplitude}}, mxp_pivot:{{pivot}}, mxp_texcoord:{{texcoord}})" target="genmdl" />
+
+  <!-- <noise3d> -->
+  <implementation name="IM_noise3d_float_genmdl" nodedef="ND_noise3d_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_noise3d_float(mxp_amplitude:{{amplitude}}, mxp_pivot:{{pivot}}, mxp_position:{{position}})" target="genmdl" />
+  <implementation name="IM_noise3d_vector2_genmdl" nodedef="ND_noise3d_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_noise3d_float2(mxp_amplitude:{{amplitude}}, mxp_pivot:{{pivot}}, mxp_position:{{position}})" target="genmdl" />
+  <implementation name="IM_noise3d_vector3_genmdl" nodedef="ND_noise3d_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_noise3d_float3(mxp_amplitude:{{amplitude}}, mxp_pivot:{{pivot}}, mxp_position:{{position}})" target="genmdl" />
+  <implementation name="IM_noise3d_vector4_genmdl" nodedef="ND_noise3d_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_noise3d_float4(mxp_amplitude:{{amplitude}}, mxp_pivot:{{pivot}}, mxp_position:{{position}})" target="genmdl" />
+
+  <!-- <fractal3d> -->
+  <implementation name="IM_fractal3d_float_genmdl" nodedef="ND_fractal3d_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_fractal3d_float(mxp_amplitude:{{amplitude}}, mxp_octaves:{{octaves}}, mxp_lacunarity:{{lacunarity}}, mxp_diminish:{{diminish}}, mxp_position:{{position}})" target="genmdl" />
+  <implementation name="IM_fractal3d_vector2_genmdl" nodedef="ND_fractal3d_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_fractal3d_float2(mxp_amplitude:{{amplitude}}, mxp_octaves:{{octaves}}, mxp_lacunarity:{{lacunarity}}, mxp_diminish:{{diminish}}, mxp_position:{{position}})" target="genmdl" />
+  <implementation name="IM_fractal3d_vector3_genmdl" nodedef="ND_fractal3d_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_fractal3d_float3(mxp_amplitude:{{amplitude}}, mxp_octaves:{{octaves}}, mxp_lacunarity:{{lacunarity}}, mxp_diminish:{{diminish}}, mxp_position:{{position}})" target="genmdl" />
+  <implementation name="IM_fractal3d_vector4_genmdl" nodedef="ND_fractal3d_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_fractal3d_float4(mxp_amplitude:{{amplitude}}, mxp_octaves:{{octaves}}, mxp_lacunarity:{{lacunarity}}, mxp_diminish:{{diminish}}, mxp_position:{{position}})" target="genmdl" />
+
+  <!-- <cellnoise2d> -->
+  <implementation name="IM_cellnoise2d_float_genmdl" nodedef="ND_cellnoise2d_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_cellnoise2d_float(mxp_texcoord:{{texcoord}})" target="genmdl" />
+
+  <!-- <cellnoise3d> -->
+  <implementation name="IM_cellnoise3d_float_genmdl" nodedef="ND_cellnoise3d_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_cellnoise3d_float(mxp_position:{{position}})" target="genmdl" />
+
+  <!-- <worleynoise2d> -->
+  <implementation name="IM_worleynoise2d_float_genmdl" nodedef="ND_worleynoise2d_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_worleynoise2d_float(mxp_texcoord:{{texcoord}}, mxp_jitter:{{jitter}})" target="genmdl" />
+  <implementation name="IM_worleynoise2d_vector2_genmdl" nodedef="ND_worleynoise2d_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_worleynoise2d_float2(mxp_texcoord:{{texcoord}}, mxp_jitter:{{jitter}})" target="genmdl" />
+  <implementation name="IM_worleynoise2d_vector3_genmdl" nodedef="ND_worleynoise2d_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_worleynoise2d_float3(mxp_texcoord:{{texcoord}}, mxp_jitter:{{jitter}})" target="genmdl" />
+
+  <!-- <worleynoise3d> -->
+  <implementation name="IM_worleynoise3d_float_genmdl" nodedef="ND_worleynoise3d_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_worleynoise3d_float(mxp_position:{{position}}, mxp_jitter:{{jitter}})" target="genmdl" />
+  <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" />
+
+  <!-- ======================================================================== -->
+  <!-- Global nodes                                                             -->
+  <!-- ======================================================================== -->
+
+  <!-- <ambientocclusion> -->
+  <implementation name="IM_ambientocclusion_float_genmdl" nodedef="ND_ambientocclusion_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ambientocclusion_float(mxp_coneangle:{{coneangle}}, mxp_maxdistance:{{maxdistance}})" target="genmdl" />
+
+  <!-- ======================================================================== -->
+  <!-- Geometric nodes                                                          -->
+  <!-- ======================================================================== -->
+
+  <!-- <position> -->
+  <implementation name="IM_position_vector3_genmdl" nodedef="ND_position_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_position_vector3(mxp_space:{{space}})" target="genmdl" />
+
+  <!-- <normal> -->
+  <implementation name="IM_normal_vector3_genmdl" nodedef="ND_normal_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_normal_vector3(mxp_space:{{space}})" target="genmdl" />
+
+  <!-- <tangent> -->
+  <implementation name="IM_tangent_vector3_genmdl" nodedef="ND_tangent_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_tangent_vector3(mxp_space:{{space}}, mxp_index:{{index}})" target="genmdl" />
+
+  <!-- <bitangent> -->
+  <implementation name="IM_bitangent_vector3_genmdl" nodedef="ND_bitangent_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_bitangent_vector3(mxp_space:{{space}}, mxp_index:{{index}})" target="genmdl" />
+
+  <!-- <texcoord> -->
+  <implementation name="IM_texcoord_vector2_genmdl" nodedef="ND_texcoord_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_texcoord_vector2(mxp_index:{{index}})" target="genmdl" />
+  <implementation name="IM_texcoord_vector3_genmdl" nodedef="ND_texcoord_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_texcoord_vector3(mxp_index:{{index}})" target="genmdl" />
+
+  <!-- <geomcolor> -->
+  <implementation name="IM_geomcolor_float_genmdl" nodedef="ND_geomcolor_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geomcolor_float(mxp_index:{{index}})" target="genmdl" />
+  <implementation name="IM_geomcolor_color3_genmdl" nodedef="ND_geomcolor_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geomcolor_color3(mxp_index:{{index}})" target="genmdl" />
+  <implementation name="IM_geomcolor_color4_genmdl" nodedef="ND_geomcolor_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geomcolor_color4(mxp_index:{{index}})" target="genmdl" />
+
+  <!-- <geompropvalue> -->
+  <implementation name="IM_geompropvalue_integer_genmdl" nodedef="ND_geompropvalue_integer" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geompropvalue_integer(mxp_geomprop:{{geomprop}}, mxp_default:{{default}})" target="genmdl" />
+  <implementation name="IM_geompropvalue_boolean_genmdl" nodedef="ND_geompropvalue_boolean" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geompropvalue_boolean(mxp_geomprop:{{geomprop}}, mxp_default:{{default}})" target="genmdl" />
+  <implementation name="IM_geompropvalue_string_genmdl" nodedef="ND_geompropvalue_string" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geompropvalue_string(mxp_geomprop:{{geomprop}}, mxp_default:{{default}})" target="genmdl" />
+  <implementation name="IM_geompropvalue_float_genmdl" nodedef="ND_geompropvalue_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geompropvalue_float(mxp_geomprop:{{geomprop}}, mxp_default:{{default}})" target="genmdl" />
+  <implementation name="IM_geompropvalue_color3_genmdl" nodedef="ND_geompropvalue_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geompropvalue_color3(mxp_geomprop:{{geomprop}}, mxp_default:{{default}})" target="genmdl" />
+  <implementation name="IM_geompropvalue_color4_genmdl" nodedef="ND_geompropvalue_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geompropvalue_color4(mxp_geomprop:{{geomprop}}, mxp_default:{{default}})" target="genmdl" />
+  <implementation name="IM_geompropvalue_vector2_genmdl" nodedef="ND_geompropvalue_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geompropvalue_vector2(mxp_geomprop:{{geomprop}}, mxp_default:{{default}})" target="genmdl" />
+  <implementation name="IM_geompropvalue_vector3_genmdl" nodedef="ND_geompropvalue_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geompropvalue_vector3(mxp_geomprop:{{geomprop}}, mxp_default:{{default}})" target="genmdl" />
+  <implementation name="IM_geompropvalue_vector4_genmdl" nodedef="ND_geompropvalue_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_geompropvalue_vector4(mxp_geomprop:{{geomprop}}, mxp_default:{{default}})" target="genmdl" />
+
+  <!-- ======================================================================== -->
+  <!-- Application nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <frame> -->
+  <implementation name="IM_frame_float_genmdl" nodedef="ND_frame_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_frame_float()" target="genmdl" />
+
+  <!-- <time> -->
+  <implementation name="IM_time_float_genmdl" nodedef="ND_time_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_time_float()" target="genmdl" />
+
+  <!-- ======================================================================== -->
+  <!-- Math nodes                                                               -->
+  <!-- ======================================================================== -->
+
+  <!-- <add> -->
+  <implementation name="IM_add_float_genmdl" nodedef="ND_add_float" sourcecode="{{in1}} + {{in2}}" target="genmdl" />
+  <implementation name="IM_add_color3_genmdl" nodedef="ND_add_color3" sourcecode="{{in1}} + {{in2}}" target="genmdl" />
+  <implementation name="IM_add_color3FA_genmdl" nodedef="ND_add_color3FA" sourcecode="{{in1}} + {{in2}}" target="genmdl" />
+  <implementation name="IM_add_color4_genmdl" nodedef="ND_add_color4" sourcecode="mx_add({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_add_color4FA_genmdl" nodedef="ND_add_color4FA" sourcecode="mx_add({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_add_vector2_genmdl" nodedef="ND_add_vector2" sourcecode="{{in1}} + {{in2}}" target="genmdl" />
+  <implementation name="IM_add_vector2FA_genmdl" nodedef="ND_add_vector2FA" sourcecode="{{in1}} + {{in2}}" target="genmdl" />
+  <implementation name="IM_add_vector3_genmdl" nodedef="ND_add_vector3" sourcecode="{{in1}} + {{in2}}" target="genmdl" />
+  <implementation name="IM_add_vector3FA_genmdl" nodedef="ND_add_vector3FA" sourcecode="{{in1}} + {{in2}}" target="genmdl" />
+  <implementation name="IM_add_vector4_genmdl" nodedef="ND_add_vector4" sourcecode="{{in1}} + {{in2}}" target="genmdl" />
+  <implementation name="IM_add_vector4FA_genmdl" nodedef="ND_add_vector4FA" sourcecode="{{in1}} + {{in2}}" target="genmdl" />
+  <implementation name="IM_add_matrix33_genmdl" nodedef="ND_add_matrix33" sourcecode="{{in1}} + {{in2}}" target="genmdl" />
+  <implementation name="IM_add_matrix33FA_genmdl" nodedef="ND_add_matrix33FA" sourcecode="{{in1}} + float3x3({{in2}})" target="genmdl" />
+  <implementation name="IM_add_matrix44_genmdl" nodedef="ND_add_matrix44" sourcecode="{{in1}} + {{in2}}" target="genmdl" />
+  <implementation name="IM_add_matrix44FA_genmdl" nodedef="ND_add_matrix44FA" sourcecode="{{in1}} + float4x4({{in2}})" target="genmdl" />
+
+  <!-- <subtract> -->
+  <implementation name="IM_subtract_float_genmdl" nodedef="ND_subtract_float" sourcecode="{{in1}} - {{in2}}" target="genmdl" />
+  <implementation name="IM_subtract_color3_genmdl" nodedef="ND_subtract_color3" sourcecode="{{in1}} - {{in2}}" target="genmdl" />
+  <implementation name="IM_subtract_color3FA_genmdl" nodedef="ND_subtract_color3FA" sourcecode="{{in1}} - {{in2}}" target="genmdl" />
+  <implementation name="IM_subtract_color4_genmdl" nodedef="ND_subtract_color4" sourcecode="mx_subtract({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_subtract_color4FA_genmdl" nodedef="ND_subtract_color4FA" sourcecode="mx_subtract({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_subtract_vector2_genmdl" nodedef="ND_subtract_vector2" sourcecode="{{in1}} - {{in2}}" target="genmdl" />
+  <implementation name="IM_subtract_vector2FA_genmdl" nodedef="ND_subtract_vector2FA" sourcecode="{{in1}} - {{in2}}" target="genmdl" />
+  <implementation name="IM_subtract_vector3_genmdl" nodedef="ND_subtract_vector3" sourcecode="{{in1}} - {{in2}}" target="genmdl" />
+  <implementation name="IM_subtract_vector3FA_genmdl" nodedef="ND_subtract_vector3FA" sourcecode="{{in1}} - {{in2}}" target="genmdl" />
+  <implementation name="IM_subtract_vector4_genmdl" nodedef="ND_subtract_vector4" sourcecode="{{in1}} - {{in2}}" target="genmdl" />
+  <implementation name="IM_subtract_vector4FA_genmdl" nodedef="ND_subtract_vector4FA" sourcecode="{{in1}} - {{in2}}" target="genmdl" />
+  <implementation name="IM_subtract_matrix33_genmdl" nodedef="ND_subtract_matrix33" sourcecode="{{in1}} - {{in2}}" target="genmdl" />
+  <implementation name="IM_subtract_matrix33FA_genmdl" nodedef="ND_subtract_matrix33FA" sourcecode="{{in1}} - float3x3({{in2}})" target="genmdl" />
+  <implementation name="IM_subtract_matrix44_genmdl" nodedef="ND_subtract_matrix44" sourcecode="{{in1}} - {{in2}}" target="genmdl" />
+  <implementation name="IM_subtract_matrix44FA_genmdl" nodedef="ND_subtract_matrix44FA" sourcecode="{{in1}} - float4x4({{in2}})" target="genmdl" />
+
+  <!-- <multiply> -->
+  <implementation name="IM_multiply_float_genmdl" nodedef="ND_multiply_float" sourcecode="{{in1}} * {{in2}}" target="genmdl" />
+  <implementation name="IM_multiply_color3_genmdl" nodedef="ND_multiply_color3" sourcecode="{{in1}} * {{in2}}" target="genmdl" />
+  <implementation name="IM_multiply_color3FA_genmdl" nodedef="ND_multiply_color3FA" sourcecode="{{in1}} * {{in2}}" target="genmdl" />
+  <implementation name="IM_multiply_color4_genmdl" nodedef="ND_multiply_color4" sourcecode="mx_multiply({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_multiply_color4FA_genmdl" nodedef="ND_multiply_color4FA" sourcecode="mx_multiply({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_multiply_vector2_genmdl" nodedef="ND_multiply_vector2" sourcecode="{{in1}} * {{in2}}" target="genmdl" />
+  <implementation name="IM_multiply_vector2FA_genmdl" nodedef="ND_multiply_vector2FA" sourcecode="{{in1}} * {{in2}}" target="genmdl" />
+  <implementation name="IM_multiply_vector3_genmdl" nodedef="ND_multiply_vector3" sourcecode="{{in1}} * {{in2}}" target="genmdl" />
+  <implementation name="IM_multiply_vector3FA_genmdl" nodedef="ND_multiply_vector3FA" sourcecode="{{in1}} * {{in2}}" target="genmdl" />
+  <implementation name="IM_multiply_vector4_genmdl" nodedef="ND_multiply_vector4" sourcecode="{{in1}} * {{in2}}" target="genmdl" />
+  <implementation name="IM_multiply_vector4FA_genmdl" nodedef="ND_multiply_vector4FA" sourcecode="{{in1}} * {{in2}}" target="genmdl" />
+  <implementation name="IM_multiply_matrix33_genmdl" nodedef="ND_multiply_matrix33" sourcecode="{{in1}} * {{in2}}" target="genmdl" />
+  <implementation name="IM_multiply_matrix44_genmdl" nodedef="ND_multiply_matrix44" sourcecode="{{in1}} * {{in2}}" target="genmdl" />
+
+  <!-- <divide> -->
+  <implementation name="IM_divide_float_genmdl" nodedef="ND_divide_float" sourcecode="{{in1}} / {{in2}}" target="genmdl" />
+  <implementation name="IM_divide_color3_genmdl" nodedef="ND_divide_color3" sourcecode="{{in1}} / {{in2}}" target="genmdl" />
+  <implementation name="IM_divide_color3FA_genmdl" nodedef="ND_divide_color3FA" sourcecode="{{in1}} / {{in2}}" target="genmdl" />
+  <implementation name="IM_divide_color4_genmdl" nodedef="ND_divide_color4" sourcecode="mx_divide({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_divide_color4FA_genmdl" nodedef="ND_divide_color4FA" sourcecode="mx_divide({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_divide_vector2_genmdl" nodedef="ND_divide_vector2" sourcecode="{{in1}} / {{in2}}" target="genmdl" />
+  <implementation name="IM_divide_vector2FA_genmdl" nodedef="ND_divide_vector2FA" sourcecode="{{in1}} / {{in2}}" target="genmdl" />
+  <implementation name="IM_divide_vector3_genmdl" nodedef="ND_divide_vector3" sourcecode="{{in1}} / {{in2}}" target="genmdl" />
+  <implementation name="IM_divide_vector3FA_genmdl" nodedef="ND_divide_vector3FA" sourcecode="{{in1}} / {{in2}}" target="genmdl" />
+  <implementation name="IM_divide_vector4_genmdl" nodedef="ND_divide_vector4" sourcecode="{{in1}} / {{in2}}" target="genmdl" />
+  <implementation name="IM_divide_vector4FA_genmdl" nodedef="ND_divide_vector4FA" sourcecode="{{in1}} / {{in2}}" target="genmdl" />
+  <implementation name="IM_divide_matrix33_genmdl" nodedef="ND_divide_matrix33" sourcecode="{{in1}}" target="genmdl" /> <!-- TODO: Implement properly -->
+  <implementation name="IM_divide_matrix44_genmdl" nodedef="ND_divide_matrix44" sourcecode="{{in1}}" target="genmdl" /> <!-- TODO: Implement properly -->
+
+  <!-- <modulo> -->
+  <implementation name="IM_modulo_float_genmdl" nodedef="ND_modulo_float" sourcecode="mx_mod({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_modulo_color3_genmdl" nodedef="ND_modulo_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_modulo_color3({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_modulo_color3FA_genmdl" nodedef="ND_modulo_color3FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_modulo_color3FA({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_modulo_color4_genmdl" nodedef="ND_modulo_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_modulo_color4({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_modulo_color4FA_genmdl" nodedef="ND_modulo_color4FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_modulo_color4FA({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_modulo_vector2_genmdl" nodedef="ND_modulo_vector2" sourcecode="mx_mod({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_modulo_vector2FA_genmdl" nodedef="ND_modulo_vector2FA" sourcecode="mx_mod({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_modulo_vector3_genmdl" nodedef="ND_modulo_vector3" sourcecode="mx_mod({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_modulo_vector3FA_genmdl" nodedef="ND_modulo_vector3FA" sourcecode="mx_mod({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_modulo_vector4_genmdl" nodedef="ND_modulo_vector4" sourcecode="mx_mod({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_modulo_vector4FA_genmdl" nodedef="ND_modulo_vector4FA" sourcecode="mx_mod({{in1}}, {{in2}})" target="genmdl" />
+
+  <!-- <invert> -->
+  <implementation name="IM_invert_float_genmdl" nodedef="ND_invert_float" sourcecode="{{amount}} - {{in}}" target="genmdl" />
+  <implementation name="IM_invert_color3_genmdl" nodedef="ND_invert_color3" sourcecode="{{amount}} - {{in}}" target="genmdl" />
+  <implementation name="IM_invert_color3FA_genmdl" nodedef="ND_invert_color3FA" sourcecode="{{amount}} - {{in}}" target="genmdl" />
+  <implementation name="IM_invert_color4_genmdl" nodedef="ND_invert_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_invert_color4({{in}}, {{amount}})" target="genmdl" />
+  <implementation name="IM_invert_color4FA_genmdl" nodedef="ND_invert_color4FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_invert_color4FA({{in}}, {{amount}})" target="genmdl" />
+  <implementation name="IM_invert_vector2_genmdl" nodedef="ND_invert_vector2" sourcecode="{{amount}} - {{in}}" target="genmdl" />
+  <implementation name="IM_invert_vector2FA_genmdl" nodedef="ND_invert_vector2FA" sourcecode="{{amount}} - {{in}}" target="genmdl" />
+  <implementation name="IM_invert_vector3_genmdl" nodedef="ND_invert_vector3" sourcecode="{{amount}} - {{in}}" target="genmdl" />
+  <implementation name="IM_invert_vector3FA_genmdl" nodedef="ND_invert_vector3FA" sourcecode="{{amount}} - {{in}}" target="genmdl" />
+  <implementation name="IM_invert_vector4_genmdl" nodedef="ND_invert_vector4" sourcecode="{{amount}} - {{in}}" target="genmdl" />
+  <implementation name="IM_invert_vector4FA_genmdl" nodedef="ND_invert_vector4FA" sourcecode="{{amount}} - {{in}}" target="genmdl" />
+
+  <!-- <absval> -->
+  <implementation name="IM_absval_float_genmdl" nodedef="ND_absval_float" sourcecode="math::abs({{in}})" target="genmdl" />
+  <implementation name="IM_absval_color3_genmdl" nodedef="ND_absval_color3" sourcecode="math::abs({{in}})" target="genmdl" />
+  <implementation name="IM_absval_color4_genmdl" nodedef="ND_absval_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_absval_color4({{in}})" target="genmdl" />
+  <implementation name="IM_absval_vector2_genmdl" nodedef="ND_absval_vector2" sourcecode="math::abs({{in}})" target="genmdl" />
+  <implementation name="IM_absval_vector3_genmdl" nodedef="ND_absval_vector3" sourcecode="math::abs({{in}})" target="genmdl" />
+  <implementation name="IM_absval_vector4_genmdl" nodedef="ND_absval_vector4" sourcecode="math::abs({{in}})" target="genmdl" />
+
+  <!-- <floor> -->
+  <implementation name="IM_floor_float_genmdl" nodedef="ND_floor_float" sourcecode="math::floor({{in}})" target="genmdl" />
+  <implementation name="IM_floor_color3_genmdl" nodedef="ND_floor_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_floor_color3({{in}})" target="genmdl" />
+  <implementation name="IM_floor_color4_genmdl" nodedef="ND_floor_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_floor_color4({{in}})" target="genmdl" />
+  <implementation name="IM_floor_vector2_genmdl" nodedef="ND_floor_vector2" sourcecode="math::floor({{in}})" target="genmdl" />
+  <implementation name="IM_floor_vector3_genmdl" nodedef="ND_floor_vector3" sourcecode="math::floor({{in}})" target="genmdl" />
+  <implementation name="IM_floor_vector4_genmdl" nodedef="ND_floor_vector4" sourcecode="math::floor({{in}})" target="genmdl" />
+  <implementation name="IM_floor_integer_genmdl" nodedef="ND_floor_integer" sourcecode="int(math::floor({{in}}))" target="genmdl" />
+
+  <!-- <ceil> -->
+  <implementation name="IM_ceil_float_genmdl" nodedef="ND_ceil_float" sourcecode="math::ceil({{in}})" target="genmdl" />
+  <implementation name="IM_ceil_color3_genmdl" nodedef="ND_ceil_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ceil_color3({{in}})" target="genmdl" />
+  <implementation name="IM_ceil_color4_genmdl" nodedef="ND_ceil_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ceil_color4({{in}})" target="genmdl" />
+  <implementation name="IM_ceil_vector2_genmdl" nodedef="ND_ceil_vector2" sourcecode="math::ceil({{in}})" target="genmdl" />
+  <implementation name="IM_ceil_vector3_genmdl" nodedef="ND_ceil_vector3" sourcecode="math::ceil({{in}})" target="genmdl" />
+  <implementation name="IM_ceil_vector4_genmdl" nodedef="ND_ceil_vector4" sourcecode="math::ceil({{in}})" target="genmdl" />
+  <implementation name="IM_ceil_integer_genmdl" nodedef="ND_ceil_integer" sourcecode="int(math::ceil({{in}}))" target="genmdl" />
+
+  <!-- <round> -->
+  <implementation name="IM_round_float_genmdl" nodedef="ND_round_float" sourcecode="math::round({{in}})" target="genmdl" />
+  <implementation name="IM_round_color3_genmdl" nodedef="ND_round_color3" sourcecode="mx::stdlib::mx_round_color3({{in}})" target="genmdl" />
+  <implementation name="IM_round_color4_genmdl" nodedef="ND_round_color4" sourcecode="mx::stdlib::mx_round_color4({{in}})" target="genmdl" />
+  <implementation name="IM_round_vector2_genmdl" nodedef="ND_round_vector2" sourcecode="math::round({{in}})" target="genmdl" />
+  <implementation name="IM_round_vector3_genmdl" nodedef="ND_round_vector3" sourcecode="math::round({{in}})" target="genmdl" />
+  <implementation name="IM_round_vector4_genmdl" nodedef="ND_round_vector4" sourcecode="math::round({{in}})" target="genmdl" />
+  <implementation name="IM_round_integer_genmdl" nodedef="ND_round_integer" sourcecode="int(math::round({{in}}))" target="genmdl" />
+
+  <!-- <power> -->
+  <implementation name="IM_power_float_genmdl" nodedef="ND_power_float" sourcecode="math::pow({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_power_color3_genmdl" nodedef="ND_power_color3" sourcecode="math::pow({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_power_color3FA_genmdl" nodedef="ND_power_color3FA" sourcecode="math::pow({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_power_color4_genmdl" nodedef="ND_power_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_power_color4({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_power_color4FA_genmdl" nodedef="ND_power_color4FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_power_color4FA({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_power_vector2_genmdl" nodedef="ND_power_vector2" sourcecode="math::pow({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_power_vector2FA_genmdl" nodedef="ND_power_vector2FA" sourcecode="math::pow({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_power_vector3_genmdl" nodedef="ND_power_vector3" sourcecode="math::pow({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_power_vector3FA_genmdl" nodedef="ND_power_vector3FA" sourcecode="math::pow({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_power_vector4_genmdl" nodedef="ND_power_vector4" sourcecode="math::pow({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_power_vector4FA_genmdl" nodedef="ND_power_vector4FA" sourcecode="math::pow({{in1}}, {{in2}})" target="genmdl" />
+
+  <!-- <sin>, <cos>, <tan>, <asin>, <acos>, <atan2> -->
+  <implementation name="IM_sin_float_genmdl" nodedef="ND_sin_float" sourcecode="math::sin({{in}})" target="genmdl" />
+  <implementation name="IM_cos_float_genmdl" nodedef="ND_cos_float" sourcecode="math::cos({{in}})" target="genmdl" />
+  <implementation name="IM_tan_float_genmdl" nodedef="ND_tan_float" sourcecode="math::tan({{in}})" target="genmdl" />
+  <implementation name="IM_asin_float_genmdl" nodedef="ND_asin_float" sourcecode="math::asin({{in}})" target="genmdl" />
+  <implementation name="IM_acos_float_genmdl" nodedef="ND_acos_float" sourcecode="math::acos({{in}})" target="genmdl" />
+  <implementation name="IM_atan2_float_genmdl" nodedef="ND_atan2_float" sourcecode="math::atan2({{in1}}, {{in2}})" target="genmdl" />
+
+  <implementation name="IM_sin_vector2_genmdl" nodedef="ND_sin_vector2" sourcecode="math::sin({{in}})" target="genmdl" />
+  <implementation name="IM_cos_vector2_genmdl" nodedef="ND_cos_vector2" sourcecode="math::cos({{in}})" target="genmdl" />
+  <implementation name="IM_tan_vector2_genmdl" nodedef="ND_tan_vector2" sourcecode="math::tan({{in}})" target="genmdl" />
+  <implementation name="IM_asin_vector2_genmdl" nodedef="ND_asin_vector2" sourcecode="math::asin({{in}})" target="genmdl" />
+  <implementation name="IM_acos_vector2_genmdl" nodedef="ND_acos_vector2" sourcecode="math::acos({{in}})" target="genmdl" />
+  <implementation name="IM_atan2_vector2_genmdl" nodedef="ND_atan2_vector2" sourcecode="math::atan2({{in1}}, {{in2}})" target="genmdl" />
+
+  <implementation name="IM_sin_vector3_genmdl" nodedef="ND_sin_vector3" sourcecode="math::sin({{in}})" target="genmdl" />
+  <implementation name="IM_cos_vector3_genmdl" nodedef="ND_cos_vector3" sourcecode="math::cos({{in}})" target="genmdl" />
+  <implementation name="IM_tan_vector3_genmdl" nodedef="ND_tan_vector3" sourcecode="math::tan({{in}})" target="genmdl" />
+  <implementation name="IM_asin_vector3_genmdl" nodedef="ND_asin_vector3" sourcecode="math::asin({{in}})" target="genmdl" />
+  <implementation name="IM_acos_vector3_genmdl" nodedef="ND_acos_vector3" sourcecode="math::acos({{in}})" target="genmdl" />
+  <implementation name="IM_atan2_vector3_genmdl" nodedef="ND_atan2_vector3" sourcecode="math::atan2({{in1}}, {{in2}})" target="genmdl" />
+
+  <implementation name="IM_sin_vector4_genmdl" nodedef="ND_sin_vector4" sourcecode="math::sin({{in}})" target="genmdl" />
+  <implementation name="IM_cos_vector4_genmdl" nodedef="ND_cos_vector4" sourcecode="math::cos({{in}})" target="genmdl" />
+  <implementation name="IM_tan_vector4_genmdl" nodedef="ND_tan_vector4" sourcecode="math::tan({{in}})" target="genmdl" />
+  <implementation name="IM_asin_vector4_genmdl" nodedef="ND_asin_vector4" sourcecode="math::asin({{in}})" target="genmdl" />
+  <implementation name="IM_acos_vector4_genmdl" nodedef="ND_acos_vector4" sourcecode="math::acos({{in}})" target="genmdl" />
+  <implementation name="IM_atan2_vector4_genmdl" nodedef="ND_atan2_vector4" sourcecode="math::atan2({{in1}}, {{in2}})" target="genmdl" />
+
+  <!-- <sqrt> -->
+  <implementation name="IM_sqrt_float_genmdl" nodedef="ND_sqrt_float" sourcecode="math::sqrt({{in}})" target="genmdl" />
+  <implementation name="IM_sqrt_vector2_genmdl" nodedef="ND_sqrt_vector2" sourcecode="math::sqrt({{in}})" target="genmdl" />
+  <implementation name="IM_sqrt_vector3_genmdl" nodedef="ND_sqrt_vector3" sourcecode="math::sqrt({{in}})" target="genmdl" />
+  <implementation name="IM_sqrt_vector4_genmdl" nodedef="ND_sqrt_vector4" sourcecode="math::sqrt({{in}})" target="genmdl" />
+
+  <!-- <ln> -->
+  <implementation name="IM_ln_float_genmdl" nodedef="ND_ln_float" sourcecode="math::log({{in}})" target="genmdl" />
+  <implementation name="IM_ln_vector2_genmdl" nodedef="ND_ln_vector2" sourcecode="math::log({{in}})" target="genmdl" />
+  <implementation name="IM_ln_vector3_genmdl" nodedef="ND_ln_vector3" sourcecode="math::log({{in}})" target="genmdl" />
+  <implementation name="IM_ln_vector4_genmdl" nodedef="ND_ln_vector4" sourcecode="math::log({{in}})" target="genmdl" />
+
+  <!-- <exp> -->
+  <implementation name="IM_exp_float_genmdl" nodedef="ND_exp_float" sourcecode="math::exp({{in}})" target="genmdl" />
+  <implementation name="IM_exp_vector2_genmdl" nodedef="ND_exp_vector2" sourcecode="math::exp({{in}})" target="genmdl" />
+  <implementation name="IM_exp_vector3_genmdl" nodedef="ND_exp_vector3" sourcecode="math::exp({{in}})" target="genmdl" />
+  <implementation name="IM_exp_vector4_genmdl" nodedef="ND_exp_vector4" sourcecode="math::exp({{in}})" target="genmdl" />
+
+  <!-- sign -->
+  <implementation name="IM_sign_float_genmdl" nodedef="ND_sign_float" sourcecode="math::sign({{in}})" target="genmdl" />
+  <implementation name="IM_sign_color3_genmdl" nodedef="ND_sign_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_sign_color3({{in}})" target="genmdl" />
+  <implementation name="IM_sign_color4_genmdl" nodedef="ND_sign_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_sign_color4({{in}})" target="genmdl" />
+  <implementation name="IM_sign_vector2_genmdl" nodedef="ND_sign_vector2" sourcecode="math::sign({{in}})" target="genmdl" />
+  <implementation name="IM_sign_vector3_genmdl" nodedef="ND_sign_vector3" sourcecode="math::sign({{in}})" target="genmdl" />
+  <implementation name="IM_sign_vector4_genmdl" nodedef="ND_sign_vector4" sourcecode="math::sign({{in}})" target="genmdl" />
+
+  <!-- <clamp> -->
+  <implementation name="IM_clamp_float_genmdl" nodedef="ND_clamp_float" sourcecode="math::clamp({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_clamp_color3_genmdl" nodedef="ND_clamp_color3" sourcecode="math::clamp({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_clamp_color3FA_genmdl" nodedef="ND_clamp_color3FA" sourcecode="math::clamp({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_clamp_color4_genmdl" nodedef="ND_clamp_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_clamp_color4({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_clamp_color4FA_genmdl" nodedef="ND_clamp_color4FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_clamp_color4FA({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_clamp_vector2_genmdl" nodedef="ND_clamp_vector2" sourcecode="math::clamp({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_clamp_vector2FA_genmdl" nodedef="ND_clamp_vector2FA" sourcecode="math::clamp({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_clamp_vector3_genmdl" nodedef="ND_clamp_vector3" sourcecode="math::clamp({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_clamp_vector3FA_genmdl" nodedef="ND_clamp_vector3FA" sourcecode="math::clamp({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_clamp_vector4_genmdl" nodedef="ND_clamp_vector4" sourcecode="math::clamp({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_clamp_vector4FA_genmdl" nodedef="ND_clamp_vector4FA" sourcecode="math::clamp({{in}}, {{low}}, {{high}})" target="genmdl" />
+
+  <!-- <min> -->
+  <implementation name="IM_min_float_genmdl" nodedef="ND_min_float" sourcecode="math::min({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_min_color3_genmdl" nodedef="ND_min_color3" sourcecode="math::min({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_min_color3FA_genmdl" nodedef="ND_min_color3FA" sourcecode="math::min({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_min_color4_genmdl" nodedef="ND_min_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_min_color4({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_min_color4FA_genmdl" nodedef="ND_min_color4FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_min_color4({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_min_vector2_genmdl" nodedef="ND_min_vector2" sourcecode="math::min({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_min_vector2FA_genmdl" nodedef="ND_min_vector2FA" sourcecode="math::min({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_min_vector3_genmdl" nodedef="ND_min_vector3" sourcecode="math::min({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_min_vector3FA_genmdl" nodedef="ND_min_vector3FA" sourcecode="math::min({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_min_vector4_genmdl" nodedef="ND_min_vector4" sourcecode="math::min({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_min_vector4FA_genmdl" nodedef="ND_min_vector4FA" sourcecode="math::min({{in1}}, {{in2}})" target="genmdl" />
+
+  <!-- <max> -->
+  <implementation name="IM_max_float_genmdl" nodedef="ND_max_float" sourcecode="math::max({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_max_color3_genmdl" nodedef="ND_max_color3" sourcecode="math::max({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_max_color3FA_genmdl" nodedef="ND_max_color3FA" sourcecode="math::max({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_max_color4_genmdl" nodedef="ND_max_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_max_color4({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_max_color4FA_genmdl" nodedef="ND_max_color4FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_max_color4({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_max_vector2_genmdl" nodedef="ND_max_vector2" sourcecode="math::max({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_max_vector2FA_genmdl" nodedef="ND_max_vector2FA" sourcecode="math::max({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_max_vector3_genmdl" nodedef="ND_max_vector3" sourcecode="math::max({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_max_vector3FA_genmdl" nodedef="ND_max_vector3FA" sourcecode="math::max({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_max_vector4_genmdl" nodedef="ND_max_vector4" sourcecode="math::max({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_max_vector4FA_genmdl" nodedef="ND_max_vector4FA" sourcecode="math::max({{in1}}, {{in2}})" target="genmdl" />
+
+  <!-- <normalize> -->
+  <implementation name="IM_normalize_vector2_genmdl" nodedef="ND_normalize_vector2" sourcecode="math::normalize({{in}})" target="genmdl" />
+  <implementation name="IM_normalize_vector3_genmdl" nodedef="ND_normalize_vector3" sourcecode="math::normalize({{in}})" target="genmdl" />
+  <implementation name="IM_normalize_vector4_genmdl" nodedef="ND_normalize_vector4" sourcecode="math::normalize({{in}})" target="genmdl" />
+
+  <!-- <magnitude> -->
+  <implementation name="IM_magnitude_vector2_genmdl" nodedef="ND_magnitude_vector2" sourcecode="math::length({{in}})" target="genmdl" />
+  <implementation name="IM_magnitude_vector3_genmdl" nodedef="ND_magnitude_vector3" sourcecode="math::length({{in}})" target="genmdl" />
+  <implementation name="IM_magnitude_vector4_genmdl" nodedef="ND_magnitude_vector4" sourcecode="math::length({{in}})" target="genmdl" />
+
+  <!-- <dotproduct> -->
+  <implementation name="IM_dotproduct_vector2_genmdl" nodedef="ND_dotproduct_vector2" sourcecode="math::dot({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_dotproduct_vector3_genmdl" nodedef="ND_dotproduct_vector3" sourcecode="math::dot({{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_dotproduct_vector4_genmdl" nodedef="ND_dotproduct_vector4" sourcecode="math::dot({{in1}}, {{in2}})" target="genmdl" />
+
+  <!-- <crossproduct> -->
+  <implementation name="IM_crossproduct_vector3_genmdl" nodedef="ND_crossproduct_vector3" sourcecode="math::cross({{in1}}, {{in2}})" target="genmdl" />
+
+  <!-- <transformpoint> -->
+  <implementation name="IM_transformpoint_vector3_genmdl" nodedef="ND_transformpoint_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_transformpoint_vector3({{in}}, {{fromspace}}, {{tospace}})" target="genmdl" />
+
+  <!-- <transformvector> -->
+  <implementation name="IM_transformvector_vector3_genmdl" nodedef="ND_transformvector_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_transformvector_vector3({{in}}, {{fromspace}}, {{tospace}})" target="genmdl" />
+
+  <!-- <transformnormal> -->
+  <implementation name="IM_transformnormal_vector3_genmdl" nodedef="ND_transformnormal_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_transformnormal_vector3({{in}}, {{fromspace}}, {{tospace}})" target="genmdl" />
+
+  <!-- <transformmatrix> -->
+  <implementation name="IM_transformmatrix_vector2M3_genmdl" nodedef="ND_transformmatrix_vector2M3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_transformmatrix_vector2M3({{in}}, {{mat}})" target="genmdl" />
+  <implementation name="IM_transformmatrix_vector3_genmdl" nodedef="ND_transformmatrix_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_transformmatrix_vector3({{in}}, {{mat}})" target="genmdl" />
+  <implementation name="IM_transformmatrix_vector3M4_genmdl" nodedef="ND_transformmatrix_vector3M4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_transformmatrix_vector3M4({{in}}, {{mat}})" target="genmdl" />
+  <implementation name="IM_transformmatrix_vector4_genmdl" nodedef="ND_transformmatrix_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_transformmatrix_vector4({{in}}, {{mat}})" target="genmdl" />
+
+  <!-- <transpose> -->
+  <implementation name="IM_transpose_matrix33_genmdl" nodedef="ND_transpose_matrix33" sourcecode="math::transpose({{in}})" target="genmdl" />
+  <implementation name="IM_transpose_matrix44_genmdl" nodedef="ND_transpose_matrix44" sourcecode="math::transpose({{in}})" target="genmdl" />
+
+  <!-- <determinant> -->
+  <implementation name="IM_determinant_matrix33_genmdl" nodedef="ND_determinant_matrix33" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_determinant_matrix33({{in}})" target="genmdl" />
+  <implementation name="IM_determinant_matrix44_genmdl" nodedef="ND_determinant_matrix44" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_determinant_matrix44({{in}})" target="genmdl" />
+
+  <!-- <invertmatrix> -->
+  <implementation name="IM_invertmatrix_matrix33_genmdl" nodedef="ND_invertmatrix_matrix33" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_invertmatrix_matrix33({{in}})" target="genmdl" />
+  <implementation name="IM_invertmatrix_matrix44_genmdl" nodedef="ND_invertmatrix_matrix44" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_invertmatrix_matrix44({{in}})" target="genmdl" />
+
+  <!-- <rotate2d> -->
+  <implementation name="IM_rotate2d_vector2_genmdl" nodedef="ND_rotate2d_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_rotate2d_vector2(mxp_in:{{in}}, mxp_amount:{{amount}})" target="genmdl" />
+
+  <!-- <rotate3d> -->
+  <implementation name="IM_rotate3d_vector3_genmdl" nodedef="ND_rotate3d_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_rotate3d_vector3(mxp_in:{{in}}, mxp_amount:{{amount}}, mxp_axis:{{axis}})" target="genmdl" />
+
+  <!-- ======================================================================== -->
+  <!-- Adjustment nodes                                                         -->
+  <!-- ======================================================================== -->
+
+  <!-- <contrast> implemented by nodegraph -->
+
+  <!-- <remap> implemented -->
+  <implementation name="IM_remap_float_genmdl" nodedef="ND_remap_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_remap_float({{in}}, {{inlow}}, {{inhigh}}, {{outlow}}, {{outhigh}})" target="genmdl" />
+  <implementation name="IM_remap_color3_genmdl" nodedef="ND_remap_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_remap_color3({{in}}, {{inlow}}, {{inhigh}}, {{outlow}}, {{outhigh}})" target="genmdl" />
+  <implementation name="IM_remap_color4_genmdl" nodedef="ND_remap_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_remap_color4({{in}}, {{inlow}}, {{inhigh}}, {{outlow}}, {{outhigh}})" target="genmdl" />
+  <implementation name="IM_remap_vector2_genmdl" nodedef="ND_remap_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_remap_vector2({{in}}, {{inlow}}, {{inhigh}}, {{outlow}}, {{outhigh}})" target="genmdl" />
+  <implementation name="IM_remap_vector3_genmdl" nodedef="ND_remap_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_remap_vector3({{in}}, {{inlow}}, {{inhigh}}, {{outlow}}, {{outhigh}})" target="genmdl" />
+  <implementation name="IM_remap_vector4_genmdl" nodedef="ND_remap_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_remap_vector4({{in}}, {{inlow}}, {{inhigh}}, {{outlow}}, {{outhigh}})" target="genmdl" />
+  <implementation name="IM_remap_color3FA_genmdl" nodedef="ND_remap_color3FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_remap_color3FA({{in}}, {{inlow}}, {{inhigh}}, {{outlow}}, {{outhigh}})" target="genmdl" />
+  <implementation name="IM_remap_color4FA_genmdl" nodedef="ND_remap_color4FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_remap_color4FA({{in}}, {{inlow}}, {{inhigh}}, {{outlow}}, {{outhigh}})" target="genmdl" />
+  <implementation name="IM_remap_vector2FA_genmdl" nodedef="ND_remap_vector2FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_remap_vector2FA({{in}}, {{inlow}}, {{inhigh}}, {{outlow}}, {{outhigh}})" target="genmdl" />
+  <implementation name="IM_remap_vector3FA_genmdl" nodedef="ND_remap_vector3FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_remap_vector3FA({{in}}, {{inlow}}, {{inhigh}}, {{outlow}}, {{outhigh}})" target="genmdl" />
+  <implementation name="IM_remap_vector4FA_genmdl" nodedef="ND_remap_vector4FA" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_remap_vector4FA({{in}}, {{inlow}}, {{inhigh}}, {{outlow}}, {{outhigh}})" target="genmdl" />
+
+  <!-- <smoothstep> -->
+  <implementation name="IM_smoothstep_float_genmdl" nodedef="ND_smoothstep_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_smoothstep_float({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_smoothstep_vector2_genmdl" nodedef="ND_smoothstep_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_smoothstep_vector2({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_smoothstep_vector3_genmdl" nodedef="ND_smoothstep_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_smoothstep_vector3({{in}}, {{low}}, {{high}})" target="genmdl" />
+  <implementation name="IM_smoothstep_vector4_genmdl" nodedef="ND_smoothstep_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_smoothstep_vector4({{in}}, {{low}}, {{high}})" target="genmdl" />
+
+  <!-- <saturate> implemented by nodegraph -->
+
+  <!-- <luminance>  -->
+  <implementation name="IM_luminance_color3_genmdl" nodedef="ND_luminance_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_luminance_color3({{in}})" target="genmdl" />
+  <implementation name="IM_luminance_color4_genmdl" nodedef="ND_luminance_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_luminance_color4({{in}})" target="genmdl" />
+
+  <!-- <rgbtohsv> -->
+  <implementation name="IM_rgbtohsv_color3_genmdl" nodedef="ND_rgbtohsv_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_rgbtohsv_color3({{in}})" target="genmdl" />
+  <implementation name="IM_rgbtohsv_color4_genmdl" nodedef="ND_rgbtohsv_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_rgbtohsv_color4({{in}})" target="genmdl" />
+
+  <!-- <hsvtorgb> -->
+  <implementation name="IM_hsvtorgb_color3_genmdl" nodedef="ND_hsvtorgb_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_hsvtorgb_color3({{in}})" target="genmdl" />
+  <implementation name="IM_hsvtorgb_color4_genmdl" nodedef="ND_hsvtorgb_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_hsvtorgb_color4({{in}})" target="genmdl" />
+
+  <!-- ======================================================================== -->
+  <!-- Compositing nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <premult> -->
+  <implementation name="IM_premult_color4_genmdl" nodedef="ND_premult_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_premult_color4({{in}})" target="genmdl" />
+
+  <!-- <unpremult> -->
+  <implementation name="IM_unpremult_color4_genmdl" nodedef="ND_unpremult_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_unpremult_color4({{in}})" target="genmdl" />
+
+  <!-- <plus> -->
+  <implementation name="IM_plus_float_genmdl" nodedef="ND_plus_float" sourcecode="({{mix}}*({{bg}} + {{fg}})) + ((1.0-{{mix}})*{{bg}})" target="genmdl" />
+  <implementation name="IM_plus_color3_genmdl" nodedef="ND_plus_color3" sourcecode="({{mix}}*({{bg}} + {{fg}})) + ((1.0-{{mix}})*{{bg}})" target="genmdl" />
+  <implementation name="IM_plus_color4_genmdl" nodedef="ND_plus_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_plus_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <minus> -->
+  <implementation name="IM_minus_float_genmdl" nodedef="ND_minus_float" sourcecode="({{mix}}*({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" target="genmdl" />
+  <implementation name="IM_minus_color3_genmdl" nodedef="ND_minus_color3" sourcecode="({{mix}}*({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" target="genmdl" />
+  <implementation name="IM_minus_color4_genmdl" nodedef="ND_minus_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_minus_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <difference> -->
+  <implementation name="IM_difference_float_genmdl" nodedef="ND_difference_float" sourcecode="({{mix}}*math::abs({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" target="genmdl" />
+  <implementation name="IM_difference_color3_genmdl" nodedef="ND_difference_color3" sourcecode="({{mix}}*math::abs({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" target="genmdl" />
+  <implementation name="IM_difference_color4_genmdl" nodedef="ND_difference_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_difference_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <burn> -->
+  <implementation name="IM_burn_float_genmdl" nodedef="ND_burn_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_burn_float({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_burn_color3_genmdl" nodedef="ND_burn_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_burn_color3({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_burn_color4_genmdl" nodedef="ND_burn_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_burn_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <dodge> -->
+  <implementation name="IM_dodge_float_genmdl" nodedef="ND_dodge_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_dodge_float({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_dodge_color3_genmdl" nodedef="ND_dodge_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_dodge_color3({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_dodge_color4_genmdl" nodedef="ND_dodge_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_dodge_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <screen> -->
+  <implementation name="IM_screen_float_genmdl" nodedef="ND_screen_float" sourcecode="({{mix}}*((1.0 - (1.0 - {{fg}}) * (1 - {{bg}})))) + ((1.0-{{mix}})*{{bg}})" target="genmdl" />
+  <implementation name="IM_screen_color3_genmdl" nodedef="ND_screen_color3" sourcecode="({{mix}}*((1.0 - (1.0 - {{fg}}) * (1 - {{bg}})))) + ((1.0-{{mix}})*{{bg}})" target="genmdl" />
+  <implementation name="IM_screen_color4_genmdl" nodedef="ND_screen_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_screen_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <disjointover> -->
+  <implementation name="IM_disjointover_color4_genmdl" nodedef="ND_disjointover_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_disjointover_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <in> -->
+  <implementation name="IM_in_color4_genmdl" nodedef="ND_in_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_in_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <mask> -->
+  <implementation name="IM_mask_color4_genmdl" nodedef="ND_mask_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_mask_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <matte> -->
+  <implementation name="IM_matte_color4_genmdl" nodedef="ND_matte_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_matte_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <out> -->
+  <implementation name="IM_out_color4_genmdl" nodedef="ND_out_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_out_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <over> -->
+  <implementation name="IM_over_color4_genmdl" nodedef="ND_over_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_over_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- <inside> -->
+  <implementation name="IM_inside_float_genmdl" nodedef="ND_inside_float" sourcecode="{{in}} * {{mask}}" target="genmdl" />
+  <implementation name="IM_inside_color3_genmdl" nodedef="ND_inside_color3" sourcecode="{{in}} * {{mask}}" target="genmdl" />
+  <implementation name="IM_inside_color4_genmdl" nodedef="ND_inside_color4" sourcecode="mx_multiply({{in}}, {{mask}})" target="genmdl" />
+
+  <!-- <outside> -->
+  <implementation name="IM_outside_float_genmdl" nodedef="ND_outside_float" sourcecode="{{in}} * (1.0 - {{mask}})" target="genmdl" />
+  <implementation name="IM_outside_color3_genmdl" nodedef="ND_outside_color3" sourcecode="{{in}} * (1.0 - {{mask}})" target="genmdl" />
+  <implementation name="IM_outside_color4_genmdl" nodedef="ND_outside_color4" sourcecode="mx_multiply({{in}}, 1.0 - {{mask}})" target="genmdl" />
+
+  <!-- <mix> -->
+  <implementation name="IM_mix_float_genmdl" nodedef="ND_mix_float" sourcecode="math::lerp({{bg}}, {{fg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_color3_genmdl" nodedef="ND_mix_color3" sourcecode="math::lerp({{bg}}, {{fg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_color3_color3_genmdl" nodedef="ND_mix_color3_color3" sourcecode="math::lerp({{bg}}, {{fg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_color4_genmdl" nodedef="ND_mix_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_mix_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_color4_color4_genmdl" nodedef="ND_mix_color4_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_mix_color4_color4({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_vector2_genmdl" nodedef="ND_mix_vector2" sourcecode="math::lerp({{bg}}, {{fg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_vector2_vector2_genmdl" nodedef="ND_mix_vector2_vector2" sourcecode="math::lerp({{bg}}, {{fg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_vector3_genmdl" nodedef="ND_mix_vector3" sourcecode="math::lerp({{bg}}, {{fg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_vector3_vector3_genmdl" nodedef="ND_mix_vector3_vector3" sourcecode="math::lerp({{bg}}, {{fg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_vector4_genmdl" nodedef="ND_mix_vector4" sourcecode="math::lerp({{bg}}, {{fg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_vector4_vector4_genmdl" nodedef="ND_mix_vector4_vector4" sourcecode="math::lerp({{bg}}, {{fg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_surfaceshader_genmdl" nodedef="ND_mix_surfaceshader" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_mix_surfaceshader({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_volumeshader_genmdl" nodedef="ND_mix_volumeshader" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_mix_volumeshader({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+  <implementation name="IM_mix_displacementshader_genmdl" nodedef="ND_mix_displacementshader" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_mix_displacementshader({{fg}}, {{bg}}, {{mix}})" target="genmdl" />
+
+  <!-- ======================================================================== -->
+  <!-- Conditional nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <ifgreater> -->
+  <implementation name="IM_ifgreater_float_genmdl" nodedef="ND_ifgreater_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_float({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreater_color3_genmdl" nodedef="ND_ifgreater_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_color3({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreater_color4_genmdl" nodedef="ND_ifgreater_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_color4({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreater_vector2_genmdl" nodedef="ND_ifgreater_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_vector2({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreater_vector3_genmdl" nodedef="ND_ifgreater_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_vector3({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreater_vector4_genmdl" nodedef="ND_ifgreater_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_vector4({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreater_floatI_genmdl" nodedef="ND_ifgreater_floatI" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_floatI({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreater_color3I_genmdl" nodedef="ND_ifgreater_color3I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_color3I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreater_color4I_genmdl" nodedef="ND_ifgreater_color4I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_color4I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreater_vector2I_genmdl" nodedef="ND_ifgreater_vector2I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_vector2I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreater_vector3I_genmdl" nodedef="ND_ifgreater_vector3I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_vector3I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreater_vector4I_genmdl" nodedef="ND_ifgreater_vector4I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreater_vector4I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+
+  <!-- <ifgreatereq> -->
+  <implementation name="IM_ifgreatereq_float_genmdl" nodedef="ND_ifgreatereq_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_float({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreatereq_color3_genmdl" nodedef="ND_ifgreatereq_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_color3({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreatereq_color4_genmdl" nodedef="ND_ifgreatereq_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_color4({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreatereq_vector2_genmdl" nodedef="ND_ifgreatereq_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_vector2({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreatereq_vector3_genmdl" nodedef="ND_ifgreatereq_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_vector3({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreatereq_vector4_genmdl" nodedef="ND_ifgreatereq_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_vector4({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreatereq_floatI_genmdl" nodedef="ND_ifgreatereq_floatI" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_floatI({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreatereq_color3I_genmdl" nodedef="ND_ifgreatereq_color3I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_color3I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreatereq_color4I_genmdl" nodedef="ND_ifgreatereq_color4I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_color4I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreatereq_vector2I_genmdl" nodedef="ND_ifgreatereq_vector2I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_vector2I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreatereq_vector3I_genmdl" nodedef="ND_ifgreatereq_vector3I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_vector3I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifgreatereq_vector4I_genmdl" nodedef="ND_ifgreatereq_vector4I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifgreatereq_vector4I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+
+  <!-- <ifequal> -->
+  <implementation name="IM_ifequal_float_genmdl" nodedef="ND_ifequal_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_float({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_color3_genmdl" nodedef="ND_ifequal_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_color3({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_color4_genmdl" nodedef="ND_ifequal_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_color4({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_vector2_genmdl" nodedef="ND_ifequal_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_vector2({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_vector3_genmdl" nodedef="ND_ifequal_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_vector3({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_vector4_genmdl" nodedef="ND_ifequal_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_vector4({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_floatI_genmdl" nodedef="ND_ifequal_floatI" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_floatI({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_color3I_genmdl" nodedef="ND_ifequal_color3I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_color3I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_color4I_genmdl" nodedef="ND_ifequal_color4I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_color4I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_vector2I_genmdl" nodedef="ND_ifequal_vector2I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_vector2I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_vector3I_genmdl" nodedef="ND_ifequal_vector3I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_vector3I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_vector4I_genmdl" nodedef="ND_ifequal_vector4I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_vector4I({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_floatB_genmdl" nodedef="ND_ifequal_floatB" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_floatB({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_color3B_genmdl" nodedef="ND_ifequal_color3B" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_color3B({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_color4B_genmdl" nodedef="ND_ifequal_color4B" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_color4B({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_vector2B_genmdl" nodedef="ND_ifequal_vector2B" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_vector2B({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_vector3B_genmdl" nodedef="ND_ifequal_vector3B" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_vector3B({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+  <implementation name="IM_ifequal_vector4B_genmdl" nodedef="ND_ifequal_vector4B" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_ifequal_vector4B({{value1}}, {{value2}}, {{in1}}, {{in2}})" target="genmdl" />
+
+  <!-- <switch> -->
+  <!-- 'which' type : float -->
+  <implementation name="IM_switch_float_genmdl" nodedef="ND_switch_float" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_float({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+  <implementation name="IM_switch_color3_genmdl" nodedef="ND_switch_color3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_color3({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+  <implementation name="IM_switch_color4_genmdl" nodedef="ND_switch_color4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_color4({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+  <implementation name="IM_switch_vector2_genmdl" nodedef="ND_switch_vector2" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_vector2({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+  <implementation name="IM_switch_vector3_genmdl" nodedef="ND_switch_vector3" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_vector3({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+  <implementation name="IM_switch_vector4_genmdl" nodedef="ND_switch_vector4" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_vector4({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+  <!-- 'which' type : integer -->
+  <implementation name="IM_switch_floatI_genmdl" nodedef="ND_switch_floatI" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_floatI({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+  <implementation name="IM_switch_color3I_genmdl" nodedef="ND_switch_color3I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_color3I({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+  <implementation name="IM_switch_color4I_genmdl" nodedef="ND_switch_color4I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_color4I({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+  <implementation name="IM_switch_vector2I_genmdl" nodedef="ND_switch_vector2I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_vector2I({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+  <implementation name="IM_switch_vector3I_genmdl" nodedef="ND_switch_vector3I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_vector3I({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+  <implementation name="IM_switch_vector4I_genmdl" nodedef="ND_switch_vector4I" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_switch_vector4I({{in1}}, {{in2}}, {{in3}}, {{in4}}, {{in5}}, {{which}})" target="genmdl" />
+
+  <!-- ======================================================================== -->
+  <!-- Channel nodes                                                            -->
+  <!-- ======================================================================== -->
+
+  <!-- <convert> -->
+  <implementation name="IM_convert_float_color3_genmdl" nodedef="ND_convert_float_color3" target="genmdl" />
+  <implementation name="IM_convert_float_color4_genmdl" nodedef="ND_convert_float_color4" target="genmdl" />
+  <implementation name="IM_convert_float_vector2_genmdl" nodedef="ND_convert_float_vector2" target="genmdl" />
+  <implementation name="IM_convert_float_vector3_genmdl" nodedef="ND_convert_float_vector3" target="genmdl" />
+  <implementation name="IM_convert_float_vector4_genmdl" nodedef="ND_convert_float_vector4" target="genmdl" />
+  <implementation name="IM_convert_vector2_vector3_genmdl" nodedef="ND_convert_vector2_vector3" target="genmdl" />
+  <implementation name="IM_convert_vector3_color3_genmdl" nodedef="ND_convert_vector3_color3" target="genmdl" />
+  <implementation name="IM_convert_vector3_vector2_genmdl" nodedef="ND_convert_vector3_vector2" target="genmdl" />
+  <implementation name="IM_convert_vector3_vector4_genmdl" nodedef="ND_convert_vector3_vector4" target="genmdl" />
+  <implementation name="IM_convert_vector4_color4_genmdl" nodedef="ND_convert_vector4_color4" target="genmdl" />
+  <implementation name="IM_convert_vector4_vector3_genmdl" nodedef="ND_convert_vector4_vector3" target="genmdl" />
+  <implementation name="IM_convert_color3_vector3_genmdl" nodedef="ND_convert_color3_vector3" target="genmdl" />
+  <implementation name="IM_convert_color4_vector4_genmdl" nodedef="ND_convert_color4_vector4" target="genmdl" />
+  <implementation name="IM_convert_color3_color4_genmdl" nodedef="ND_convert_color3_color4" target="genmdl" />
+  <implementation name="IM_convert_color4_color3_genmdl" nodedef="ND_convert_color4_color3" target="genmdl" />
+  <implementation name="IM_convert_boolean_float_genmdl" nodedef="ND_convert_boolean_float" target="genmdl" />
+  <implementation name="IM_convert_integer_float_genmdl" nodedef="ND_convert_integer_float" target="genmdl" />
+
+  <!-- <swizzle> -->
+  <implementation name="IM_swizzle_float_color3_genmdl" nodedef="ND_swizzle_float_color3" target="genmdl" />
+  <implementation name="IM_swizzle_float_color4_genmdl" nodedef="ND_swizzle_float_color4" target="genmdl" />
+  <implementation name="IM_swizzle_float_vector2_genmdl" nodedef="ND_swizzle_float_vector2" target="genmdl" />
+  <implementation name="IM_swizzle_float_vector3_genmdl" nodedef="ND_swizzle_float_vector3" target="genmdl" />
+  <implementation name="IM_swizzle_float_vector4_genmdl" nodedef="ND_swizzle_float_vector4" target="genmdl" />
+  <implementation name="IM_swizzle_color3_float_genmdl" nodedef="ND_swizzle_color3_float" target="genmdl" />
+  <implementation name="IM_swizzle_color3_color3_genmdl" nodedef="ND_swizzle_color3_color3" target="genmdl" />
+  <implementation name="IM_swizzle_color3_color4_genmdl" nodedef="ND_swizzle_color3_color4" target="genmdl" />
+  <implementation name="IM_swizzle_color3_vector2_genmdl" nodedef="ND_swizzle_color3_vector2" target="genmdl" />
+  <implementation name="IM_swizzle_color3_vector3_genmdl" nodedef="ND_swizzle_color3_vector3" target="genmdl" />
+  <implementation name="IM_swizzle_color3_vector4_genmdl" nodedef="ND_swizzle_color3_vector4" target="genmdl" />
+  <implementation name="IM_swizzle_color4_float_genmdl" nodedef="ND_swizzle_color4_float" target="genmdl" />
+  <implementation name="IM_swizzle_color4_color3_genmdl" nodedef="ND_swizzle_color4_color3" target="genmdl" />
+  <implementation name="IM_swizzle_color4_color4_genmdl" nodedef="ND_swizzle_color4_color4" target="genmdl" />
+  <implementation name="IM_swizzle_color4_vector2_genmdl" nodedef="ND_swizzle_color4_vector2" target="genmdl" />
+  <implementation name="IM_swizzle_color4_vector3_genmdl" nodedef="ND_swizzle_color4_vector3" target="genmdl" />
+  <implementation name="IM_swizzle_color4_vector4_genmdl" nodedef="ND_swizzle_color4_vector4" target="genmdl" />
+  <implementation name="IM_swizzle_vector2_float_genmdl" nodedef="ND_swizzle_vector2_float" target="genmdl" />
+  <implementation name="IM_swizzle_vector2_color3_genmdl" nodedef="ND_swizzle_vector2_color3" target="genmdl" />
+  <implementation name="IM_swizzle_vector2_color4_genmdl" nodedef="ND_swizzle_vector2_color4" target="genmdl" />
+  <implementation name="IM_swizzle_vector2_vector2_genmdl" nodedef="ND_swizzle_vector2_vector2" target="genmdl" />
+  <implementation name="IM_swizzle_vector2_vector3_genmdl" nodedef="ND_swizzle_vector2_vector3" target="genmdl" />
+  <implementation name="IM_swizzle_vector2_vector4_genmdl" nodedef="ND_swizzle_vector2_vector4" target="genmdl" />
+  <implementation name="IM_swizzle_vector3_float_genmdl" nodedef="ND_swizzle_vector3_float" target="genmdl" />
+  <implementation name="IM_swizzle_vector3_color3_genmdl" nodedef="ND_swizzle_vector3_color3" target="genmdl" />
+  <implementation name="IM_swizzle_vector3_color4_genmdl" nodedef="ND_swizzle_vector3_color4" target="genmdl" />
+  <implementation name="IM_swizzle_vector3_vector2_genmdl" nodedef="ND_swizzle_vector3_vector2" target="genmdl" />
+  <implementation name="IM_swizzle_vector3_vector3_genmdl" nodedef="ND_swizzle_vector3_vector3" target="genmdl" />
+  <implementation name="IM_swizzle_vector3_vector4_genmdl" nodedef="ND_swizzle_vector3_vector4" target="genmdl" />
+  <implementation name="IM_swizzle_vector4_float_genmdl" nodedef="ND_swizzle_vector4_float" target="genmdl" />
+  <implementation name="IM_swizzle_vector4_color3_genmdl" nodedef="ND_swizzle_vector4_color3" target="genmdl" />
+  <implementation name="IM_swizzle_vector4_color4_genmdl" nodedef="ND_swizzle_vector4_color4" target="genmdl" />
+  <implementation name="IM_swizzle_vector4_vector2_genmdl" nodedef="ND_swizzle_vector4_vector2" target="genmdl" />
+  <implementation name="IM_swizzle_vector4_vector3_genmdl" nodedef="ND_swizzle_vector4_vector3" target="genmdl" />
+  <implementation name="IM_swizzle_vector4_vector4_genmdl" nodedef="ND_swizzle_vector4_vector4" target="genmdl" />
+
+  <!-- <combine2> -->
+  <implementation name="IM_combine2_vector2_genmdl" nodedef="ND_combine2_vector2" target="genmdl" />
+  <implementation name="IM_combine2_color4CF_genmdl" nodedef="ND_combine2_color4CF" target="genmdl" />
+  <implementation name="IM_combine2_vector4VF_genmdl" nodedef="ND_combine2_vector4VF" target="genmdl" />
+  <implementation name="IM_combine2_vector4VV_genmdl" nodedef="ND_combine2_vector4VV" target="genmdl" />
+
+  <!-- <combine3> -->
+  <implementation name="IM_combine3_color3_genmdl" nodedef="ND_combine3_color3" target="genmdl" />
+  <implementation name="IM_combine3_vector3_genmdl" nodedef="ND_combine3_vector3" target="genmdl" />
+
+  <!-- <combine4> -->
+  <implementation name="IM_combine4_color4_genmdl" nodedef="ND_combine4_color4" target="genmdl" />
+  <implementation name="IM_combine4_vector4_genmdl" nodedef="ND_combine4_vector4" target="genmdl" />
+
+  <!-- <creatematrix> -->
+  <implementation name="IM_creatematrix_vector3_matrix33_genmdl" nodedef="ND_creatematrix_vector3_matrix33" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_creatematrix_vector3_matrix33({{in1}}, {{in2}}, {{in3}})" target="genmdl" />
+  <implementation name="IM_creatematrix_vector3_matrix44_genmdl" nodedef="ND_creatematrix_vector3_matrix44" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_creatematrix_vector3_matrix44({{in1}}, {{in2}}, {{in3}}, {{in4}})" target="genmdl" />
+  <implementation name="IM_creatematrix_vector4_matrix44_genmdl" nodedef="ND_creatematrix_vector4_matrix44" sourcecode="materialx::stdlib_{{MDL_VERSION_SUFFIX}}::mx_creatematrix_vector4_matrix44({{in1}}, {{in2}}, {{in3}}, {{in4}})" target="genmdl" />
+
+  <!-- ======================================================================== -->
+  <!-- Convolution nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <blur> -->
+  <implementation name="IM_blur_float_genmdl" nodedef="ND_blur_float" target="genmdl" />
+  <implementation name="IM_blur_color3_genmdl" nodedef="ND_blur_color3" target="genmdl" />
+  <implementation name="IM_blur_color4_genmdl" nodedef="ND_blur_color4" target="genmdl" />
+  <implementation name="IM_blur_vector2_genmdl" nodedef="ND_blur_vector2" target="genmdl" />
+  <implementation name="IM_blur_vector3_genmdl" nodedef="ND_blur_vector3" target="genmdl" />
+  <implementation name="IM_blur_vector4_genmdl" nodedef="ND_blur_vector4" target="genmdl" />
+
+  <!-- <heighttonormal> -->
+  <implementation name="IM_heighttonormal_vector3_genmdl" nodedef="ND_heighttonormal_vector3" target="genmdl" />
+
+  <!-- ======================================================================== -->
+  <!-- Organization nodes                                                       -->
+  <!-- ======================================================================== -->
+
+  <!-- <dot> -->
+  <implementation name="IM_dot_float_genmdl" nodedef="ND_dot_float" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_color3_genmdl" nodedef="ND_dot_color3" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_color4_genmdl" nodedef="ND_dot_color4" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_vector2_genmdl" nodedef="ND_dot_vector2" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_vector3_genmdl" nodedef="ND_dot_vector3" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_vector4_genmdl" nodedef="ND_dot_vector4" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_boolean_genmdl" nodedef="ND_dot_boolean" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_integer_genmdl" nodedef="ND_dot_integer" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_matrix33_genmdl" nodedef="ND_dot_matrix33" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_matrix44_genmdl" nodedef="ND_dot_matrix44" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_string_genmdl" nodedef="ND_dot_string" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_filename_genmdl" nodedef="ND_dot_filename" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_surfaceshader_genmdl" nodedef="ND_dot_surfaceshader" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_displacementshader_genmdl" nodedef="ND_dot_displacementshader" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_volumeshader_genmdl" nodedef="ND_dot_volumeshader" sourcecode="{{in}}" target="genmdl" />
+  <implementation name="IM_dot_lightshader_genmdl" nodedef="ND_dot_lightshader" sourcecode="{{in}}" target="genmdl" />
+
+</materialx>

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/lib/mx_math.metal

@@ -0,0 +1,107 @@
+#define M_FLOAT_EPS 1e-8
+
+float mx_square(float x)
+{
+    return x*x;
+}
+
+vec2 mx_square(vec2 x)
+{
+    return x*x;
+}
+
+vec3 mx_square(vec3 x)
+{
+    return x*x;
+}
+
+#ifdef __DECL_GL_MATH_FUNCTIONS__
+
+float radians(float degree) { return (degree * M_PI_F / 180.0f); }
+
+float3x3 inverse(float3x3 m)
+{
+    float n11 = m[0][0], n12 = m[1][0], n13 = m[2][0];
+    float n21 = m[0][1], n22 = m[1][1], n23 = m[2][1];
+    float n31 = m[0][2], n32 = m[1][2], n33 = m[2][2];
+
+    float det = determinant(m);
+    float idet = 1.0f / det;
+
+    float3x3 ret;
+
+    ret[0][0] = idet * (n22 * n33 - n32 * n23);
+    ret[1][0] = idet * (n32 * n13 - n12 * n33);
+    ret[2][0] = idet * (n12 * n23 - n22 * n13);
+    
+    ret[0][1] = idet * (n31 * n23 - n21 * n33);
+    ret[1][1] = idet * (n11 * n33 - n31 * n13);
+    ret[2][1] = idet * (n21 * n13 - n11 * n23);
+    
+    ret[0][2] = idet * (n21 * n32 - n31 * n22);
+    ret[1][2] = idet * (n31 * n12 - n11 * n32);
+    ret[2][2] = idet * (n11 * n22 - n21 * n12);
+
+    return ret;
+}
+
+float4x4 inverse(float4x4 m)
+{
+    float n11 = m[0][0], n12 = m[1][0], n13 = m[2][0], n14 = m[3][0];
+    float n21 = m[0][1], n22 = m[1][1], n23 = m[2][1], n24 = m[3][1];
+    float n31 = m[0][2], n32 = m[1][2], n33 = m[2][2], n34 = m[3][2];
+    float n41 = m[0][3], n42 = m[1][3], n43 = m[2][3], n44 = m[3][3];
+
+    float t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44;
+    float t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44;
+    float t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44;
+    float t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
+
+    float det = determinant(m);
+    float idet = 1.0f / det;
+
+    float4x4 ret;
+
+    ret[0][0] = t11 * idet;
+    ret[0][1] = (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) * idet;
+    ret[0][2] = (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) * idet;
+    ret[0][3] = (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) * idet;
+
+    ret[1][0] = t12 * idet;
+    ret[1][1] = (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) * idet;
+    ret[1][2] = (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) * idet;
+    ret[1][3] = (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) * idet;
+
+    ret[2][0] = t13 * idet;
+    ret[2][1] = (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) * idet;
+    ret[2][2] = (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) * idet;
+    ret[2][3] = (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) * idet;
+
+    ret[3][0] = t14 * idet;
+    ret[3][1] = (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) * idet;
+    ret[3][2] = (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) * idet;
+    ret[3][3] = (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) * idet;
+
+    return ret;
+}
+
+template<class T1, class T2>
+T1 mod(T1 x, T2 y)
+{
+    return x - y * floor(x/y);
+}
+
+template <typename T>
+T atan(T y_over_x) { return ::atan(y_over_x); }
+
+template <typename T>
+T atan(T y, T x) { return ::atan2(y, x); }
+
+#define lessThan(a, b) ((a) < (b))
+#define lessThanEqual(a, b) ((a) <= (b))
+#define greaterThan(a, b) ((a) > (b))
+#define greaterThanEqual(a, b) ((a) >= (b))
+#define equal(a, b) ((a) == (b))
+#define notEqual(a, b) ((a) != (b))
+
+#endif

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/lib/mx_matscalaroperators.metal

@@ -0,0 +1,55 @@
+float3x3 operator+(float3x3 a, float b)
+{
+    return a + float3x3(b,b,b,b,b,b,b,b,b);
+}
+
+float4x4 operator+(float4x4 a, float b)
+{
+    return a + float4x4(b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b);
+}
+
+float3x3 operator-(float3x3 a, float b)
+{
+    return a - float3x3(b,b,b,b,b,b,b,b,b);
+}
+
+float4x4 operator-(float4x4 a, float b)
+{
+    return a - float4x4(b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b);
+}
+
+float3x3 operator/(float3x3 a, float3x3 b)
+{
+    for(int i = 0; i < 3; ++i)
+        for(int j = 0; j < 3; ++j)
+            a[i][j] /= b[i][j];
+
+    return a;
+}
+
+float4x4 operator/(float4x4 a, float4x4 b)
+{
+    for(int i = 0; i < 4; ++i)
+        for(int j = 0; j < 4; ++j)
+            a[i][j] /= b[i][j];
+
+    return a;
+}
+
+float3x3 operator/(float3x3 a, float b)
+{
+    for(int i = 0; i < 3; ++i)
+        for(int j = 0; j < 3; ++j)
+            a[i][j] /= b;
+
+    return a;
+}
+
+float4x4 operator/(float4x4 a, float b)
+{
+    for(int i = 0; i < 4; ++i)
+        for(int j = 0; j < 4; ++j)
+            a[i][j] /= b;
+
+    return a;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/lib/mx_sampling.metal

@@ -0,0 +1,91 @@
+// Restrict to 7x7 kernel size for performance reasons
+#define MX_MAX_SAMPLE_COUNT 49
+// Size of all weights for all levels (including level 1)
+#define MX_WEIGHT_ARRAY_SIZE 84
+
+//
+// Function to compute the sample size relative to a texture coordinate
+//
+vec2 mx_compute_sample_size_uv(vec2 uv, float filterSize, float filterOffset)
+{
+   vec2 derivUVx = dFdx(uv) * 0.5f;
+   vec2 derivUVy = dFdy(uv) * 0.5f;
+   float derivX = abs(derivUVx.x) + abs(derivUVy.x);
+   float derivY = abs(derivUVx.y) + abs(derivUVy.y);
+   float sampleSizeU = 2.0f * filterSize * derivX + filterOffset;
+   if (sampleSizeU < 1.0E-05f)
+       sampleSizeU = 1.0E-05f;
+   float sampleSizeV = 2.0f * filterSize * derivY + filterOffset;
+   if (sampleSizeV < 1.0E-05f)
+       sampleSizeV = 1.0E-05f;
+   return vec2(sampleSizeU, sampleSizeV);
+}
+
+//
+// Compute a normal mapped to 0..1 space based on a set of input
+// samples using a Sobel filter.
+//
+vec3 mx_normal_from_samples_sobel(constant float S[9], float _scale)
+{
+    float nx = S[0] - S[2] + (2.0*S[3]) - (2.0*S[5]) + S[6] - S[8];
+    float ny = S[0] + (2.0*S[1]) + S[2] - S[6] - (2.0*S[7]) - S[8];
+    float nz = max(_scale, M_FLOAT_EPS) * sqrt(max(1.0 - nx * nx - ny * ny, M_FLOAT_EPS));
+    vec3 norm = normalize(vec3(nx, ny, nz));
+    return (norm + 1.0) * 0.5;
+}
+
+//
+// Apply filter for float samples S, using weights W.
+// sampleCount should be a square of a odd number in the range { 1, 3, 5, 7 }
+//
+float mx_convolution_float(float S[MX_MAX_SAMPLE_COUNT], constant float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    float result = 0.0;
+    for (int i = 0;  i < sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}
+
+//
+// Apply filter for vec2 samples S, using weights W.
+// sampleCount should be a square of a odd number in the range { 1, 3, 5, 7 }
+//
+vec2 mx_convolution_vec2(vec2 S[MX_MAX_SAMPLE_COUNT], constant float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    vec2 result = vec2(0.0);
+    for (int i=0;  i<sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}
+
+//
+// Apply filter for vec3 samples S, using weights W.
+// sampleCount should be a square of a odd number in the range { 1, 3, 5, 7 }
+//
+vec3 mx_convolution_vec3(vec3 S[MX_MAX_SAMPLE_COUNT], constant float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    vec3 result = vec3(0.0);
+    for (int i=0;  i<sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}
+
+//
+// Apply filter for vec4 samples S, using weights W.
+// sampleCount should be a square of a odd number { 1, 3, 5, 7 }
+//
+vec4 mx_convolution_vec4(vec4 S[MX_MAX_SAMPLE_COUNT], constant float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    vec4 result = vec4(0.0);
+    for (int i=0;  i<sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/lib/mx_texture.metal

@@ -0,0 +1,30 @@
+struct MetalTexture
+{
+    texture2d<float> tex;
+    sampler s;
+    int get_width() { return tex.get_width(); }
+    int get_height() { return tex.get_height(); }
+    int get_num_mip_levels() { return tex.get_num_mip_levels(); }
+};
+
+int get_width(MetalTexture mtlTex) { return mtlTex.get_width(); }
+
+float4 texture(MetalTexture mtlTex, float2 uv)
+{
+    return mtlTex.tex.sample(mtlTex.s, uv);
+}
+
+float4 textureLod(MetalTexture mtlTex, float2 uv, float lod)
+{
+    return mtlTex.tex.sample(mtlTex.s, uv, level(lod));
+}
+
+int2 textureSize(MetalTexture mtlTex, int mipLevel)
+{
+    return int2(mtlTex.get_width(), mtlTex.get_height());
+}
+
+int texture_mips(MetalTexture mtlTex)
+{
+    return mtlTex.tex.get_num_mip_levels();
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/mx_burn_color3.metal

@@ -0,0 +1,9 @@
+#include "mx_burn_float.metal"
+
+void mx_burn_color3(vec3 fg, vec3 bg, float mixval, out vec3 result)
+{
+    float f;
+    mx_burn_float(fg.x, bg.x, mixval, f); result.x = f;
+    mx_burn_float(fg.y, bg.y, mixval, f); result.y = f;
+    mx_burn_float(fg.z, bg.z, mixval, f); result.z = f;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/mx_burn_color4.metal

@@ -0,0 +1,10 @@
+#include "mx_burn_float.metal"
+
+void mx_burn_color4(vec4 fg, vec4 bg, float mixval, out vec4 result)
+{
+    float f;
+    mx_burn_float(fg.x, bg.x, mixval, f); result.x = f;
+    mx_burn_float(fg.y, bg.y, mixval, f); result.y = f;
+    mx_burn_float(fg.z, bg.z, mixval, f); result.z = f;
+    mx_burn_float(fg.w, bg.w, mixval, f); result.w = f;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/mx_burn_float.metal

@@ -0,0 +1,9 @@
+void mx_burn_float(float fg, float bg, float mixval, out float result)
+{
+    if (abs(fg) < M_FLOAT_EPS)
+    {
+        result = 0.0;
+        return;
+    }
+    result = mixval*(1.0 - ((1.0 - bg) / fg)) + ((1.0-mixval)*bg);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/mx_dodge_color3.metal

@@ -0,0 +1,9 @@
+#include "mx_dodge_float.metal"
+
+void mx_dodge_color3(vec3 fg, vec3 bg, float mixval, out vec3 result)
+{
+    float f;
+    mx_dodge_float(fg.x, bg.x, mixval, f); result.x = f;
+    mx_dodge_float(fg.y, bg.y, mixval, f); result.y = f;
+    mx_dodge_float(fg.z, bg.z, mixval, f); result.z = f;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/mx_dodge_color4.metal

@@ -0,0 +1,10 @@
+#include "mx_dodge_float.metal"
+
+void mx_dodge_color4(vec4 fg , vec4 bg , float mixval, out vec4 result)
+{
+    float f;
+    mx_dodge_float(fg.x, bg.x, mixval, f); result.x = f;
+    mx_dodge_float(fg.y, bg.y, mixval, f); result.y = f;
+    mx_dodge_float(fg.z, bg.z, mixval, f); result.z = f;
+    mx_dodge_float(fg.w, bg.w, mixval, f); result.w = f;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/mx_dodge_float.metal

@@ -0,0 +1,9 @@
+void mx_dodge_float(float fg, float bg, float mixval, out float result)
+{
+    if (abs(1.0 - fg) < M_FLOAT_EPS)
+    {
+        result = 0.0;
+        return;
+    }
+    result = mixval*(bg / (1.0 - fg)) + ((1.0-mixval)*bg);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/mx_normalmap.metal

@@ -0,0 +1,21 @@
+void mx_normalmap_vector2(vec3 value, int map_space, vec2 normal_scale, vec3 N, vec3 T,  out vec3 result)
+{
+    // Decode the normal map.
+    value = all(value == vec3(0.0f)) ? vec3(0.0, 0.0, 1.0) : value * 2.0 - 1.0;
+
+    // Transform from tangent space if needed.
+    if (map_space == 0)
+    {
+        vec3 B = normalize(cross(N, T));
+        value.xy *= normal_scale;
+        value = T * value.x + B * value.y + N * value.z;
+    }
+
+    // Normalize the result.
+    result = normalize(value);
+}
+
+void mx_normalmap_float(vec3 value, int map_space, float normal_scale, vec3 N, vec3 T,  out vec3 result)
+{
+    mx_normalmap_vector2(value, map_space, vec2(normal_scale), N, T, result);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/mx_smoothstep_float.metal

@@ -0,0 +1,9 @@
+void mx_smoothstep_float(float val, float low, float high, out float result)
+{
+    if (val <= low)
+        result = 0.0;
+    else if (val >= high)
+        result = 1.0;
+    else
+        result = smoothstep(low, high, val);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/mx_smoothstep_vector2.metal

@@ -0,0 +1,8 @@
+#include "mx_smoothstep_float.metal"
+
+void mx_smoothstep_vector2(vec2 val, vec2 low, vec2 high, out vec2 result)
+{
+    float f;
+    mx_smoothstep_float(val.x, low.x, high.x, f); result.x = f;
+    mx_smoothstep_float(val.y, low.y, high.y, f); result.y = f;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/mx_smoothstep_vector3.metal

@@ -0,0 +1,9 @@
+#include "mx_smoothstep_float.metal"
+
+void mx_smoothstep_vector3(vec3 val, vec3 low, vec3 high, thread vec3& result)
+    {
+        float f;
+        mx_smoothstep_float(val.x, low.x, high.x, f); result.x = f;
+        mx_smoothstep_float(val.y, low.y, high.y, f); result.y = f;
+        mx_smoothstep_float(val.z, low.z, high.z, f); result.z = f;
+    }

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/mx_smoothstep_vector4.metal

@@ -0,0 +1,10 @@
+#include "mx_smoothstep_float.metal"
+
+void mx_smoothstep_vector4(vec4 val, vec4 low, vec4 high, out vec4 result)
+{
+    float f;
+    mx_smoothstep_float(val.x, low.x, high.x, f); result.x = f;
+    mx_smoothstep_float(val.y, low.y, high.y, f); result.y = f;
+    mx_smoothstep_float(val.z, low.z, high.z, f); result.z = f;
+    mx_smoothstep_float(val.w, low.w, high.w, f); result.w = f;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genmsl/stdlib_genmsl_impl.mtlx

@@ -0,0 +1,774 @@
+<?xml version="1.0"?>
+<materialx version="1.38">
+  <!--
+    Copyright Contributors to the MaterialX Project
+    SPDX-License-Identifier: Apache-2.0
+
+    Declarations for msl implementations of standard nodes included in the MaterialX specification.
+  -->
+
+  <!-- ======================================================================== -->
+  <!-- Shader nodes                                                             -->
+  <!-- ======================================================================== -->
+
+  <!-- <surfacematerial> -->
+  <implementation name="IM_surfacematerial_genmsl" nodedef="ND_surfacematerial" target="genmsl" />
+
+  <!-- <surface_unlit> -->
+  <implementation name="IM_surface_unlit_genmsl" nodedef="ND_surface_unlit" target="genmsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Texture nodes                                                            -->
+  <!-- ======================================================================== -->
+
+  <!-- <image> -->
+  <implementation name="IM_image_float_genmsl" nodedef="ND_image_float" file="../genglsl/mx_image_float.glsl" function="mx_image_float" target="genmsl">
+    <input name="default" type="float" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_color3_genmsl" nodedef="ND_image_color3" file="../genglsl/mx_image_color3.glsl" function="mx_image_color3" target="genmsl">
+    <input name="default" type="color3" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_color4_genmsl" nodedef="ND_image_color4" file="../genglsl/mx_image_color4.glsl" function="mx_image_color4" target="genmsl">
+    <input name="default" type="color4" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_vector2_genmsl" nodedef="ND_image_vector2" file="../genglsl/mx_image_vector2.glsl" function="mx_image_vector2" target="genmsl">
+    <input name="default" type="vector2" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_vector3_genmsl" nodedef="ND_image_vector3" file="../genglsl/mx_image_vector3.glsl" function="mx_image_vector3" target="genmsl">
+    <input name="default" type="vector3" implname="default_value" />
+  </implementation>
+  <implementation name="IM_image_vector4_genmsl" nodedef="ND_image_vector4" file="../genglsl/mx_image_vector4.glsl" function="mx_image_vector4" target="genmsl">
+    <input name="default" type="vector4" implname="default_value" />
+  </implementation>
+
+  <!-- <normalmap> -->
+  <implementation name="IM_normalmap_float_genmsl" nodedef="ND_normalmap" file="mx_normalmap.metal" function="mx_normalmap_float" target="genmsl" />
+  <implementation name="IM_normalmap_vector2_genmsl" nodedef="ND_normalmap_vector2" file="mx_normalmap.metal" function="mx_normalmap_vector2" target="genmsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Procedural nodes                                                         -->
+  <!-- ======================================================================== -->
+
+  <!-- <constant> -->
+  <implementation name="IM_constant_float_genmsl" nodedef="ND_constant_float" target="genmsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_color3_genmsl" nodedef="ND_constant_color3" target="genmsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_color4_genmsl" nodedef="ND_constant_color4" target="genmsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_vector2_genmsl" nodedef="ND_constant_vector2" target="genmsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_vector3_genmsl" nodedef="ND_constant_vector3" target="genmsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_vector4_genmsl" nodedef="ND_constant_vector4" target="genmsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_boolean_genmsl" nodedef="ND_constant_boolean" target="genmsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_integer_genmsl" nodedef="ND_constant_integer" target="genmsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_matrix33_genmsl" nodedef="ND_constant_matrix33" target="genmsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_matrix44_genmsl" nodedef="ND_constant_matrix44" target="genmsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_string_genmsl" nodedef="ND_constant_string" target="genmsl" sourcecode="{{value}}" />
+  <implementation name="IM_constant_filename_genmsl" nodedef="ND_constant_filename" target="genmsl" sourcecode="{{value}}" />
+
+  <!-- <ramplr> -->
+  <implementation name="IM_ramplr_float_genmsl" nodedef="ND_ramplr_float" file="../genglsl/mx_ramplr_float.glsl" function="mx_ramplr_float" target="genmsl" />
+  <implementation name="IM_ramplr_color3_genmsl" nodedef="ND_ramplr_color3" file="../genglsl/mx_ramplr_vector3.glsl" function="mx_ramplr_vector3" target="genmsl" />
+  <implementation name="IM_ramplr_color4_genmsl" nodedef="ND_ramplr_color4" file="../genglsl/mx_ramplr_vector4.glsl" function="mx_ramplr_vector4" target="genmsl" />
+  <implementation name="IM_ramplr_vector2_genmsl" nodedef="ND_ramplr_vector2" file="../genglsl/mx_ramplr_vector2.glsl" function="mx_ramplr_vector2" target="genmsl" />
+  <implementation name="IM_ramplr_vector3_genmsl" nodedef="ND_ramplr_vector3" file="../genglsl/mx_ramplr_vector3.glsl" function="mx_ramplr_vector3" target="genmsl" />
+  <implementation name="IM_ramplr_vector4_genmsl" nodedef="ND_ramplr_vector4" file="../genglsl/mx_ramplr_vector4.glsl" function="mx_ramplr_vector4" target="genmsl" />
+
+  <!-- <ramptb> -->
+  <implementation name="IM_ramptb_float_genmsl" nodedef="ND_ramptb_float" file="../genglsl/mx_ramptb_float.glsl" function="mx_ramptb_float" target="genmsl" />
+  <implementation name="IM_ramptb_color3_genmsl" nodedef="ND_ramptb_color3" file="../genglsl/mx_ramptb_vector3.glsl" function="mx_ramptb_vector3" target="genmsl" />
+  <implementation name="IM_ramptb_color4_genmsl" nodedef="ND_ramptb_color4" file="../genglsl/mx_ramptb_vector4.glsl" function="mx_ramptb_vector4" target="genmsl" />
+  <implementation name="IM_ramptb_vector2_genmsl" nodedef="ND_ramptb_vector2" file="../genglsl/mx_ramptb_vector2.glsl" function="mx_ramptb_vector2" target="genmsl" />
+  <implementation name="IM_ramptb_vector3_genmsl" nodedef="ND_ramptb_vector3" file="../genglsl/mx_ramptb_vector3.glsl" function="mx_ramptb_vector3" target="genmsl" />
+  <implementation name="IM_ramptb_vector4_genmsl" nodedef="ND_ramptb_vector4" file="../genglsl/mx_ramptb_vector4.glsl" function="mx_ramptb_vector4" target="genmsl" />
+
+  <!-- <splitlr> -->
+  <implementation name="IM_splitlr_float_genmsl" nodedef="ND_splitlr_float" file="../genglsl/mx_splitlr_float.glsl" function="mx_splitlr_float" target="genmsl" />
+  <implementation name="IM_splitlr_color3_genmsl" nodedef="ND_splitlr_color3" file="../genglsl/mx_splitlr_vector3.glsl" function="mx_splitlr_vector3" target="genmsl" />
+  <implementation name="IM_splitlr_color4_genmsl" nodedef="ND_splitlr_color4" file="../genglsl/mx_splitlr_vector4.glsl" function="mx_splitlr_vector4" target="genmsl" />
+  <implementation name="IM_splitlr_vector2_genmsl" nodedef="ND_splitlr_vector2" file="../genglsl/mx_splitlr_vector2.glsl" function="mx_splitlr_vector2" target="genmsl" />
+  <implementation name="IM_splitlr_vector3_genmsl" nodedef="ND_splitlr_vector3" file="../genglsl/mx_splitlr_vector3.glsl" function="mx_splitlr_vector3" target="genmsl" />
+  <implementation name="IM_splitlr_vector4_genmsl" nodedef="ND_splitlr_vector4" file="../genglsl/mx_splitlr_vector4.glsl" function="mx_splitlr_vector4" target="genmsl" />
+
+  <!-- <splittb> -->
+  <implementation name="IM_splittb_float_genmsl" nodedef="ND_splittb_float" file="../genglsl/mx_splittb_float.glsl" function="mx_splittb_float" target="genmsl" />
+  <implementation name="IM_splittb_color3_genmsl" nodedef="ND_splittb_color3" file="../genglsl/mx_splittb_vector3.glsl" function="mx_splittb_vector3" target="genmsl" />
+  <implementation name="IM_splittb_color4_genmsl" nodedef="ND_splittb_color4" file="../genglsl/mx_splittb_vector4.glsl" function="mx_splittb_vector4" target="genmsl" />
+  <implementation name="IM_splittb_vector2_genmsl" nodedef="ND_splittb_vector2" file="../genglsl/mx_splittb_vector2.glsl" function="mx_splittb_vector2" target="genmsl" />
+  <implementation name="IM_splittb_vector3_genmsl" nodedef="ND_splittb_vector3" file="../genglsl/mx_splittb_vector3.glsl" function="mx_splittb_vector3" target="genmsl" />
+  <implementation name="IM_splittb_vector4_genmsl" nodedef="ND_splittb_vector4" file="../genglsl/mx_splittb_vector4.glsl" function="mx_splittb_vector4" target="genmsl" />
+
+  <!-- <noise2d> -->
+  <implementation name="IM_noise2d_float_genmsl" nodedef="ND_noise2d_float" file="../genglsl/mx_noise2d_float.glsl" function="mx_noise2d_float" target="genmsl" />
+  <implementation name="IM_noise2d_vector2_genmsl" nodedef="ND_noise2d_vector2" file="../genglsl/mx_noise2d_vector2.glsl" function="mx_noise2d_vector2" target="genmsl" />
+  <implementation name="IM_noise2d_vector3_genmsl" nodedef="ND_noise2d_vector3" file="../genglsl/mx_noise2d_vector3.glsl" function="mx_noise2d_vector3" target="genmsl" />
+  <implementation name="IM_noise2d_vector4_genmsl" nodedef="ND_noise2d_vector4" file="../genglsl/mx_noise2d_vector4.glsl" function="mx_noise2d_vector4" target="genmsl" />
+
+  <!-- <noise3d> -->
+  <implementation name="IM_noise3d_float_genmsl" nodedef="ND_noise3d_float" file="../genglsl/mx_noise3d_float.glsl" function="mx_noise3d_float" target="genmsl" />
+  <implementation name="IM_noise3d_vector2_genmsl" nodedef="ND_noise3d_vector2" file="../genglsl/mx_noise3d_vector2.glsl" function="mx_noise3d_vector2" target="genmsl" />
+  <implementation name="IM_noise3d_vector3_genmsl" nodedef="ND_noise3d_vector3" file="../genglsl/mx_noise3d_vector3.glsl" function="mx_noise3d_vector3" target="genmsl" />
+  <implementation name="IM_noise3d_vector4_genmsl" nodedef="ND_noise3d_vector4" file="../genglsl/mx_noise3d_vector4.glsl" function="mx_noise3d_vector4" target="genmsl" />
+
+  <!-- <fractal3d> -->
+  <implementation name="IM_fractal3d_float_genmsl" nodedef="ND_fractal3d_float" file="../genglsl/mx_fractal3d_float.glsl" function="mx_fractal3d_float" target="genmsl" />
+  <implementation name="IM_fractal3d_vector2_genmsl" nodedef="ND_fractal3d_vector2" file="../genglsl/mx_fractal3d_vector2.glsl" function="mx_fractal3d_vector2" target="genmsl" />
+  <implementation name="IM_fractal3d_vector3_genmsl" nodedef="ND_fractal3d_vector3" file="../genglsl/mx_fractal3d_vector3.glsl" function="mx_fractal3d_vector3" target="genmsl" />
+  <implementation name="IM_fractal3d_vector4_genmsl" nodedef="ND_fractal3d_vector4" file="../genglsl/mx_fractal3d_vector4.glsl" function="mx_fractal3d_vector4" target="genmsl" />
+
+  <!-- <cellnoise2d> -->
+  <implementation name="IM_cellnoise2d_float_genmsl" nodedef="ND_cellnoise2d_float" file="../genglsl/mx_cellnoise2d_float.glsl" function="mx_cellnoise2d_float" target="genmsl" />
+
+  <!-- <cellnoise3d> -->
+  <implementation name="IM_cellnoise3d_float_genmsl" nodedef="ND_cellnoise3d_float" file="../genglsl/mx_cellnoise3d_float.glsl" function="mx_cellnoise3d_float" target="genmsl" />
+
+  <!-- <worleynoise2d> -->
+  <implementation name="IM_worleynoise2d_float_genmsl" nodedef="ND_worleynoise2d_float" file="../genglsl/mx_worleynoise2d_float.glsl" function="mx_worleynoise2d_float" target="genmsl" />
+  <implementation name="IM_worleynoise2d_vector2_genmsl" nodedef="ND_worleynoise2d_vector2" file="../genglsl/mx_worleynoise2d_vector2.glsl" function="mx_worleynoise2d_vector2" target="genmsl" />
+  <implementation name="IM_worleynoise2d_vector3_genmsl" nodedef="ND_worleynoise2d_vector3" file="../genglsl/mx_worleynoise2d_vector3.glsl" function="mx_worleynoise2d_vector3" target="genmsl" />
+
+  <!-- <worleynoise3d> -->
+  <implementation name="IM_worleynoise3d_float_genmsl" nodedef="ND_worleynoise3d_float" file="../genglsl/mx_worleynoise3d_float.glsl" function="mx_worleynoise3d_float" target="genmsl" />
+  <implementation name="IM_worleynoise3d_vector2_genmsl" nodedef="ND_worleynoise3d_vector2" file="../genglsl/mx_worleynoise3d_vector2.glsl" function="mx_worleynoise3d_vector2" target="genmsl" />
+  <implementation name="IM_worleynoise3d_vector3_genmsl" nodedef="ND_worleynoise3d_vector3" file="../genglsl/mx_worleynoise3d_vector3.glsl" function="mx_worleynoise3d_vector3" target="genmsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Global nodes                                                             -->
+  <!-- ======================================================================== -->
+
+  <!-- <ambientocclusion> -->
+
+  <!-- ======================================================================== -->
+  <!-- Geometric nodes                                                          -->
+  <!-- ======================================================================== -->
+
+  <!-- <position> -->
+  <implementation name="IM_position_vector3_genmsl" nodedef="ND_position_vector3" target="genmsl" />
+
+  <!-- <normal> -->
+  <implementation name="IM_normal_vector3_genmsl" nodedef="ND_normal_vector3" target="genmsl" />
+
+  <!-- <tangent> -->
+  <implementation name="IM_tangent_vector3_genmsl" nodedef="ND_tangent_vector3" target="genmsl" />
+
+  <!-- <bitangent> -->
+  <implementation name="IM_bitangent_vector3_genmsl" nodedef="ND_bitangent_vector3" target="genmsl" />
+
+  <!-- <texcoord> -->
+  <implementation name="IM_texcoord_vector2_genmsl" nodedef="ND_texcoord_vector2" target="genmsl" />
+  <implementation name="IM_texcoord_vector3_genmsl" nodedef="ND_texcoord_vector3" target="genmsl" />
+
+  <!-- <geomcolor> -->
+  <implementation name="IM_geomcolor_float_genmsl" nodedef="ND_geomcolor_float" target="genmsl" />
+  <implementation name="IM_geomcolor_color3_genmsl" nodedef="ND_geomcolor_color3" target="genmsl" />
+  <implementation name="IM_geomcolor_color4_genmsl" nodedef="ND_geomcolor_color4" target="genmsl" />
+
+  <!-- <geompropvalue> -->
+  <implementation name="IM_geompropvalue_integer_genmsl" nodedef="ND_geompropvalue_integer" function="mx_geompropvalue_int" target="genmsl" />
+  <implementation name="IM_geompropvalue_boolean_genmsl" nodedef="ND_geompropvalue_boolean" function="mx_geompropvalue_bool" target="genmsl" />
+  <implementation name="IM_geompropvalue_string_genmsl" nodedef="ND_geompropvalue_string" function="mx_geompropvalue_string" target="genmsl" />
+  <implementation name="IM_geompropvalue_float_genmsl" nodedef="ND_geompropvalue_float" function="mx_geompropvalue_float" target="genmsl" />
+  <implementation name="IM_geompropvalue_color3_genmsl" nodedef="ND_geompropvalue_color3" function="mx_geompropvalue_color" target="genmsl" />
+  <implementation name="IM_geompropvalue_color4_genmsl" nodedef="ND_geompropvalue_color4" function="mx_geompropvalue_color4" target="genmsl" />
+  <implementation name="IM_geompropvalue_vector2_genmsl" nodedef="ND_geompropvalue_vector2" function="mx_geompropvalue_vector2" target="genmsl" />
+  <implementation name="IM_geompropvalue_vector3_genmsl" nodedef="ND_geompropvalue_vector3" function="mx_geompropvalue_vector" target="genmsl" />
+  <implementation name="IM_geompropvalue_vector4_genmsl" nodedef="ND_geompropvalue_vector4" function="mx_geompropvalue_vector4" target="genmsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Application nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <frame> -->
+
+  <implementation name="IM_frame_float_genmsl" nodedef="ND_frame_float" function="mx_frame_float" target="genmsl" />
+
+  <!-- <time> -->
+  <implementation name="IM_time_float_genmsl" nodedef="ND_time_float" function="mx_time_float" target="genmsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Math nodes                                                               -->
+  <!-- ======================================================================== -->
+
+  <!-- <add> -->
+  <implementation name="IM_add_float_genmsl" nodedef="ND_add_float" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_color3_genmsl" nodedef="ND_add_color3" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_color3FA_genmsl" nodedef="ND_add_color3FA" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_color4_genmsl" nodedef="ND_add_color4" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_color4FA_genmsl" nodedef="ND_add_color4FA" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector2_genmsl" nodedef="ND_add_vector2" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector2FA_genmsl" nodedef="ND_add_vector2FA" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector3_genmsl" nodedef="ND_add_vector3" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector3FA_genmsl" nodedef="ND_add_vector3FA" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector4_genmsl" nodedef="ND_add_vector4" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_vector4FA_genmsl" nodedef="ND_add_vector4FA" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_matrix33_genmsl" nodedef="ND_add_matrix33" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_matrix33FA_genmsl" nodedef="ND_add_matrix33FA" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_matrix44_genmsl" nodedef="ND_add_matrix44" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+  <implementation name="IM_add_matrix44FA_genmsl" nodedef="ND_add_matrix44FA" target="genmsl" sourcecode="{{in1}} + {{in2}}" />
+
+  <!-- <subtract> -->
+  <implementation name="IM_subtract_float_genmsl" nodedef="ND_subtract_float" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_color3_genmsl" nodedef="ND_subtract_color3" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_color3FA_genmsl" nodedef="ND_subtract_color3FA" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_color4_genmsl" nodedef="ND_subtract_color4" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_color4FA_genmsl" nodedef="ND_subtract_color4FA" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector2_genmsl" nodedef="ND_subtract_vector2" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector2FA_genmsl" nodedef="ND_subtract_vector2FA" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector3_genmsl" nodedef="ND_subtract_vector3" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector3FA_genmsl" nodedef="ND_subtract_vector3FA" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector4_genmsl" nodedef="ND_subtract_vector4" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_vector4FA_genmsl" nodedef="ND_subtract_vector4FA" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_matrix33_genmsl" nodedef="ND_subtract_matrix33" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_matrix33FA_genmsl" nodedef="ND_subtract_matrix33FA" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_matrix44_genmsl" nodedef="ND_subtract_matrix44" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+  <implementation name="IM_subtract_matrix44FA_genmsl" nodedef="ND_subtract_matrix44FA" target="genmsl" sourcecode="{{in1}} - {{in2}}" />
+
+  <!-- <multiply> -->
+  <implementation name="IM_multiply_float_genmsl" nodedef="ND_multiply_float" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_color3_genmsl" nodedef="ND_multiply_color3" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_color3FA_genmsl" nodedef="ND_multiply_color3FA" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_color4_genmsl" nodedef="ND_multiply_color4" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_color4FA_genmsl" nodedef="ND_multiply_color4FA" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector2_genmsl" nodedef="ND_multiply_vector2" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector2FA_genmsl" nodedef="ND_multiply_vector2FA" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector3_genmsl" nodedef="ND_multiply_vector3" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector3FA_genmsl" nodedef="ND_multiply_vector3FA" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector4_genmsl" nodedef="ND_multiply_vector4" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_vector4FA_genmsl" nodedef="ND_multiply_vector4FA" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_matrix33_genmsl" nodedef="ND_multiply_matrix33" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+  <implementation name="IM_multiply_matrix44_genmsl" nodedef="ND_multiply_matrix44" target="genmsl" sourcecode="{{in1}} * {{in2}}" />
+
+  <!-- <divide> -->
+  <implementation name="IM_divide_float_genmsl" nodedef="ND_divide_float" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_color3_genmsl" nodedef="ND_divide_color3" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_color3FA_genmsl" nodedef="ND_divide_color3FA" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_color4_genmsl" nodedef="ND_divide_color4" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_color4FA_genmsl" nodedef="ND_divide_color4FA" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector2_genmsl" nodedef="ND_divide_vector2" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector2FA_genmsl" nodedef="ND_divide_vector2FA" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector3_genmsl" nodedef="ND_divide_vector3" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector3FA_genmsl" nodedef="ND_divide_vector3FA" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector4_genmsl" nodedef="ND_divide_vector4" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_vector4FA_genmsl" nodedef="ND_divide_vector4FA" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_matrix33_genmsl" nodedef="ND_divide_matrix33" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+  <implementation name="IM_divide_matrix44_genmsl" nodedef="ND_divide_matrix44" target="genmsl" sourcecode="{{in1}} / {{in2}}" />
+
+  <!-- <modulo> -->
+  <implementation name="IM_modulo_float_genmsl" nodedef="ND_modulo_float" target="genmsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_color3_genmsl" nodedef="ND_modulo_color3" target="genmsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_color3FA_genmsl" nodedef="ND_modulo_color3FA" target="genmsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_color4_genmsl" nodedef="ND_modulo_color4" target="genmsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_color4FA_genmsl" nodedef="ND_modulo_color4FA" target="genmsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector2_genmsl" nodedef="ND_modulo_vector2" target="genmsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector2FA_genmsl" nodedef="ND_modulo_vector2FA" target="genmsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector3_genmsl" nodedef="ND_modulo_vector3" target="genmsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector3FA_genmsl" nodedef="ND_modulo_vector3FA" target="genmsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector4_genmsl" nodedef="ND_modulo_vector4" target="genmsl" sourcecode="mod({{in1}}, {{in2}})" />
+  <implementation name="IM_modulo_vector4FA_genmsl" nodedef="ND_modulo_vector4FA" target="genmsl" sourcecode="mod({{in1}}, {{in2}})" />
+
+  <!-- <invert> -->
+  <implementation name="IM_invert_float_genmsl" nodedef="ND_invert_float" target="genmsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_color3_genmsl" nodedef="ND_invert_color3" target="genmsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_color3FA_genmsl" nodedef="ND_invert_color3FA" target="genmsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_color4_genmsl" nodedef="ND_invert_color4" target="genmsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_color4FA_genmsl" nodedef="ND_invert_color4FA" target="genmsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector2_genmsl" nodedef="ND_invert_vector2" target="genmsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector2FA_genmsl" nodedef="ND_invert_vector2FA" target="genmsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector3_genmsl" nodedef="ND_invert_vector3" target="genmsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector3FA_genmsl" nodedef="ND_invert_vector3FA" target="genmsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector4_genmsl" nodedef="ND_invert_vector4" target="genmsl" sourcecode="{{amount}} - {{in}}" />
+  <implementation name="IM_invert_vector4FA_genmsl" nodedef="ND_invert_vector4FA" target="genmsl" sourcecode="{{amount}} - {{in}}" />
+
+  <!-- <absval> -->
+  <implementation name="IM_absval_float_genmsl" nodedef="ND_absval_float" target="genmsl" sourcecode="abs({{in}})" />
+  <implementation name="IM_absval_color3_genmsl" nodedef="ND_absval_color3" target="genmsl" sourcecode="abs({{in}})" />
+  <implementation name="IM_absval_color4_genmsl" nodedef="ND_absval_color4" target="genmsl" sourcecode="abs({{in}})" />
+  <implementation name="IM_absval_vector2_genmsl" nodedef="ND_absval_vector2" target="genmsl" sourcecode="abs({{in}})" />
+  <implementation name="IM_absval_vector3_genmsl" nodedef="ND_absval_vector3" target="genmsl" sourcecode="abs({{in}})" />
+  <implementation name="IM_absval_vector4_genmsl" nodedef="ND_absval_vector4" target="genmsl" sourcecode="abs({{in}})" />
+
+  <!-- <floor> -->
+  <implementation name="IM_floor_float_genmsl" nodedef="ND_floor_float" target="genmsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_color3_genmsl" nodedef="ND_floor_color3" target="genmsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_color4_genmsl" nodedef="ND_floor_color4" target="genmsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_vector2_genmsl" nodedef="ND_floor_vector2" target="genmsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_vector3_genmsl" nodedef="ND_floor_vector3" target="genmsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_vector4_genmsl" nodedef="ND_floor_vector4" target="genmsl" sourcecode="floor({{in}})" />
+  <implementation name="IM_floor_integer_genmsl" nodedef="ND_floor_integer" target="genmsl" sourcecode="int(floor({{in}}))" />
+
+  <!-- <ceil> -->
+  <implementation name="IM_ceil_float_genmsl" nodedef="ND_ceil_float" target="genmsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_color3_genmsl" nodedef="ND_ceil_color3" target="genmsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_color4_genmsl" nodedef="ND_ceil_color4" target="genmsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_vector2_genmsl" nodedef="ND_ceil_vector2" target="genmsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_vector3_genmsl" nodedef="ND_ceil_vector3" target="genmsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_vector4_genmsl" nodedef="ND_ceil_vector4" target="genmsl" sourcecode="ceil({{in}})" />
+  <implementation name="IM_ceil_integer_genmsl" nodedef="ND_ceil_integer" target="genmsl" sourcecode="int(ceil({{in}}))" />
+
+  <!-- <round> -->
+  <implementation name="IM_round_float_genmsl" nodedef="ND_round_float" target="genmsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_color3_genmsl" nodedef="ND_round_color3" target="genmsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_color4_genmsl" nodedef="ND_round_color4" target="genmsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_vector2_genmsl" nodedef="ND_round_vector2" target="genmsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_vector3_genmsl" nodedef="ND_round_vector3" target="genmsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_vector4_genmsl" nodedef="ND_round_vector4" target="genmsl" sourcecode="round({{in}})" />
+  <implementation name="IM_round_integer_genmsl" nodedef="ND_round_integer" target="genmsl" sourcecode="int(round({{in}}))" />
+
+  <!-- <power> -->
+  <implementation name="IM_power_float_genmsl" nodedef="ND_power_float" target="genmsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_color3_genmsl" nodedef="ND_power_color3" target="genmsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_color3FA_genmsl" nodedef="ND_power_color3FA" target="genmsl" sourcecode="pow({{in1}}, vec3({{in2}}))" />
+  <implementation name="IM_power_color4_genmsl" nodedef="ND_power_color4" target="genmsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_color4FA_genmsl" nodedef="ND_power_color4FA" target="genmsl" sourcecode="pow({{in1}}, vec4({{in2}}))" />
+  <implementation name="IM_power_vector2_genmsl" nodedef="ND_power_vector2" target="genmsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_vector2FA_genmsl" nodedef="ND_power_vector2FA" target="genmsl" sourcecode="pow({{in1}}, vec2({{in2}}))" />
+  <implementation name="IM_power_vector3_genmsl" nodedef="ND_power_vector3" target="genmsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_vector3FA_genmsl" nodedef="ND_power_vector3FA" target="genmsl" sourcecode="pow({{in1}}, vec3({{in2}}))" />
+  <implementation name="IM_power_vector4_genmsl" nodedef="ND_power_vector4" target="genmsl" sourcecode="pow({{in1}}, {{in2}})" />
+  <implementation name="IM_power_vector4FA_genmsl" nodedef="ND_power_vector4FA" target="genmsl" sourcecode="pow({{in1}}, vec4({{in2}}))" />
+
+  <!-- <sin>, <cos>, <tan>, <asin>, <acos>, <atan2> -->
+  <implementation name="IM_sin_float_genmsl" nodedef="ND_sin_float" target="genmsl" sourcecode="sin({{in}})" />
+  <implementation name="IM_cos_float_genmsl" nodedef="ND_cos_float" target="genmsl" sourcecode="cos({{in}})" />
+  <implementation name="IM_tan_float_genmsl" nodedef="ND_tan_float" target="genmsl" sourcecode="tan({{in}})" />
+  <implementation name="IM_asin_float_genmsl" nodedef="ND_asin_float" target="genmsl" sourcecode="asin({{in}})" />
+  <implementation name="IM_acos_float_genmsl" nodedef="ND_acos_float" target="genmsl" sourcecode="acos({{in}})" />
+  <implementation name="IM_atan2_float_genmsl" nodedef="ND_atan2_float" target="genmsl" sourcecode="atan({{in1}}, {{in2}})" />
+  <implementation name="IM_sin_vector2_genmsl" nodedef="ND_sin_vector2" target="genmsl" sourcecode="sin({{in}})" />
+  <implementation name="IM_cos_vector2_genmsl" nodedef="ND_cos_vector2" target="genmsl" sourcecode="cos({{in}})" />
+  <implementation name="IM_tan_vector2_genmsl" nodedef="ND_tan_vector2" target="genmsl" sourcecode="tan({{in}})" />
+  <implementation name="IM_asin_vector2_genmsl" nodedef="ND_asin_vector2" target="genmsl" sourcecode="asin({{in}})" />
+  <implementation name="IM_acos_vector2_genmsl" nodedef="ND_acos_vector2" target="genmsl" sourcecode="acos({{in}})" />
+  <implementation name="IM_atan2_vector2_genmsl" nodedef="ND_atan2_vector2" target="genmsl" sourcecode="atan({{in1}}, {{in2}})" />
+  <implementation name="IM_sin_vector3_genmsl" nodedef="ND_sin_vector3" target="genmsl" sourcecode="sin({{in}})" />
+  <implementation name="IM_cos_vector3_genmsl" nodedef="ND_cos_vector3" target="genmsl" sourcecode="cos({{in}})" />
+  <implementation name="IM_tan_vector3_genmsl" nodedef="ND_tan_vector3" target="genmsl" sourcecode="tan({{in}})" />
+  <implementation name="IM_asin_vector3_genmsl" nodedef="ND_asin_vector3" target="genmsl" sourcecode="asin({{in}})" />
+  <implementation name="IM_acos_vector3_genmsl" nodedef="ND_acos_vector3" target="genmsl" sourcecode="acos({{in}})" />
+  <implementation name="IM_atan2_vector3_genmsl" nodedef="ND_atan2_vector3" target="genmsl" sourcecode="atan({{in1}}, {{in2}})" />
+  <implementation name="IM_sin_vector4_genmsl" nodedef="ND_sin_vector4" target="genmsl" sourcecode="sin({{in}})" />
+  <implementation name="IM_cos_vector4_genmsl" nodedef="ND_cos_vector4" target="genmsl" sourcecode="cos({{in}})" />
+  <implementation name="IM_tan_vector4_genmsl" nodedef="ND_tan_vector4" target="genmsl" sourcecode="tan({{in}})" />
+  <implementation name="IM_asin_vector4_genmsl" nodedef="ND_asin_vector4" target="genmsl" sourcecode="asin({{in}})" />
+  <implementation name="IM_acos_vector4_genmsl" nodedef="ND_acos_vector4" target="genmsl" sourcecode="acos({{in}})" />
+  <implementation name="IM_atan2_vector4_genmsl" nodedef="ND_atan2_vector4" target="genmsl" sourcecode="atan({{in1}}, {{in2}})" />
+
+  <!-- <sqrt> -->
+  <implementation name="IM_sqrt_float_genmsl" nodedef="ND_sqrt_float" target="genmsl" sourcecode="sqrt({{in}})" />
+  <implementation name="IM_sqrt_vector2_genmsl" nodedef="ND_sqrt_vector2" target="genmsl" sourcecode="sqrt({{in}})" />
+  <implementation name="IM_sqrt_vector3_genmsl" nodedef="ND_sqrt_vector3" target="genmsl" sourcecode="sqrt({{in}})" />
+  <implementation name="IM_sqrt_vector4_genmsl" nodedef="ND_sqrt_vector4" target="genmsl" sourcecode="sqrt({{in}})" />
+
+  <!-- <ln> -->
+  <implementation name="IM_ln_float_genmsl" nodedef="ND_ln_float" target="genmsl" sourcecode="log({{in}})" />
+  <implementation name="IM_ln_vector2_genmsl" nodedef="ND_ln_vector2" target="genmsl" sourcecode="log({{in}})" />
+  <implementation name="IM_ln_vector3_genmsl" nodedef="ND_ln_vector3" target="genmsl" sourcecode="log({{in}})" />
+  <implementation name="IM_ln_vector4_genmsl" nodedef="ND_ln_vector4" target="genmsl" sourcecode="log({{in}})" />
+
+  <!-- <exp> -->
+  <implementation name="IM_exp_float_genmsl" nodedef="ND_exp_float" target="genmsl" sourcecode="exp({{in}})" />
+  <implementation name="IM_exp_vector2_genmsl" nodedef="ND_exp_vector2" target="genmsl" sourcecode="exp({{in}})" />
+  <implementation name="IM_exp_vector3_genmsl" nodedef="ND_exp_vector3" target="genmsl" sourcecode="exp({{in}})" />
+  <implementation name="IM_exp_vector4_genmsl" nodedef="ND_exp_vector4" target="genmsl" sourcecode="exp({{in}})" />
+
+  <!-- sign -->
+  <implementation name="IM_sign_float_genmsl" nodedef="ND_sign_float" target="genmsl" sourcecode="sign({{in}})" />
+  <implementation name="IM_sign_color3_genmsl" nodedef="ND_sign_color3" target="genmsl" sourcecode="sign({{in}})" />
+  <implementation name="IM_sign_color4_genmsl" nodedef="ND_sign_color4" target="genmsl" sourcecode="sign({{in}})" />
+  <implementation name="IM_sign_vector2_genmsl" nodedef="ND_sign_vector2" target="genmsl" sourcecode="sign({{in}})" />
+  <implementation name="IM_sign_vector3_genmsl" nodedef="ND_sign_vector3" target="genmsl" sourcecode="sign({{in}})" />
+  <implementation name="IM_sign_vector4_genmsl" nodedef="ND_sign_vector4" target="genmsl" sourcecode="sign({{in}})" />
+
+  <!-- <clamp> -->
+  <implementation name="IM_clamp_float_genmsl" nodedef="ND_clamp_float" target="genmsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_color3_genmsl" nodedef="ND_clamp_color3" target="genmsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_color3FA_genmsl" nodedef="ND_clamp_color3FA" target="genmsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_color4_genmsl" nodedef="ND_clamp_color4" target="genmsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_color4FA_genmsl" nodedef="ND_clamp_color4FA" target="genmsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector2_genmsl" nodedef="ND_clamp_vector2" target="genmsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector2FA_genmsl" nodedef="ND_clamp_vector2FA" target="genmsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector3_genmsl" nodedef="ND_clamp_vector3" target="genmsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector3FA_genmsl" nodedef="ND_clamp_vector3FA" target="genmsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector4_genmsl" nodedef="ND_clamp_vector4" target="genmsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+  <implementation name="IM_clamp_vector4FA_genmsl" nodedef="ND_clamp_vector4FA" target="genmsl" sourcecode="clamp({{in}}, {{low}}, {{high}})" />
+
+  <!-- <min> -->
+  <implementation name="IM_min_float_genmsl" nodedef="ND_min_float" target="genmsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_color3_genmsl" nodedef="ND_min_color3" target="genmsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_color3FA_genmsl" nodedef="ND_min_color3FA" target="genmsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_color4_genmsl" nodedef="ND_min_color4" target="genmsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_color4FA_genmsl" nodedef="ND_min_color4FA" target="genmsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector2_genmsl" nodedef="ND_min_vector2" target="genmsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector2FA_genmsl" nodedef="ND_min_vector2FA" target="genmsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector3_genmsl" nodedef="ND_min_vector3" target="genmsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector3FA_genmsl" nodedef="ND_min_vector3FA" target="genmsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector4_genmsl" nodedef="ND_min_vector4" target="genmsl" sourcecode="min({{in1}}, {{in2}})" />
+  <implementation name="IM_min_vector4FA_genmsl" nodedef="ND_min_vector4FA" target="genmsl" sourcecode="min({{in1}}, {{in2}})" />
+
+  <!-- <max> -->
+  <implementation name="IM_max_float_genmsl" nodedef="ND_max_float" target="genmsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_color3_genmsl" nodedef="ND_max_color3" target="genmsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_color3FA_genmsl" nodedef="ND_max_color3FA" target="genmsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_color4_genmsl" nodedef="ND_max_color4" target="genmsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_color4FA_genmsl" nodedef="ND_max_color4FA" target="genmsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector2_genmsl" nodedef="ND_max_vector2" target="genmsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector2FA_genmsl" nodedef="ND_max_vector2FA" target="genmsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector3_genmsl" nodedef="ND_max_vector3" target="genmsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector3FA_genmsl" nodedef="ND_max_vector3FA" target="genmsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector4_genmsl" nodedef="ND_max_vector4" target="genmsl" sourcecode="max({{in1}}, {{in2}})" />
+  <implementation name="IM_max_vector4FA_genmsl" nodedef="ND_max_vector4FA" target="genmsl" sourcecode="max({{in1}}, {{in2}})" />
+
+  <!-- <normalize> -->
+  <implementation name="IM_normalize_vector2_genmsl" nodedef="ND_normalize_vector2" target="genmsl" sourcecode="normalize({{in}})" />
+  <implementation name="IM_normalize_vector3_genmsl" nodedef="ND_normalize_vector3" target="genmsl" sourcecode="normalize({{in}})" />
+  <implementation name="IM_normalize_vector4_genmsl" nodedef="ND_normalize_vector4" target="genmsl" sourcecode="normalize({{in}})" />
+
+  <!-- <magnitude> -->
+  <implementation name="IM_magnitude_vector2_genmsl" nodedef="ND_magnitude_vector2" target="genmsl" sourcecode="length({{in}})" />
+  <implementation name="IM_magnitude_vector3_genmsl" nodedef="ND_magnitude_vector3" target="genmsl" sourcecode="length({{in}})" />
+  <implementation name="IM_magnitude_vector4_genmsl" nodedef="ND_magnitude_vector4" target="genmsl" sourcecode="length({{in}})" />
+
+  <!-- <dotproduct> -->
+  <implementation name="IM_dotproduct_vector2_genmsl" nodedef="ND_dotproduct_vector2" target="genmsl" sourcecode="dot({{in1}}, {{in2}})" />
+  <implementation name="IM_dotproduct_vector3_genmsl" nodedef="ND_dotproduct_vector3" target="genmsl" sourcecode="dot({{in1}}, {{in2}})" />
+  <implementation name="IM_dotproduct_vector4_genmsl" nodedef="ND_dotproduct_vector4" target="genmsl" sourcecode="dot({{in1}}, {{in2}})" />
+
+  <!-- <crossproduct> -->
+  <implementation name="IM_crossproduct_vector3_genmsl" nodedef="ND_crossproduct_vector3" target="genmsl" sourcecode="cross({{in1}}, {{in2}})" />
+
+  <!-- <transformpoint> -->
+  <implementation name="IM_transformpoint_vector3_genmsl" nodedef="ND_transformpoint_vector3" target="genmsl" />
+
+  <!-- <transformvector> -->
+  <implementation name="IM_transformvector_vector3_genmsl" nodedef="ND_transformvector_vector3" target="genmsl" />
+
+  <!-- <transformnormal> -->
+  <implementation name="IM_transformnormal_vector3_genmsl" nodedef="ND_transformnormal_vector3" target="genmsl" />
+
+  <!-- <transformmatrix> -->
+  <implementation name="IM_transformmatrix_vector2M3_genmsl" nodedef="ND_transformmatrix_vector2M3" function="mx_transformmatrix_vector2M3" file="../genglsl/mx_transformmatrix_vector2M3.glsl" target="genmsl" />
+  <implementation name="IM_transformmatrix_vector3_genmsl" nodedef="ND_transformmatrix_vector3" target="genmsl" sourcecode="{{mat}} * {{in}}" />
+  <implementation name="IM_transformmatrix_vector3M4_genmsl" nodedef="ND_transformmatrix_vector3M4" function="mx_transformmatrix_vector3M4" file="../genglsl/mx_transformmatrix_vector3M4.glsl" target="genmsl" />
+  <implementation name="IM_transformmatrix_vector4_genmsl" nodedef="ND_transformmatrix_vector4" target="genmsl" sourcecode="{{mat}} * {{in}}" />
+
+  <!-- <transpose> -->
+  <implementation name="IM_transpose_matrix33_genmsl" nodedef="ND_transpose_matrix33" target="genmsl" sourcecode="transpose({{in}})" />
+  <implementation name="IM_transpose_matrix44_genmsl" nodedef="ND_transpose_matrix44" target="genmsl" sourcecode="transpose({{in}})" />
+
+  <!-- <determinant> -->
+  <implementation name="IM_determinant_matrix33_genmsl" nodedef="ND_determinant_matrix33" target="genmsl" sourcecode="determinant({{in}})" />
+  <implementation name="IM_determinant_matrix44_genmsl" nodedef="ND_determinant_matrix44" target="genmsl" sourcecode="determinant({{in}})" />
+
+  <!-- <invertmatrix> -->
+  <implementation name="IM_invertmatrix_matrix33_genmsl" nodedef="ND_invertmatrix_matrix33" target="genmsl" sourcecode="inverse({{in}})" />
+  <implementation name="IM_invertmatrix_matrix44_genmsl" nodedef="ND_invertmatrix_matrix44" target="genmsl" sourcecode="inverse({{in}})" />
+
+  <!-- <rotate2d> -->
+  <implementation name="IM_rotate2d_vector2_genmsl" nodedef="ND_rotate2d_vector2" file="../genglsl/mx_rotate_vector2.glsl" function="mx_rotate_vector2" target="genmsl" />
+
+  <!-- <rotate3d> -->
+  <implementation name="IM_rotate3d_vector3_genmsl" nodedef="ND_rotate3d_vector3" file="../genglsl/mx_rotate_vector3.glsl" function="mx_rotate_vector3" target="genmsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Adjustment nodes                                                         -->
+  <!-- ======================================================================== -->
+
+  <!-- <contrast> -->
+
+  <!-- <remap> -->
+  <implementation name="IM_remap_float_genmsl" nodedef="ND_remap_float" target="genmsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_color3_genmsl" nodedef="ND_remap_color3" target="genmsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_color3FA_genmsl" nodedef="ND_remap_color3FA" target="genmsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_color4_genmsl" nodedef="ND_remap_color4" target="genmsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_color4FA_genmsl" nodedef="ND_remap_color4FA" target="genmsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector2_genmsl" nodedef="ND_remap_vector2" target="genmsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector2FA_genmsl" nodedef="ND_remap_vector2FA" target="genmsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector3_genmsl" nodedef="ND_remap_vector3" target="genmsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector3FA_genmsl" nodedef="ND_remap_vector3FA" target="genmsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector4_genmsl" nodedef="ND_remap_vector4" target="genmsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+  <implementation name="IM_remap_vector4FA_genmsl" nodedef="ND_remap_vector4FA" target="genmsl" sourcecode="{{outlow}} + ({{in}} - {{inlow}}) * ({{outhigh}} - {{outlow}}) / ({{inhigh}} - {{inlow}})" />
+
+  <!-- <smoothstep> -->
+  <implementation name="IM_smoothstep_float_genmsl" nodedef="ND_smoothstep_float" file="mx_smoothstep_float.metal" function="mx_smoothstep_float" target="genmsl" />
+  <implementation name="IM_smoothstep_vector2_genmsl" nodedef="ND_smoothstep_vector2" file="mx_smoothstep_vector2.metal" function="mx_smoothstep_vector2" target="genmsl" />
+  <implementation name="IM_smoothstep_vector3_genmsl" nodedef="ND_smoothstep_vector3" file="mx_smoothstep_vector3.metal" function="mx_smoothstep_vector3" target="genmsl" />
+  <implementation name="IM_smoothstep_vector4_genmsl" nodedef="ND_smoothstep_vector4" file="mx_smoothstep_vector4.metal" function="mx_smoothstep_vector4" target="genmsl" />
+
+  <!-- <luminance> -->
+  <implementation name="IM_luminance_color3_genmsl" nodedef="ND_luminance_color3" file="../genglsl/mx_luminance_color3.glsl" function="mx_luminance_color3" target="genmsl" />
+  <implementation name="IM_luminance_color4_genmsl" nodedef="ND_luminance_color4" file="../genglsl/mx_luminance_color4.glsl" function="mx_luminance_color4" target="genmsl" />
+
+  <!-- <rgbtohsv> -->
+  <implementation name="IM_rgbtohsv_color3_genmsl" nodedef="ND_rgbtohsv_color3" file="../genglsl/mx_rgbtohsv_color3.glsl" function="mx_rgbtohsv_color3" target="genmsl" />
+  <implementation name="IM_rgbtohsv_color4_genmsl" nodedef="ND_rgbtohsv_color4" file="../genglsl/mx_rgbtohsv_color4.glsl" function="mx_rgbtohsv_color4" target="genmsl" />
+
+  <!-- <hsvtorgb> -->
+  <implementation name="IM_hsvtorgb_color3_genmsl" nodedef="ND_hsvtorgb_color3" file="../genglsl/mx_hsvtorgb_color3.glsl" function="mx_hsvtorgb_color3" target="genmsl" />
+  <implementation name="IM_hsvtorgb_color4_genmsl" nodedef="ND_hsvtorgb_color4" file="../genglsl/mx_hsvtorgb_color4.glsl" function="mx_hsvtorgb_color4" target="genmsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Compositing nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <premult> -->
+  <implementation name="IM_premult_color4_genmsl" nodedef="ND_premult_color4" file="../genglsl/mx_premult_color4.glsl" function="mx_premult_color4" target="genmsl" />
+  <!-- <unpremult> -->
+  <implementation name="IM_unpremult_color4_genmsl" nodedef="ND_unpremult_color4" file="../genglsl/mx_unpremult_color4.glsl" function="mx_unpremult_color4" target="genmsl" />
+
+  <!-- <plus> -->
+  <implementation name="IM_plus_float_genmsl" nodedef="ND_plus_float" target="genmsl" sourcecode="({{mix}}*({{bg}} + {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_plus_color3_genmsl" nodedef="ND_plus_color3" target="genmsl" sourcecode="({{mix}}*({{bg}} + {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_plus_color4_genmsl" nodedef="ND_plus_color4" target="genmsl" sourcecode="({{mix}}*({{bg}} + {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+
+  <!-- <minus> -->
+  <implementation name="IM_minus_float_genmsl" nodedef="ND_minus_float" target="genmsl" sourcecode="({{mix}}*({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_minus_color3_genmsl" nodedef="ND_minus_color3" target="genmsl" sourcecode="({{mix}}*({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_minus_color4_genmsl" nodedef="ND_minus_color4" target="genmsl" sourcecode="({{mix}}*({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+
+  <!-- <difference> -->
+  <implementation name="IM_difference_float_genmsl" nodedef="ND_difference_float" target="genmsl" sourcecode="({{mix}}*abs({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_difference_color3_genmsl" nodedef="ND_difference_color3" target="genmsl" sourcecode="({{mix}}*abs({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_difference_color4_genmsl" nodedef="ND_difference_color4" target="genmsl" sourcecode="({{mix}}*abs({{bg}} - {{fg}})) + ((1.0-{{mix}})*{{bg}})" />
+
+  <!-- <burn> -->
+  <implementation name="IM_burn_float_genmsl" nodedef="ND_burn_float" file="mx_burn_float.metal" function="mx_burn_float" target="genmsl" />
+  <implementation name="IM_burn_color3_genmsl" nodedef="ND_burn_color3" file="mx_burn_color3.metal" function="mx_burn_color3" target="genmsl" />
+  <implementation name="IM_burn_color4_genmsl" nodedef="ND_burn_color4" file="mx_burn_color4.metal" function="mx_burn_color4" target="genmsl" />
+
+  <!-- <dodge> -->
+  <implementation name="IM_dodge_float_genmsl" nodedef="ND_dodge_float" file="mx_dodge_float.metal" function="mx_dodge_float" target="genmsl" />
+  <implementation name="IM_dodge_color3_genmsl" nodedef="ND_dodge_color3" file="mx_dodge_color3.metal" function="mx_dodge_color3" target="genmsl" />
+  <implementation name="IM_dodge_color4_genmsl" nodedef="ND_dodge_color4" file="mx_dodge_color4.metal" function="mx_dodge_color4" target="genmsl" />
+
+  <!-- <screen> -->
+  <implementation name="IM_screen_float_genmsl" nodedef="ND_screen_float" target="genmsl" sourcecode="({{mix}}*((1.0 - (1.0 - {{fg}}) * (1.0 - {{bg}})))) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_screen_color3_genmsl" nodedef="ND_screen_color3" target="genmsl" sourcecode="({{mix}}*((1.0 - (1.0 - {{fg}}) * (1.0 - {{bg}})))) + ((1.0-{{mix}})*{{bg}})" />
+  <implementation name="IM_screen_color4_genmsl" nodedef="ND_screen_color4" target="genmsl" sourcecode="({{mix}}*((1.0 - (1.0 - {{fg}}) * (1.0 - {{bg}})))) + ((1.0-{{mix}})*{{bg}})" />
+
+  <!-- <disjointover> -->
+  <implementation name="IM_disjointover_color4_genmsl" nodedef="ND_disjointover_color4" file="../genglsl/mx_disjointover_color4.glsl" function="mx_disjointover_color4" target="genmsl" />
+
+  <!-- <in> -->
+  <implementation name="IM_in_color4_genmsl" nodedef="ND_in_color4" target="genmsl" sourcecode="({{fg}}*{{bg}}.a  * {{mix}}) + ({{bg}} * (1.0-{{mix}}));" />
+
+  <!-- <mask> -->
+  <implementation name="IM_mask_color4_genmsl" nodedef="ND_mask_color4" target="genmsl" sourcecode="({{bg}}*{{fg}}.a  * {{mix}}) + ({{bg}} * (1.0-{{mix}}));" />
+
+  <!-- <matte> -->
+  <implementation name="IM_matte_color4_genmsl" nodedef="ND_matte_color4" target="genmsl" sourcecode="vec4( {{fg}}.xyz*{{fg}}.w + {{bg}}.xyz*(1.0-{{fg}}.w), {{fg}}.w + ({{bg}}.w*(1.0-{{fg}}.w)) ) * {{mix}} + ({{bg}} * (1.0-{{mix}}));" />
+
+  <!-- <out> -->
+  <implementation name="IM_out_color4_genmsl" nodedef="ND_out_color4" target="genmsl" sourcecode="({{fg}}*(1.0-{{bg}}.a)  * {{mix}}) + ({{bg}} * (1.0-{{mix}}));" />
+
+  <!-- <over> -->
+  <implementation name="IM_over_color4_genmsl" nodedef="ND_over_color4" target="genmsl" sourcecode="({{fg}} + ({{bg}}*(1.0-{{fg}}[3]))) * {{mix}} + {{bg}} * (1.0-{{mix}})" />
+
+  <!-- <inside> -->
+  <implementation name="IM_inside_float_genmsl" nodedef="ND_inside_float" target="genmsl" sourcecode="{{in}} * {{mask}}" />
+  <implementation name="IM_inside_color3_genmsl" nodedef="ND_inside_color3" target="genmsl" sourcecode="{{in}} * {{mask}}" />
+  <implementation name="IM_inside_color4_genmsl" nodedef="ND_inside_color4" target="genmsl" sourcecode="{{in}} * {{mask}}" />
+
+  <!-- <outside> -->
+  <implementation name="IM_outside_float_genmsl" nodedef="ND_outside_float" target="genmsl" sourcecode="{{in}} * (1.0 - {{mask}})" />
+  <implementation name="IM_outside_color3_genmsl" nodedef="ND_outside_color3" target="genmsl" sourcecode="{{in}} * (1.0 - {{mask}})" />
+  <implementation name="IM_outside_color4_genmsl" nodedef="ND_outside_color4" target="genmsl" sourcecode="{{in}} * (1.0 - {{mask}})" />
+
+  <!-- <mix> -->
+  <implementation name="IM_mix_float_genmsl" nodedef="ND_mix_float" target="genmsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_color3_genmsl" nodedef="ND_mix_color3" target="genmsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_color3_color3_genmsl" nodedef="ND_mix_color3_color3" target="genmsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_color4_genmsl" nodedef="ND_mix_color4" target="genmsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_color4_color4_genmsl" nodedef="ND_mix_color4_color4" target="genmsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector2_genmsl" nodedef="ND_mix_vector2" target="genmsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector2_vector2_genmsl" nodedef="ND_mix_vector2_vector2" target="genmsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector3_genmsl" nodedef="ND_mix_vector3" target="genmsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector3_vector3_genmsl" nodedef="ND_mix_vector3_vector3" target="genmsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector4_genmsl" nodedef="ND_mix_vector4" target="genmsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_vector4_vector4_genmsl" nodedef="ND_mix_vector4_vector4" target="genmsl" sourcecode="mix({{bg}}, {{fg}}, {{mix}})" />
+  <implementation name="IM_mix_surfaceshader_genmsl" nodedef="ND_mix_surfaceshader" function="mx_mix_surfaceshader" file="../genglsl/mx_mix_surfaceshader.glsl" target="genmsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Conditional nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <ifgreater -->
+  <implementation name="IM_ifgreater_float_genmsl" nodedef="ND_ifgreater_float" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_color3_genmsl" nodedef="ND_ifgreater_color3" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_color4_genmsl" nodedef="ND_ifgreater_color4" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector2_genmsl" nodedef="ND_ifgreater_vector2" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector3_genmsl" nodedef="ND_ifgreater_vector3" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector4_genmsl" nodedef="ND_ifgreater_vector4" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_floatI_genmsl" nodedef="ND_ifgreater_floatI" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_color3I_genmsl" nodedef="ND_ifgreater_color3I" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_color4I_genmsl" nodedef="ND_ifgreater_color4I" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector2I_genmsl" nodedef="ND_ifgreater_vector2I" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector3I_genmsl" nodedef="ND_ifgreater_vector3I" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreater_vector4I_genmsl" nodedef="ND_ifgreater_vector4I" target="genmsl" sourcecode="({{value1}} > {{value2}}) ? {{in1}} : {{in2}}" />
+
+  <!-- <ifgreatereq -->
+  <implementation name="IM_ifgreatereq_float_genmsl" nodedef="ND_ifgreatereq_float" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_color3_genmsl" nodedef="ND_ifgreatereq_color3" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_color4_genmsl" nodedef="ND_ifgreatereq_color4" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector2_genmsl" nodedef="ND_ifgreatereq_vector2" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector3_genmsl" nodedef="ND_ifgreatereq_vector3" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector4_genmsl" nodedef="ND_ifgreatereq_vector4" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_floatI_genmsl" nodedef="ND_ifgreatereq_floatI" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_color3I_genmsl" nodedef="ND_ifgreatereq_color3I" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_color4I_genmsl" nodedef="ND_ifgreatereq_color4I" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector2I_genmsl" nodedef="ND_ifgreatereq_vector2I" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector3I_genmsl" nodedef="ND_ifgreatereq_vector3I" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifgreatereq_vector4I_genmsl" nodedef="ND_ifgreatereq_vector4I" target="genmsl" sourcecode="({{value1}} >= {{value2}}) ? {{in1}} : {{in2}}" />
+
+  <!-- <ifequal -->
+  <implementation name="IM_ifequal_float_genmsl" nodedef="ND_ifequal_float" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color3_genmsl" nodedef="ND_ifequal_color3" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color4_genmsl" nodedef="ND_ifequal_color4" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector2_genmsl" nodedef="ND_ifequal_vector2" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector3_genmsl" nodedef="ND_ifequal_vector3" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector4_genmsl" nodedef="ND_ifequal_vector4" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_floatI_genmsl" nodedef="ND_ifequal_floatI" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color3I_genmsl" nodedef="ND_ifequal_color3I" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color4I_genmsl" nodedef="ND_ifequal_color4I" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector2I_genmsl" nodedef="ND_ifequal_vector2I" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector3I_genmsl" nodedef="ND_ifequal_vector3I" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector4I_genmsl" nodedef="ND_ifequal_vector4I" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_floatB_genmsl" nodedef="ND_ifequal_floatB" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color3B_genmsl" nodedef="ND_ifequal_color3B" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_color4B_genmsl" nodedef="ND_ifequal_color4B" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector2B_genmsl" nodedef="ND_ifequal_vector2B" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector3B_genmsl" nodedef="ND_ifequal_vector3B" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+  <implementation name="IM_ifequal_vector4B_genmsl" nodedef="ND_ifequal_vector4B" target="genmsl" sourcecode="({{value1}} == {{value2}}) ? {{in1}} : {{in2}}" />
+
+  <!-- <switch> -->
+
+  <!-- 'which' type : float -->
+  <implementation name="IM_switch_float_genmsl" nodedef="ND_switch_float" target="genmsl" />
+  <implementation name="IM_switch_color3_genmsl" nodedef="ND_switch_color3" target="genmsl" />
+  <implementation name="IM_switch_color4_genmsl" nodedef="ND_switch_color4" target="genmsl" />
+  <implementation name="IM_switch_vector2_genmsl" nodedef="ND_switch_vector2" target="genmsl" />
+  <implementation name="IM_switch_vector3_genmsl" nodedef="ND_switch_vector3" target="genmsl" />
+  <implementation name="IM_switch_vector4_genmsl" nodedef="ND_switch_vector4" target="genmsl" />
+
+  <!-- 'which' type : integer -->
+  <implementation name="IM_switch_floatI_genmsl" nodedef="ND_switch_floatI" target="genmsl" />
+  <implementation name="IM_switch_color3I_genmsl" nodedef="ND_switch_color3I" target="genmsl" />
+  <implementation name="IM_switch_color4I_genmsl" nodedef="ND_switch_color4I" target="genmsl" />
+  <implementation name="IM_switch_vector2I_genmsl" nodedef="ND_switch_vector2I" target="genmsl" />
+  <implementation name="IM_switch_vector3I_genmsl" nodedef="ND_switch_vector3I" target="genmsl" />
+  <implementation name="IM_switch_vector4I_genmsl" nodedef="ND_switch_vector4I" target="genmsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Channel nodes                                                            -->
+  <!-- ======================================================================== -->
+
+  <!-- <convert> -->
+  <implementation name="IM_convert_float_color3_genmsl" nodedef="ND_convert_float_color3" target="genmsl" />
+  <implementation name="IM_convert_float_color4_genmsl" nodedef="ND_convert_float_color4" target="genmsl" />
+  <implementation name="IM_convert_float_vector2_genmsl" nodedef="ND_convert_float_vector2" target="genmsl" />
+  <implementation name="IM_convert_float_vector3_genmsl" nodedef="ND_convert_float_vector3" target="genmsl" />
+  <implementation name="IM_convert_float_vector4_genmsl" nodedef="ND_convert_float_vector4" target="genmsl" />
+  <implementation name="IM_convert_vector2_vector3_genmsl" nodedef="ND_convert_vector2_vector3" target="genmsl" />
+  <implementation name="IM_convert_vector3_vector2_genmsl" nodedef="ND_convert_vector3_vector2" target="genmsl" />
+  <implementation name="IM_convert_vector3_color3_genmsl" nodedef="ND_convert_vector3_color3" target="genmsl" />
+  <implementation name="IM_convert_vector3_vector4_genmsl" nodedef="ND_convert_vector3_vector4" target="genmsl" />
+  <implementation name="IM_convert_vector4_vector3_genmsl" nodedef="ND_convert_vector4_vector3" target="genmsl" />
+  <implementation name="IM_convert_vector4_color4_genmsl" nodedef="ND_convert_vector4_color4" target="genmsl" />
+  <implementation name="IM_convert_color3_vector3_genmsl" nodedef="ND_convert_color3_vector3" target="genmsl" />
+  <implementation name="IM_convert_color4_vector4_genmsl" nodedef="ND_convert_color4_vector4" target="genmsl" />
+  <implementation name="IM_convert_color3_color4_genmsl" nodedef="ND_convert_color3_color4" target="genmsl" />
+  <implementation name="IM_convert_color4_color3_genmsl" nodedef="ND_convert_color4_color3" target="genmsl" />
+  <implementation name="IM_convert_boolean_float_genmsl" nodedef="ND_convert_boolean_float" target="genmsl" />
+  <implementation name="IM_convert_integer_float_genmsl" nodedef="ND_convert_integer_float" target="genmsl" />
+
+  <!-- <swizzle> -->
+  <!-- from type: float -->
+  <implementation name="IM_swizzle_float_color3_genmsl" nodedef="ND_swizzle_float_color3" target="genmsl" />
+  <implementation name="IM_swizzle_float_color4_genmsl" nodedef="ND_swizzle_float_color4" target="genmsl" />
+  <implementation name="IM_swizzle_float_vector2_genmsl" nodedef="ND_swizzle_float_vector2" target="genmsl" />
+  <implementation name="IM_swizzle_float_vector3_genmsl" nodedef="ND_swizzle_float_vector3" target="genmsl" />
+  <implementation name="IM_swizzle_float_vector4_genmsl" nodedef="ND_swizzle_float_vector4" target="genmsl" />
+  <!-- from type: color3 -->
+  <implementation name="IM_swizzle_color3_float_genmsl" nodedef="ND_swizzle_color3_float" target="genmsl" />
+  <implementation name="IM_swizzle_color3_color3_genmsl" nodedef="ND_swizzle_color3_color3" target="genmsl" />
+  <implementation name="IM_swizzle_color3_color4_genmsl" nodedef="ND_swizzle_color3_color4" target="genmsl" />
+  <implementation name="IM_swizzle_color3_vector2_genmsl" nodedef="ND_swizzle_color3_vector2" target="genmsl" />
+  <implementation name="IM_swizzle_color3_vector3_genmsl" nodedef="ND_swizzle_color3_vector3" target="genmsl" />
+  <implementation name="IM_swizzle_color3_vector4_genmsl" nodedef="ND_swizzle_color3_vector4" target="genmsl" />
+  <!-- from type: color4 -->
+  <implementation name="IM_swizzle_color4_float_genmsl" nodedef="ND_swizzle_color4_float" target="genmsl" />
+  <implementation name="IM_swizzle_color4_color3_genmsl" nodedef="ND_swizzle_color4_color3" target="genmsl" />
+  <implementation name="IM_swizzle_color4_color4_genmsl" nodedef="ND_swizzle_color4_color4" target="genmsl" />
+  <implementation name="IM_swizzle_color4_vector2_genmsl" nodedef="ND_swizzle_color4_vector2" target="genmsl" />
+  <implementation name="IM_swizzle_color4_vector3_genmsl" nodedef="ND_swizzle_color4_vector3" target="genmsl" />
+  <implementation name="IM_swizzle_color4_vector4_genmsl" nodedef="ND_swizzle_color4_vector4" target="genmsl" />
+  <!-- from type: vector2 -->
+  <implementation name="IM_swizzle_vector2_float_genmsl" nodedef="ND_swizzle_vector2_float" target="genmsl" />
+  <implementation name="IM_swizzle_vector2_color3_genmsl" nodedef="ND_swizzle_vector2_color3" target="genmsl" />
+  <implementation name="IM_swizzle_vector2_color4_genmsl" nodedef="ND_swizzle_vector2_color4" target="genmsl" />
+  <implementation name="IM_swizzle_vector2_vector2_genmsl" nodedef="ND_swizzle_vector2_vector2" target="genmsl" />
+  <implementation name="IM_swizzle_vector2_vector3_genmsl" nodedef="ND_swizzle_vector2_vector3" target="genmsl" />
+  <implementation name="IM_swizzle_vector2_vector4_genmsl" nodedef="ND_swizzle_vector2_vector4" target="genmsl" />
+  <!-- from type: vector3 -->
+  <implementation name="IM_swizzle_vector3_float_genmsl" nodedef="ND_swizzle_vector3_float" target="genmsl" />
+  <implementation name="IM_swizzle_vector3_color3_genmsl" nodedef="ND_swizzle_vector3_color3" target="genmsl" />
+  <implementation name="IM_swizzle_vector3_color4_genmsl" nodedef="ND_swizzle_vector3_color4" target="genmsl" />
+  <implementation name="IM_swizzle_vector3_vector2_genmsl" nodedef="ND_swizzle_vector3_vector2" target="genmsl" />
+  <implementation name="IM_swizzle_vector3_vector3_genmsl" nodedef="ND_swizzle_vector3_vector3" target="genmsl" />
+  <implementation name="IM_swizzle_vector3_vector4_genmsl" nodedef="ND_swizzle_vector3_vector4" target="genmsl" />
+  <!-- from type: vector4 -->
+  <implementation name="IM_swizzle_vector4_float_genmsl" nodedef="ND_swizzle_vector4_float" target="genmsl" />
+  <implementation name="IM_swizzle_vector4_color3_genmsl" nodedef="ND_swizzle_vector4_color3" target="genmsl" />
+  <implementation name="IM_swizzle_vector4_color4_genmsl" nodedef="ND_swizzle_vector4_color4" target="genmsl" />
+  <implementation name="IM_swizzle_vector4_vector2_genmsl" nodedef="ND_swizzle_vector4_vector2" target="genmsl" />
+  <implementation name="IM_swizzle_vector4_vector3_genmsl" nodedef="ND_swizzle_vector4_vector3" target="genmsl" />
+  <implementation name="IM_swizzle_vector4_vector4_genmsl" nodedef="ND_swizzle_vector4_vector4" target="genmsl" />
+
+  <!-- <combine> -->
+  <implementation name="IM_combine2_vector2_genmsl" nodedef="ND_combine2_vector2" target="genmsl" />
+  <implementation name="IM_combine2_color4CF_genmsl" nodedef="ND_combine2_color4CF" target="genmsl" />
+  <implementation name="IM_combine2_vector4VF_genmsl" nodedef="ND_combine2_vector4VF" target="genmsl" />
+  <implementation name="IM_combine2_vector4VV_genmsl" nodedef="ND_combine2_vector4VV" target="genmsl" />
+  <implementation name="IM_combine3_color3_genmsl" nodedef="ND_combine3_color3" target="genmsl" />
+  <implementation name="IM_combine3_vector3_genmsl" nodedef="ND_combine3_vector3" target="genmsl" />
+  <implementation name="IM_combine4_color4_genmsl" nodedef="ND_combine4_color4" target="genmsl" />
+  <implementation name="IM_combine4_vector4_genmsl" nodedef="ND_combine4_vector4" target="genmsl" />
+
+  <!-- <creatematrix> -->
+  <implementation name="IM_creatematrix_vector3_matrix33_genmsl" nodedef="ND_creatematrix_vector3_matrix33" file="../genglsl/mx_creatematrix_vector3_matrix33.glsl" function="mx_creatematrix_vector3_matrix33" target="genmsl" />
+  <implementation name="IM_creatematrix_vector3_matrix44_genmsl" nodedef="ND_creatematrix_vector3_matrix44" file="../genglsl/mx_creatematrix_vector3_matrix44.glsl" function="mx_creatematrix_vector3_matrix44" target="genmsl" />
+  <implementation name="IM_creatematrix_vector4_matrix44_genmsl" nodedef="ND_creatematrix_vector4_matrix44" file="../genglsl/mx_creatematrix_vector4_matrix44.glsl" function="mx_creatematrix_vector4_matrix44" target="genmsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Convolution nodes                                                        -->
+  <!-- ======================================================================== -->
+
+  <!-- <blur> -->
+  <implementation name="IM_blur_float_genmsl" nodedef="ND_blur_float" target="genmsl" />
+  <implementation name="IM_blur_color3_genmsl" nodedef="ND_blur_color3" target="genmsl" />
+  <implementation name="IM_blur_color4_genmsl" nodedef="ND_blur_color4" target="genmsl" />
+  <implementation name="IM_blur_vector2_genmsl" nodedef="ND_blur_vector2" target="genmsl" />
+  <implementation name="IM_blur_vector3_genmsl" nodedef="ND_blur_vector3" target="genmsl" />
+  <implementation name="IM_blur_vector4_genmsl" nodedef="ND_blur_vector4" target="genmsl" />
+
+  <!-- <heighttonormal> -->
+  <implementation name="IM_heighttonormal_vector3_genmsl" nodedef="ND_heighttonormal_vector3" target="genmsl" />
+
+  <!-- ======================================================================== -->
+  <!-- Organization nodes                                                       -->
+  <!-- ======================================================================== -->
+
+  <!-- <dot> -->
+  <implementation name="IM_dot_float_genmsl" nodedef="ND_dot_float" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_color3_genmsl" nodedef="ND_dot_color3" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_color4_genmsl" nodedef="ND_dot_color4" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_vector2_genmsl" nodedef="ND_dot_vector2" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_vector3_genmsl" nodedef="ND_dot_vector3" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_vector4_genmsl" nodedef="ND_dot_vector4" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_integer_genmsl" nodedef="ND_dot_integer" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_boolean_genmsl" nodedef="ND_dot_boolean" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_matrix33_genmsl" nodedef="ND_dot_matrix33" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_matrix44_genmsl" nodedef="ND_dot_matrix44" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_string_genmsl" nodedef="ND_dot_string" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_filename_genmsl" nodedef="ND_dot_filename" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_surfaceshader_genmsl" nodedef="ND_dot_surfaceshader" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_displacementshader_genmsl" nodedef="ND_dot_displacementshader" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_volumeshader_genmsl" nodedef="ND_dot_volumeshader" target="genmsl" sourcecode="{{in}}" />
+  <implementation name="IM_dot_lightshader_genmsl" nodedef="ND_dot_lightshader" target="genmsl" sourcecode="{{in}}" />
+</materialx>

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genosl/include/color4.h

@@ -0,0 +1,343 @@
+// Open Shading Language : Copyright (c) 2009-2017 Sony Pictures Imageworks Inc., et al.
+// https://github.com/imageworks/OpenShadingLanguage/blob/master/LICENSE
+
+#pragma once
+#define COLOR4_H
+
+
+// color4 is a color + alpha
+struct color4
+{
+    color rgb;
+    float a;
+};
+
+
+
+//
+// For color4, define math operators to match color
+//
+
+color4 __operator__neg__(color4 a)
+{
+    return color4(-a.rgb, -a.a);
+}
+
+color4 __operator__add__(color4 a, color4 b)
+{
+    return color4(a.rgb + b.rgb, a.a + b.a);
+}
+
+color4 __operator__add__(color4 a, int b)
+{
+    return a + color4(color(b), b);
+}
+
+color4 __operator__add__(color4 a, float b)
+{
+    return a + color4(color(b), b);
+}
+
+color4 __operator__add__(int a, color4 b)
+{
+    return color4(color(a), a) + b;
+}
+
+color4 __operator__add__(float a, color4 b)
+{
+    return color4(color(a), a) + b;
+}
+
+color4 __operator__sub__(color4 a, color4 b)
+{
+    return color4(a.rgb - b.rgb, a.a - b.a);
+}
+
+color4 __operator__sub__(color4 a, int b)
+{
+    return a - color4(color(b), b);
+}
+
+color4 __operator__sub__(color4 a, float b)
+{
+    return a - color4(color(b), b);
+}
+
+color4 __operator__sub__(int a, color4 b)
+{
+    return color4(color(a), a) - b;
+}
+
+color4 __operator__sub__(float a, color4 b)
+{
+    return color4(color(a), a) - b;
+}
+
+color4 __operator__mul__(color4 a, color4 b)
+{
+    return color4(a.rgb * b.rgb, a.a * b.a);
+}
+
+color4 __operator__mul__(color4 a, int b)
+{
+    return a * color4(color(b), b);
+}
+
+color4 __operator__mul__(color4 a, float b)
+{
+    return a * color4(color(b), b);
+}
+
+color4 __operator__mul__(int a, color4 b)
+{
+    return color4(color(a), a) * b;
+}
+
+color4 __operator__mul__(float a, color4 b)
+{
+    return color4(color(a), a) * b;
+}
+
+color4 __operator__div__(color4 a, color4 b)
+{
+    return color4(a.rgb / b.rgb, a.a / b.a);
+}
+
+color4 __operator__div__(color4 a, int b)
+{
+    float b_inv = 1.0/b;
+    return a * color4(color(b_inv), b_inv);
+}
+
+color4 __operator__div__(color4 a, float b)
+{
+    float b_inv = 1.0/b;
+    return a * color4(color(b_inv), b_inv);
+}
+
+color4 __operator_div__(int a, color4 b)
+{
+    return color4(color(a), a) / b;
+}
+
+color4 __operator__div__(float a, color4 b)
+{
+    return color4(color(a), a) / b;
+}
+
+int __operator__eq__(color4 a, color4 b)
+{
+    return (a.rgb == b.rgb) && (a.a == b.a);
+}
+
+int __operator__ne__(color4 a, color4 b)
+{
+    return (a.rgb != b.rgb) || (a.a != b.a);
+}
+
+
+
+//
+// For color4, define most of the stdosl functions to match color
+//
+
+color4 abs(color4 a)
+{
+    return color4(abs(a.rgb), abs(a.a));
+}
+
+color4 ceil(color4 a)
+{
+    return color4(ceil(a.rgb), ceil(a.a));
+}
+
+color4 round(color4 a)
+{
+    return color4(round(a.rgb), round(a.a));
+}
+
+color4 floor(color4 a)
+{
+    return color4(floor(a.rgb), floor(a.a));
+}
+
+color4 sqrt(color4 a)
+{
+    return color4(sqrt(a.rgb), sqrt(a.a));
+}
+
+color4 exp(color4 a)
+{
+    return color4(exp(a.rgb), exp(a.a));
+}
+
+color4 log(color4 a)
+{
+    return color4(log(a.rgb), log(a.a));
+}
+
+color4 log2(color4 a)
+{
+    return color4(log2(a.rgb), log2(a.a));
+}
+
+color4 mix(color4 a, color4 b, float x )
+{
+    return color4(mix(a.rgb, b.rgb, x),
+                  mix(a.a, b.a, x));
+}
+
+color4 mix(color4 a, color4 b, color4 x )
+{
+    return color4(mix(a.rgb, b.rgb, x.rgb),
+                  mix(a.a, b.a, x.a));
+}
+
+float dot(color4 a, color b)
+{
+    return dot(a.rgb, b);
+}
+
+color4 smoothstep(color4 edge0, color4 edge1, color4 c)
+{
+    return color4(smoothstep(edge0.rgb, edge1.rgb, c.rgb),
+                  smoothstep(edge0.a, edge1.a, c.a));
+}
+
+color4 smoothstep(float edge0, float edge1, color4 c)
+{
+    return smoothstep(color4(color(edge0), edge0), color4(color(edge1), edge1), c);
+}
+
+color4 clamp(color4 c, color4 minval, color4 maxval)
+{
+    return color4(clamp(c.rgb, minval.rgb, maxval.rgb),
+                  clamp(c.a, minval.a, maxval.a));
+}
+
+color4 clamp(color4 c, float minval, float maxval)
+{
+    return clamp(c, color4(color(minval), minval), color4(color(maxval), maxval));
+}
+
+color4 max(color4 a, color4 b)
+{
+    return color4(max(a.rgb, b.rgb),
+                  max(a.a, b.a));
+}
+
+color4 max(color4 a, float b)
+{
+    return color4(max(a.rgb, b),
+                  max(a.a, b));
+}
+
+color4 min(color4 a, color4 b)
+{
+    return color4(min(a.rgb, b.rgb),
+                  min(a.a, b.a));
+}
+
+color4 min(color4 a, float b)
+{
+    return color4(min(a.rgb, b),
+                  min(a.a, b));
+}
+
+color4 mod(color4 a, color4 b)
+{
+    return color4(mod(a.rgb, b.rgb),
+                  mod(a.a, b.a));
+}
+
+color4 mod(color4 a, int b)
+{
+    return mod(a, color4(color(b), b));
+}
+
+color4 mod(color4 a, float b)
+{
+    return mod(a, color4(color(b), b));
+}
+
+color4 fmod(color4 a, color4 b)
+{
+    return color4(fmod(a.rgb, b.rgb),
+                  fmod(a.a, b.a));
+}
+
+color4 fmod(color4 a, int b)
+{
+    return fmod(a, color4(color(b), b));
+}
+
+color4 fmod(color4 a, float b)
+{
+    return fmod(a, color4(color(b), b));
+}
+
+color4 pow(color4 base, color4 power)
+{
+    return color4(pow(base.rgb, power.rgb),
+                  pow(base.a, power.a));
+}
+
+color4 pow(color4 base, float power)
+{
+    return color4(pow(base.rgb, power),
+                  pow(base.a, power));
+}
+
+color4 sign(color4 a)
+{
+    return color4(sign(a.rgb),
+                  sign(a.a));
+}
+
+color4 sin(color4 a)
+{
+    return color4(sin(a.rgb),
+                  sin(a.a));
+}
+
+color4 cos(color4 a)
+{
+    return color4(cos(a.rgb),
+                  cos(a.a));
+}
+
+color4 tan(color4 a)
+{
+    return color4(tan(a.rgb),
+                  tan(a.a));
+}
+
+color4 asin(color4 a)
+{
+    return color4(asin(a.rgb),
+                  asin(a.a));
+}
+
+color4 acos(color4 a)
+{
+    return color4(acos(a.rgb),
+                  acos(a.a));
+}
+
+color4 atan2(color4 a, float f)
+{
+    return color4(atan2(a.rgb, f),
+                  atan2(a.a, f));
+}
+
+color4 atan2(color4 a, color4 b)
+{
+    return color4(atan2(a.rgb, b.rgb),
+                  atan2(a.a, b.a));
+}
+
+
+color4 transformc (string fromspace, string tospace, color4 C)
+{
+    return color4 (transformc (fromspace, tospace, C.rgb), C.a);
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genosl/include/matrix33.h

@@ -0,0 +1,165 @@
+// Open Shading Language : Copyright (c) 2009-2017 Sony Pictures Imageworks Inc., et al.
+// https://github.com/imageworks/OpenShadingLanguage/blob/master/LICENSE
+//
+// MaterialX specification (c) 2017 Lucasfilm Ltd.
+// http://www.materialx.org/
+
+#pragma once
+#define MATRIX33_H
+
+
+struct matrix33
+{
+    matrix m;
+};
+
+int isValidAs33(matrix m44)
+{
+    return m44[0][3] == 0 && 
+           m44[1][3] == 0 &&
+           m44[2][3] == 0 &&
+           m44[3][0] == 0 &&
+           m44[3][1] == 0 &&
+           m44[3][2] == 0 &&
+           m44[3][3] == 1;
+}
+
+matrix matrix33To44 (matrix33 m33)
+{
+    return m33.m;
+}
+
+// Convert an arbitrary m44 to m33 by removing the translation
+//QUESTION: should we check if it's valid to represent the 4x4 as a 3x3?
+matrix33 matrix44To33 (matrix m44)
+{
+    matrix33 m33;
+    m33.m = m44;
+    m33.m[0][3] = 0;
+    m33.m[1][3] = 0;
+    m33.m[2][3] = 0;
+    m33.m[3][0] = 0;
+    m33.m[3][1] = 0;
+    m33.m[3][2] = 0;
+    m33.m[3][3] = 1;
+
+    return m33;
+}
+
+matrix33 __operator__neg__(matrix33 a)
+{
+    matrix33 m33;
+    m33.m = -a.m;
+    return m33;
+}
+
+
+matrix33 __operator__mul__(int a, matrix33 b)
+{
+    matrix33 m33;
+    m33.m = a * b.m;
+    return m33;
+}
+
+matrix33 __operator__mul__(float a, matrix33 b)
+{
+    matrix33 m33;
+    m33.m = a * b.m;
+    return m33;
+}
+
+matrix33 __operator__mul__(matrix33 a, int b)
+{
+    matrix33 m33;
+    m33.m = a.m * b;
+    return m33;
+}
+
+matrix33 __operator__mul__(matrix33 a, float b)
+{
+    matrix33 m33;
+    m33.m = a.m * b;
+    return m33;
+}
+
+matrix33 __operator__mul__(matrix33 a, matrix33 b)
+{
+    matrix33 m33;
+    m33.m = a.m * b.m;
+    return m33;
+}
+
+matrix33 __operator__div__(int a, matrix33 b)
+{
+    matrix33 m33;
+    m33.m = a / b.m;
+    return m33;
+}
+
+matrix33 __operator__div__(float a, matrix33 b)
+{
+    matrix33 m33;
+    m33.m = a / b.m;
+    return m33;
+}
+
+matrix33 __operator__div__(matrix33 a, int b)
+{
+    matrix33 m33;
+    m33.m = a.m / b;
+    return m33;
+}
+
+matrix33 __operator__div__(matrix33 a, float b)
+{
+    matrix33 m33;
+    m33.m = a.m / b;
+    return m33;
+}
+
+matrix33 __operator__div__(matrix33 a, matrix33 b)
+{
+    matrix33 m33;
+    m33.m = a.m / b.m;
+    return m33;
+}
+
+int __operator__eq__(matrix33 a, matrix33 b)
+{
+    return a.m == b.m;
+}
+
+int __operator__ne__(matrix33 a, matrix33 b)
+{
+    return a.m != b.m;
+}
+
+float determinant (matrix33 a)
+{
+    return determinant(a.m);
+}
+
+matrix33 transpose(matrix33 a)
+{
+    matrix33 m33;
+    m33.m = transpose(a.m);
+    return m33;
+}
+
+point transform(matrix33 a, point b)
+{
+    return transform(a.m, b);
+}
+
+vector transform(matrix33 a, vector b)
+{
+    return transform(a.m, b);
+}
+
+normal transform(matrix33 a, normal b)
+{
+    return transform(a.m, b);
+}
+
+
+

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genosl/include/mx_funcs.h

@@ -0,0 +1,530 @@
+// Open Shading Language : Copyright (c) 2009-2017 Sony Pictures Imageworks Inc., et al.
+// https://github.com/imageworks/OpenShadingLanguage/blob/master/LICENSE
+//
+// MaterialX specification (c) 2017 Lucasfilm Ltd.
+// http://www.materialx.org/
+
+#pragma once
+
+#include "color4.h"
+#include "vector2.h"
+#include "vector4.h"
+#include "matrix33.h"
+
+//
+// Support functions for OSL implementations of the MaterialX nodes.
+//
+
+float mx_ternary(int expr, float v1, float v2) { if (expr) return v1; else return v2; }
+color mx_ternary(int expr, color v1, color v2) { if (expr) return v1; else return v2; }
+color4 mx_ternary(int expr, color4 v1, color4 v2) { if (expr) return v1; else return v2; }
+vector mx_ternary(int expr, vector v1, vector v2) { if (expr) return v1; else return v2; }
+vector2 mx_ternary(int expr, vector2 v1, vector2 v2) { if (expr) return v1; else return v2; }
+vector4 mx_ternary(int expr, vector4 v1, vector4 v2) { if (expr) return v1; else return v2; }
+matrix mx_ternary(int expr, matrix v1, matrix v2) { if (expr) return v1; else return v2; }
+matrix33 mx_ternary(int expr, matrix33 v1, matrix33 v2) { if (expr) return v1; else return v2; }
+
+
+matrix33 mx_add(matrix33 a, matrix33 b)
+{
+    return matrix33(matrix(
+        a.m[0][0]+b.m[0][0], a.m[0][1]+b.m[0][1], a.m[0][2]+b.m[0][2], 0.0,
+        a.m[1][0]+b.m[1][0], a.m[1][1]+b.m[1][1], a.m[1][2]+b.m[1][2], 0.0,
+        a.m[2][0]+b.m[2][0], a.m[2][1]+b.m[2][1], a.m[2][2]+b.m[2][2], 0.0,
+        0.0, 0.0, 0.0, 1.0));
+}
+
+matrix33 mx_add(matrix33 a, float b)
+{
+    return matrix33(matrix(
+        a.m[0][0]+b, a.m[0][1]+b, a.m[0][2]+b, 0.0,
+        a.m[1][0]+b, a.m[1][1]+b, a.m[1][2]+b, 0.0,
+        a.m[2][0]+b, a.m[2][1]+b, a.m[2][2]+b, 0.0,
+        0.0, 0.0, 0.0, 1.0));
+}
+
+matrix mx_add(matrix a, matrix b)
+{
+    return matrix(
+        a[0][0]+b[0][0], a[0][1]+b[0][1], a[0][2]+b[0][2], a[0][3]+b[0][3],
+        a[1][0]+b[1][0], a[1][1]+b[1][1], a[1][2]+b[1][2], a[1][3]+b[1][3],
+        a[2][0]+b[2][0], a[2][1]+b[2][1], a[2][2]+b[2][2], a[2][3]+b[2][3],
+        a[3][0]+b[3][0], a[3][1]+b[3][1], a[3][2]+b[3][2], a[3][3]+b[3][3]);
+}
+
+matrix mx_add(matrix a, float b)
+{
+    return matrix(
+        a[0][0]+b, a[0][1]+b, a[0][2]+b, a[0][3]+b,
+        a[1][0]+b, a[1][1]+b, a[1][2]+b, a[1][3]+b,
+        a[2][0]+b, a[2][1]+b, a[2][2]+b, a[2][3]+b,
+        a[3][0]+b, a[3][1]+b, a[3][2]+b, a[3][3]+b);
+}
+
+
+matrix33 mx_subtract(matrix33 a, matrix33 b)
+{
+    return matrix33(matrix(
+        a.m[0][0]-b.m[0][0], a.m[0][1]-b.m[0][1], a.m[0][2]-b.m[0][2], 0.0,
+        a.m[1][0]-b.m[1][0], a.m[1][1]-b.m[1][1], a.m[1][2]-b.m[1][2], 0.0,
+        a.m[2][0]-b.m[2][0], a.m[2][1]-b.m[2][1], a.m[2][2]-b.m[2][2], 0.0,
+        0.0, 0.0, 0.0, 1.0));
+}
+
+matrix33 mx_subtract(matrix33 a, float b)
+{
+    return matrix33(matrix(
+        a.m[0][0]-b, a.m[0][1]-b, a.m[0][2]-b, 0.0,
+        a.m[1][0]-b, a.m[1][1]-b, a.m[1][2]-b, 0.0,
+        a.m[2][0]-b, a.m[2][1]-b, a.m[2][2]-b, 0.0,
+        0.0, 0.0, 0.0, 1.0));
+}
+
+matrix mx_subtract(matrix a, matrix b)
+{
+   return matrix(
+       a[0][0]-b[0][0], a[0][1]-b[0][1], a[0][2]-b[0][2], a[0][3]-b[0][3],
+       a[1][0]-b[1][0], a[1][1]-b[1][1], a[1][2]-b[1][2], a[1][3]-b[1][3],
+       a[2][0]-b[2][0], a[2][1]-b[2][1], a[2][2]-b[2][2], a[2][3]-b[2][3],
+       a[3][0]-b[3][0], a[3][1]-b[3][1], a[3][2]-b[3][2], a[3][3]-b[3][3]);
+}
+
+matrix mx_subtract(matrix a, float b)
+{
+    return matrix(
+        a[0][0]-b, a[0][1]-b, a[0][2]-b, a[0][3]-b,
+        a[1][0]-b, a[1][1]-b, a[1][2]-b, a[1][3]-b,
+        a[2][0]-b, a[2][1]-b, a[2][2]-b, a[2][3]-b,
+        a[3][0]-b, a[3][1]-b, a[3][2]-b, a[3][3]-b);
+}
+
+
+float mx_remap(float in, float inLow, float inHigh, float outLow, float outHigh, int doClamp)
+{
+      float x = (in - inLow)/(inHigh-inLow);
+      if (doClamp == 1) {
+           x = clamp(x, 0, 1);
+      }
+      return outLow + (outHigh - outLow) * x;
+}
+
+color mx_remap(color in, color inLow, color inHigh, color outLow, color outHigh, int doClamp)
+{
+      color x = (in - inLow) / (inHigh - inLow);
+      if (doClamp == 1) {
+           x = clamp(x, 0, 1);
+      }
+      return outLow + (outHigh - outLow) * x;
+}
+
+color mx_remap(color in, float inLow, float inHigh, float outLow, float outHigh, int doClamp)
+{
+      color x = (in - inLow) / (inHigh - inLow);
+      if (doClamp == 1) {
+           x = clamp(x, 0, 1);
+      }
+      return outLow + (outHigh - outLow) * x;
+}
+
+color4 mx_remap(color4 c, color4 inLow, color4 inHigh, color4 outLow, color4 outHigh, int doClamp)
+{
+      return color4(mx_remap(c.rgb, inLow.rgb, inHigh.rgb, outLow.rgb, outHigh.rgb, doClamp),
+                    mx_remap(c.a, inLow.a, inHigh.a, outLow.a, outHigh.a, doClamp));
+}
+
+color4 mx_remap(color4 c, float inLow, float inHigh, float outLow, float outHigh, int doClamp)
+{
+    color4 c4_inLow = color4(color(inLow), inLow);
+    color4 c4_inHigh = color4(color(inHigh), inHigh);
+    color4 c4_outLow = color4(color(outLow), outLow);
+    color4 c4_outHigh = color4(color(outHigh), outHigh);
+    return mx_remap(c, c4_inLow, c4_inHigh, c4_outLow, c4_outHigh, doClamp);
+}
+
+vector2 mx_remap(vector2 in, vector2 inLow, vector2 inHigh, vector2 outLow, vector2 outHigh, int doClamp)
+{
+    return vector2(mx_remap(in.x, inLow.x, inHigh.x, outLow.x, outHigh.x, doClamp),
+                   mx_remap(in.y, inLow.y, inHigh.y, outLow.y, outHigh.y, doClamp));
+}
+
+vector2 mx_remap(vector2 in, float inLow, float inHigh, float outLow, float outHigh, int doClamp)
+{
+    return vector2(mx_remap(in.x, inLow, inHigh, outLow, outHigh, doClamp),
+                   mx_remap(in.y, inLow, inHigh, outLow, outHigh, doClamp));
+}
+
+vector4 mx_remap(vector4 in, vector4 inLow, vector4 inHigh, vector4 outLow, vector4 outHigh, int doClamp)
+{
+    return vector4(mx_remap(in.x, inLow.x, inHigh.x, outLow.x, outHigh.x, doClamp),
+                   mx_remap(in.y, inLow.y, inHigh.y, outLow.y, outHigh.y, doClamp),
+                   mx_remap(in.z, inLow.z, inHigh.z, outLow.z, outHigh.z, doClamp),
+                   mx_remap(in.w, inLow.w, inHigh.w, outLow.w, outHigh.w, doClamp));
+}
+
+vector4 mx_remap(vector4 in, float inLow, float inHigh, float outLow, float outHigh, int doClamp)
+{
+    return vector4(mx_remap(in.x, inLow, inHigh, outLow, outHigh, doClamp),
+                   mx_remap(in.y, inLow, inHigh, outLow, outHigh, doClamp),
+                   mx_remap(in.z, inLow, inHigh, outLow, outHigh, doClamp),
+                   mx_remap(in.w, inLow, inHigh, outLow, outHigh, doClamp));
+}
+
+
+float mx_contrast(float in, float amount, float pivot)
+{
+    float out = in - pivot;
+    out *= amount;
+    out += pivot;
+    return out;
+}
+
+color mx_contrast(color in, color amount, color pivot)
+{
+    color out = in - pivot;
+    out *= amount;
+    out += pivot;
+    return out;
+}
+
+color mx_contrast(color in, float amount, float pivot)
+{
+    color out = in - pivot;
+    out *= amount;
+    out += pivot;
+    return out;
+}
+
+color4 mx_contrast(color4 c, color4 amount, color4 pivot)
+{
+    return color4(mx_contrast(c.rgb, amount.rgb, pivot.rgb),
+                  mx_contrast(c.a, amount.a, pivot.a));
+}
+
+color4 mx_contrast(color4 c, float amount, float pivot)
+{
+    return mx_contrast(c, color4(color(amount), amount), color4(color(pivot), pivot));
+}
+
+vector2 mx_contrast(vector2 in, vector2 amount, vector2 pivot)
+{
+    return vector2 (mx_contrast(in.x, amount.x, pivot.x),
+                    mx_contrast(in.y, amount.y, pivot.y));
+}
+
+vector2 mx_contrast(vector2 in, float amount, float pivot)
+{
+    return mx_contrast(in, vector2(amount, amount), vector2(pivot, pivot));
+}
+
+vector4 mx_contrast(vector4 in, vector4 amount, vector4 pivot)
+{
+    return vector4(mx_contrast(in.x, amount.x, pivot.x),
+                   mx_contrast(in.y, amount.y, pivot.y),
+                   mx_contrast(in.z, amount.z, pivot.z),
+                   mx_contrast(in.w, amount.w, pivot.w));
+}
+
+vector4 mx_contrast(vector4 in, float amount, float pivot)
+{
+    return vector4(mx_contrast(in.x, amount, pivot),
+                   mx_contrast(in.y, amount, pivot),
+                   mx_contrast(in.z, amount, pivot),
+                   mx_contrast(in.w, amount, pivot));
+}
+
+
+vector2 mx_noise(string noisetype, float x, float y)
+{
+    color cnoise = (color) noise(noisetype, x, y);
+    return vector2 (cnoise[0], cnoise[1]);
+}
+
+color4 mx_noise(string noisetype, float x, float y)
+{
+    color cnoise = (color) noise(noisetype, x, y);
+    float fnoise = (float) noise(noisetype, x + 19, y + 73);
+    return color4 (cnoise, fnoise);
+}
+
+vector4 mx_noise(string noisetype, float x, float y)
+{
+    color cnoise = (color) noise(noisetype, x, y);
+    float fnoise = (float) noise(noisetype, x + 19, y + 73);
+    return vector4 (cnoise[0], cnoise[1], cnoise[2], fnoise);
+}
+
+vector2 mx_noise(string noisetype, point position)
+{
+    color cnoise = (color) noise(noisetype, position);
+    return vector2 (cnoise[0], cnoise[1]);
+}
+
+color4 mx_noise(string noisetype, point position)
+{
+    color cnoise = (color) noise(noisetype, position);
+    float fnoise = (float) noise(noisetype, position+vector(19,73,29));
+    return color4 (cnoise, fnoise);
+}
+
+vector4 mx_noise(string noisetype, point position)
+{
+    color cnoise = (color) noise(noisetype, position);
+    float fnoise = (float) noise(noisetype, position+vector(19,73,29));
+    return vector4 (cnoise[0], cnoise[1], cnoise[2], fnoise);
+}
+
+
+float mx_fbm(point position, int octaves, float lacunarity, float diminish, string noisetype)
+{
+    float out = 0;
+    float amp = 1.0;
+    point p = position;
+
+    for (int i = 0;  i < octaves;  i += 1) {
+        out += amp * noise(noisetype, p);
+        amp *= diminish;
+        p *= lacunarity;
+    }
+    return out;
+}
+
+color mx_fbm(point position, int octaves, float lacunarity, float diminish, string noisetype)
+{
+    color out = 0;
+    float amp = 1.0;
+    point p = position;
+
+    for (int i = 0;  i < octaves;  i += 1) {
+        out += amp * (color)noise(noisetype, p);
+        amp *= diminish;
+        p *= lacunarity;
+    }
+    return out;
+}
+
+vector2 mx_fbm(point position, int octaves, float lacunarity, float diminish, string noisetype)
+{
+    return vector2((float) mx_fbm(position, octaves, lacunarity, diminish, noisetype),
+                   (float) mx_fbm(position+point(19, 193, 17), octaves, lacunarity, diminish, noisetype));
+}
+
+color4 mx_fbm(point position, int octaves, float lacunarity, float diminish, string noisetype)
+{
+    color c = (color) mx_fbm(position, octaves, lacunarity, diminish, noisetype);
+    float f = (float) mx_fbm(position+point(19, 193, 17), octaves, lacunarity, diminish, noisetype);
+    return color4 (c, f);
+}
+
+vector4 mx_fbm(point position, int octaves, float lacunarity, float diminish, string noisetype)
+{
+    color c = (color) mx_fbm(position, octaves, lacunarity, diminish, noisetype);
+    float f = (float) mx_fbm(position+point(19, 193, 17), octaves, lacunarity, diminish, noisetype);
+    return vector4 (c[0], c[1], c[2], f);
+}
+
+
+void mx_split_float(output float x, output int ix)
+{
+    ix = int(floor(x));
+    x -= ix;
+}
+
+float mx_worley_distance(vector2 p, int x, int y, int X, int Y, float jitter, int metric)
+{
+    vector o = cellnoise(x+X, y+Y);
+    o = (o - .5)*jitter + .5;
+    float cposx = x + o[0];
+    float cposy = y + o[1];
+    float diffx = cposx - p.x;
+    float diffy = cposy - p.y;
+
+    if (metric == 2)
+        return abs(diffx) + abs(diffy);     // Manhattan distance
+    if (metric == 3)
+        return max(abs(diffx), abs(diffy)); // Chebyshev distance
+    return diffx*diffx + diffy*diffy;       // Euclidean or distance^2
+}
+
+float mx_worley_distance(vector p, int x, int y, int z, int X, int Y, int Z, float jitter, int metric)
+{
+    vector o = cellnoise(vector(x+X, y+Y, z+Z));
+    o = (o - .5)*jitter + .5;
+    vector cpos = vector(x, y, z) + o;
+    vector diff = cpos - p;
+
+    if (metric == 2)
+        return abs(diff[0]) + abs(diff[1]);     // Manhattan distance
+    if (metric == 3)
+        return max(abs(diff[0]), abs(diff[1])); // Chebyshev distance
+    return dot(diff, diff);                     // Eucldean or distance^2
+}
+
+void mx_sort_distance(float dist, output vector2 result)
+{
+    if (dist < result.x)
+    {
+        result.y = result.x;
+        result.x = dist;
+    }
+    else if (dist < result.y)
+    {
+        result.y = dist;
+    }
+}
+
+void mx_sort_distance(float dist, output vector result)
+{
+    if (dist < result[0])
+    {
+        result[2] = result[1];
+        result[1] = result[0];
+        result[0] = dist;
+    }
+    else if (dist < result[1])
+    {
+        result[2] = result[1];
+        result[1] = dist;
+    }
+    else if (dist < result[2])
+    {
+        result[2] = dist;
+    }
+}
+
+float mx_worley_noise_float(vector2 p, float jitter, int metric)
+{
+    int X, Y;
+    vector2 seed = p;
+    float result = 1e6;
+
+    mx_split_float(seed.x, X);
+    mx_split_float(seed.y, Y);
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            float d = mx_worley_distance(seed, x, y, X, Y, jitter, metric);
+            result = min(result, d);
+        }
+    }
+    if (metric == 0)
+        result = sqrt(result);
+    return result;
+}
+
+vector2 mx_worley_noise_vector2(vector2 p, float jitter, int metric)
+{
+    int X, Y;
+    vector2 seed = p;
+    vector2 result = vector2(1e6, 1e6);
+
+    mx_split_float(seed.x, X);
+    mx_split_float(seed.y, Y);
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            float d = mx_worley_distance(seed, x, y, X, Y, jitter, metric);
+            mx_sort_distance(d, result);
+        }
+    }
+    if (metric == 0)
+        result = sqrt(result);
+    return result;
+}
+
+vector mx_worley_noise_vector3(vector2 p, float jitter, int metric)
+{
+    int X, Y;
+    vector2 seed = p;
+    vector result = vector(1e6, 1e6, 1e6);
+
+    mx_split_float(seed.x, X);
+    mx_split_float(seed.y, Y);
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            float d = mx_worley_distance(seed, x, y, X, Y, jitter, metric);
+            mx_sort_distance(d, result);
+        }
+    }
+    if (metric == 0)
+        result = sqrt(result);
+    return result;
+}
+
+float mx_worley_noise_float(vector p, float jitter, int metric)
+{
+    int X, Y, Z;
+    vector seed = p;
+    float result = 1e6;
+
+    mx_split_float(seed[0], X);
+    mx_split_float(seed[1], Y);
+    mx_split_float(seed[2], Z);
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            for (int z = -1; z <= 1; ++z)
+            {
+                float d = mx_worley_distance(seed, x, y, z, X, Y, Z, jitter, metric);
+                result = min(result, d);
+            }
+        }
+    }
+    if (metric == 0)
+        result = sqrt(result);
+    return result;
+}
+
+vector2 mx_worley_noise_vector2(vector p, float jitter, int metric)
+{
+    int X, Y, Z;
+    vector seed = p;
+    vector2 result = vector2(1e6, 1e6);
+
+    mx_split_float(seed[0], X);
+    mx_split_float(seed[1], Y);
+    mx_split_float(seed[2], Z);
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            for (int z = -1; z <= 1; ++z)
+            {
+                float d = mx_worley_distance(seed, x, y, z, X, Y, Z, jitter, metric);
+                mx_sort_distance(d, result);
+            }
+        }
+    }
+    if (metric == 0)
+        result = sqrt(result);
+    return result;
+}
+
+vector mx_worley_noise_vector3(vector p, float jitter, int metric)
+{
+    int X, Y, Z;
+    vector result = 1e6;
+    vector seed = p;
+
+    mx_split_float(seed[0], X);
+    mx_split_float(seed[1], Y);
+    mx_split_float(seed[2], Z);
+    for (int x = -1; x <= 1; ++x)
+    {
+        for (int y = -1; y <= 1; ++y)
+        {
+            for (int z = -1; z <= 1; ++z)
+            {
+                float d = mx_worley_distance(seed, x, y, z, X, Y, Z, jitter, metric);
+                mx_sort_distance(d, result);
+            }
+        }
+    }
+    if (metric == 0)
+        result = sqrt(result);
+    return result;
+}

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genosl/include/vector2.h

@@ -0,0 +1,336 @@
+// Open Shading Language : Copyright (c) 2009-2017 Sony Pictures Imageworks Inc., et al.
+// https://github.com/imageworks/OpenShadingLanguage/blob/master/LICENSE
+
+#pragma once
+#define VECTOR2_H
+
+// vector2 is a 2D vector
+struct vector2
+{
+    float x;
+    float y;
+};
+
+
+
+//
+// For vector2, define math operators to match vector
+//
+
+vector2 __operator__neg__(vector2 a)
+{
+    return vector2(-a.x, -a.y);
+}
+
+vector2 __operator__add__(vector2 a, vector2 b)
+{
+    return vector2(a.x + b.x, a.y + b.y);
+}
+
+vector2 __operator__add__(vector2 a, int b)
+{
+    return a + vector2(b, b);
+}
+
+vector2 __operator__add__(vector2 a, float b)
+{
+    return a + vector2(b, b);
+}
+
+vector2 __operator__add__(int a, vector2 b)
+{
+    return vector2(a, a) + b;
+}
+
+vector2 __operator__add__(float a, vector2 b)
+{
+    return vector2(a, a) + b;
+}
+
+vector2 __operator__sub__(vector2 a, vector2 b)
+{
+    return vector2(a.x - b.x, a.y - b.y);
+}
+
+vector2 __operator__sub__(vector2 a, int b)
+{
+    return a - vector2(b, b);
+}
+
+vector2 __operator__sub__(vector2 a, float b)
+{
+    return a - vector2(b, b);
+}
+
+vector2 __operator__sub__(int a, vector2 b)
+{
+    return vector2(a, a) - b;
+}
+
+vector2 __operator__sub__(float a, vector2 b)
+{
+    return vector2(a, a) - b;
+}
+
+vector2 __operator__mul__(vector2 a, vector2 b)
+{
+    return vector2(a.x * b.x, a.y * b.y);
+}
+
+vector2 __operator__mul__(vector2 a, int b)
+{
+    return a * vector2(b, b);
+}
+
+vector2 __operator__mul__(vector2 a, float b)
+{
+    return a * vector2(b, b);
+}
+
+vector2 __operator__mul__(int a, vector2 b)
+{
+    return b * vector2(a, a);
+}
+
+vector2 __operator__mul__(float a, vector2 b)
+{
+    return b * vector2(a, a);
+}
+
+vector2 __operator__div__(vector2 a, vector2 b)
+{
+    return vector2(a.x / b.x, a.y / b.y);
+}
+
+vector2 __operator__div__(vector2 a, int b)
+{
+    float b_inv = 1.0/b;
+    return a * vector2(b_inv, b_inv);
+}
+
+vector2 __operator__div__(vector2 a, float b)
+{
+    float b_inv = 1.0/b;
+    return a * vector2(b_inv, b_inv);
+}
+
+vector2 __operator__div__(int a, vector2 b)
+{
+    return vector2(a, a) / b;
+}
+
+vector2 __operator__div__(float a, vector2 b)
+{
+    return vector2(a, a) / b;
+}
+
+int __operator__eq__(vector2 a, vector2 b)
+{
+    return (a.x == b.x) && (a.y == b.y);
+}
+
+int __operator__ne__(vector2 a, vector2 b)
+{
+    return (a.x != b.x) || (a.y != b.y);
+}
+
+
+
+
+//
+// For vector2, define most of the stdosl functions to match vector
+//
+
+vector2 abs(vector2 a)
+{
+    return vector2 (abs(a.x), abs(a.y));
+}
+
+vector2 ceil(vector2 a)
+{
+    return vector2 (ceil(a.x), ceil(a.y));
+}
+
+vector2 round(vector2 a)
+{
+    return vector2 (round(a.x), round(a.y));
+}
+
+vector2 floor(vector2 a)
+{
+    return vector2 (floor(a.x), floor(a.y));
+}
+
+vector2 sqrt(vector2 a)
+{
+    return vector2 (sqrt(a.x), sqrt(a.y));
+}
+
+vector2 exp(vector2 a)
+{
+    return vector2 (exp(a.x), exp(a.y));
+}
+
+vector2 log(vector2 a)
+{
+    return vector2 (log(a.x), log(a.y));
+}
+
+vector2 log2(vector2 a)
+{
+    return vector2 (log2(a.x), log2(a.y));
+}
+
+vector2 mix(vector2 a, vector2 b, float x )
+{
+    return vector2 (mix(a.x, b.x, x), mix(a.y, b.y, x));
+}
+
+vector2 mix(vector2 a, vector2 b, vector2 x )
+{
+    return vector2 (mix(a.x, b.x, x.x), mix(a.y, b.y, x.y));
+}
+
+float dot(vector2 a, vector2 b)
+{
+    return (a.x * b.x + a.y * b.y);
+}
+
+float length (vector2 a)
+{
+    return hypot (a.x, a.y);
+}
+
+vector2 smoothstep(vector2 low, vector2 high, vector2 in)
+{
+    return vector2 (smoothstep(low.x, high.x, in.x),
+                    smoothstep(low.y, high.y, in.y));
+}
+
+vector2 smoothstep(float low, float high, vector2 in)
+{
+    return vector2 (smoothstep(low, high, in.x),
+                    smoothstep(low, high, in.y));
+}
+
+vector2 clamp(vector2 in, vector2 low, vector2 high)
+{
+    return vector2 (clamp(in.x, low.x, high.x),
+                    clamp(in.y, low.y, high.y));
+}
+
+vector2 clamp(vector2 in, float low, float high)
+{
+    return clamp(in, vector2(low, low), vector2(high, high));
+}
+
+vector2 max(vector2 a, vector2 b)
+{
+    return vector2 (max(a.x, b.x),
+                    max(a.y, b.y));
+}
+
+vector2 max(vector2 a, float b)
+{
+    return max(a, vector2(b, b));
+}
+
+vector2 normalize(vector2 a)
+{
+    return a / length(a);
+}
+
+vector2 min(vector2 a, vector2 b)
+{
+    return vector2 (min(a.x, a.x),
+                    min(b.y, b.y));
+}
+
+vector2 min(vector2 a, float b)
+{
+    return min(a, vector2(b, b));
+}
+
+vector2 mod(vector2 a, vector2 b)
+{
+    return vector2(mod(a.x, b.x),
+                   mod(a.y, b.y));
+}
+
+vector2 mod(vector2 a, float b)
+{
+    return mod(a, vector2(b, b));
+}
+
+vector2 fmod(vector2 a, vector2 b)
+{
+    return vector2 (fmod(a.x, b.x),
+                    fmod(a.y, b.y));
+}
+
+vector2 fmod(vector2 a, float b)
+{
+    return fmod(a, vector2(b, b));
+}
+
+vector2 pow(vector2 in, vector2 amount)
+{
+    return vector2(pow(in.x, amount.x),
+                   pow(in.y, amount.y));
+}
+
+vector2 pow(vector2 in, float amount)
+{
+    return vector2(pow(in.x, amount),
+                   pow(in.y, amount));
+}
+
+vector2 sign(vector2 a)
+{
+    return vector2(sign(a.x),
+                   sign(a.y));
+}
+
+vector2 sin(vector2 a)
+{
+    return vector2(sin(a.x),
+                   sin(a.y));
+}
+
+vector2 cos(vector2 a)
+{
+    return vector2(cos(a.x),
+                   cos(a.y));
+}
+
+vector2 tan(vector2 a)
+{
+    return vector2(tan(a.x),
+                   tan(a.y));
+}
+
+vector2 asin(vector2 a)
+{
+    return vector2(asin(a.x),
+                   asin(a.y));
+}
+
+vector2 acos(vector2 a)
+{
+    return vector2(acos(a.x),
+                   acos(a.y));
+}
+
+vector2 atan2(vector2 a, float f)
+{
+    return vector2(atan2(a.x, f),
+                  atan2(a.y, f));
+}
+
+vector2 atan2(vector2 a, vector2 b)
+{
+    return vector2(atan2(a.x, b.x),
+                  atan2(a.y, b.y));
+}
+
+

Packaged/Windows/Engine/Binaries/ThirdParty/MaterialX/libraries/stdlib/genosl/include/vector4.h

@@ -0,0 +1,423 @@
+// Open Shading Language : Copyright (c) 2009-2017 Sony Pictures Imageworks Inc., et al.
+// https://github.com/imageworks/OpenShadingLanguage/blob/master/LICENSE
+
+#pragma once
+#define VECTOR4_H
+
+
+// vector4 is a 4D vector
+struct vector4
+{
+    float x;
+    float y;
+    float z;
+    float w;
+};
+
+
+
+//
+// For vector4, define math operators to match vector
+//
+
+vector4 __operator__neg__(vector4 a)
+{
+    return vector4(-a.x, -a.y, -a.z, -a.w);
+}
+
+vector4 __operator__add__(vector4 a, vector4 b)
+{
+    return vector4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
+}
+
+vector4 __operator__add__(vector4 a, int b)
+{
+    return a + vector4(b, b, b, b);
+}
+
+vector4 __operator__add__(vector4 a, float b)
+{
+    return a + vector4(b, b, b, b);
+}
+
+vector4 __operator__add__(int a, vector4 b)
+{
+    return vector4(a, a, a, a) + b;
+}
+
+vector4 __operator__add__(float a, vector4 b)
+{
+    return vector4(a, a, a, a) + b;
+}
+
+vector4 __operator__sub__(vector4 a, vector4 b)
+{
+    return vector4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
+}
+
+vector4 __operator__sub__(vector4 a, int b)
+{
+    return a - vector4(b, b, b, b);
+}
+
+vector4 __operator__sub__(vector4 a, float b)
+{
+    return a - vector4(b, b, b, b);
+}
+
+vector4 __operator__sub__(int a, vector4 b)
+{
+    return vector4(a, a, a, a) - b;
+}
+
+vector4 __operator__sub__(float a, vector4 b)
+{
+    return vector4(a, a, a, a) - b;
+}
+
+vector4 __operator__mul__(vector4 a, vector4 b)
+{
+    return vector4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
+}
+
+vector4 __operator__mul__(vector4 a, int b)
+{
+    return a * vector4(b, b, b, b);
+}
+
+vector4 __operator__mul__(vector4 a, float b)
+{
+    return a * vector4(b, b, b, b);
+}
+
+vector4 __operator__mul__(int a, vector4 b)
+{
+    return vector4(a, a, a, a) * b;
+}
+
+vector4 __operator__mul__(float a, vector4 b)
+{
+    return vector4(a, a, a, a) * b;
+}
+
+vector4 __operator__div__(vector4 a, vector4 b)
+{
+    return vector4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
+}
+
+vector4 __operator__div__(vector4 a, int b)
+{
+    float b_inv = 1.0/b;
+    return a * vector4(b_inv, b_inv, b_inv, b_inv);
+}
+
+vector4 __operator__div__(vector4 a, float b)
+{
+    float b_inv = 1.0/b;
+    return a * vector4(b_inv, b_inv, b_inv, b_inv);
+}
+
+vector4 __operator__div__(int a, vector4 b)
+{
+    return vector4(a, a, a, a) / b;
+}
+
+vector4 __operator__div__(float a, vector4 b)
+{
+    return vector4(a, a, a, a) / b;
+}
+
+int __operator__eq__(vector4 a, vector4 b)
+{
+    return (a.x == b.x) && (a.y == b.y) && (a.z == b.z) && (a.w == b.w);
+}
+
+int __operator__ne__(vector4 a, vector4 b)
+{
+    return (a.x != b.x) || (a.y != b.y) || (a.z != b.z) || (a.w != b.w);
+}
+
+
+
+
+//
+// For vector4, define most of the stdosl functions to match vector
+//
+
+vector4 abs(vector4 in)
+{
+    return vector4 (abs(in.x),
+                    abs(in.y),
+                    abs(in.z),
+                    abs(in.w));
+}
+
+vector4 ceil(vector4 in)
+{
+    return vector4 (ceil(in.x),
+                    ceil(in.y),
+                    ceil(in.z),
+                    ceil(in.w));
+}
+
+vector4 round(vector4 in)
+{
+    return vector4 (round(in.x),
+                    round(in.y),
+                    round(in.z),
+                    round(in.w));
+}
+
+vector4 floor(vector4 in)
+{
+    return vector4 (floor(in.x),
+                    floor(in.y),
+                    floor(in.z),
+                    floor(in.w));
+}
+
+vector4 sqrt(vector4 in)
+{
+    return vector4 (sqrt(in.x),
+                    sqrt(in.y),
+                    sqrt(in.z),
+                    sqrt(in.w));
+}
+
+vector4 exp(vector4 in)
+{
+    return vector4 (exp(in.x),
+                    exp(in.y),
+                    exp(in.z),
+                    exp(in.w));
+}
+
+vector4 log(vector4 in)
+{
+    return vector4 (log(in.x),
+                    log(in.y),
+                    log(in.z),
+                    log(in.w));
+}
+
+vector4 log2(vector4 in)
+{
+    return vector4 (log2(in.x),
+                    log2(in.y),
+                    log2(in.z),
+                    log2(in.w));
+}
+
+vector4 mix(vector4 value1, vector4 value2, float x )
+{
+    return vector4 (mix( value1.x, value2.x, x),
+                    mix( value1.y, value2.y, x),
+                    mix( value1.z, value2.z, x),
+                    mix( value1.w, value2.w, x));
+}
+
+vector4 mix(vector4 value1, vector4 value2, vector4 x )
+{
+    return vector4 (mix( value1.x, value2.x, x.x),
+                    mix( value1.y, value2.y, x.y),
+                    mix( value1.z, value2.z, x.z),
+                    mix( value1.w, value2.w, x.w));
+}
+
+vector vec4ToVec3(vector4 v)
+{
+    return vector(v.x, v.y, v.z) / v.w;
+}
+
+float dot(vector4 a, vector4 b)
+{
+    return ((a.x * b.x) + (a.y * b.y) + (a.z * b.z) + (a.w * b.w));
+}
+
+float length (vector4 a)
+{
+    return sqrt (a.x*a.x + a.y*a.y + a.z*a.z + a.w*a.w);
+}
+
+vector4 smoothstep(vector4 low, vector4 high, vector4 in)
+{
+    return vector4 (smoothstep(low.x, high.x, in.x),
+                    smoothstep(low.y, high.y, in.y),
+                    smoothstep(low.z, high.z, in.z),
+                    smoothstep(low.w, high.w, in.w));
+}
+
+vector4 smoothstep(float low, float high, vector4 in)
+{
+    return vector4 (smoothstep(low, high, in.x),
+                    smoothstep(low, high, in.y),
+                    smoothstep(low, high, in.z),
+                    smoothstep(low, high, in.w));
+}
+
+vector4 clamp(vector4 in, vector4 low, vector4 high)
+{
+    return vector4 (clamp(in.x, low.x, high.x),
+                    clamp(in.y, low.y, high.y),
+                    clamp(in.z, low.z, high.z),
+                    clamp(in.w, low.w, high.w));
+}
+
+vector4 clamp(vector4 in, float low, float high)
+{
+    return vector4 (clamp(in.x, low, high),
+                    clamp(in.y, low, high),
+                    clamp(in.z, low, high),
+                    clamp(in.w, low, high));
+}
+
+vector4 max(vector4 a, vector4 b)
+{
+    return vector4 (max(a.x, b.x),
+                    max(a.y, b.y),
+                    max(a.z, b.z),
+                    max(a.w, b.w));
+}
+
+vector4 max(vector4 a, float b)
+{
+    return max(a, vector4(b, b, b, b));
+}
+
+vector4 normalize(vector4 a)
+{
+    return a / length(a);
+}
+
+vector4 min(vector4 a, vector4 b)
+{
+    return vector4 (min(a.x, b.x),
+                    min(a.y, b.y),
+                    min(a.z, b.z),
+                    min(a.w, b.w));
+}
+
+vector4 min(vector4 a, float b)
+{
+    return min(a, vector4(b, b, b, b));
+}
+
+vector4 mod(vector4 a, vector4 b)
+{
+    return vector4(mod(a.x, b.x),
+                   mod(a.y, b.y),
+                   mod(a.z, b.z),
+                   mod(a.w, b.w));
+}
+
+vector4 mod(vector4 a, float b)
+{
+    return mod(a, vector4(b, b, b, b));
+}
+
+vector4 fmod(vector4 a, vector4 b)
+{
+    return vector4 (fmod(a.x, b.x),
+                    fmod(a.y, b.y),
+                    fmod(a.z, b.z),
+                    fmod(a.w, b.w));
+}
+
+vector4 fmod(vector4 a, float b)
+{
+    return fmod(a, vector4(b, b, b, b));
+}
+
+vector4 pow(vector4 in, vector4 amount)
+{
+    return vector4 (pow(in.x, amount.x),
+                    pow(in.y, amount.y),
+                    pow(in.z, amount.z),
+                    pow(in.w, amount.w));
+}
+
+vector4 pow(vector4 in, float amount)
+{
+    return vector4 (pow(in.x, amount),
+                    pow(in.y, amount),
+                    pow(in.z, amount),
+                    pow(in.w, amount));
+}
+
+vector4 sign(vector4 a)
+{
+    return vector4(sign(a.x),
+                   sign(a.y),
+                   sign(a.z),
+                   sign(a.w));
+}
+
+vector4 sin(vector4 a)
+{
+    return vector4(sin(a.x),
+                   sin(a.y),
+                   sin(a.z),
+                   sin(a.w));
+}
+
+vector4 cos(vector4 a)
+{
+    return vector4(cos(a.x),
+                   cos(a.y),
+                   cos(a.z),
+                   cos(a.w));
+}
+
+vector4 tan(vector4 a)
+{
+    return vector4(tan(a.x),
+                   tan(a.y),
+                   tan(a.z),
+                   tan(a.w));
+}
+
+vector4 asin(vector4 a)
+{
+    return vector4(asin(a.x),
+                   asin(a.y),
+                   asin(a.z),
+                   asin(a.w));
+}
+
+vector4 acos(vector4 a)
+{
+    return vector4(acos(a.x),
+                   acos(a.y),
+                   acos(a.z),
+                   acos(a.w));
+}
+
+vector4 atan2(vector4 a, float f)
+{
+    return vector4(atan2(a.x, f),
+                   atan2(a.y, f),
+                   atan2(a.z, f),
+                   atan2(a.w, f));
+}
+
+vector4 atan2(vector4 a, vector4 b)
+{
+    return vector4(atan2(a.x, b.x),
+                   atan2(a.y, b.y),
+                   atan2(a.z, b.z),
+                   atan2(a.w, b.w));
+}
+
+
+vector4 transform (matrix M, vector4 p)
+{
+    return vector4 (M[0][0]*p.x + M[1][0]*p.y + M[2][0]*p.z + M[3][0]*p.w,
+                    M[0][1]*p.x + M[1][1]*p.y + M[2][1]*p.z + M[3][1]*p.w,
+                    M[0][2]*p.x + M[1][2]*p.y + M[2][2]*p.z + M[3][2]*p.w,
+                    M[0][3]*p.x + M[1][3]*p.y + M[2][3]*p.z + M[3][3]*p.w);
+}
+
+vector4 transform (string fromspace, string tospace, vector4 p)
+{
+    return transform (matrix(fromspace,tospace), p);
+}