This change alters the behavior of SdfAssetPath in a few ways:

Renames the existing _assetPath member and meaning of first parameter to the constructor to now represent the raw authored path in the layerr.  Added explicit getters for this authored path. It is important to note that when authoring scene description, this value will be used for serilization, all other fields will be ignored.

Adds a new evaluatedPath field to SdfAssetPath.  This field is meant to hold the original asset path as authored in the layer with any variable expressions evaluated.  This field is only populated if passed in at construction time.

Changes the behavior of SdfAssetPath::GetAssetPath to return the evaulated path if present, otherwise returns the raw authored path.  This is to preserve compatibility with existing callers who were relying on this method to return them the unresolved asset path containing evaulated expression variables.

Additionally, _MakeResolvedAssetPathsImpl in UsdStage has been augmented to provide the unresolved, evaluated path when creating SdfAssetPath objects.  This function services calls to UsdAttribute::Get().

(Internal change: 2358824)

Author: matthewcpp

pxr/usd/sdf/assetPath.cpp

@@ -122,34 +122,42 @@ SdfAssetPath::SdfAssetPath()
 {
 }
 
-SdfAssetPath::SdfAssetPath(const std::string &path)
-    : _assetPath(path)
-{
-    if (!_ValidateAssetPathString(path.c_str())) {
+SdfAssetPath::SdfAssetPath(const std::string &authoredPath)
+    : _authoredPath(authoredPath)
+{   
+    if (!_ValidateAssetPathString(authoredPath.c_str())) {
         *this = SdfAssetPath();
     }
 }
 
-SdfAssetPath::SdfAssetPath(const std::string &path,
+SdfAssetPath::SdfAssetPath(const std::string &authoredPath,
                            const std::string &resolvedPath)
-    : _assetPath(path)
+    : _authoredPath(authoredPath)
     , _resolvedPath(resolvedPath)
 {
-    if (!_ValidateAssetPathString(path.c_str()) ||
+    if (!_ValidateAssetPathString(authoredPath.c_str()) ||
         !_ValidateAssetPathString(resolvedPath.c_str())) {
         *this = SdfAssetPath();
     }
 }
 
+SdfAssetPath::SdfAssetPath(const SdfAssetPathParams &params)
+    : _authoredPath(params.authoredPath)
+    , _evaluatedPath(params.evaluatedPath)
+    , _resolvedPath(params.resolvedPath)
+{
+    if (!_ValidateAssetPathString(params.authoredPath.c_str()) ||
+        !_ValidateAssetPathString(params.evaluatedPath.c_str()) ||
+        !_ValidateAssetPathString(params.resolvedPath.c_str())) {
+        *this = SdfAssetPath();
+    }
+}
+
 bool
 SdfAssetPath::operator<(const SdfAssetPath &rhs) const
 {
-    if (_assetPath < rhs._assetPath)
-        return true;
-    if (rhs._assetPath < _assetPath)
-        return false;
-
-    return _resolvedPath < rhs._resolvedPath;
+    return std::tie(_authoredPath, _resolvedPath, _evaluatedPath) < 
+           std::tie(rhs._authoredPath, rhs._resolvedPath, rhs._evaluatedPath);
 }
 
 std::ostream& 

pxr/usd/sdf/assetPath.h

@@ -18,13 +18,56 @@
 
 PXR_NAMESPACE_OPEN_SCOPE
 
+class SdfAssetPath;
+
+/// \struct SdfAssetPathParams
+/// Helper class for explicitly setting values when creating a SdfAssetPath
+///
+/// Example usage:
+/// \code
+/// SdfAssetPath myAssetPath(
+///    SdfAssetPathParams()
+///        .Authored("blah_{VAR}.usda")
+///        .Evaluated("blah_foo.usda")
+///        .Resolved("/foo/bar/blah_foo.usda")
+/// );
+/// \endcode
+///
+class SdfAssetPathParams {
+public:
+    SdfAssetPathParams& Authored(const std::string &authoredPath_) {
+        authoredPath = authoredPath_;
+        return *this;
+    }
+
+    SdfAssetPathParams& Evaluated(const std::string &evaluatedPath_) {
+        evaluatedPath = evaluatedPath_;
+        return *this;
+    }
+
+    SdfAssetPathParams& Resolved(const std::string &resolvedPath_) {
+        resolvedPath = resolvedPath_;
+        return *this;
+    }
+
+private:
+    friend class SdfAssetPath;
+
+    std::string authoredPath;
+    std::string evaluatedPath;
+    std::string resolvedPath;
+};
+
 /// \class SdfAssetPath
 ///
-/// Contains an asset path and an optional resolved path.  Asset paths may
-/// contain non-control UTF-8 encoded characters.  Specifically, U+0000..U+001F
-/// (C0 controls), U+007F (delete), and U+0080..U+009F (C1 controls) are
-/// disallowed.  Attempts to construct asset paths with such characters will
-/// issue a TfError and produce the default-constructed empty asset path.
+/// Contains an asset path and optional evaluated and resolved paths.
+/// When this class is used to author scene description, the value returned
+/// by GetAssetPath() is serialized out, all other fields are ignored.
+/// Asset paths may contain non-control UTF-8 encoded characters.
+/// Specifically, U+0000..U+001F (C0 controls), U+007F (delete), 
+/// and U+0080..U+009F (C1 controls) are disallowed.  Attempts to construct
+/// asset paths with such characters will issue a TfError and produce the 
+/// default-constructed empty asset path.
 ///
 class SdfAssetPath
 {
@@ -36,29 +79,41 @@ class SdfAssetPath
     /// Construct an empty asset path.
     SDF_API SdfAssetPath();
 
-    /// Construct an asset path with \p path and no associated resolved path.
+    /// Construct an asset path with \p authoredPath and no associated
+    /// evaluated or resolved path.
     ///
-    /// If the passed \p path is not valid UTF-8 or contains C0 or C1 control
-    /// characters, raise a TfError and return the default-constructed empty
-    /// asset path.
-    SDF_API explicit SdfAssetPath(const std::string &path);
+    /// If the passed \p authoredPath is not valid UTF-8 or contains C0 or C1
+    /// control characters, raise a TfError and return the default-constructed
+    /// empty asset path.
+    SDF_API explicit SdfAssetPath(const std::string &authoredPath);
 
-    /// Construct an asset path with \p path and an associated \p resolvedPath.
+    /// Construct an asset path with \p authoredPath and an associated
+    /// \p resolvedPath.
     ///
-    /// If either the passed \path or \p resolvedPath are not valid UTF-8 or
-    /// either contain C0 or C1 control characters, raise a TfError and return
+    /// If either the passed \p authoredPath or \p resolvedPath are not valid 
+    /// UTF-8 or either contain C0 or C1 control characters, raise a TfError and
+    /// return the default-constructed empty asset path.
+    SDF_API
+    SdfAssetPath(const std::string &authoredPath, 
+                 const std::string &resolvedPath);
+
+    /// Construct an asset path using a SdfAssetPathParams object
+    ///
+    /// If any fields of the passed in structure are not valid UTF-8 or either 
+    /// contain C0 or C1 control, characters, raise a TfError and return
     /// the default-constructed empty asset path.
     SDF_API
-    SdfAssetPath(const std::string &path, const std::string &resolvedPath);
+    SdfAssetPath(const SdfAssetPathParams &params);
 
     /// @}
 
     ///\name Operators
     /// @{
 
-    /// Equality, including the resolved path.
+    /// Equality, including the evaluated and resolved paths.
     bool operator==(const SdfAssetPath &rhs) const {
-        return _assetPath == rhs._assetPath &&
+        return _authoredPath == rhs._authoredPath &&
+               _evaluatedPath == rhs._evaluatedPath &&
                _resolvedPath == rhs._resolvedPath;
     }
 
@@ -68,7 +123,7 @@ class SdfAssetPath
         return !(*this == rhs);
     }
 
-    /// Ordering first by asset path, then by resolved path.
+    /// Ordering first by asset path, resolved path, then by evaluated path.
     SDF_API bool operator<(const SdfAssetPath &rhs) const;
 
     /// Less than or equal operator
@@ -91,7 +146,7 @@ class SdfAssetPath
 
     /// Hash function
     size_t GetHash() const {
-        return TfHash::Combine(_assetPath, _resolvedPath);
+        return TfHash::Combine(_authoredPath, _evaluatedPath, _resolvedPath);
     }
 
     /// \class Hash
@@ -109,17 +164,50 @@ class SdfAssetPath
     /// \name Accessors
     /// @{
 
-    /// Return the asset path.
+    /// Returns the asset path as it was authored in the original layer.  When
+    /// authoring scene description, this value is used for serialization.
+    const std::string &GetAuthoredPath() const & {
+        return _authoredPath;
+    }
+
+    /// Overload for rvalues, move out the asset path.
+    std::string GetAuthoredPath() const && {
+        return std::move(_authoredPath);
+    }
+
+    /// Return the evaluated asset path, if any.  The evaluated path's value
+    /// consists of the authored path with any expression variables
+    /// evaluated.  If the authored path does not contain any expression
+    /// variables, this field will be empty.
+    ///
+    /// Note that SdfAssetPath carries an evaluated path only if its creator
+    /// passed one to the constructor.  SdfAssetPath never performs variable
+    /// expression evaluation itself.
+    const std::string &GetEvaluatedPath() const & {
+        return _evaluatedPath;
+    }
+
+    /// Overload for rvalues, move out the evaluated path.
+    std::string GetEvaluatedPath() const && {
+        return std::move(_evaluatedPath);
+    }
+
+    /// Return the asset path. If the the evaluated path is not empty, it will
+    /// be returned, otherwise the raw, authored path is returned.
+    /// The value this function returns is the exact input that is passed to
+    /// asset resolution.
     const std::string &GetAssetPath() const & {
-        return _assetPath;
+        return _evaluatedPath.empty() ? _authoredPath : _evaluatedPath;
     }
 
     /// Overload for rvalues, move out the asset path.
     std::string GetAssetPath() const && {
-        return std::move(_assetPath);
+        return std::move(
+                _evaluatedPath.empty() ? _authoredPath : _evaluatedPath);
     }
 
-    /// Return the resolved asset path, if any.
+    /// Return the resolved asset path, if any.  This is the resolved value of
+    /// GetAssetPath()
     ///
     /// Note that SdfAssetPath carries a resolved path only if its creator
     /// passed one to the constructor.  SdfAssetPath never performs resolution
@@ -135,13 +223,41 @@ class SdfAssetPath
 
     /// @}
 
+    /// \name Setters
+    /// @{
+
+    /// Sets the authored path.  This value is the path exactly as it is
+    /// authored in the layer.
+    void SetAuthoredPath(const std::string &authoredPath) {
+        _authoredPath = authoredPath;
+    }
+
+    /// Sets the evaluated path.  This value is the result of performing
+    /// variable expression resolution on the authored path.
+    void SetEvaluatedPath(const std::string &evaluatedPath) {
+        _evaluatedPath = evaluatedPath;
+    }
+
+    /// Sets the resolved path.  This value is the result of asset resolution.
+    void SetResolvedPath(const std::string &resolvedPath) {
+        _resolvedPath = resolvedPath;
+    }
+
+    /// @}
+
 private:
     friend inline void swap(SdfAssetPath &lhs, SdfAssetPath &rhs) {
-        lhs._assetPath.swap(rhs._assetPath);
+        lhs._authoredPath.swap(rhs._authoredPath);
+        lhs._evaluatedPath.swap(rhs._evaluatedPath);
         lhs._resolvedPath.swap(rhs._resolvedPath);
     }
 
-    std::string _assetPath;
+    /// Raw path, as authored in the layer.
+    std::string _authoredPath;
+    /// Contains the evaluated authored path, if variable expressions
+    /// were present, otherwise empty.
+    std::string _evaluatedPath;
+    /// Fully evaluated and resolved path
     std::string _resolvedPath;
 };
 

pxr/usd/sdf/fileIO_Common.cpp

@@ -140,7 +140,7 @@ _StringFromValue(const TfToken& s)
 static string
 _StringFromValue(const SdfAssetPath& assetPath)
 {
-    return _StringFromAssetPath(assetPath.GetAssetPath());
+    return _StringFromAssetPath(assetPath.GetAuthoredPath());
 }
 
 static string