Initial implementation of structs in MaterialX

python/Scripts/generateshader.py

@@ -139,6 +139,9 @@ def main():
         shadergen.setUnitSystem(unitsystem)
         genoptions.targetDistanceUnit = 'meter'
 
+        print('- Set up Struct typedefs ...')
+        shadergen.loadStructTypeDefs(doc)
+
         # Look for renderable nodes
         nodes = mx_gen_shader.findRenderableElements(doc)
         if not nodes:
@@ -165,6 +168,8 @@ def main():
                 if gentarget in ['glsl', 'essl', 'vulkan', 'msl']:
                     pixelSource = shader.getSourceCode(mx_gen_shader.PIXEL_STAGE)
                     filename = pathPrefix + "/" + shader.getName() + "." + gentarget + ".frag"
+                    if gentarget == "msl":
+                        filename += ".metal"
                     print('--- Wrote pixel shader to: ' + filename)
                     file = open(filename, 'w+')
                     file.write(pixelSource)
@@ -173,6 +178,8 @@ def main():
 
                     vertexSource = shader.getSourceCode(mx_gen_shader.VERTEX_STAGE)
                     filename = pathPrefix + "/" + shader.getName() + "." + gentarget + ".vert"
+                    if gentarget == "msl":
+                        filename += ".metal"
                     print('--- Wrote vertex shader to: ' + filename)
                     file = open(filename, 'w+')
                     file.write(vertexSource)

source/JsMaterialX/JsMaterialXCore/JsValue.cpp

@@ -47,7 +47,7 @@ EMSCRIPTEN_BINDINGS(value)
         .function("copy", &mx::Value::copy, ems::pure_virtual()) 
         .function("getTypeString", &mx::Value::getTypeString)
         .function("getValueString", &mx::Value::getValueString)
-        .class_function("createValueFromStrings", &mx::Value::createValueFromStrings)
+        BIND_CLASS_FUNC("createValueFromStrings", mx::Value, createValueFromStrings, 2, 3, stRef, stRef, mx::ConstTypeDefPtr)
         .class_function("setFloatFormat", &mx::Value::setFloatFormat)
         .class_function("setFloatPrecision", &mx::Value::setFloatPrecision)
         .class_function("getFloatFormat", &mx::Value::getFloatFormat)

source/MaterialXCore/Definition.cpp

@@ -196,4 +196,12 @@ vector<UnitDefPtr> UnitTypeDef::getUnitDefs() const
     return unitDefs;
 }
 
+ValuePtr AttributeDef::getValue() const
+{
+    if (!hasValue())
+        return ValuePtr();
+
+    return Value::createValueFromStrings(getValueString(), getType(), getDocument()->getTypeDef(getType()));
+}
+
 MATERIALX_NAMESPACE_END

source/MaterialXCore/Definition.h

@@ -423,11 +423,11 @@ class MX_CORE_API TargetDef : public TypedElement
 
 /// @class Member
 /// A member element within a TypeDef.
-class MX_CORE_API Member : public TypedElement
+class MX_CORE_API Member : public ValueElement
 {
   public:
     Member(ElementPtr parent, const string& name) :
-        TypedElement(parent, CATEGORY, name)
+        ValueElement(parent, CATEGORY, name)
     {
     }
     virtual ~Member() { }
@@ -625,12 +625,7 @@ class MX_CORE_API AttributeDef : public TypedElement
     ///
     /// @return A shared pointer to the typed value of this element, or an
     ///    empty shared pointer if no value is present.
-    ValuePtr getValue() const
-    {
-        if (!hasValue())
-            return ValuePtr();
-        return Value::createValueFromStrings(getValueString(), getType());
-    }
+    ValuePtr getValue() const;
 
     /// @}
     /// @name Elements

source/MaterialXCore/Element.cpp

@@ -495,6 +495,22 @@ string ValueElement::getResolvedValueString(StringResolverPtr resolver) const
     return resolver->resolve(getValueString(), getType());
 }
 
+ValuePtr ValueElement::getValue() const
+{
+    if (!hasValue())
+        return ValuePtr();
+
+    return Value::createValueFromStrings(getValueString(), getType(), getDocument()->getTypeDef(getType()));
+}
+
+ValuePtr ValueElement::getResolvedValue(StringResolverPtr resolver) const
+{
+    if (!hasValue())
+        return ValuePtr();
+
+    return Value::createValueFromStrings(getResolvedValueString(resolver), getType(), getDocument()->getTypeDef(getType()));
+}
+
 ValuePtr ValueElement::getDefaultValue() const
 {
     ConstElementPtr parent = getParent();

source/MaterialXCore/Element.h

@@ -1025,12 +1025,7 @@ class MX_CORE_API ValueElement : public TypedElement
     ///
     /// @return A shared pointer to the typed value of this element, or an
     ///    empty shared pointer if no value is present.
-    ValuePtr getValue() const
-    {
-        if (!hasValue())
-            return ValuePtr();
-        return Value::createValueFromStrings(getValueString(), getType());
-    }
+    ValuePtr getValue() const;
 
     /// Return the resolved value of an element as a generic value object, which
     /// may be queried to access its data.
@@ -1040,12 +1035,7 @@ class MX_CORE_API ValueElement : public TypedElement
     ///    will be created at this scope and applied to the return value.
     /// @return A shared pointer to the typed value of this element, or an
     ///    empty shared pointer if no value is present.
-    ValuePtr getResolvedValue(StringResolverPtr resolver = nullptr) const
-    {
-        if (!hasValue())
-            return ValuePtr();
-        return Value::createValueFromStrings(getResolvedValueString(resolver), getType());
-    }
+    ValuePtr getResolvedValue(StringResolverPtr resolver = nullptr) const;
 
     /// Return the default value for this element as a generic value object, which
     /// may be queried to access its data.

source/MaterialXCore/Exception.h

@@ -50,6 +50,14 @@ class MX_CORE_API Exception : public std::exception
     string _msg;
 };
 
+/// @class ExceptionTypeError
+/// An exception that is thrown when a type mismatch is encountered.
+class MX_CORE_API ExceptionTypeError : public Exception
+{
+  public:
+    using Exception::Exception;
+};
+
 MATERIALX_NAMESPACE_END
 
 #endif

source/MaterialXCore/Value.cpp

@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include <MaterialXCore/Definition.h>
+#include <MaterialXCore/Document.h>
 #include <MaterialXCore/Value.h>
 
 #include <iomanip>
@@ -267,12 +269,18 @@ template <class T> ValuePtr TypedValue<T>::createFromString(const string& value)
 // Value methods
 //
 
-ValuePtr Value::createValueFromStrings(const string& value, const string& type)
+ValuePtr Value::createValueFromStrings(const string& value, const string& type, ConstTypeDefPtr typeDefPtr)
 {
     CreatorMap::iterator it = _creatorMap.find(type);
     if (it != _creatorMap.end())
         return it->second(value);
 
+    if (typeDefPtr && !typeDefPtr->getMembers().empty())
+    {
+        // If we're given a TypeDef pointer that has child members, then we can create a new AggregateValue.
+        return AggregateValue::createAggregateValueFromString(value, type, typeDefPtr);
+    }
+
     return TypedValue<string>::createFromString(value);
 }
 
@@ -291,6 +299,70 @@ template <class T> const T& Value::asA() const
     return typedVal->getData();
 }
 
+template <>
+MX_CORE_API bool Value::isA<AggregateValue>() const
+{
+    return dynamic_cast<const AggregateValue*>(this) != nullptr;
+}
+
+template <>
+MX_CORE_API const AggregateValue& Value::asA<AggregateValue>() const
+{
+    const AggregateValue* typedVal = dynamic_cast<const AggregateValue*>(this);
+    if (!typedVal)
+    {
+        throw ExceptionTypeError("Incorrect type specified for value");
+    }
+    return *typedVal;
+}
+
+/// Return value string.
+string AggregateValue::getValueString() const
+{
+    if (_data.empty())
+        return "";
+
+    std::string result = "{";
+    std::string separator = "";
+    for (const auto& val : _data)
+    {
+        result += separator + val->getValueString();
+        separator = ";";
+    }
+    result += "}";
+
+    return result;
+}
+
+AggregateValuePtr AggregateValue::createAggregateValueFromString(const string& value, const string& type, ConstTypeDefPtr typeDefPtr)
+{
+    StringVec subValues = parseStructValueString(value);
+
+    AggregateValuePtr result = AggregateValue::createAggregateValue(type);
+    const auto& members = typeDefPtr->getMembers();
+
+    if (subValues.size() != members.size())
+    {
+        std::stringstream ss;
+        ss << "Wrong number of initializers - expect " << members.size();
+        throw Exception(ss.str());
+    }
+
+    auto doc = typeDefPtr->getDocument();
+    for (size_t i = 0; i < members.size(); ++i)
+    {
+        const auto& member = members[i];
+
+        // This will return nullptr if the type is not a listed typedef.
+        ConstTypeDefPtr subTypeDef = doc->getTypeDef(members[i]->getType());
+
+        // Calling Value::createValueFromStrings() here allows support for recursively nested structs.
+        result->appendValue(Value::createValueFromStrings(subValues[i], member->getType(), subTypeDef));
+    }
+
+    return result;
+}
+
 ScopedFloatFormatting::ScopedFloatFormatting(Value::FloatFormat format, int precision) :
     _format(Value::getFloatFormat()),
     _precision(Value::getFloatPrecision())

source/MaterialXCore/Value.h

@@ -24,21 +24,22 @@ using BoolVec = vector<bool>;
 using FloatVec = vector<float>;
 
 class Value;
+class AggregateValue;
 
 /// A shared pointer to a Value
 using ValuePtr = shared_ptr<Value>;
 /// A shared pointer to a const Value
 using ConstValuePtr = shared_ptr<const Value>;
 
-template <class T> class TypedValue;
+/// A shared pointer to an Aggregate Value
+using AggregateValuePtr = shared_ptr<AggregateValue>;
+/// A shared pointer to a const Aggregate Value
+using ConstAggregateValuePtr = shared_ptr<const AggregateValue>;
 
-/// @class ExceptionTypeError
-/// An exception that is thrown when a type mismatch is encountered.
-class MX_CORE_API ExceptionTypeError : public Exception
-{
-  public:
-    using Exception::Exception;
-};
+class TypeDef;
+using ConstTypeDefPtr = shared_ptr<const TypeDef>;
+
+template <class T> class TypedValue;
 
 /// A generic, discriminated value, whose type may be queried dynamically.
 class MX_CORE_API Value
@@ -73,7 +74,7 @@ class MX_CORE_API Value
     /// Create a new value instance from value and type strings.
     /// @return A shared pointer to a typed value, or an empty shared pointer
     ///    if the conversion to the given data type cannot be performed.
-    static ValuePtr createValueFromStrings(const string& value, const string& type);
+    static ValuePtr createValueFromStrings(const string& value, const string& type, ConstTypeDefPtr typeDefPtr = nullptr);
 
     /// Create a deep copy of the value.
     virtual ValuePtr copy() const = 0;
@@ -193,6 +194,65 @@ template <class T> class MX_CORE_API TypedValue : public Value
     T _data;
 };
 
+/// The class template for typed subclasses of Value
+class MX_CORE_API AggregateValue : public Value
+{
+  public:
+    AggregateValue(const string& typeName) :
+        _typeName(typeName)
+    {
+    }
+    virtual ~AggregateValue() { }
+
+    /// Create a deep copy of the value.
+    ValuePtr copy() const override
+    {
+        auto result = createAggregateValue(_typeName);
+        for (const auto& val : _data)
+        {
+            result->appendValue(val->copy());
+        }
+        return result;
+    }
+
+    /// Append a member value to the aggregate.
+    void appendValue(ConstValuePtr valuePtr) {
+        _data.emplace_back(valuePtr);
+    }
+
+    const vector<ConstValuePtr>&  getMembers() const {
+        return _data;
+    }
+
+    /// Query an indexed member value from the aggregate.
+    ConstValuePtr getMemberValue(size_t index) const {
+        return _data[index];
+    }
+
+    /// Return type string.
+    const string& getTypeString() const override  { return _typeName; }
+
+    /// Return value string.
+    string getValueString() const override;
+
+    //
+    // Static helper methods
+    //
+
+    /// Create a new value from an object of any valid MaterialX type.
+    static AggregateValuePtr createAggregateValue(const string& typeName)
+    {
+        return std::make_shared<AggregateValue>(typeName);
+    }
+
+    static AggregateValuePtr createAggregateValueFromString(const string& value, const string& type, ConstTypeDefPtr typeDefPtr);
+
+  private:
+    const string _typeName;
+
+    vector<ConstValuePtr> _data;
+};
+
 /// @class ScopedFloatFormatting
 /// An RAII class for controlling the float formatting of values.
 class MX_CORE_API ScopedFloatFormatting

source/MaterialXGenGlsl/GlslSyntax.cpp

@@ -375,4 +375,40 @@ bool GlslSyntax::remapEnumeration(const string& value, TypeDesc type, const stri
     return true;
 }
 
+StructTypeSyntaxPtr GlslSyntax::createStructSyntax(const string& structTypeName, const string& defaultValue,
+                                       const string& uniformDefaultValue, const string& typeAlias,
+                                       const string& typeDefinition) const
+{
+    return std::make_shared<GlslStructTypeSyntax>(
+        this,
+        structTypeName,
+        defaultValue,
+        uniformDefaultValue,
+        typeAlias,
+        typeDefinition);
+}
+
+string GlslStructTypeSyntax::getValue(const Value& value, bool /* uniform */) const
+{
+    const AggregateValue& aggValue = static_cast<const AggregateValue&>(value);
+
+    string result = aggValue.getTypeString() + "(";
+
+    string separator = "";
+    for (const auto& memberValue : aggValue.getMembers()) {
+        result += separator;
+        separator = ",";
+
+        auto memberTypeName = memberValue->getTypeString();
+        auto memberTypeDesc = TypeDesc::get(memberTypeName);
+
+        // recursively use the syntax to generate the output, so we can supported nested structs.
+        result += _parentSyntax->getValue(memberTypeDesc, *memberValue, true);
+    }
+
+    result += ")";
+
+    return result;
+}
+
 MATERIALX_NAMESPACE_END