static size_t _Hash(SdfAssetPath const &self) { size_t hash = 0; boost::hash_combine(hash, self.GetAssetPath()); boost::hash_combine(hash, self.GetResolvedPath()); return hash; }
PXR_NAMESPACE_OPEN_SCOPE static std::string _Repr(SdfAssetPath const &self) { std::ostringstream repr; repr << TF_PY_REPR_PREFIX << "AssetPath(" << TfPyRepr(self.GetAssetPath()); const std::string & resolvedPath = self.GetResolvedPath(); if (!resolvedPath.empty()) { repr << ", " << TfPyRepr(resolvedPath); } repr << ")"; return repr.str(); }
HdTextureResourceSharedPtr UsdImagingGL_GetTextureResource(UsdPrim const& usdPrim, SdfPath const& usdPath, UsdTimeCode time) { if (!TF_VERIFY(usdPrim)) return HdTextureResourceSharedPtr(); if (!TF_VERIFY(usdPath != SdfPath())) return HdTextureResourceSharedPtr(); UsdAttribute attr = _GetTextureResourceAttr(usdPrim, usdPath); SdfAssetPath asset; if (!TF_VERIFY(attr) || !TF_VERIFY(attr.Get(&asset, time))) { return HdTextureResourceSharedPtr(); } HdTextureType textureType = HdTextureType::Uv; TfToken filePath = TfToken(asset.GetResolvedPath()); // If the path can't be resolved, it's either an UDIM texture // or the texture doesn't exists and we can to exit early. if (filePath.IsEmpty()) { filePath = TfToken(asset.GetAssetPath()); if (GlfIsSupportedUdimTexture(filePath)) { textureType = HdTextureType::Udim; } else { TF_DEBUG(USDIMAGING_TEXTURES).Msg( "File does not exist, returning nullptr"); TF_WARN("Unable to find Texture '%s' with path '%s'.", filePath.GetText(), usdPath.GetText()); return {}; } } else { if (GlfIsSupportedPtexTexture(filePath)) { textureType = HdTextureType::Ptex; } } GlfImage::ImageOriginLocation origin = UsdImagingGL_ComputeTextureOrigin(usdPrim); HdWrap wrapS = _GetWrapS(usdPrim, textureType); HdWrap wrapT = _GetWrapT(usdPrim, textureType); HdMinFilter minFilter = _GetMinFilter(usdPrim); HdMagFilter magFilter = _GetMagFilter(usdPrim); float memoryLimit = _GetMemoryLimit(usdPrim); TF_DEBUG(USDIMAGING_TEXTURES).Msg( "Loading texture: id(%s), type(%s)\n", usdPath.GetText(), textureType == HdTextureType::Uv ? "Uv" : textureType == HdTextureType::Ptex ? "Ptex" : "Udim"); HdTextureResourceSharedPtr texResource; TfStopwatch timer; timer.Start(); // Udim's can't be loaded through like other textures, because // we can't select the right factory based on the file type. // We also need to pass the layer context to the factory, // so each file gets resolved properly. GlfTextureHandleRefPtr texture; if (textureType == HdTextureType::Udim) { UdimTextureFactory factory(_FindLayerHandle(attr, time)); texture = GlfTextureRegistry::GetInstance().GetTextureHandle( filePath, origin, &factory); } else { texture = GlfTextureRegistry::GetInstance().GetTextureHandle( filePath, origin); } texResource = HdTextureResourceSharedPtr( new HdStSimpleTextureResource(texture, textureType, wrapS, wrapT, minFilter, magFilter, memoryLimit)); timer.Stop(); TF_DEBUG(USDIMAGING_TEXTURES).Msg(" Load time: %.3f s\n", timer.GetSeconds()); return texResource; }
HdTextureResource::ID UsdImagingGL_GetTextureResourceID(UsdPrim const& usdPrim, SdfPath const& usdPath, UsdTimeCode time, size_t salt) { if (!TF_VERIFY(usdPrim)) { return HdTextureResource::ID(-1); } if (!TF_VERIFY(usdPath != SdfPath())) { return HdTextureResource::ID(-1); } // If the texture name attribute doesn't exist, it might be badly specified // in scene data. UsdAttribute attr = _GetTextureResourceAttr(usdPrim, usdPath); SdfAssetPath asset; if (!attr || !attr.Get(&asset, time)) { TF_WARN("Unable to find texture attribute <%s> in scene data", usdPath.GetText()); return HdTextureResource::ID(-1); } HdTextureType textureType = HdTextureType::Uv; TfToken filePath = TfToken(asset.GetResolvedPath()); if (!filePath.IsEmpty()) { // If the resolved path contains a correct path, then we are // dealing with a ptex or uv textures. if (GlfIsSupportedPtexTexture(filePath)) { textureType = HdTextureType::Ptex; } else { textureType = HdTextureType::Uv; } } else { // If the path couldn't be resolved, then it might be a Udim as they // contain special characters in the path to identify them <Udim>. // Another option is that the path is just wrong and it can not be // resolved. filePath = TfToken(asset.GetAssetPath()); if (GlfIsSupportedUdimTexture(filePath)) { const GlfContextCaps& caps = GlfContextCaps::GetInstance(); if (!UsdImaging_UdimTilesExist(filePath, caps.maxArrayTextureLayers, _FindLayerHandle(attr, time))) { TF_WARN("Unable to find Texture '%s' with path '%s'. Fallback " "textures are not supported for udim", filePath.GetText(), usdPath.GetText()); return HdTextureResource::ID(-1); } if (!caps.arrayTexturesEnabled) { TF_WARN("OpenGL context does not support array textures, " "skipping UDIM Texture %s with path %s.", filePath.GetText(), usdPath.GetText()); return HdTextureResource::ID(-1); } textureType = HdTextureType::Udim; } else if (GlfIsSupportedPtexTexture(filePath)) { TF_WARN("Unable to find Texture '%s' with path '%s'. Fallback " "textures are not supported for ptex", filePath.GetText(), usdPath.GetText()); return HdTextureResource::ID(-1); } else { TF_WARN("Unable to find Texture '%s' with path '%s'. A black " "texture will be substituted in its place.", filePath.GetText(), usdPath.GetText()); return HdTextureResource::ID(-1); } } GlfImage::ImageOriginLocation origin = UsdImagingGL_ComputeTextureOrigin(usdPrim); // Hash on the texture filename. size_t hash = asset.GetHash(); // Hash in wrapping and filtering metadata. HdWrap wrapS = _GetWrapS(usdPrim, textureType); HdWrap wrapT = _GetWrapT(usdPrim, textureType); HdMinFilter minFilter = _GetMinFilter(usdPrim); HdMagFilter magFilter = _GetMagFilter(usdPrim); float memoryLimit = _GetMemoryLimit(usdPrim); boost::hash_combine(hash, origin); boost::hash_combine(hash, wrapS); boost::hash_combine(hash, wrapT); boost::hash_combine(hash, minFilter); boost::hash_combine(hash, magFilter); boost::hash_combine(hash, memoryLimit); // Salt the result to prevent collisions in non-shared imaging. // Note that the salt is ignored for fallback texture hashes above. boost::hash_combine(hash, salt); return HdTextureResource::ID(hash); }