diff --git a/lib/mayaUsd/fileio/jobs/readJob.cpp b/lib/mayaUsd/fileio/jobs/readJob.cpp index ef1d5ad072..7646e9433c 100644 --- a/lib/mayaUsd/fileio/jobs/readJob.cpp +++ b/lib/mayaUsd/fileio/jobs/readJob.cpp @@ -528,7 +528,7 @@ void UsdMaya_ReadJob::_DoImportPrimIt( TfToken typeName = prim.GetTypeName(); if (UsdMayaPrimReaderRegistry::ReaderFactoryFn factoryFn - = UsdMayaPrimReaderRegistry::FindOrFallback(typeName)) { + = UsdMayaPrimReaderRegistry::FindOrFallback(typeName, mArgs, prim)) { UsdMayaPrimReaderSharedPtr primReader = factoryFn(args); if (primReader) { TempNodeTrackerScope scope(readCtx); diff --git a/lib/mayaUsd/fileio/primReader.cpp b/lib/mayaUsd/fileio/primReader.cpp index e8e8a67175..785997a3f9 100644 --- a/lib/mayaUsd/fileio/primReader.cpp +++ b/lib/mayaUsd/fileio/primReader.cpp @@ -22,6 +22,15 @@ UsdMayaPrimReader::UsdMayaPrimReader(const UsdMayaPrimReaderArgs& args) { } +/* static */ +UsdMayaPrimReader::ContextSupport +UsdMayaPrimReader::CanImport(const UsdMayaJobImportArgs&, const UsdPrim& importPrim) +{ + // Default value for all readers is Fallback. More specialized writers can + // override the base CanImport to report Supported/Unsupported as necessary. + return ContextSupport::Fallback; +} + bool UsdMayaPrimReader::HasPostReadSubtree() const { return false; } void UsdMayaPrimReader::PostReadSubtree(UsdMayaPrimReaderContext&) { } diff --git a/lib/mayaUsd/fileio/primReader.h b/lib/mayaUsd/fileio/primReader.h index 64a416b63f..6826d773b2 100644 --- a/lib/mayaUsd/fileio/primReader.h +++ b/lib/mayaUsd/fileio/primReader.h @@ -31,6 +31,25 @@ class UsdMayaPrimReader UsdMayaPrimReader(const UsdMayaPrimReaderArgs&); virtual ~UsdMayaPrimReader() {}; + /// The level of support a reader can offer for a given context + /// + /// A basic reader that gives correct results across most contexts should + /// report `Fallback`, while a specialized reader that really shines in a + /// given context should report `Supported` when the context is right and + /// `Unsupported` if the context is not as expected. + enum class ContextSupport + { + Supported, + Fallback, + Unsupported + }; + + /// This static function is expected for all prim readers and allows + /// declaring how well this class can support the current context: + MAYAUSD_CORE_PUBLIC + static ContextSupport + CanImport(const UsdMayaJobImportArgs& importArgs, const UsdPrim& importPrim); + /// Reads the USD prim given by the prim reader args into a Maya shape, /// modifying the prim reader context as a result. /// Returns true if successful. diff --git a/lib/mayaUsd/fileio/primReaderRegistry.cpp b/lib/mayaUsd/fileio/primReaderRegistry.cpp index 6668491346..276d89d05e 100644 --- a/lib/mayaUsd/fileio/primReaderRegistry.cpp +++ b/lib/mayaUsd/fileio/primReaderRegistry.cpp @@ -43,8 +43,42 @@ TF_DEFINE_PRIVATE_TOKENS( ); // clang-format on -typedef std::map _Registry; -static _Registry _reg; +namespace { +struct _RegistryEntry +{ + UsdMayaPrimReaderRegistry::ContextPredicateFn _pred; + UsdMayaPrimReaderRegistry::ReaderFactoryFn _fn; + int _index; +}; + +typedef std::unordered_multimap _Registry; +static _Registry _reg; +static int _indexCounter = 0; + +_Registry::const_iterator +_Find(const TfToken& typeName, const UsdMayaJobImportArgs& importArgs, const UsdPrim& importPrim) +{ + using ContextSupport = UsdMayaPrimReader::ContextSupport; + + _Registry::const_iterator ret = _reg.cend(); + _Registry::const_iterator first, last; + + std::tie(first, last) = _reg.equal_range(typeName); + while (first != last) { + ContextSupport support = first->second._pred(importArgs, importPrim); + // Look for a "Supported" reader. If no "Supported" reader is found, use a "Fallback" reader + if (support == ContextSupport::Supported) { + ret = first; + break; + } else if (support == ContextSupport::Fallback && ret == _reg.end()) { + ret = first; + } + ++first; + } + + return ret; +} +} // namespace /* static */ void UsdMayaPrimReaderRegistry::Register( @@ -53,13 +87,63 @@ void UsdMayaPrimReaderRegistry::Register( bool fromPython) { TfToken tfTypeName(t.GetTypeName()); + int index = _indexCounter++; + TF_DEBUG(PXRUSDMAYA_REGISTRY) + .Msg("Registering UsdMayaPrimReader for TfType %s.\n", tfTypeName.GetText()); + + // Use default ContextSupport if not specified + _reg.insert(std::make_pair( + tfTypeName, + _RegistryEntry { [](const UsdMayaJobImportArgs&, const UsdPrim) { + return UsdMayaPrimReader::ContextSupport::Fallback; + }, + fn, + index })); + + if (fn) { + UsdMaya_RegistryHelper::AddUnloader( + [tfTypeName, index]() { + _Registry::const_iterator it, itEnd; + std::tie(it, itEnd) = _reg.equal_range(tfTypeName); + for (; it != itEnd; ++it) { + if (it->second._index == index) { + _reg.erase(it); + break; + } + } + }, + fromPython); + } +} + +/* static */ +void UsdMayaPrimReaderRegistry::Register( + const TfType& t, + UsdMayaPrimReaderRegistry::ContextPredicateFn pred, + UsdMayaPrimReaderRegistry::ReaderFactoryFn fn, + bool fromPython) +{ + TfToken tfTypeName(t.GetTypeName()); + int index = _indexCounter++; TF_DEBUG(PXRUSDMAYA_REGISTRY) .Msg("Registering UsdMayaPrimReader for TfType %s.\n", tfTypeName.GetText()); - std::pair<_Registry::iterator, bool> insertStatus = _reg.insert(std::make_pair(tfTypeName, fn)); - if (insertStatus.second) { - UsdMaya_RegistryHelper::AddUnloader([tfTypeName]() { _reg.erase(tfTypeName); }, fromPython); - } else { - TF_CODING_ERROR("Multiple readers for type %s", tfTypeName.GetText()); + _reg.insert(std::make_pair(tfTypeName, _RegistryEntry { pred, fn, index })); + + // The unloader uses the index to know which entry to erase when there are + // more than one for the same usdInfoId. + if (fn) { + UsdMaya_RegistryHelper::AddUnloader( + [tfTypeName, index]() { + _Registry::const_iterator it, itEnd; + std::tie(it, itEnd) = _reg.equal_range(tfTypeName); + for (; it != itEnd; ++it) { + if (it->second._index == index) { + _reg.erase(it); + break; + } + } + }, + fromPython); } } @@ -70,8 +154,10 @@ void UsdMayaPrimReaderRegistry::RegisterRaw(const TfType& t, UsdMayaPrimReaderRe } /* static */ -UsdMayaPrimReaderRegistry::ReaderFactoryFn -UsdMayaPrimReaderRegistry::Find(const TfToken& usdTypeName) +UsdMayaPrimReaderRegistry::ReaderFactoryFn UsdMayaPrimReaderRegistry::Find( + const TfToken& usdTypeName, + const UsdMayaJobImportArgs& importArgs, + const UsdPrim& importPrim) { TfRegistryManager::GetInstance().SubscribeTo(); @@ -81,8 +167,12 @@ UsdMayaPrimReaderRegistry::Find(const TfToken& usdTypeName) std::string typeNameStr = tfType.GetTypeName(); TfToken typeName(typeNameStr); ReaderFactoryFn ret = nullptr; - if (TfMapLookup(_reg, typeName, &ret)) { - return ret; + + // For that we are using unordered_multimap now, we can't use TfMapLookup anymore + _Registry::const_iterator it = _Find(typeName, importArgs, importPrim); + + if (it != _reg.end()) { + return it->second._fn; } static const TfTokenVector SCOPE = { _tokens->UsdMaya, _tokens->PrimReader }; @@ -90,19 +180,27 @@ UsdMayaPrimReaderRegistry::Find(const TfToken& usdTypeName) // ideally something just registered itself. if not, we at least put it in // the registry in case we encounter it again. - if (!TfMapLookup(_reg, typeName, &ret)) { + if (_reg.count(typeName) == 0) { TF_DEBUG(PXRUSDMAYA_REGISTRY) .Msg("No usdMaya reader plugin for TfType %s. No maya plugin.\n", typeName.GetText()); - _reg[typeName] = nullptr; + Register( + tfType, + [](const UsdMayaJobImportArgs&, const UsdPrim&) { + return UsdMayaPrimReader::ContextSupport::Fallback; + }, + nullptr); } - return ret; + + return nullptr; } /* static */ -UsdMayaPrimReaderRegistry::ReaderFactoryFn -UsdMayaPrimReaderRegistry::FindOrFallback(const TfToken& usdTypeName) +UsdMayaPrimReaderRegistry::ReaderFactoryFn UsdMayaPrimReaderRegistry::FindOrFallback( + const TfToken& usdTypeName, + const UsdMayaJobImportArgs& importArgs, + const UsdPrim& importPrim) { - if (ReaderFactoryFn fn = Find(usdTypeName)) { + if (ReaderFactoryFn fn = Find(usdTypeName, importArgs, importPrim)) { return fn; } diff --git a/lib/mayaUsd/fileio/primReaderRegistry.h b/lib/mayaUsd/fileio/primReaderRegistry.h index 7a991bc2e2..d42135752e 100644 --- a/lib/mayaUsd/fileio/primReaderRegistry.h +++ b/lib/mayaUsd/fileio/primReaderRegistry.h @@ -54,6 +54,11 @@ struct UsdMayaPrimReaderRegistry /// for the given prim reader args. typedef std::function ReaderFactoryFn; + /// Predicate function, i.e. a function that can tell the level of support + /// the reader function will provide for a given context. + using ContextPredicateFn = std::function< + UsdMayaPrimReader::ContextSupport(const UsdMayaJobImportArgs&, const UsdPrim&)>; + /// Reader function, i.e. a function that reads a prim. This is the /// signature of the function declared in the PXRUSDMAYA_DEFINE_READER /// macro. @@ -63,7 +68,16 @@ struct UsdMayaPrimReaderRegistry MAYAUSD_CORE_PUBLIC static void Register(const TfType& type, ReaderFactoryFn fn, bool fromPython = false); + /// \brief Register \p fn as a reader provider for \p type and provide the supportability. + MAYAUSD_CORE_PUBLIC + static void Register( + const TfType& type, + ContextPredicateFn pred, + ReaderFactoryFn fn, + bool fromPython = false); + /// \brief Register \p fn as a reader provider for \p T. + /// Context support will be set to default "Fallback" /// /// Example for registering a reader factory in your custom plugin, assuming /// that MyType is registered with the TfType system: @@ -85,6 +99,30 @@ struct UsdMayaPrimReaderRegistry } } + /// \brief Register \p fn as a reader provider for \p T and provide the supportability. + /// Use "Supported" to override default reader + /// + /// Example for registering a reader factory in your custom plugin, assuming + /// that MyType is registered with the TfType system: + /// \code{.cpp} + /// class MyReader : public UsdMayaPrimReader { + /// static UsdMayaPrimReaderSharedPtr Create( + /// const UsdMayaPrimReaderArgs&); + /// }; + /// TF_REGISTRY_FUNCTION_WITH_TAG(UsdMayaPrimReaderRegistry, MyType) { + /// UsdMayaPrimReaderRegistry::Register(ContextSupport, MyReader::Create); + /// } + /// \endcode + template + static void Register(ContextPredicateFn pred, ReaderFactoryFn fn, bool fromPython = false) + { + if (TfType t = TfType::Find()) { + Register(t, pred, fn, fromPython); + } else { + TF_CODING_ERROR("Cannot register unknown TfType: %s.", ArchGetDemangled().c_str()); + } + } + /// \brief Wraps \p fn in a ReaderFactoryFn and registers that factory /// function as a reader provider for \p T. /// This is a helper method for the macro PXRUSDMAYA_DEFINE_READER; @@ -100,13 +138,19 @@ struct UsdMayaPrimReaderRegistry /// prim.GetTypeName() /// \endcode MAYAUSD_CORE_PUBLIC - static ReaderFactoryFn Find(const TfToken& usdTypeName); + static ReaderFactoryFn Find( + const TfToken& usdTypeName, + const UsdMayaJobImportArgs& importArgs, + const UsdPrim& importPrim); /// Similar to Find(), but returns a "fallback" prim reader factory if none /// can be found for \p usdTypeName. Thus, this always returns a valid /// reader factory. MAYAUSD_CORE_PUBLIC - static ReaderFactoryFn FindOrFallback(const TfToken& usdTypeName); + static ReaderFactoryFn FindOrFallback( + const TfToken& usdTypeName, + const UsdMayaJobImportArgs& importArgs, + const UsdPrim& importPrim); }; // Lookup TfType by name instead of static C++ type when diff --git a/lib/mayaUsd/fileio/primUpdater.cpp b/lib/mayaUsd/fileio/primUpdater.cpp index 07bc85bea6..673cc477b9 100644 --- a/lib/mayaUsd/fileio/primUpdater.cpp +++ b/lib/mayaUsd/fileio/primUpdater.cpp @@ -74,7 +74,12 @@ bool UsdMayaPrimUpdater::canEditAsMaya() const // Invalid prim cannot be edited. if (!prim) return false; - return (UsdMayaPrimReaderRegistry::Find(prim.GetTypeName()) != nullptr); + + UsdMayaJobImportArgs jobArgs = UsdMayaJobImportArgs::CreateFromDictionary( + _context->GetUserArgs(), + /* importWithProxyShapes = */ false, + GfInterval::GetFullInterval()); + return (UsdMayaPrimReaderRegistry::Find(prim.GetTypeName(), jobArgs, prim) != nullptr); } bool UsdMayaPrimUpdater::editAsMaya() { return true; } diff --git a/lib/mayaUsd/fileio/shaderReader.cpp b/lib/mayaUsd/fileio/shaderReader.cpp index afb9631c79..497537889e 100644 --- a/lib/mayaUsd/fileio/shaderReader.cpp +++ b/lib/mayaUsd/fileio/shaderReader.cpp @@ -36,7 +36,7 @@ UsdMayaShaderReader::UsdMayaShaderReader(const UsdMayaPrimReaderArgs& readArgs) } /* static */ -UsdMayaShaderReader::ContextSupport UsdMayaShaderReader::CanImport(const UsdMayaJobImportArgs&) +UsdMayaPrimReader::ContextSupport UsdMayaShaderReader::CanImport(const UsdMayaJobImportArgs&) { // Default value for all readers is Fallback. More specialized writers can // override the base CanImport to report Supported/Unsupported as necessary. diff --git a/lib/mayaUsd/fileio/shaderReader.h b/lib/mayaUsd/fileio/shaderReader.h index 450519d50e..1411c63fad 100644 --- a/lib/mayaUsd/fileio/shaderReader.h +++ b/lib/mayaUsd/fileio/shaderReader.h @@ -41,19 +41,6 @@ class UsdMayaShaderReader : public UsdMayaPrimReader MAYAUSD_CORE_PUBLIC UsdMayaShaderReader(const UsdMayaPrimReaderArgs&); - /// The level of support a reader can offer for a given context - /// - /// A basic reader that gives correct results across most contexts should - /// report `Fallback`, while a specialized reader that really shines in a - /// given context should report `Supported` when the context is right and - /// `Unsupported` if the context is not as expected. - enum class ContextSupport - { - Supported, - Fallback, - Unsupported - }; - /// This static function is expected for all shader readers and allows /// declaring how well this class can support the current context: MAYAUSD_CORE_PUBLIC diff --git a/lib/mayaUsd/fileio/shaderReaderRegistry.cpp b/lib/mayaUsd/fileio/shaderReaderRegistry.cpp index 410baf48c9..1d932d6517 100644 --- a/lib/mayaUsd/fileio/shaderReaderRegistry.cpp +++ b/lib/mayaUsd/fileio/shaderReaderRegistry.cpp @@ -57,7 +57,7 @@ static int _ _Registry::const_iterator _Find(const TfToken& usdInfoId, const UsdMayaJobImportArgs& importArgs) { - using ContextSupport = UsdMayaShaderReader::ContextSupport; + using ContextSupport = UsdMayaPrimReader::ContextSupport; _Registry::const_iterator ret = _reg.cend(); _Registry::const_iterator first, last; @@ -120,7 +120,7 @@ void UsdMayaShaderReaderRegistry::Register( UsdMayaShaderReaderRegistry::ReaderFactoryFn UsdMayaShaderReaderRegistry::Find(const TfToken& usdInfoId, const UsdMayaJobImportArgs& importArgs) { - using ContextSupport = UsdMayaShaderReader::ContextSupport; + using ContextSupport = UsdMayaPrimReader::ContextSupport; TfRegistryManager::GetInstance().SubscribeTo(); _Registry::const_iterator it = _Find(usdInfoId, importArgs); diff --git a/lib/mayaUsd/fileio/shaderReaderRegistry.h b/lib/mayaUsd/fileio/shaderReaderRegistry.h index 76027377c1..0b1ab22887 100644 --- a/lib/mayaUsd/fileio/shaderReaderRegistry.h +++ b/lib/mayaUsd/fileio/shaderReaderRegistry.h @@ -75,7 +75,7 @@ struct UsdMayaShaderReaderRegistry /// Predicate function, i.e. a function that can tell the level of support /// the reader function will provide for a given context. using ContextPredicateFn - = std::function; + = std::function; /// Reader factory function, i.e. a function that creates a prim reader /// for the given prim reader args. diff --git a/lib/mayaUsd/fileio/shading/symmetricShaderReader.cpp b/lib/mayaUsd/fileio/shading/symmetricShaderReader.cpp index a86ceb8cd4..ce841edca9 100644 --- a/lib/mayaUsd/fileio/shading/symmetricShaderReader.cpp +++ b/lib/mayaUsd/fileio/shading/symmetricShaderReader.cpp @@ -74,7 +74,7 @@ void UsdMayaSymmetricShaderReader::RegisterReader( } /* static */ -UsdMayaShaderReader::ContextSupport UsdMayaSymmetricShaderReader::CanImport( +UsdMayaPrimReader::ContextSupport UsdMayaSymmetricShaderReader::CanImport( const UsdMayaJobImportArgs& importArgs, const TfToken& materialConversion) { diff --git a/lib/mayaUsd/python/wrapPrimReader.cpp b/lib/mayaUsd/python/wrapPrimReader.cpp index 0475221777..b00ff54bbb 100644 --- a/lib/mayaUsd/python/wrapPrimReader.cpp +++ b/lib/mayaUsd/python/wrapPrimReader.cpp @@ -112,20 +112,35 @@ class PrimReaderWrapper return sptr; } + UsdMayaPrimReader::ContextSupport + operator()(const UsdMayaJobImportArgs& args, const UsdPrim& importPrim) + { + boost::python::object pyClass = GetPythonObject(_classIndex); + if (!pyClass) { + // Prototype was unregistered + return UsdMayaPrimReader::ContextSupport::Unsupported; + } + TfPyLock pyLock; + if (PyObject_HasAttrString(pyClass.ptr(), "CanImport")) { + boost::python::object CanImport = pyClass.attr("CanImport"); + PyObject* callable = CanImport.ptr(); + auto res = boost::python::call(callable, args, importPrim); + return UsdMayaPrimReader::ContextSupport(res); + } else { + return UsdMayaPrimReader::CanImport(args, importPrim); + } + } + // Create a new wrapper for a Python class that is seen for the first time for a given // purpose. If we already have a registration for this purpose: update the class to // allow the previously issued factory function to use it. - static UsdMayaPrimReaderRegistry::ReaderFactoryFn - Register(boost::python::object cl, const std::string& typeName) + static FactoryFnWrapper + Register(boost::python::object cl, const std::string& typeName, bool& updated) { size_t classIndex = RegisterPythonObject(cl, GetKey(cl, typeName)); - if (classIndex != UsdMayaPythonObjectRegistry::UPDATED) { - // Return a new factory function: - return FactoryFnWrapper { classIndex }; - } else { - // We already registered a factory function for this purpose: - return nullptr; - } + updated = classIndex == UsdMayaPythonObjectRegistry::UPDATED; + // Return a new factory function: + return FactoryFnWrapper { classIndex }; } // Unregister a class for a given purpose. This will cause the associated factory @@ -152,10 +167,11 @@ class PrimReaderWrapper static void Register(boost::python::object cl, const std::string& typeName) { - UsdMayaPrimReaderRegistry::ReaderFactoryFn fn = FactoryFnWrapper::Register(cl, typeName); - if (fn) { + bool updated = false; + FactoryFnWrapper fn = FactoryFnWrapper::Register(cl, typeName, updated); + if (!updated) { auto type = TfType::FindByName(typeName); - UsdMayaPrimReaderRegistry::Register(type, fn, true); + UsdMayaPrimReaderRegistry::Register(type, fn, fn, true); } } @@ -297,20 +313,20 @@ class ShaderReaderWrapper : public PrimReaderWrapper return sptr; } - // We can have multiple function objects, this one apapts the CanImport function: - UsdMayaShaderReader::ContextSupport operator()(const UsdMayaJobImportArgs& args) + // We can have multiple function objects, this one adapts the CanImport function: + UsdMayaPrimReader::ContextSupport operator()(const UsdMayaJobImportArgs& args) { boost::python::object pyClass = GetPythonObject(_classIndex); if (!pyClass) { // Prototype was unregistered - return UsdMayaShaderReader::ContextSupport::Unsupported; + return UsdMayaPrimReader::ContextSupport::Unsupported; } TfPyLock pyLock; if (PyObject_HasAttrString(pyClass.ptr(), "CanImport")) { boost::python::object CanImport = pyClass.attr("CanImport"); PyObject* callable = CanImport.ptr(); auto res = boost::python::call(callable, args); - return UsdMayaShaderReader::ContextSupport(res); + return UsdMayaPrimReader::ContextSupport(res); } else { return UsdMayaShaderReader::CanImport(args); } @@ -499,13 +515,25 @@ void wrapPrimReaderArgs() .def("GetUseAsAnimationCache", &UsdMayaPrimReaderArgs::GetUseAsAnimationCache); } +TF_REGISTRY_FUNCTION(TfEnum) +{ + TF_ADD_ENUM_NAME(UsdMayaPrimReader::ContextSupport::Supported, "Supported"); + TF_ADD_ENUM_NAME(UsdMayaPrimReader::ContextSupport::Fallback, "Fallback"); + TF_ADD_ENUM_NAME(UsdMayaPrimReader::ContextSupport::Unsupported, "Unsupported"); +} + void wrapPrimReader() { using namespace boost::python; typedef UsdMayaPrimReader This; - class_, boost::noncopyable>("PrimReader", no_init) - .def("__init__", make_constructor(&PrimReaderWrapper<>::New)) + class_, boost::noncopyable> c("PrimReader", no_init); + + scope s(c); + + TfPyWrapEnum(); + + c.def("__init__", make_constructor(&PrimReaderWrapper<>::New)) .def("Read", pure_virtual(&UsdMayaPrimReader::Read)) .def( "HasPostReadSubtree", @@ -522,13 +550,6 @@ void wrapPrimReader() .staticmethod("Unregister"); } -TF_REGISTRY_FUNCTION(TfEnum) -{ - TF_ADD_ENUM_NAME(UsdMayaShaderReader::ContextSupport::Supported, "Supported"); - TF_ADD_ENUM_NAME(UsdMayaShaderReader::ContextSupport::Fallback, "Fallback"); - TF_ADD_ENUM_NAME(UsdMayaShaderReader::ContextSupport::Unsupported, "Unsupported"); -} - //---------------------------------------------------------------------------------------------------------------------- void wrapShaderReader() { @@ -540,8 +561,6 @@ void wrapShaderReader() scope s(c); - TfPyWrapEnum(); - c.def("__init__", make_constructor(&ShaderReaderWrapper::New)) .def("Read", pure_virtual(&UsdMayaPrimReader::Read)) .def( diff --git a/lib/usd/translators/shading/mtlxSymmetricShaderReader.cpp b/lib/usd/translators/shading/mtlxSymmetricShaderReader.cpp index 4ed3d21650..bc1892b48a 100644 --- a/lib/usd/translators/shading/mtlxSymmetricShaderReader.cpp +++ b/lib/usd/translators/shading/mtlxSymmetricShaderReader.cpp @@ -138,7 +138,7 @@ TF_REGISTRY_FUNCTION(UsdMayaShaderReaderRegistry) }; /* static */ -UsdMayaShaderReader::ContextSupport +UsdMayaPrimReader::ContextSupport MtlxUsd_SymmetricShaderReader::CanImport(const UsdMayaJobImportArgs& importArgs) { if (importArgs.GetMaterialConversion() == TrMtlxTokens->conversionName) { diff --git a/lib/usd/translators/shading/usdBlinnReader.cpp b/lib/usd/translators/shading/usdBlinnReader.cpp index 74881ef5bb..f557dffdf2 100644 --- a/lib/usd/translators/shading/usdBlinnReader.cpp +++ b/lib/usd/translators/shading/usdBlinnReader.cpp @@ -78,7 +78,7 @@ PxrUsdTranslators_BlinnReader::PxrUsdTranslators_BlinnReader(const UsdMayaPrimRe } /* static */ -UsdMayaShaderReader::ContextSupport +UsdMayaPrimReader::ContextSupport PxrUsdTranslators_BlinnReader::CanImport(const UsdMayaJobImportArgs& importArgs) { return importArgs.preferredMaterial == UsdMayaPreferredMaterialTokens->blinn diff --git a/plugin/pxr/maya/lib/usdMaya/readJob_ImportWithProxies.cpp b/plugin/pxr/maya/lib/usdMaya/readJob_ImportWithProxies.cpp index b52535fb19..5df33ff309 100644 --- a/plugin/pxr/maya/lib/usdMaya/readJob_ImportWithProxies.cpp +++ b/plugin/pxr/maya/lib/usdMaya/readJob_ImportWithProxies.cpp @@ -260,7 +260,7 @@ bool UsdMaya_ReadJobWithSceneAssembly::_ProcessCameraPrims(const std::vectorRead(ctx); diff --git a/test/lib/mayaUsd/fileio/testShaderReader.py b/test/lib/mayaUsd/fileio/testShaderReader.py index 82819b4974..ad19ad0970 100644 --- a/test/lib/mayaUsd/fileio/testShaderReader.py +++ b/test/lib/mayaUsd/fileio/testShaderReader.py @@ -40,7 +40,7 @@ class mtlxShaderReaderTest(mayaUsdLib.ShaderReader): @classmethod def CanImport(cls, args): - return cls.ContextSupport.Supported + return mayaUsdLib.PrimReader.ContextSupport.Supported def IsConverter(self): mtlxShaderReaderTest.IsConverterCalled = True