Merge branch 'AcademySoftwareFoundation:main' into node_editor_traversal

Author: kwokcb

javascript/MaterialXView/source/viewer.js

@@ -182,7 +182,7 @@ export class Scene
 
                 if (!child.geometry.attributes.normal)
                 {
-                    var startNormalTime = performance.new();
+                    var startNormalTime = performance.now();
                     child.geometry.computeVertexNormals();
                     normalTime += performance.now() - startNormalTime;
                 }

libraries/pbrlib/genglsl/lib/mx_environment_fis.glsl

@@ -59,7 +59,7 @@ vec3 mx_environment_radiance(vec3 N, vec3 V, vec3 X, vec2 alpha, int distributio
     radiance /= G1V * float(envRadianceSamples);
 
     // Return the final radiance.
-    return radiance * $envLightIntensity;
+    return ($envRadianceSamples == 0 ? vec3(0.0) : radiance) * $envLightIntensity;
 }
 
 vec3 mx_environment_irradiance(vec3 N)

libraries/stdlib/genmsl/lib/mx_math.metal

@@ -6,27 +6,27 @@
 #define mx_asin metal::asin
 #define mx_acos metal::acos
 
-vec2 mx_matrix_mul(vec2 v, mat2 m) { return v * m; }
-vec3 mx_matrix_mul(vec3 v, mat3 m) { return v * m; }
-vec4 mx_matrix_mul(vec4 v, mat4 m) { return v * m; }
-vec2 mx_matrix_mul(mat2 m, vec2 v) { return m * v; }
-vec3 mx_matrix_mul(mat3 m, vec3 v) { return m * v; }
-vec4 mx_matrix_mul(mat4 m, vec4 v) { return m * v; }
-mat2 mx_matrix_mul(mat2 m1, mat2 m2) { return m1 * m2; }
-mat3 mx_matrix_mul(mat3 m1, mat3 m2) { return m1 * m2; }
-mat4 mx_matrix_mul(mat4 m1, mat4 m2) { return m1 * m2; }
+float2 mx_matrix_mul(float2 v, float2x2 m) { return v * m; }
+float3 mx_matrix_mul(float3 v, float3x3 m) { return v * m; }
+float4 mx_matrix_mul(float4 v, float4x4 m) { return v * m; }
+float2 mx_matrix_mul(float2x2 m, float2 v) { return m * v; }
+float3 mx_matrix_mul(float3x3 m, float3 v) { return m * v; }
+float4 mx_matrix_mul(float4x4 m, float4 v) { return m * v; }
+float2x2 mx_matrix_mul(float2x2 m1, float2x2 m2) { return m1 * m2; }
+float3x3 mx_matrix_mul(float3x3 m1, float3x3 m2) { return m1 * m2; }
+float4x4 mx_matrix_mul(float4x4 m1, float4x4 m2) { return m1 * m2; }
 
 float mx_square(float x)
 {
     return x*x;
 }
 
-vec2 mx_square(vec2 x)
+float2 mx_square(float2 x)
 {
     return x*x;
 }
 
-vec3 mx_square(vec3 x)
+float3 mx_square(float3 x)
 {
     return x*x;
 }
@@ -118,17 +118,17 @@ float mx_atan(float y, float x)
     return metal::atan2(y, x);
 }
 
-vec2 mx_atan(vec2 y, vec2 x)
+float2 mx_atan(float2 y, float2 x)
 {
     return metal::atan2(y, x);
 }
 
-vec3 mx_atan(vec3 y, vec3 x)
+float3 mx_atan(float3 y, float3 x)
 {
     return metal::atan2(y, x);
 }
 
-vec4 mx_atan(vec4 y, vec4 x)
+float4 mx_atan(float4 y, float4 x)
 {
     return metal::atan2(y, x);
 }
@@ -138,7 +138,7 @@ float mx_radians(float degree)
     return (degree * M_PI_F / 180.0f);
 }
 
-vec2 mx_radians(vec2 degree)
+float2 mx_radians(float2 degree)
 {
     return (degree * M_PI_F / 180.0f);
 }

source/MaterialXGenHw/HwConstants.cpp

@@ -126,8 +126,10 @@ const string ENV_IRRADIANCE_SAMPLER2D_SPLIT   = "sampler2D(u_envIradiance_textur
 
 const string TEX_SAMPLER_SAMPLER2D            = "tex_sampler";
 const string TEX_SAMPLER_SAMPLER2D_SPLIT      = "sampler2D(tex_texture, tex_sampler)";
+const string TEX_SAMPLER_SAMPLER2D_MSL        = "tex_sampler";
 const string TEX_SAMPLER_SIGNATURE            = "sampler2D tex_sampler";
 const string TEX_SAMPLER_SIGNATURE_SPLIT      = "texture2D tex_texture, sampler tex_sampler";
+const string TEX_SAMPLER_SIGNATURE_MSL        = "MetalTexture tex_sampler";
 
 const string ENV_LIGHT_INTENSITY              = "u_envLightIntensity";
 const string ENV_PREFILTER_MIP                = "u_envPrefilterMip";

source/MaterialXGenHw/HwConstants.h

@@ -213,8 +213,10 @@ extern MX_GENHW_API const string LIGHT_DATA_MAX_LIGHT_SOURCES;
 /// Texture sampler parameters (for both combined and separate values)
 extern MX_GENHW_API const string TEX_SAMPLER_SAMPLER2D;
 extern MX_GENHW_API const string TEX_SAMPLER_SAMPLER2D_SPLIT;
+extern MX_GENHW_API const string TEX_SAMPLER_SAMPLER2D_MSL;
 extern MX_GENHW_API const string TEX_SAMPLER_SIGNATURE;
 extern MX_GENHW_API const string TEX_SAMPLER_SIGNATURE_SPLIT;
+extern MX_GENHW_API const string TEX_SAMPLER_SIGNATURE_MSL;
 
 /// Variable blocks names.
 extern MX_GENHW_API const string VERTEX_INPUTS;    // Geometric inputs for vertex stage.

source/MaterialXGenHw/Nodes/HwSurfaceNode.cpp

@@ -114,7 +114,8 @@ void HwSurfaceNode::emitFunctionCall(const ShaderNode& node, GenContext& context
             shadergen.emitComment("Shadow occlusion", stage);
             if (context.getOptions().hwShadowMap)
             {
-                shadergen.emitLine("vec3 shadowCoord = mx_matrix_mul(" + HW::T_SHADOW_MATRIX + ", vec4(" + prefix + HW::T_POSITION_WORLD + ", 1.0)).xyz", stage);
+                shadergen.emitLine("vec4 shadowCoord4 = mx_matrix_mul(" + HW::T_SHADOW_MATRIX + ", vec4(" + prefix + HW::T_POSITION_WORLD + ", 1.0))", stage);
+                shadergen.emitLine("vec3 shadowCoord = shadowCoord4.xyz / shadowCoord4.w;", stage);
                 shadergen.emitLine("shadowCoord = shadowCoord * 0.5 + 0.5", stage);
                 shadergen.emitLine("vec2 shadowMoments = texture(" + HW::T_SHADOW_MAP + ", shadowCoord.xy).xy", stage);
                 shadergen.emitLine("occlusion = mx_variance_shadow_occlusion(shadowMoments, shadowCoord.z)", stage);
@@ -270,6 +271,11 @@ void HwSurfaceNode::emitLightLoop(const ShaderNode& node, GenContext& context, S
         shadergen.emitComment("Accumulate the light's contribution", stage);
         shadergen.emitLine(outColor + " += lightShader.intensity * " + bsdf->getOutput()->getVariable() + ".response", stage);
 
+        shadergen.emitLineBreak(stage);
+
+        shadergen.emitComment("Clear shadow factor for next light", stage);
+        shadergen.emitLine("occlusion = 1.0", stage);
+
         shadergen.emitScopeEnd(stage);
         shadergen.emitLineBreak(stage);
     }

source/MaterialXGenMsl/MslShaderGenerator.cpp

@@ -129,6 +129,9 @@ MslShaderGenerator::MslShaderGenerator(TypeSystemPtr typeSystem) :
     _lightSamplingNodes.push_back(ShaderNode::create(nullptr, "sampleLightSource", HwLightSamplerNode::create()));
 
     _tokenSubstitutions[HW::T_CLOSURE_DATA_CONSTRUCTOR] = "{closureType, L, V, N, P, occlusion}";
+
+    _tokenSubstitutions[HW::T_TEX_SAMPLER_SAMPLER2D]    = HW::TEX_SAMPLER_SAMPLER2D_MSL;
+    _tokenSubstitutions[HW::T_TEX_SAMPLER_SIGNATURE]    = HW::TEX_SAMPLER_SIGNATURE_MSL;
 }
 
 ShaderPtr MslShaderGenerator::generate(const string& name, ElementPtr element, GenContext& context) const
@@ -157,6 +160,8 @@ ShaderPtr MslShaderGenerator::generate(const string& name, ElementPtr element, G
     emitVertexStage(shader->getGraph(), context, vs);
     replaceTokens(_tokenSubstitutions, vs);
 
+    MetalizeGeneratedShader(vs);
+
     // Emit code for pixel shader stage
     ShaderStage& ps = shader->getStage(Stage::PIXEL);
     emitPixelStage(shader->getGraph(), context, ps);
@@ -222,7 +227,7 @@ void MslShaderGenerator::MetalizeGeneratedShader(ShaderStage& shaderStage) const
                     }
                     else
                     {
-                        sourceCode.replace(beg, typename_end - beg, "thread " + typeName + "&");
+                        sourceCode.replace(beg, typename_end - beg, "thread " + typeName + " &");
                     }
                 }
                 pos = sourceCode.find(keyword, pos);
@@ -236,14 +241,30 @@ void MslShaderGenerator::MetalizeGeneratedShader(ShaderStage& shaderStage) const
     replaceTokens["dFdy"] = "dfdy";
     replaceTokens["dFdx"] = "dfdx";
 
+    replaceTokens["vec2"] = "float2";
+    replaceTokens["vec3"] = "float3";
+    replaceTokens["vec4"] = "float4";
+    replaceTokens["ivec2"] = "int2";
+    replaceTokens["ivec3"] = "int3";
+    replaceTokens["ivec4"] = "int4";
+    replaceTokens["uvec2"] = "uint2";
+    replaceTokens["uvec3"] = "uint3";
+    replaceTokens["uvec4"] = "uint4";
+    replaceTokens["bvec2"] = "bool2";
+    replaceTokens["bvec3"] = "bool3";
+    replaceTokens["bvec4"] = "bool4";
+    replaceTokens["mat2"] = "float2x2";
+    replaceTokens["mat3"] = "float3x3";
+    replaceTokens["mat4"] = "float4x4";
+
     auto isAllowedAfterToken = [](char ch) -> bool
     {
         return std::isspace(ch) || ch == '(' || ch == ')' || ch == ',';
     };
 
     auto isAllowedBeforeToken = [](char ch) -> bool
     {
-        return std::isspace(ch) || ch == '(' || ch == ',' || ch == '-';
+        return std::isspace(ch) || ch == '(' || ch == ',' || ch == '+' || ch == '-';
     };
 
     for (const auto& t : replaceTokens)
@@ -295,7 +316,7 @@ void MslShaderGenerator::emitGlobalVariables(GenContext& context,
     {
         if (globalContextMembers)
         {
-            emitLine("vec4 gl_FragCoord", stage);
+            emitLine("float4 gl_FragCoord", stage);
         }
         if (globalContextConstructorInit)
         {
@@ -593,9 +614,9 @@ void MslShaderGenerator::emitVertexStage(const ShaderGraph& graph, GenContext& c
         emitString("\tGlobalContext ctx {", stage);
         emitGlobalVariables(context, stage, EMIT_GLOBAL_SCOPE_CONTEXT_MEMBER_INIT, true, false);
         emitLine("}", stage, true);
-        emitLine(vertexData.getName() + " out = ctx.VertexMain()", stage, true);
-        emitLine("out.pos.y = -out.pos.y", stage, true);
-        emitLine("return out", stage, true);
+        emitLine(vertexData.getName() + " outVertex = ctx.VertexMain()", stage, true);
+        emitLine("outVertex.pos.y = -outVertex.pos.y", stage, true);
+        emitLine("return outVertex", stage, true);
     }
     emitScopeEnd(stage);
     emitLineBreak(stage);
@@ -650,22 +671,6 @@ void MslShaderGenerator::emitDirectives(GenContext&, ShaderStage& stage) const
     emitLine("#include <simd/simd.h>", stage, false);
     emitLine("using namespace metal;", stage, false);
 
-    emitLine("#define vec2 float2", stage, false);
-    emitLine("#define vec3 float3", stage, false);
-    emitLine("#define vec4 float4", stage, false);
-    emitLine("#define ivec2 int2", stage, false);
-    emitLine("#define ivec3 int3", stage, false);
-    emitLine("#define ivec4 int4", stage, false);
-    emitLine("#define uvec2 uint2", stage, false);
-    emitLine("#define uvec3 uint3", stage, false);
-    emitLine("#define uvec4 uint4", stage, false);
-    emitLine("#define bvec2 bool2", stage, false);
-    emitLine("#define bvec3 bool3", stage, false);
-    emitLine("#define bvec4 bool4", stage, false);
-    emitLine("#define mat2 float2x2", stage, false);
-    emitLine("#define mat3 float3x3", stage, false);
-    emitLine("#define mat4 float4x4", stage, false);
-
     emitLineBreak(stage);
 }
 

source/MaterialXGenMsl/MslSyntax.cpp

@@ -176,9 +176,9 @@ MslSyntax::MslSyntax(TypeSystemPtr typeSystem) : Syntax(typeSystem)
         Type::COLOR3,
         std::make_shared<AggregateTypeSyntax>(
             this,
-            "vec3",
-            "vec3(0.0)",
-            "vec3(0.0)",
+            "float3",
+            "float3(0.0)",
+            "float3(0.0)",
             EMPTY_STRING,
             EMPTY_STRING,
             VEC3_MEMBERS));
@@ -187,9 +187,9 @@ MslSyntax::MslSyntax(TypeSystemPtr typeSystem) : Syntax(typeSystem)
         Type::COLOR4,
         std::make_shared<AggregateTypeSyntax>(
             this,
-            "vec4",
-            "vec4(0.0)",
-            "vec4(0.0)",
+            "float4",
+            "float4(0.0)",
+            "float4(0.0)",
             EMPTY_STRING,
             EMPTY_STRING,
             VEC4_MEMBERS));
@@ -198,9 +198,9 @@ MslSyntax::MslSyntax(TypeSystemPtr typeSystem) : Syntax(typeSystem)
         Type::VECTOR2,
         std::make_shared<AggregateTypeSyntax>(
             this,
-            "vec2",
-            "vec2(0.0)",
-            "vec2(0.0)",
+            "float2",
+            "float2(0.0)",
+            "float2(0.0)",
             EMPTY_STRING,
             EMPTY_STRING,
             VEC2_MEMBERS));
@@ -209,9 +209,9 @@ MslSyntax::MslSyntax(TypeSystemPtr typeSystem) : Syntax(typeSystem)
         Type::VECTOR3,
         std::make_shared<AggregateTypeSyntax>(
             this,
-            "vec3",
-            "vec3(0.0)",
-            "vec3(0.0)",
+            "float3",
+            "float3(0.0)",
+            "float3(0.0)",
             EMPTY_STRING,
             EMPTY_STRING,
             VEC3_MEMBERS));
@@ -220,9 +220,9 @@ MslSyntax::MslSyntax(TypeSystemPtr typeSystem) : Syntax(typeSystem)
         Type::VECTOR4,
         std::make_shared<AggregateTypeSyntax>(
             this,
-            "vec4",
-            "vec4(0.0)",
-            "vec4(0.0)",
+            "float4",
+            "float4(0.0)",
+            "float4(0.0)",
             EMPTY_STRING,
             EMPTY_STRING,
             VEC4_MEMBERS));
@@ -231,17 +231,17 @@ MslSyntax::MslSyntax(TypeSystemPtr typeSystem) : Syntax(typeSystem)
         Type::MATRIX33,
         std::make_shared<AggregateTypeSyntax>(
             this,
-            "mat3",
-            "mat3(1.0)",
-            "mat3(1.0)"));
+            "float3x3",
+            "float3x3(1.0)",
+            "float3x3(1.0)"));
 
     registerTypeSyntax(
         Type::MATRIX44,
         std::make_shared<AggregateTypeSyntax>(
             this,
-            "mat4",
-            "mat4(1.0)",
-            "mat4(1.0)"));
+            "float4x4",
+            "float4x4(1.0)",
+            "float4x4(1.0)"));
 
     registerTypeSyntax(
         Type::STRING,

source/MaterialXGenShader/ShaderTranslator.cpp

@@ -19,7 +19,7 @@ void ShaderTranslator::connectTranslationInputs(NodePtr shader, NodeDefPtr trans
     std::set<OutputPtr> origOutputs;
     for (InputPtr shaderInput : origInputs)
     {
-        if (translationNodeDef->getInput(shaderInput->getName()))
+        if (translationNodeDef->getActiveInput(shaderInput->getName()))
         {
             InputPtr input = _translationNode->addInput(shaderInput->getName(), shaderInput->getType());
 
@@ -78,15 +78,14 @@ void ShaderTranslator::connectTranslationInputs(NodePtr shader, NodeDefPtr trans
 void ShaderTranslator::connectTranslationOutputs(NodePtr shader)
 {
     DocumentPtr doc = shader->getDocument();
-    InterfaceElementPtr implement = _translationNode->getImplementation();
-    NodeGraphPtr translationGraph = implement ? implement->asA<NodeGraph>() : nullptr;
-    if (!translationGraph)
+    NodeDefPtr nodeDef = _translationNode->getNodeDef();
+    if (!nodeDef)
     {
-        throw Exception("No graph implementation for " + _translationNode->getCategory() + " was found");
+        throw Exception("No nodedef for " + _translationNode->getCategory() + " was found");
     }
 
     // Iterate through outputs of the translation graph.
-    for (OutputPtr translationGraphOutput : translationGraph->getOutputs())
+    for (OutputPtr translationGraphOutput : nodeDef->getActiveOutputs())
     {
         // Convert output name to input name, using a hardcoded naming convention for now.
         string outputName = translationGraphOutput->getName();