bool
UsdRelationship::SetTargets(const SdfPathVector& targets) const
{
SdfPathVector mappedPaths;
mappedPaths.reserve(targets.size());
BOOST_FOREACH(const SdfPath &target, targets) {
std::string errMsg;
mappedPaths.push_back(_GetTargetForAuthoring(target, &errMsg));
if (mappedPaths.back().IsEmpty()) {
TF_CODING_ERROR("Cannot set target <%s> on relationship <%s>: %s",
target.GetText(), GetPath().GetText(),
errMsg.c_str());
return false;
}
}
GfRange2d
GfRange2d::GetQuadrant(size_t i) const
{
if (i > 3) {
TF_CODING_ERROR("Invalid quadrant %zu > 3.", i);
return GfRange2d();
}
GfVec2d a = GetCorner(i);
GfVec2d b = .5 * (_min + _max);
return GfRange2d(
GfVec2d(GfMin(a[0], b[0]), GfMin(a[1], b[1])),
GfVec2d(GfMax(a[0], b[0]), GfMax(a[1], b[1])));
}
bool
UsdGeomPrimvar::SetIndices(const VtIntArray &indices,
UsdTimeCode time) const
{
// Check if the typeName is array valued here and issue a warning
// if it's not.
SdfValueTypeName typeName = GetTypeName();
if (!typeName.IsArray()) {
TF_CODING_ERROR("Setting indices on non-array valued primvar of type "
"'%s'.", typeName.GetAsToken().GetText());
return false;
}
return _GetIndicesAttr(/*create*/ true).Set(indices, time);
}
GlfTextureHandleRefPtr
GlfTextureRegistry::_CreateTexture(const TfToken &texture,
GlfImage::ImageOriginLocation originLocation)
{
GlfTextureRefPtr result;
if (GlfTextureFactoryBase* factory = _GetTextureFactory(texture)) {
result = factory->New(texture, originLocation);
if (!result) {
TF_CODING_ERROR("[PluginLoad] Cannot construct texture for "
"type '%s'\n",
TfStringGetSuffix(texture).c_str());
}
}
return result ? GlfTextureHandle::New(result) : TfNullPtr;
}
PrimType *
Hd_PrimTypeIndex<PrimType>::GetFallbackPrim(const TfToken &typeId) const
{
HD_TRACE_FUNCTION();
typename _TypeIndex::const_iterator typeIt = _index.find(typeId);
if (typeIt ==_index.end()) {
TF_CODING_ERROR("Unsupported prim type: %s", typeId.GetText());
return nullptr;
}
const _PrimTypeEntry &typeEntry = _entries[typeIt->second];
return typeEntry.fallbackPrim;
}
GfRange3d
GfRange3d::GetOctant(size_t i) const
{
if (i > 7) {
TF_CODING_ERROR("Invalid octant %zu > 7.", i);
return GfRange3d();
}
GfVec3d a = GetCorner(i);
GfVec3d b = .5 * (_min + _max);
return GfRange3d(
GfVec3d(GfMin(a[0], b[0]), GfMin(a[1], b[1]), GfMin(a[2], b[2])),
GfVec3d(GfMax(a[0], b[0]), GfMax(a[1], b[1]), GfMax(a[2], b[2])));
}
bool
UsdGeomCurves::SetWidthsInterpolation(TfToken const &interpolation)
{
if (UsdGeomPrimvar::IsValidInterpolation(interpolation)) {
return GetWidthsAttr().SetMetadata(UsdGeomTokens->interpolation,
interpolation);
}
TF_CODING_ERROR("Attempt to set invalid interpolation "
"\"%s\" for widths attr on prim %s",
interpolation.GetText(),
GetPrim().GetPath().GetString().c_str());
return false;
}
GLenum
HdConversions::GetMinFilter(HdMinFilter filter)
{
switch (filter) {
case HdMinFilterNearest : return GL_NEAREST;
case HdMinFilterLinear : return GL_LINEAR;
case HdMinFilterNearestMipmapNearest : return GL_NEAREST_MIPMAP_NEAREST;
case HdMinFilterLinearMipmapNearest : return GL_LINEAR_MIPMAP_NEAREST;
case HdMinFilterNearestMipmapLinear : return GL_NEAREST_MIPMAP_LINEAR;
case HdMinFilterLinearMipmapLinear : return GL_LINEAR_MIPMAP_LINEAR;
}
TF_CODING_ERROR("Unexpected HdMinFilter type %d", filter);
return GL_NEAREST_MIPMAP_LINEAR;
}
void
UsdMayaAdaptor::SchemaAdaptor::RemoveAttribute(
const TfToken& attrName, MDGModifier& modifier)
{
if (!*this) {
TF_CODING_ERROR("Schema adaptor is not valid");
return;
}
SdfAttributeSpecHandle attrDef = _schemaDef->GetAttributes()[attrName];
if (!attrDef) {
TF_CODING_ERROR("Attribute '%s' doesn't exist on schema '%s'",
attrName.GetText(), _schemaDef->GetName().c_str());
return;
}
std::string mayaAttrName = _GetMayaAttrNameOrAlias(attrDef);
MFnDependencyNode node(_handle.object());
if (node.hasAttribute(mayaAttrName.c_str())) {
MObject attr = node.attribute(mayaAttrName.c_str());
modifier.removeAttribute(_handle.object(), attr);
modifier.doIt();
}
}
std::vector<UsdGeomPrimvar>
UsdGeomPrimvarsAPI::GetPrimvarsWithAuthoredValues() const
{
const UsdPrim &prim = GetPrim();
if (!prim){
TF_CODING_ERROR("Called GetPrimvarsWithAuthoredValues on invalid prim: %s",
UsdDescribe(prim).c_str());
return std::vector<UsdGeomPrimvar>();
}
return _MakePrimvars(prim.GetAuthoredPropertiesInNamespace(
UsdGeomPrimvar::_GetNamespacePrefix()),
[](UsdGeomPrimvar const &pv) {
return pv.HasAuthoredValue();
});
}
bool
UsdMayaAdaptor::GetMetadata(const TfToken& key, VtValue* value) const
{
if (!*this) {
return false;
}
if (!SdfSchema::GetInstance().IsRegistered(key)) {
TF_CODING_ERROR("Metadata key '%s' is not registered", key.GetText());
return false;
}
MFnDependencyNode node(_handle.object());
return _GetMetadataUnchecked(node, key, value);
}
bool
Hd_SmoothNormalsComputation::Resolve()
{
// dependency check first
if (_adjacencyBuilder) {
if (not _adjacencyBuilder->IsResolved()) return false;
}
if (_points) {
if (not _points->IsResolved()) return false;
}
if (not _TryLock()) return false;
HD_TRACE_FUNCTION();
HD_MALLOC_TAG_FUNCTION();
if (not TF_VERIFY(_adjacency)) return true;
int numPoints = _points->GetNumElements();
HdBufferSourceSharedPtr normals;
switch (_points->GetGLElementDataType()) {
case GL_FLOAT_VEC3:
normals = HdBufferSourceSharedPtr(
new HdVtBufferSource(
_dstName, VtValue(
_adjacency->ComputeSmoothNormals(
numPoints,
static_cast<const GfVec3f*>(_points->GetData())))));
break;
case GL_DOUBLE_VEC3:
normals = HdBufferSourceSharedPtr(
new HdVtBufferSource(
_dstName, VtValue(
_adjacency->ComputeSmoothNormals(
numPoints,
static_cast<const GfVec3d*>(_points->GetData())))));
break;
default:
TF_CODING_ERROR("Unsupported points type for computing smooth normals");
break;
}
_SetResult(normals);
// call base class to mark as resolved.
_SetResolved();
return true;
}
bool
UsdSkelSkeletonQuery::ComputeSkinningTransforms(VtMatrix4dArray* xforms,
UsdTimeCode time) const
{
TRACE_FUNCTION();
if(!xforms) {
TF_CODING_ERROR("'xforms' pointer is null.");
return false;
}
if(TF_VERIFY(IsValid(), "invalid skeleton query.")) {
return _ComputeSkinningTransforms(xforms, time);
}
return false;
}
GlfTextureHandleRefPtr
GlfTextureRegistry::_CreateTexture(const TfToken &texture,
GlfImage::ImageOriginLocation originLocation,
const GlfTextureFactoryBase *textureFactory)
{
GlfTextureRefPtr result;
if (textureFactory != nullptr) {
result = textureFactory->New(texture, originLocation);
if (!result) {
TF_CODING_ERROR("Supplied Texture factory cannot construct texture "
"for token '%s'\n",
texture.GetText());
}
}
return result ? GlfTextureHandle::New(result) : TfNullPtr;
}
void
UsdMayaAdaptor::ClearMetadata(const TfToken& key, MDGModifier& modifier)
{
if (!*this) {
TF_CODING_ERROR("Adaptor is not valid");
return;
}
MFnDependencyNode node(_handle.object());
std::string mayaAttrName = _GetMayaAttrNameForMetadataKey(key);
if (node.hasAttribute(mayaAttrName.c_str())) {
MObject attr = node.attribute(mayaAttrName.c_str());
modifier.removeAttribute(_handle.object(), attr);
modifier.doIt();
}
}
GlfTextureHandleRefPtr
GlfTextureRegistry::_CreateTexture(const TfTokenVector &textures,
const size_t numTextures)
{
GlfTextureRefPtr result;
TfToken filename = textures.empty() ? TfToken() : textures.front();
if (GlfTextureFactoryBase* factory = _GetTextureFactory(filename)) {
result = factory->New(textures);
if (!result) {
TF_CODING_ERROR("[PluginLoad] Cannot construct texture for "
"type '%s'\n",
TfStringGetSuffix(filename).c_str());
}
}
return result ? GlfTextureHandle::New(result) : TfNullPtr;
}
double
JsValue::GetReal() const
{
if (_holder->type == IntType) {
return IsUInt64() ?
static_cast<double>(GetUInt64()) :
static_cast<double>(GetInt64());
}
std::string whyNot;
if (not _CheckType(_holder->type, RealType, &whyNot)) {
TF_CODING_ERROR(whyNot);
return 0;
}
return boost::get<double>(_holder->value);
}
HdRprim *
HdStreamRenderDelegate::CreateRprim(TfToken const& typeId,
SdfPath const& rprimId,
SdfPath const& instancerId)
{
if (typeId == HdPrimTypeTokens->mesh) {
return new HdStMesh(rprimId, instancerId);
} else if (typeId == HdPrimTypeTokens->basisCurves) {
return new HdStBasisCurves(rprimId, instancerId);
} else if (typeId == HdPrimTypeTokens->points) {
return new HdStPoints(rprimId, instancerId);
} else {
TF_CODING_ERROR("Unknown Rprim Type %s", typeId.GetText());
}
return nullptr;
}
void
HdRenderIndex::InsertRprim(TfToken const& typeId,
HdSceneDelegate* sceneDelegate,
SdfPath const& rprimId,
SdfPath const& instancerId /*= SdfPath()*/)
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
if (ARCH_UNLIKELY(TfMapLookupPtr(_rprimMap, rprimId))) {
return;
}
SdfPath const &sceneDelegateId = sceneDelegate->GetDelegateID();
if (!rprimId.HasPrefix(sceneDelegateId)) {
TF_CODING_ERROR("Scene Delegate Id (%s) must prefix prim Id (%s)",
sceneDelegateId.GetText(), rprimId.GetText());
return;
}
HdRprim *rprim = _renderDelegate->CreateRprim(typeId,
rprimId,
instancerId);
if (rprim == nullptr) {
return;
}
_rprimIds.Insert(rprimId);
_tracker.RprimInserted(rprimId, rprim->GetInitialDirtyBitsMask());
_AllocatePrimId(rprim);
_RprimInfo info = {
sceneDelegate,
rprim
};
_rprimMap[rprimId] = std::move(info);
SdfPath instanceId = rprim->GetInstancerId();
if (!instanceId.IsEmpty()) {
_tracker.InstancerRPrimInserted(instanceId, rprimId);
}
}
HdSprim *
HdStreamRenderDelegate::CreateFallbackSprim(TfToken const& typeId)
{
if (typeId == HdPrimTypeTokens->camera) {
return new HdxCamera(SdfPath::EmptyPath());
} else if (typeId == HdPrimTypeTokens->light) {
return new HdxLight(SdfPath::EmptyPath());
} else if (typeId == HdPrimTypeTokens->drawTarget) {
return new HdxDrawTarget(SdfPath::EmptyPath());
} else if (typeId == HdPrimTypeTokens->shader) {
return _CreateFallbackShaderPrim();
} else {
TF_CODING_ERROR("Unknown Sprim Type %s", typeId.GetText());
}
return nullptr;
}
SdfAttributeSpecHandle
SdfAttributeSpec::New(
const SdfRelationshipSpecHandle& owner,
const SdfPath& targetPath,
const std::string& name,
const SdfValueTypeName& typeName,
SdfVariability variability,
bool custom)
{
TRACE_FUNCTION();
if (not owner) {
TF_CODING_ERROR("NULL owner relationship");
return TfNullPtr;
}
return _New(owner, targetPath, name, typeName, variability, custom);
}
bool
UsdSkel_CacheImpl::ReadScope::Populate(const UsdSkelRoot& root)
{
TRACE_FUNCTION();
TF_DEBUG(USDSKEL_CACHE).Msg("[UsdSkelCache]: Populate map from <%s>\n",
root.GetPrim().GetPath().GetText());
if(!root) {
TF_CODING_ERROR("'root' is invalid.");
return false;
}
_RecursivePopulate(root.GetPrim(), SkinningQueryKey(),
UsdSkelAnimQuery(), /*depth*/ 1);
return true;
}
/* static */
void
UsdMayaAdaptor::RegisterTypedSchemaConversion(
const std::string& nodeTypeName,
const TfType& usdType)
{
const auto iterAndInserted = _schemaLookup.insert(
std::make_pair(nodeTypeName, usdType));
if (iterAndInserted.second) {
UsdMaya_RegistryHelper::AddUnloader([nodeTypeName]() {
_schemaLookup.erase(nodeTypeName);
});
}
else {
TF_CODING_ERROR("Typed schema conversion already registered for Maya "
"type %s", nodeTypeName.c_str());
}
}
SdfValueTypeName
SdfPropertySpec::GetTypeName() const
{
// See comment in GetValueType().
switch (GetSpecType()) {
case SdfSpecTypeAttribute:
return GetSchema().FindOrCreateType(_GetAttributeValueTypeName());
case SdfSpecTypeRelationship:
return SdfValueTypeName();
default:
TF_CODING_ERROR("Unrecognized subclass of SdfPropertySpec on <%s>",
GetPath().GetText());
return SdfValueTypeName();
}
}
bool
UsdPrim::_IsA(const TfType& schemaType) const
{
// Check Schema TfType
if (schemaType.IsUnknown()) {
TF_CODING_ERROR("Unknown schema type (%s) is invalid for IsA query",
schemaType.GetTypeName().c_str());
return false;
}
// Get Prim TfType
const std::string &typeName = GetTypeName().GetString();
return !typeName.empty() &&
PlugRegistry::FindDerivedTypeByName<UsdSchemaBase>(typeName).
IsA(schemaType);
}
JsValue
JsParseStream(
std::istream& istr,
JsParseError* error)
{
if (!istr) {
TF_CODING_ERROR("Stream error");
return JsValue();
}
// Parse streams by reading into a string first. This makes it easier to
// yield good error messages that include line and column numbers, rather
// than the character offset that rapidjson currently provides.
return JsParseString(std::string(
(std::istreambuf_iterator<char>(istr)),
std::istreambuf_iterator<char>()),
error);
}
HdSprim *
HdStreamRenderDelegate::CreateSprim(TfToken const& typeId,
SdfPath const& sprimId)
{
if (typeId == HdPrimTypeTokens->camera) {
return new HdxCamera(sprimId);
} else if (typeId == HdPrimTypeTokens->light) {
return new HdxLight(sprimId);
} else if (typeId == HdPrimTypeTokens->drawTarget) {
return new HdxDrawTarget(sprimId);
} else if (typeId == HdPrimTypeTokens->shader) {
return new HdStShader(sprimId);
} else {
TF_CODING_ERROR("Unknown Sprim Type %s", typeId.GetText());
}
return nullptr;
}
void
HdConversions::GetGlFormat(HdFormat inFormat, GLenum *outFormat, GLenum *outType, GLenum *outInternalFormat)
{
if ((inFormat < 0) || (inFormat >= HdFormatCount))
{
TF_CODING_ERROR("Unexpected HdFormat %d", inFormat);
*outFormat = GL_RGBA;
*outType = GL_BYTE;
*outInternalFormat = GL_RGBA8;
return;
}
const _FormatDesc &desc = FORMAT_DESC[inFormat];
*outFormat = desc.format;
*outType = desc.type;
*outInternalFormat = desc.internalFormat;
}
PXR_NAMESPACE_OPEN_SCOPE
// ---------------------------------------------------------------------------
// Delegate implementation.
/* virtual */
VtValue
HdStreamTaskController::_Delegate::Get(SdfPath const& id, TfToken const& key)
{
_ValueCache *vcache = TfMapLookupPtr(_valueCacheMap, id);
VtValue ret;
if (vcache && TfMapLookup(*vcache, key, &ret)) {
return ret;
}
TF_CODING_ERROR("%s:%s doesn't exist in the value cache\n",
id.GetText(), key.GetText());
return VtValue();
}
bool
UsdSkelSkeletonQuery::ComputeJointLocalTransforms(VtMatrix4dArray* xforms,
UsdTimeCode time,
bool atRest) const
{
TRACE_FUNCTION();
if(!xforms) {
TF_CODING_ERROR("'xforms' pointer is null.");
return false;
}
if(TF_VERIFY(IsValid(), "invalid skeleton query.")) {
atRest = atRest || !_HasMappableAnim();
return _ComputeJointLocalTransforms(xforms, time, atRest);
}
return false;
}
