Replace pxr namespace with PXR_NS to allow building against custom USD builds.

Author: dansheerin

maya_plugin/test/testUsdTranslation.cpp

@@ -37,7 +37,7 @@ TEST(UsdTranslationTests, addStageToCache) {
 
     // On windows we need to cast to long int, otheriwse its a warning as error
     ASSERT_TRUE(
-        pxr::UsdUtilsStageCache::Get().Find(pxr::UsdStageCache::Id::FromLongInt(
+        PXR_NS::UsdUtilsStageCache::Get().Find(PXR_NS::UsdStageCache::Id::FromLongInt(
             static_cast<long int>(cacheId))) ==
         const_cast<BifrostUsd::Stage&>(*stage).getStagePtr());
 
@@ -56,8 +56,8 @@ TEST(UsdTranslationTests, portRemoved) {
     translator->portRemoved("somestage", "someproxy");
 
     // On windows we need to cast to long int, otheriwse its a warning as error
-    ASSERT_FALSE(pxr::UsdUtilsStageCache::Get().Find(
-        pxr::UsdStageCache::Id::FromLongInt(static_cast<long int>(cacheId))));
+    ASSERT_FALSE(PXR_NS::UsdUtilsStageCache::Get().Find(
+        PXR_NS::UsdStageCache::Id::FromLongInt(static_cast<long int>(cacheId))));
 
     delete translator;
 }

src/BifrostUsd/Attribute.cpp

@@ -19,11 +19,11 @@
 
 #include <Amino/Cpp/ClassDefine.h>
 
-/// \todo BIFROST-6874 remove pxr::Work_EnsureDetachedTaskProgress();
+/// \todo BIFROST-6874 remove PXR_NS::Work_EnsureDetachedTaskProgress();
 #include <pxr/base/work/detachedTask.h>
 
 namespace BifrostUsd {
-Attribute::Attribute(pxr::UsdAttribute attribute, Amino::Ptr<Prim> prim)
+Attribute::Attribute(PXR_NS::UsdAttribute attribute, Amino::Ptr<Prim> prim)
     : pxr_attribute(std::move(attribute)), prim_ptr(std::move(prim)) {
     assert((prim_ptr != nullptr) == (pxr_attribute.IsValid()));
 }
@@ -37,13 +37,13 @@ Amino::Ptr<BifrostUsd::Attribute> Amino::createDefaultClass() {
     // Destructor of USD instances are lauching threads. This result in
     // a deadlock on windows when unloading the library (which destroys the
     // default constructed object held in static variables).
-    /// \todo BIFROST-6874 remove pxr::Work_EnsureDetachedTaskProgress();
-    pxr::Work_EnsureDetachedTaskProgress();
+    /// \todo BIFROST-6874 remove PXR_NS::Work_EnsureDetachedTaskProgress();
+    PXR_NS::Work_EnsureDetachedTaskProgress();
     auto stage    = Amino::newClassPtr<BifrostUsd::Stage>();
     auto pxr_prim = stage->get().GetPseudoRoot();
     auto prim     = Amino::newClassPtr<BifrostUsd::Prim>(pxr_prim, stage);
     auto pxr_attr =
-        pxr_prim.CreateAttribute(pxr::TfToken(""), pxr::SdfValueTypeName());
+        pxr_prim.CreateAttribute(PXR_NS::TfToken(""), PXR_NS::SdfValueTypeName());
     return Amino::newClassPtr<BifrostUsd::Attribute>(pxr_attr, prim);
 }
 AMINO_DEFINE_DEFAULT_CLASS(BifrostUsd::Attribute);

src/BifrostUsd/Layer.cpp

@@ -20,7 +20,7 @@
 
 #include <Amino/Cpp/ClassDefine.h>
 
-/// \todo BIFROST-6874 remove pxr::Work_EnsureDetachedTaskProgress();
+/// \todo BIFROST-6874 remove PXR_NS::Work_EnsureDetachedTaskProgress();
 #include <pxr/base/work/detachedTask.h>
 
 // Note: To silence warnings coming from USD library
@@ -100,16 +100,16 @@ Amino::String getFilenameWithValidUsdFileFormat(const Amino::String& filename =
 BifrostUsd::Layer const s_invalidLayer{BifrostUsd::Layer::Invalid{}};
 
 struct Sublayer {
-    pxr::SdfLayerRefPtr sublayer;
+    PXR_NS::SdfLayerRefPtr sublayer;
     Amino::String       sublayerPath;
 };
 
-Amino::Array<Sublayer> getSublayers(const pxr::SdfLayerRefPtr layer) {
+Amino::Array<Sublayer> getSublayers(const PXR_NS::SdfLayerRefPtr layer) {
     Amino::Array<Sublayer> layers;
     if (layer) {
         auto subLayerPaths = layer->GetSubLayerPaths();
         for (size_t i = 0; i < subLayerPaths.size(); ++i) {
-            auto sublayer = pxr::SdfLayer::FindOrOpenRelativeToLayer(
+            auto sublayer = PXR_NS::SdfLayer::FindOrOpenRelativeToLayer(
                 layer, subLayerPaths[i]);
             std::string sublayerPath = subLayerPaths[i];
             if (sublayer) {
@@ -128,7 +128,7 @@ Layer::Layer(Layer::Invalid) { assert(!isValid()); }
 
 Layer::Layer(const Amino::String& tag) {
     m_tag = getTagWithValidUsdFileFormat(tag);
-    m_layer = pxr::SdfLayer::CreateAnonymous(m_tag.c_str());
+    m_layer = PXR_NS::SdfLayer::CreateAnonymous(m_tag.c_str());
 }
 
 Layer::Layer(const Amino::String& filePath,
@@ -151,10 +151,10 @@ Layer::Layer(const Amino::String& filePath,
 
     // Temporary Stage that will help in loading relative files and give us
     // access to the sublayers
-    auto stage = pxr::UsdStage::Open(m_originalFilePath.c_str());
+    auto stage = PXR_NS::UsdStage::Open(m_originalFilePath.c_str());
     if (stage) {
         if (isEditable) {
-            m_layer = pxr::SdfLayer::CreateAnonymous(m_tag.c_str());
+            m_layer = PXR_NS::SdfLayer::CreateAnonymous(m_tag.c_str());
             m_layer->TransferContent(stage->GetRootLayer());
             auto sublayers = getSublayers(stage->GetRootLayer());
             // Clear the sublayerPaths
@@ -180,7 +180,7 @@ Layer::Layer(const Amino::String& filePath,
     }
 }
 
-Layer::Layer(const pxr::SdfLayerRefPtr layer,
+Layer::Layer(const PXR_NS::SdfLayerRefPtr layer,
              const bool                isEditable,
              const Amino::String&      originalFilePath) {
     auto validOriginalPath = originalFilePath.empty() ? "" :
@@ -203,7 +203,7 @@ Layer::Layer(const pxr::SdfLayerRefPtr layer,
     }
     auto sublayers = getSublayers(layer);
     if (isEditable) {
-        m_layer = pxr::SdfLayer::CreateAnonymous(m_tag.c_str());
+        m_layer = PXR_NS::SdfLayer::CreateAnonymous(m_tag.c_str());
         m_layer->TransferContent(layer);
         // Clear the sublayerPaths
         m_layer->SetSubLayerPaths(std::vector<std::string>());
@@ -239,7 +239,7 @@ Layer::Layer(const Layer& other, const Amino::String& savefilePath)
     }
 
     if (other.m_layer->PermissionToEdit()) {
-        m_layer = pxr::SdfLayer::CreateAnonymous(m_tag.c_str());
+        m_layer = PXR_NS::SdfLayer::CreateAnonymous(m_tag.c_str());
         m_layer->TransferContent(other.m_layer);
 
         // Replace sublayers coming from the other layer by the one created by
@@ -375,7 +375,7 @@ bool Layer::exportToFile(const Amino::String& filePath,
         return false;
     }
 
-    auto outLayer = pxr::SdfLayer::CreateNew(outFilePath);
+    auto outLayer = PXR_NS::SdfLayer::CreateNew(outFilePath);
     if (!outLayer) {
         return false;
     }
@@ -411,7 +411,7 @@ bool Layer::exportToFile(const Amino::String& filePath,
 }
 
 Amino::String Layer::exportToString(bool exportSubLayers) const {
-    auto outLayer = pxr::SdfLayer::CreateAnonymous(
+    auto outLayer = PXR_NS::SdfLayer::CreateAnonymous(
         getTagWithValidUsdFileFormat().c_str());
     outLayer->TransferContent(m_layer);
 
@@ -473,8 +473,8 @@ Amino::Ptr<BifrostUsd::Layer> Amino::createDefaultClass() {
     // Destructor of USD instances are lauching threads. This result in
     // a deadlock on windows when unloading the library (which destroys the
     // default constructed object held in static variables).
-    /// \todo BIFROST-6874 remove pxr::Work_EnsureDetachedTaskProgress();
-    pxr::Work_EnsureDetachedTaskProgress();
+    /// \todo BIFROST-6874 remove PXR_NS::Work_EnsureDetachedTaskProgress();
+    PXR_NS::Work_EnsureDetachedTaskProgress();
     return Amino::newClassPtr<BifrostUsd::Layer>(
         BifrostUsd::Layer::Invalid{});
 }

src/BifrostUsd/Prim.cpp

@@ -19,11 +19,11 @@
 
 // #include <core/logger.h>
 
-/// \todo BIFROST-6874 remove pxr::Work_EnsureDetachedTaskProgress();
+/// \todo BIFROST-6874 remove PXR_NS::Work_EnsureDetachedTaskProgress();
 #include <pxr/base/work/detachedTask.h>
 
 namespace BifrostUsd {
-Prim::Prim(pxr::UsdPrim prim, Amino::Ptr<Stage> stage)
+Prim::Prim(PXR_NS::UsdPrim prim, Amino::Ptr<Stage> stage)
     : pxr_prim(std::move(prim)), stage_ptr(std::move(stage)) {
     assert((stage_ptr != nullptr) == (pxr_prim.IsValid()));
 }
@@ -37,8 +37,8 @@ Amino::Ptr<BifrostUsd::Prim> Amino::createDefaultClass() {
     // Destructor of USD instances are lauching threads. This result in
     // a deadlock on windows when unloading the library (which destroys the
     // default constructed object held in static variables).
-    /// \todo BIFROST-6874 remove pxr::Work_EnsureDetachedTaskProgress();
-    pxr::Work_EnsureDetachedTaskProgress();
+    /// \todo BIFROST-6874 remove PXR_NS::Work_EnsureDetachedTaskProgress();
+    PXR_NS::Work_EnsureDetachedTaskProgress();
     auto stage    = Amino::newClassPtr<BifrostUsd::Stage>();
     auto pxr_prim = stage->get().GetPseudoRoot();
     return Amino::newClassPtr<BifrostUsd::Prim>(pxr_prim, stage);

src/BifrostUsd/Stage.cpp

@@ -33,7 +33,7 @@ BIFUSD_WARNING_DISABLE_MSC(4800)
 #include <pxr/usd/usd/prim.h>
 #include <pxr/usd/usd/stage.h>
 
-/// \todo BIFROST-6874 remove pxr::Work_EnsureDetachedTaskProgress();
+/// \todo BIFROST-6874 remove PXR_NS::Work_EnsureDetachedTaskProgress();
 #include <pxr/base/work/detachedTask.h>
 
 BIFUSD_WARNING_POP
@@ -42,11 +42,11 @@ BIFUSD_WARNING_POP
 
 namespace {
 
-pxr::UsdStage::InitialLoadSet GetPxrInitialLoadSet(
+PXR_NS::UsdStage::InitialLoadSet GetPxrInitialLoadSet(
     BifrostUsd::InitialLoadSet load) {
     return load == BifrostUsd::InitialLoadSet::LoadAll
-               ? pxr::UsdStage::InitialLoadSet::LoadAll
-               : pxr::UsdStage::InitialLoadSet::LoadNone;
+               ? PXR_NS::UsdStage::InitialLoadSet::LoadAll
+               : PXR_NS::UsdStage::InitialLoadSet::LoadNone;
 }
 
 } // namespace
@@ -55,36 +55,36 @@ namespace BifrostUsd {
 
 Stage::Stage()
     : m_rootLayer(Amino::newClassPtr<Layer>()),
-      m_stage(pxr::UsdStage::Open(m_rootLayer->m_layer)) {}
+      m_stage(PXR_NS::UsdStage::Open(m_rootLayer->m_layer)) {}
 
 Stage::Stage(Invalid) { assert(!isValid()); }
 
 Stage::Stage(const Layer& rootLayer, const InitialLoadSet load)
     : m_rootLayer(Amino::newClassPtr<Layer>(rootLayer)),
       m_stage(
-          pxr::UsdStage::Open(m_rootLayer->m_layer, GetPxrInitialLoadSet(load)))
+          PXR_NS::UsdStage::Open(m_rootLayer->m_layer, GetPxrInitialLoadSet(load)))
 
 {}
 
 Stage::Stage(const Layer&                       rootLayer,
-             const pxr::UsdStagePopulationMask& mask,
+             const PXR_NS::UsdStagePopulationMask& mask,
              const InitialLoadSet               load)
     : m_rootLayer(Amino::newClassPtr<Layer>(rootLayer)),
-      m_stage(pxr::UsdStage::OpenMasked(
+      m_stage(PXR_NS::UsdStage::OpenMasked(
           m_rootLayer->m_layer, mask, GetPxrInitialLoadSet(load)))
 
 {}
 
 Stage::Stage(const Amino::String& filePath, const InitialLoadSet load)
     : m_rootLayer(Amino::newClassPtr<Layer>(filePath, "")),
-      m_stage(pxr::UsdStage::Open(m_rootLayer->m_layer,
+      m_stage(PXR_NS::UsdStage::Open(m_rootLayer->m_layer,
                                   GetPxrInitialLoadSet(load))) {}
 
 Stage::Stage(const Amino::String&               filePath,
-             const pxr::UsdStagePopulationMask& mask,
+             const PXR_NS::UsdStagePopulationMask& mask,
              const InitialLoadSet               load)
     : m_rootLayer(Amino::newClassPtr<Layer>(filePath, "")),
-      m_stage(pxr::UsdStage::OpenMasked(
+      m_stage(PXR_NS::UsdStage::OpenMasked(
           m_rootLayer->m_layer, mask, GetPxrInitialLoadSet(load))) {}
 
 Stage::Stage(const Stage& other) : Stage(*other.m_rootLayer) {
@@ -101,7 +101,7 @@ Stage::Stage(const Stage& other) : Stage(*other.m_rootLayer) {
 
 Stage& Stage::operator=(const Stage& other) {
     m_rootLayer = Amino::newClassPtr<Layer>(*other.m_rootLayer);
-    m_stage     = pxr::UsdStage::Open(m_rootLayer->m_layer);
+    m_stage     = PXR_NS::UsdStage::Open(m_rootLayer->m_layer);
 
     // The newly created UsdStage has the root layer as its default EditTarget.
     // We can't just copy the m_editLayerIndex, but must set the desired
@@ -148,7 +148,7 @@ bool Stage::setEditLayerIndex(const int layerIndex,
         const size_t numLayers = subLayerPaths.size();
         if (static_cast<size_t>(layerIndex) < numLayers) {
             // Find the sublayer
-            auto layer = pxr::SdfLayer::FindOrOpen(subLayerPaths[layerIndex]);
+            auto layer = PXR_NS::SdfLayer::FindOrOpen(subLayerPaths[layerIndex]);
             if (layer) {
                 m_stage->SetEditTarget(layer);
                 m_editLayerIndex = layerIndex;
@@ -166,11 +166,11 @@ bool Stage::setEditLayerIndex(const int layerIndex,
     return false;
 }
 
-pxr::UsdVariantSet Stage::getLastModifedVariantSet() const {
-    pxr::UsdPrim variant_prim;
+PXR_NS::UsdVariantSet Stage::getLastModifedVariantSet() const {
+    PXR_NS::UsdPrim variant_prim;
     if (this->hasLastModifiedVariantSetPrim()) {
         variant_prim = m_stage->GetPrimAtPath(
-            pxr::SdfPath(this->last_modified_variant_set_prim.c_str()));
+            PXR_NS::SdfPath(this->last_modified_variant_set_prim.c_str()));
     }
     return variant_prim.GetVariantSet(
         this->last_modified_variant_set_name.c_str());
@@ -189,8 +189,8 @@ Amino::Ptr<BifrostUsd::Stage> Amino::createDefaultClass() {
     // Destructor of USD instances are lauching threads. This result in
     // a deadlock on windows when unloading the library (which destroys the
     // default constructed object held in static variables).
-    /// \todo BIFROST-6874 remove pxr::Work_EnsureDetachedTaskProgress();
-    pxr::Work_EnsureDetachedTaskProgress();
+    /// \todo BIFROST-6874 remove PXR_NS::Work_EnsureDetachedTaskProgress();
+    PXR_NS::Work_EnsureDetachedTaskProgress();
     return Amino::newClassPtr<BifrostUsd::Stage>();
 }
 AMINO_DEFINE_DEFAULT_CLASS(BifrostUsd::Stage);

src/BifrostUsd/StageCache.cpp

@@ -36,7 +36,7 @@ bool StageCache::addStageToCache(const Amino::Ptr<BifrostUsd::Stage>& stage,
     if (stage) {
         auto usdStagePtr =
             const_cast<Stage&>(*stage).getStagePtr();
-        auto id = pxr::UsdUtilsStageCache::Get().Insert(usdStagePtr);
+        auto id = PXR_NS::UsdUtilsStageCache::Get().Insert(usdStagePtr);
 
         if (id && id.IsValid()) {
             // Note: on the USD side, this is implemented as a long int
@@ -54,11 +54,11 @@ bool StageCache::removeStageFromCache(int64_t id) {
         // Which is platform dependent.  We interface ith a 64 bit int.
         // So we cast.
         assert(id <= std::numeric_limits<int>::max());
-        return pxr::UsdUtilsStageCache::Get().Erase(
-            pxr::UsdStageCache::Id::FromLongInt(static_cast<int>(id)));
+        return PXR_NS::UsdUtilsStageCache::Get().Erase(
+            PXR_NS::UsdStageCache::Id::FromLongInt(static_cast<int>(id)));
 #else
-        return pxr::UsdUtilsStageCache::Get().Erase(
-            pxr::UsdStageCache::Id::FromLongInt(id));
+        return PXR_NS::UsdUtilsStageCache::Get().Erase(
+            PXR_NS::UsdStageCache::Id::FromLongInt(id));
 #endif
 }
 

src/BifrostUsd/include/Attribute.h

@@ -51,7 +51,7 @@ class AMINO_ANNOTATE("Amino::Class") USD_DECL Attribute {
 public:
 #ifndef DISABLE_PXR_HEADERS
     Attribute() = default;
-    Attribute(pxr::UsdAttribute attribute, Amino::Ptr<Prim> prim);
+    Attribute(PXR_NS::UsdAttribute attribute, Amino::Ptr<Prim> prim);
 
     Attribute(const Attribute&)      = default;
     Attribute(Attribute &&) noexcept = default;
@@ -67,11 +67,11 @@ class AMINO_ANNOTATE("Amino::Class") USD_DECL Attribute {
         return prim_ptr != nullptr;
     }
 
-    pxr::UsdAttribute const* operator->() const { return &pxr_attribute; }
+    PXR_NS::UsdAttribute const* operator->() const { return &pxr_attribute; }
     Amino::Ptr<Prim> const& getPrim() const { return prim_ptr; }
 
 private:
-    pxr::UsdAttribute pxr_attribute;
+    PXR_NS::UsdAttribute pxr_attribute;
 
     // We need to keep a pointer to the prims since attributes can only exist on
     // prims and if we don't then Bifrost will cleanup the prims if they are

src/BifrostUsd/include/Layer.h

@@ -64,7 +64,7 @@ class AMINO_ANNOTATE("Amino::Class") USD_DECL Layer {
                    const Amino::String& savefilePath = "",
                    const bool           isEditable   = true);
 
-    explicit Layer(const pxr::SdfLayerRefPtr layer,
+    explicit Layer(const PXR_NS::SdfLayerRefPtr layer,
                    const bool                isEditable       = true,
                    const Amino::String&      originalFilePath = "");
 
@@ -90,25 +90,25 @@ class AMINO_ANNOTATE("Amino::Class") USD_DECL Layer {
     bool     isValid() const { return m_layer != nullptr; }
     explicit operator bool() const { return isValid(); }
 
-    /// \brief Accessors to the underlying pxr::SdfLayer.
+    /// \brief Accessors to the underlying PXR_NS::SdfLayer.
     ///
     /// These accessor should be used instead of getting the underlying
-    /// pxr::SdfLayerRefPtr directly, because they propagate constness to the
-    /// pxr::SdfLayer pointer.
+    /// PXR_NS::SdfLayerRefPtr directly, because they propagate constness to the
+    /// PXR_NS::SdfLayer pointer.
     ///
     /// This helps avoiding unintentionally creating side effects in other
     /// pointers to the same \ref BifrostUsd::Layer.
     /// \{
-    pxr::SdfLayer&       get() { return *m_layer; }
-    pxr::SdfLayer&       operator*() { return *m_layer; }
-    pxr::SdfLayer*       operator->() { return m_layer.operator->(); }
-    pxr::SdfLayer const& get() const { return *m_layer; }
-    pxr::SdfLayer const& operator*() const { return *m_layer; }
-    pxr::SdfLayer const* operator->() const { return m_layer.operator->(); }
+    PXR_NS::SdfLayer&       get() { return *m_layer; }
+    PXR_NS::SdfLayer&       operator*() { return *m_layer; }
+    PXR_NS::SdfLayer*       operator->() { return m_layer.operator->(); }
+    PXR_NS::SdfLayer const& get() const { return *m_layer; }
+    PXR_NS::SdfLayer const& operator*() const { return *m_layer; }
+    PXR_NS::SdfLayer const* operator->() const { return m_layer.operator->(); }
     /// \}
 
     // This function is purposefully non-const. Be careful with it.
-    pxr::SdfLayerRefPtr getLayerPtr() { return m_layer; }
+    PXR_NS::SdfLayerRefPtr getLayerPtr() { return m_layer; }
 
     void                       setFilePath(const Amino::String& filePath);
     const Amino::String&       getFilePath() const;
@@ -221,7 +221,7 @@ class AMINO_ANNOTATE("Amino::Class") USD_DECL Layer {
     friend Stage;
 
     /// The underlying anonymous sdf layer.
-    pxr::SdfLayerRefPtr m_layer;
+    PXR_NS::SdfLayerRefPtr m_layer;
 
     /// The file path where to save this Layer.
     /// Can be an empty string, which will disable file export if no other