@tushar-br/editing-pack 1.0.194 → 1.0.195

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/include/vector4.h

@@ -0,0 +1,424 @@
+// Copyright Contributors to the Open Shading Language project.
+// SPDX-License-Identifier: BSD-3-Clause
+// https://github.com/AcademySoftwareFoundation/OpenShadingLanguage
+
+#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 / float(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__neq__(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 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 normalize(vector4 a)
+{
+    return a / length(a);
+}
+
+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);
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/lib/mx_sampling.osl

@@ -0,0 +1,150 @@
+// 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
+//
+vector2 mx_compute_sample_size_uv(vector2 uv, float filterSize, float filterOffset)
+{
+   vector derivUVx = Dx(vector(uv.x, uv.y, 0.0)) * 0.5;
+   vector derivUVy = Dy(vector(uv.x, uv.y, 0.0)) * 0.5;
+   float derivX = abs(derivUVx[0]) + abs(derivUVy[0]);
+   float derivY = abs(derivUVx[1]) + abs(derivUVy[1]);
+   float sampleSizeU = filterSize * derivX + filterOffset;
+   if (sampleSizeU < 1.0E-05)
+       sampleSizeU = 1.0E-05;
+   float sampleSizeV = filterSize * derivY + filterOffset;
+   if (sampleSizeV < 1.0E-05)
+       sampleSizeV = 1.0E-05;
+   return vector2(sampleSizeU, sampleSizeV);
+}
+
+// Kernel weights for box filter
+void mx_get_box_weights(output float W[MX_MAX_SAMPLE_COUNT], int filterSize)
+{
+    int sampleCount = filterSize*filterSize;
+    float value = 1.0 / float(sampleCount);
+    for (int i=0; i<sampleCount; i++)
+    {
+        W[i] = value;
+    }
+}
+
+// Kernel weights for Gaussian filter. Sigma is assumed to be 1.
+void mx_get_gaussian_weights(output float W[MX_MAX_SAMPLE_COUNT], int filterSize)
+{
+    if (filterSize >= 7)
+    {
+        W[0] = 0.000036;  W[1] = 0.000363;  W[2] = 0.001446;  W[3] = 0.002291;  W[4] = 0.001446;  W[5] = 0.000363;  W[6] = 0.000036;
+        W[7] = 0.000363;  W[8] = 0.003676;  W[9] = 0.014662;  W[10] = 0.023226; W[11] = 0.014662; W[12] = 0.003676; W[13] = 0.000363;
+        W[14] = 0.001446; W[15] = 0.014662; W[16] = 0.058488; W[17] = 0.092651; W[18] = 0.058488; W[19] = 0.014662; W[20] = 0.001446;
+        W[21] = 0.002291; W[22] = 0.023226; W[23] = 0.092651; W[24] = 0.146768; W[25] = 0.092651; W[26] = 0.023226; W[27] = 0.002291;
+        W[28] = 0.001446; W[29] = 0.014662; W[30] = 0.058488; W[31] = 0.092651; W[32] = 0.058488; W[33] = 0.014662; W[34] = 0.001446;
+        W[35] = 0.000363; W[36] = 0.003676; W[37] = 0.014662; W[38] = 0.023226; W[39] = 0.014662; W[40] = 0.003676; W[41] = 0.000363;
+        W[42] = 0.000036; W[43] = 0.000363; W[44] = 0.001446; W[45] = 0.002291; W[46] = 0.001446; W[47] = 0.000363; W[48] = 0.000036;
+    }
+    else if (filterSize >= 5)
+    {
+        W[0] = 0.003765;  W[1] = 0.015019;  W[2] = 0.023792;  W[3] = 0.015019;  W[4] = 0.003765;
+        W[5] = 0.015019;  W[6] = 0.059912;  W[7] = 0.094907;  W[8] = 0.059912;  W[9] = 0.015019;
+        W[10] = 0.023792; W[11] = 0.094907; W[12] = 0.150342; W[13] = 0.094907; W[14] = 0.023792;
+        W[15] = 0.015019; W[16] = 0.059912; W[17] = 0.094907; W[18] = 0.059912; W[19] = 0.015019;
+        W[20] = 0.003765; W[21] = 0.015019; W[22] = 0.023792; W[23] = 0.015019; W[24] = 0.003765;
+    }
+    else if (filterSize >= 3)
+    {
+        W[0] = 0.0625; W[1] = 0.125; W[2] = 0.0625;
+        W[3] = 0.125;  W[4] = 0.25;  W[5] = 0.125;
+        W[6] = 0.0625; W[7] = 0.125; W[8] = 0.0625;
+    }
+    else
+    {
+        W[0] = 1.0;
+    }
+}
+
+//
+// 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 vector2 samples S, using weights W.
+// sampleCount should be a square of a odd number in the range { 1, 3, 5, 7 }
+//
+vector2 mx_convolution_vector2(vector2 S[MX_MAX_SAMPLE_COUNT], float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    vector2 result = vector2(0.0, 0.0);
+    for (int i=0;  i<sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}
+
+//
+// Apply filter for vector samples S, using weights W.
+// sampleCount should be a square of a odd number in the range { 1, 3, 5, 7 }
+//
+vector mx_convolution_vector(vector S[MX_MAX_SAMPLE_COUNT], float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    vector result = vector(0.0, 0.0, 0.0);
+    for (int i=0;  i<sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}
+
+//
+// Apply filter for vector4 samples S, using weights W.
+// sampleCount should be a square of a odd number { 1, 3, 5, 7 }
+//
+vector4 mx_convolution_vector4(vector4 S[MX_MAX_SAMPLE_COUNT], float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    vector4 result = vector4(0.0, 0.0, 0.0, 0.0);
+    for (int i=0;  i<sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}
+
+//
+// Apply filter for color samples S, using weights W.
+// sampleCount should be a square of a odd number in the range { 1, 3, 5, 7 }
+//
+color mx_convolution_color(color S[MX_MAX_SAMPLE_COUNT], float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    color result = color(0.0);
+    for (int i=0;  i<sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}
+
+//
+// Apply filter for color4 samples S, using weights W.
+// sampleCount should be a square of a odd number { 1, 3, 5, 7 }
+//
+color4 mx_convolution_color4(color4 S[MX_MAX_SAMPLE_COUNT], float W[MX_WEIGHT_ARRAY_SIZE], int offset, int sampleCount)
+{
+    color4 result = color4(color(0.0, 0.0, 0.0), 0.0);
+    for (int i=0;  i<sampleCount; i++)
+    {
+        result += S[i]*W[i+offset];
+    }
+    return result;
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/lib/mx_transform_uv.osl

@@ -0,0 +1,4 @@
+vector2 mx_transform_uv(vector2 texcoord)
+{
+    return texcoord;
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/lib/mx_transform_uv_vflip.osl

@@ -0,0 +1,4 @@
+vector2 mx_transform_uv(vector2 texcoord)
+{
+    return vector2(texcoord.x, 1.0 - texcoord.y);
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/mx_burn_color3.osl

@@ -0,0 +1,8 @@
+#include "mx_burn_float.osl"
+
+void mx_burn_color3(color fg, color bg, float mix, output color result)
+{
+    mx_burn_float(fg[0], bg[0], mix, result[0]);
+    mx_burn_float(fg[1], bg[1], mix, result[1]);
+    mx_burn_float(fg[2], bg[2], mix, result[2]);
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/mx_burn_color4.osl

@@ -0,0 +1,9 @@
+#include "mx_burn_float.osl"
+
+void mx_burn_color4(color4 fg, color4 bg, float mix, output color4 result)
+{
+    mx_burn_float(fg.rgb[0], bg.rgb[0], mix, result.rgb[0]);
+    mx_burn_float(fg.rgb[1], bg.rgb[1], mix, result.rgb[1]);
+    mx_burn_float(fg.rgb[2], bg.rgb[2], mix, result.rgb[2]);
+    mx_burn_float(fg.a, bg.a, mix, result.a);
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/mx_burn_float.osl

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

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/mx_cellnoise2d_float.osl

@@ -0,0 +1,4 @@
+void mx_cellnoise2d_float(vector2 texcoord, output float result)
+{
+    result = cellnoise(texcoord.x, texcoord.y);
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/mx_cellnoise3d_float.osl

@@ -0,0 +1,4 @@
+void mx_cellnoise3d_float(vector position, output float result)
+{
+    result = cellnoise(position);
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/mx_creatematrix.osl

@@ -0,0 +1,23 @@
+void mx_creatematrix_vector3_matrix33(vector in1, vector in2, vector in3, output matrix result)
+{
+    result = matrix(in1.x, in1.y, in1.z,  0.0,
+                    in2.x, in2.y, in2.z,  0.0,
+                    in3.x, in3.y, in3.z,  0.0,
+                    0.0,   0.0,   0.0,    1.0);
+}
+
+void mx_creatematrix_vector3_matrix44(vector in1, vector in2, vector in3, vector in4, output matrix result)
+{
+    result = matrix(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);
+}
+
+void mx_creatematrix_vector4_matrix44(vector4 in1, vector4 in2, vector4 in3, vector4 in4, output matrix result)
+{
+    result = matrix(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);
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/mx_disjointover_color4.osl

@@ -0,0 +1,25 @@
+void mx_disjointover_color4(color4 fg, color4 bg, float mix, output color4 result)
+{
+    float summedAlpha = fg.a + bg.a;
+
+    if (summedAlpha <= 1)
+    {
+        result.rgb = fg.rgb + bg.rgb;
+    }
+    else
+    {
+        if (abs(bg.a) < M_FLOAT_EPS)
+        {
+            result.rgb = 0.0;
+        }
+        else
+        {
+            float x = (1 - fg.a) / bg.a;
+            result.rgb = fg.rgb + bg.rgb * x;
+        }
+    }
+    result.a = min(summedAlpha, 1.0);
+
+    result.rgb = result.rgb * mix + (1.0 - mix) * bg.rgb;
+    result.a = result.a * mix + (1.0 - mix) * bg.a;
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/mx_dodge_color3.osl

@@ -0,0 +1,8 @@
+#include "mx_dodge_float.osl"
+
+void mx_dodge_color3(color fg, color bg, float mix, output color result)
+{
+    mx_dodge_float(fg[0], bg[0], mix, result[0]);
+    mx_dodge_float(fg[1], bg[1], mix, result[1]);
+    mx_dodge_float(fg[2], bg[2], mix, result[2]);
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/mx_dodge_color4.osl

@@ -0,0 +1,9 @@
+#include "mx_dodge_float.osl"
+
+void mx_dodge_color4(color4 fg , color4 bg , float mix , output color4 result)
+{
+    mx_dodge_float(fg.rgb[0], bg.rgb[0], mix, result.rgb[0]);
+    mx_dodge_float(fg.rgb[1], bg.rgb[1], mix, result.rgb[1]);
+    mx_dodge_float(fg.rgb[2], bg.rgb[2], mix, result.rgb[2]);
+    mx_dodge_float(fg.a, bg.a, mix, result.a);
+}

package/staging_area/Blender/blender.shared/usd/usdMtlx/resources/libraries/stdlib/genosl/mx_dodge_float.osl

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