v1.0.4

Author: Keith Blackstone

.gitignore

@@ -43,11 +43,16 @@ build-meta
 .vscode/*
 .idea
 
-# Generated
+# Generated documentation
 docs
-Testing
 bin
+
+# Test
+Testing
 test/__pycache__
-test/assets/*/*.usd
-test/assets/*/*/*.usd
 test/output
+test/assets/fbx/*.usd
+test/assets/gltf/*.usd
+test/assets/obj/*/*.usd
+test/assets/ply/*.usd
+test/assets/stl/*.usd

changelog.txt

@@ -1,3 +1,17 @@
+v1.0.4  May 31st, 2024
+gltf:
+    - ability to open gltf file from within usd archive
+    - scaling fix for normal map data and mipmap support for texture nodes
+ply:
+    - clipping and axis adjusting for ply assets
+sbsar:
+    - Add SbsarConfig plugin to allow to control cache size in an APP
+utility:
+    - asset resolver fix for uppercase extensions
+    - trim extensions when parsing for file format
+    - tftoken cleanup
+    - refactor GetConnectedSources into GetValueProducingAttributes
+
 v1.0.3  April 29th, 2024
 fbx:
 	- fix for setting image filename path

fbx/src/fileFormat.cpp

@@ -29,8 +29,8 @@ using namespace adobe::usd;
 PXR_NAMESPACE_OPEN_SCOPE
 
 static std::mutex mutex;
-const TfToken UsdFbxFileFormat::assetsPathToken("fbxAssetsPath");
-const TfToken UsdFbxFileFormat::phongToken("fbxPhong");
+const TfToken UsdFbxFileFormat::assetsPathToken("fbxAssetsPath", TfToken::Immortal);
+const TfToken UsdFbxFileFormat::phongToken("fbxPhong", TfToken::Immortal);
 
 TF_DEFINE_PUBLIC_TOKENS(UsdFbxFileFormatTokens, USDFBX_FILE_FORMAT_TOKENS);
 
@@ -95,6 +95,7 @@ UsdFbxFileFormat::Read(SdfLayer* layer, const std::string& resolvedPath, bool me
     TfStopwatch w;
     w.Start();
     TF_DEBUG_MSG(FILE_FORMAT_FBX, "Read: %s\n", resolvedPath.c_str());
+    std::string fileType = getFileExtension(resolvedPath, DEBUG_TAG);
     SdfAbstractDataRefPtr layerData = InitData(layer->GetFileFormatArguments());
     FbxDataConstPtr data = TfDynamic_cast<const FbxDataConstPtr>(layerData);
     UsdData usd;
@@ -113,7 +114,7 @@ UsdFbxFileFormat::Read(SdfLayer* layer, const std::string& resolvedPath, bool me
           readFbx(fbx, resolvedPath, false), "Error reading FBX from %s\n", resolvedPath.c_str());
         GUARD(importFbx(options, fbx, usd), "Error translating FBX to USD\n");
     }
-    GUARD(writeLayer(layerOptions, usd, layer, layerData, DEBUG_TAG, SdfFileFormat::_SetLayerData),
+    GUARD(writeLayer(layerOptions, usd, layer, layerData, fileType, DEBUG_TAG, SdfFileFormat::_SetLayerData),
           "Error writing to the USD layer\n");
 
     if (options.importImages) {

fbx/src/plugInfo.json.in

@@ -27,7 +27,7 @@
                     },
                     "adobe::usd::FbxResolver" : {
                         "bases": [ "ArPackageResolver" ],
-                        "extensions": [ "fbx" ]
+                        "extensions": [ "fbx", "FBX", "Fbx" ]
                     }
                 }
             },

gltf/src/fileFormat.cpp

@@ -24,13 +24,15 @@ governing permissions and limitations under the License.
 
 // USD
 #include <pxr/base/tf/pathUtils.h>
+#include <pxr/base/tf/stringUtils.h>
+#include <pxr/usd/ar/packageUtils.h>
 #include <pxr/usd/usd/usdaFileFormat.h>
 
 PXR_NAMESPACE_OPEN_SCOPE
 
 using namespace adobe::usd;
 
-const TfToken UsdGltfFileFormat::assetsPathToken("gltfAssetsPath");
+const TfToken UsdGltfFileFormat::assetsPathToken("gltfAssetsPath", TfToken::Immortal);
 
 TF_DEFINE_PUBLIC_TOKENS(UsdGltfFileFormatTokens, USDGLTF_FILE_FORMAT_TOKENS);
 
@@ -89,32 +91,34 @@ UsdGltfFileFormat::CanRead(const std::string& filePath) const
     return true;
 }
 
+/*static*/
 bool
-UsdGltfFileFormat::_ReadFromStream(SdfLayer* layer,
-                                   std::istream& input,
-                                   bool metadataOnly,
-                                   std::string* outErr,
-                                   std::istream& mtlinput) const
+UsdGltfFileFormat::OpenGltfAsset(const std::string& resolvedPath,
+                                 std::shared_ptr<ArAsset>& asset,
+                                 std::string& baseDir,
+                                 bool& isAscii)
 {
-    // // Read Obj data stream.
-    // UsdGltfStream gltfStream;
-    // if (!UsdObjReadDataFromStream(input, mtlinput, &gltfStream, outErr))
-    //     return false;
-
-    // // Translate obj to usd schema.
-    // SdfLayerRefPtr objAsUsd = UsdObjTranslateObjToUsd(gltfStream);
-    // if (!objAsUsd)
-    //     return false;
-
-    // // Move generated content into final layer.
-    // layer->TransferContent(objAsUsd);
+    asset = ArGetResolver().OpenAsset(ArResolvedPath(resolvedPath));
+    if (!asset) {
+        TF_WARN("Couldn't open asset %s", resolvedPath.c_str());
+        return false;
+    }
+
+    // Extract the inner most name of a potentially nest path, e.g. "archive.usdz[myAsset.gltf]"
+    auto [packagePath, packagedPath] = ArSplitPackageRelativePathInner(resolvedPath);
+
+    // If we have a direct path on disk, we set the baseDir to the same folder
+    if (packagedPath.empty()) {
+        baseDir = TfGetPathName(packagePath);
+    }
+
+    const std::string& fileName = packagedPath.empty() ? packagePath : packagedPath;
+    std::string ext = TfStringToLower(TfGetExtension(fileName));
+    isAscii = (ext == "gltf");
+
     return true;
 }
 
-// void function(TfDebug::FILE_FORMAT_GLTF a) {
-//     TF_DEBUG_MSG(a, "Experiment debug cdoe\n");
-// }
-
 bool
 UsdGltfFileFormat::Read(PXR_NS::SdfLayer* layer,
                         const std::string& resolvedPath,
@@ -123,44 +127,99 @@ UsdGltfFileFormat::Read(PXR_NS::SdfLayer* layer,
     TfStopwatch w;
     w.Start();
     TF_DEBUG_MSG(FILE_FORMAT_GLTF, "Read: %s\n", resolvedPath.c_str());
-    SdfAbstractDataRefPtr layerData = InitData(layer->GetFileFormatArguments());
-    GltfDataConstPtr data = TfDynamic_cast<const GltfDataConstPtr>(layerData);
-    UsdData usd;
+
+    std::shared_ptr<ArAsset> asset;
+    std::string baseDir;
+    bool isAscii = false;
+    if (!OpenGltfAsset(resolvedPath, asset, baseDir, isAscii)) {
+        return false;
+    }
+
+    std::shared_ptr<const char> buffer = asset->GetBuffer();
+    size_t bufferSize = asset->GetSize();
+    TF_DEBUG_MSG(FILE_FORMAT_GLTF,
+                 "Type: %s, Base path: '%s', Size: %zu KB\n",
+                 isAscii ? "GLTF" : "GLB",
+                 baseDir.c_str(),
+                 bufferSize >> 10);
+
     tinygltf::Model gltf;
+    GUARD(readGltfFromMemory(gltf, baseDir, isAscii, &*buffer, bufferSize),
+          "Error reading glTF file\n");
+
+    UsdData usd;
     ImportGltfOptions options;
     options.importGeometry = true;
     options.importMaterials = true;
     options.importImages = true;
+    GUARD(importGltf(options, gltf, usd, resolvedPath), "Error translating glTF to USD\n");
+
+    SdfAbstractDataRefPtr layerData = InitData(layer->GetFileFormatArguments());
+    GltfDataConstPtr data = TfDynamic_cast<const GltfDataConstPtr>(layerData);
     WriteLayerOptions layerOptions;
     layerOptions.writeMaterialX = data->writeMaterialX;
     layerOptions.pruneJoints = false;
     layerOptions.assetsPath = data->assetsPath;
-    GUARD(readGltf(gltf, resolvedPath), "Error reading glTF file\n");
-    GUARD(importGltf(options, gltf, usd, resolvedPath), "Error translating glTF to USD\n");
-    GUARD(writeLayer(layerOptions, usd, layer, layerData, DEBUG_TAG, SdfFileFormat::_SetLayerData),
-          "Error writing to the USD layer\n");
+    std::string ext = isAscii ? "GLTF" : "GLB";
+    GUARD(
+      writeLayer(layerOptions, usd, layer, layerData, ext, DEBUG_TAG, SdfFileFormat::_SetLayerData),
+      "Error writing to the USD layer\n");
 
+    // Populate the GLTF resolver with the images we just parsed from the asset, so that we don't
+    // have to open the asset again.
     if (options.importImages) {
         Resolver::populateCache(resolvedPath, std::move(usd.images));
     } else {
         Resolver::clearCache(resolvedPath);
     }
 
     w.Stop();
-    TF_DEBUG_MSG(FILE_FORMAT_GLTF, "Total time: %ld ms\n", static_cast<long int>(w.GetMilliseconds()));
+    TF_DEBUG_MSG(
+      FILE_FORMAT_GLTF, "Total time: %ld ms\n", static_cast<long int>(w.GetMilliseconds()));
+
     return true;
 }
 
 bool
 UsdGltfFileFormat::ReadFromString(SdfLayer* layer, const std::string& str) const
 {
-    std::string error;
-    std::stringstream ss(str);
-    std::stringstream ssmtl("");
-    if (!_ReadFromStream(layer, ss, /*metadataOnly=*/false, &error, ssmtl)) {
-        TF_RUNTIME_ERROR("Failed to read GLTF data from string: %s", error.c_str());
-        return false;
-    }
+    TfStopwatch w;
+    w.Start();
+    TF_DEBUG_MSG(FILE_FORMAT_GLTF, "ReadFromString: %zu KB\n", str.size() >> 10);
+
+    // We don't have a base directory for external references. So only complete GLTF files will work
+    // with this path
+    std::string baseDir;
+    bool isAscii = true;
+
+    tinygltf::Model gltf;
+    GUARD(readGltfFromMemory(gltf, baseDir, isAscii, &str[0], str.size()),
+          "Error reading glTF from string\n");
+
+    UsdData usd;
+    ImportGltfOptions options;
+    options.importGeometry = true;
+    options.importMaterials = true;
+    options.importImages = true;
+    GUARD(importGltf(options, gltf, usd, ""), "Error translating glTF to USD\n");
+
+    SdfAbstractDataRefPtr layerData = InitData(layer->GetFileFormatArguments());
+    GltfDataConstPtr data = TfDynamic_cast<const GltfDataConstPtr>(layerData);
+    WriteLayerOptions layerOptions;
+    layerOptions.writeMaterialX = data->writeMaterialX;
+    layerOptions.pruneJoints = false;
+    layerOptions.assetsPath = data->assetsPath;
+    std::string ext = isAscii ? "GLTF" : "GLB";
+    GUARD(
+      writeLayer(layerOptions, usd, layer, layerData, ext, DEBUG_TAG, SdfFileFormat::_SetLayerData),
+      "Error writing to the USD layer\n");
+
+    // Note, we can't populate the path resolver since we don't have an associated file
+
+    w.Stop();
+    TF_DEBUG_MSG(
+      FILE_FORMAT_GLTF, "Total time: %ld ms\n", static_cast<long int>(w.GetMilliseconds()));
+
     return true;
 }
 

gltf/src/fileFormat.h

@@ -11,22 +11,32 @@ governing permissions and limitations under the License.
 */
 #pragma once
 #include "api.h"
-#include <iosfwd>
+#include <version.h>
+
+#include <sdfUtils.h>
+
 #include <pxr/base/tf/staticTokens.h>
 #include <pxr/pxr.h>
 #include <pxr/usd/pcp/dynamicFileFormatInterface.h>
-#include <sdfUtils.h>
+
+#include <iosfwd>
 #include <string>
-#include <version.h>
 
 PXR_NAMESPACE_OPEN_SCOPE
 
-#define USDGLTF_FILE_FORMAT_TOKENS ((Id, "gltf"))((Version, FILE_FORMATS_VERSION))((Target, "usd"))
+// clang-format off
+#define USDGLTF_FILE_FORMAT_TOKENS \
+    ((Id, "gltf")) \
+    ((Version, FILE_FORMATS_VERSION)) \
+    ((Target, "usd"))
+// clang-format on
 
 TF_DECLARE_PUBLIC_TOKENS(UsdGltfFileFormatTokens, USDGLTF_FILE_FORMAT_TOKENS);
 TF_DECLARE_WEAK_AND_REF_PTRS(GltfData);
 TF_DECLARE_WEAK_AND_REF_PTRS(UsdGltfFileFormat);
 
+class ArAsset;
+
 /// \ingroup usdgltf
 /// \brief SdfData specialization for working with glTF files.
 class GltfData : public FileFormatDataBase
@@ -45,6 +55,13 @@ class USDGLTF_API UsdGltfFileFormat
   public:
     friend class GltfData;
 
+    // If successful, returns true and fills in the assetPtr, baseDir and the isAscii flag
+    // baseDir can be used to resolve external assets
+    static bool OpenGltfAsset(const std::string& resolvedPath,
+                              std::shared_ptr<ArAsset>& assetPtr,
+                              std::string& baseDir,
+                              bool& isAscii);
+
     virtual SdfAbstractDataRefPtr InitData(const FileFormatArguments& args) const override;
 
     virtual void ComposeFieldsForFileFormatArguments(const std::string& assetPath,
@@ -61,8 +78,8 @@ class USDGLTF_API UsdGltfFileFormat
     virtual bool CanRead(const std::string& file) const override;
 
     virtual bool Read(SdfLayer* layer,
-                      const std::string& resolved_path,
-                      bool metadata_only) const override;
+                      const std::string& resolvedPath,
+                      bool metadataOnly) const override;
 
     virtual bool ReadFromString(SdfLayer* layer, const std::string& str) const override;
 
@@ -88,13 +105,6 @@ class USDGLTF_API UsdGltfFileFormat
     virtual ~UsdGltfFileFormat();
 
     UsdGltfFileFormat();
-
-  private:
-    bool _ReadFromStream(SdfLayer* layer,
-                         std::istream& input,
-                         bool metadataOnly,
-                         std::string* outErr,
-                         std::istream& mtlinput) const;
 };
 
 PXR_NAMESPACE_CLOSE_SCOPE