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(); }
void UsdImagingGprimAdapter::_DiscoverPrimvarsDeprecated(UsdGeomGprim const& gprim, SdfPath const& cachePath, UsdPrim const& shaderPrim, UsdTimeCode time, UsdImagingValueCache* valueCache) { UsdImagingValueCache::PrimvarInfo primvar; std::vector<UsdProperty> const& props = shaderPrim.GetProperties(); TF_FOR_ALL(propIt, props) { UsdAttribute attr = propIt->As<UsdAttribute>(); if (not attr) { continue; } if (attr.GetPath().IsNamespacedPropertyPath()) { continue; } // Ok this is a parameter, check source input. if (UsdAttribute texAttr = shaderPrim.GetAttribute( TfToken(attr.GetPath().GetName() + ":texture"))) { TfToken t; SdfAssetPath ap; VtValue v; UsdGeomPrimvar primvarAttr; texAttr.Get(&ap, UsdTimeCode::Default()); bool isPtex = GlfPtexTexture::IsPtexTexture(TfToken(ap.GetAssetPath())); if (isPtex) { t = UsdImagingTokens->ptexFaceIndex; // Allow the client to override this name texAttr.GetMetadata(UsdImagingTokens->faceIndexPrimvar, &t); primvarAttr = gprim.GetPrimvar(t); if (primvarAttr) { if (primvarAttr.ComputeFlattened(&v, time)) { primvar.name = t; primvar.interpolation = primvarAttr.GetInterpolation(); valueCache->GetPrimvar(cachePath, t) = v; _MergePrimvar(primvar, &valueCache->GetPrimvars(cachePath)); } } t = UsdImagingTokens->ptexFaceOffset; // Allow the client to override this name texAttr.GetMetadata(UsdImagingTokens->faceOffsetPrimvar, &t); primvarAttr = gprim.GetPrimvar(t); if (primvarAttr) { primvar.name = t; primvar.interpolation = primvarAttr.GetInterpolation(); if (primvarAttr.ComputeFlattened(&v, time)) { valueCache->GetPrimvar(cachePath, t) = v; _MergePrimvar(primvar, &valueCache->GetPrimvars(cachePath)); } } } else { texAttr.GetMetadata(UsdImagingTokens->uvPrimvar, &t); primvarAttr = gprim.GetPrimvar(t); if (TF_VERIFY(primvarAttr, "%s\n", t.GetText())) { if (TF_VERIFY(primvarAttr.ComputeFlattened(&v, time))) { primvar.name = t; // does not include primvars: primvar.interpolation = primvarAttr.GetInterpolation(); // Convert double to float, we don't need double precision. if (v.IsHolding<VtVec2dArray>()) { v = VtValue::Cast<VtVec2fArray>(v); } valueCache->GetPrimvar(cachePath, t) = v; _MergePrimvar(primvar, &valueCache->GetPrimvars(cachePath)); } } } } else if (UsdAttribute pvAttr = shaderPrim.GetAttribute( TfToken(attr.GetPath().GetName() + ":primvar"))) { TfToken t; VtValue v; UsdGeomPrimvar primvarAttr; if (TF_VERIFY(pvAttr.Get(&t, UsdTimeCode::Default()))) { primvarAttr = gprim.GetPrimvar(t); if (TF_VERIFY(primvarAttr.ComputeFlattened(&v, time))) { primvar.name = t; // does not include primvars: primvar.interpolation = primvarAttr.GetInterpolation(); valueCache->GetPrimvar(cachePath, t) = v; _MergePrimvar(primvar, &valueCache->GetPrimvars(cachePath)); } } } }
static string _StringFromValue(const SdfAssetPath& assetPath) { return _StringFromAssetPath(assetPath.GetAssetPath()); }
static bool _Nonzero(SdfAssetPath const &self) { return !self.GetAssetPath().empty(); }
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); }