void UsdGeomPrimvar::BlockIndices() 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; } _GetIndicesAttr(/*create*/ true).Block(); }
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); }
/* static */ UsdGeomXformOp::Precision UsdGeomXformOp::GetPrecisionFromValueTypeName(const SdfValueTypeName &typeName) { if (typeName == SdfValueTypeNames->Matrix4d) return PrecisionDouble; else if (typeName == SdfValueTypeNames->Double3) return PrecisionDouble; else if (typeName == SdfValueTypeNames->Float3) return PrecisionFloat; else if (typeName == SdfValueTypeNames->Half3) return PrecisionHalf; else if (typeName == SdfValueTypeNames->Double) return PrecisionDouble; else if (typeName == SdfValueTypeNames->Float) return PrecisionFloat; else if (typeName == SdfValueTypeNames->Half) return PrecisionHalf; else if (typeName == SdfValueTypeNames->Quatd) return PrecisionDouble; else if (typeName == SdfValueTypeNames->Quatf) return PrecisionFloat; else if (typeName == SdfValueTypeNames->Quath) return PrecisionHalf; TF_CODING_ERROR("Invalid typeName '%s' specified.", typeName.GetAsToken().GetText()); // Return default precision, which is double. return PrecisionDouble; }
SdfAttributeSpecHandle SdfAttributeSpec::_New( const SdfSpecHandle &owner, const SdfPath& attrPath, const SdfValueTypeName& typeName, SdfVariability variability, bool custom) { if (not owner) { TF_CODING_ERROR("NULL owner"); return TfNullPtr; } if (not typeName) { TF_CODING_ERROR("Cannot create attribute spec <%s> with invalid type", attrPath.GetText()); return TfNullPtr; } SdfChangeBlock block; // AttributeSpecs are considered initially to have only required fields // only if they are not custom. bool hasOnlyRequiredFields = (not custom); if (not Sdf_ChildrenUtils<Sdf_AttributeChildPolicy>::CreateSpec( owner->GetLayer(), attrPath, SdfSpecTypeAttribute, hasOnlyRequiredFields)) { return TfNullPtr; } SdfAttributeSpecHandle spec = owner->GetLayer()->GetAttributeAtPath(attrPath); // Avoid expensive dormancy checks in the case of binary-backed data. SdfAttributeSpec *specPtr = get_pointer(spec); if (TF_VERIFY(specPtr)) { specPtr->SetField(SdfFieldKeys->Custom, custom); specPtr->SetField(SdfFieldKeys->TypeName, typeName.GetAsToken()); specPtr->SetField(SdfFieldKeys->Variability, variability); } return spec; }
void add(const SdfValueTypeName& scalar, const char* alias = NULL) { static const bool isShaped = true; const SdfValueTypeName array = scalar.GetArrayType(); const std::string scalarName = alias ? std::string(alias) : scalar.GetAsToken().GetString(); const std::string arrayName = alias ? std::string(alias) + "[]" : array.GetAsToken().GetString(); _ValueFactoryMap &f = *_factories; f[scalarName] = ValueFactory(scalarName, scalar.GetDimensions(), !isShaped, boost::bind(MakeScalarValueTemplate<CppType>, _1, _2, _3, _4)); f[arrayName] = ValueFactory(arrayName, array.GetDimensions(), isShaped, boost::bind(MakeShapedValueTemplate<CppType>, _1, _2, _3, _4)); }
SdfAttributeSpecHandle SdfAttributeSpec::_New( const SdfRelationshipSpecHandle& owner, const SdfPath& path, const std::string& name, const SdfValueTypeName& typeName, SdfVariability variability, bool custom) { if (not owner) { TF_CODING_ERROR("NULL owner"); return TfNullPtr; } if (not typeName) { TF_CODING_ERROR("Cannot create attribute spec <%s> with invalid type", owner->GetPath().AppendTarget(path). AppendProperty(TfToken(name)).GetText()); return TfNullPtr; } SdfChangeBlock block; // Determine the path of the relationship target SdfPath absPath = path.MakeAbsolutePath(owner->GetPath().GetPrimPath()); SdfPath targetPath = owner->GetPath().AppendTarget(absPath); // Check to make sure that the name is valid if (not Sdf_ChildrenUtils<Sdf_AttributeChildPolicy>::IsValidName(name)) { TF_CODING_ERROR( "Cannot create attribute on %s with invalid name: %s", targetPath.GetText(), name.c_str()); return TfNullPtr; } // Create the relationship target if it doesn't already exist. Note // that this does not automatically get added to the relationship's // target path list. SdfSpecHandle targetSpec = owner->_FindOrCreateTargetSpec(path); // AttributeSpecs are considered initially to have only required fields // only if they are not custom. bool hasOnlyRequiredFields = (not custom); // Create the relational attribute spec SdfPath attrPath = targetPath.AppendRelationalAttribute(TfToken(name)); if (not Sdf_ChildrenUtils<Sdf_AttributeChildPolicy>::CreateSpec( owner->GetLayer(), attrPath, SdfSpecTypeAttribute, hasOnlyRequiredFields)) { return TfNullPtr; } SdfAttributeSpecHandle spec = owner->GetLayer()->GetAttributeAtPath(attrPath); // Avoid expensive dormancy checks in the case of binary-backed data. SdfAttributeSpec *specPtr = get_pointer(spec); if (TF_VERIFY(specPtr)) { specPtr->SetField(SdfFieldKeys->Custom, custom); specPtr->SetField(SdfFieldKeys->TypeName, typeName.GetAsToken()); specPtr->SetField(SdfFieldKeys->Variability, variability); } return spec; }