/// <summary>
/// Loads the variant sets and selection state from USD into the UsdVariantSet behaviour.
/// </summary>
public void LoadFromUsd(pxr.UsdPrim prim)
{
var variantSets = prim.GetVariantSets();
var setNames = variantSets.GetNames();
m_variantSetNames = setNames.ToArray();
m_selected = m_variantSetNames.Select(setName => variantSets.GetVariantSelection(setName)).ToArray();
m_variants = m_variantSetNames.SelectMany(setName => variantSets.GetVariantSet(setName).GetVariantNames()).ToArray();
m_variantCounts = m_variantSetNames.Select(setName => variantSets.GetVariantSet(setName).GetVariantNames().Count).ToArray();
m_primPath = prim.GetPath();
}
/// <summary>
/// Exports a single GameObject to USD, does not export components.
/// </summary>
static void ObjectToUsd(GameObject gameObj, pxr.UsdPrim prim, Scene scene)
{
var obj = new SerializedObject(gameObj);
var sb = new System.Text.StringBuilder();
var path = prim.GetPath().ToString();
sb.AppendLine("Visited: " + path);
prim.SetCustomDataByKey(new pxr.TfToken("unity:name"), new pxr.TfToken(gameObj.name));
var itr = obj.GetIterator();
itr.Next(true);
PropertyToUsd(path, "", scene, itr, sb);
}
/// <summary>
/// Internal helper for serializing data to USD.
/// </summary>
/// <param name="attrName">The USD attribute name.</param>
/// <param name="csType">The C# type.</param>
/// <param name="csValue">The C# value.</param>
/// <param name="usdTime">The time at which to sample key frames.</param>
/// <param name="prim">The USD prim at which to write values.</param>
/// <param name="imgble">The UsdGeomImagable attrbiute, used when writing PrimVars.</param>
/// <param name="memberInfo">The field/property providing serialization metadata.</param>
/// <param name="usdNamespace">The optional USD namespace at which values live.</param>
/// <param name="srcObject">The source object name, used when remapping names.</param>
/// <returns>True on success.</returns>
/// <remarks>
/// Note that "success" in the return value does not indicate data was written, rather it
/// indicates that no unexpected states were encountered. E.g. calling WriteAttr on a field
/// marked as [NotSerialized] does not cause this method to return false, since non-serialized
/// fields are an expected state this function may encounter.
/// </remarks>
bool WriteAttr(string attrName, Type csType, object csValue, pxr.UsdTimeCode usdTime,
pxr.UsdPrim prim, pxr.UsdGeomImageable imgble, MemberInfo memberInfo,
string usdNamespace, string srcObject = null)
{
if (Reflect.IsNonSerialized(memberInfo))
{
Console.WriteLine("Non serialized");
return(true);
}
// If serializing a Primvar<T>, extract the held value and save it in csValue, allowing the
// all downstream logic to act as if it's operating on the held value itself.
PrimvarBase pvBase = null;
if (csType.IsGenericType && csType.GetGenericTypeDefinition() == typeof(Primvar <>))
{
if (csValue == null)
{
// Object not written, still considered success.
return(true);
}
pvBase = (PrimvarBase)csValue;
csValue = (csValue as ValueAccessor).GetValue();
if (csValue == null)
{
// Object not written, still considered success.
return(true);
}
csType = csValue.GetType();
}
bool isCustomData = Reflect.IsCustomData(memberInfo);
bool isMetaData = Reflect.IsMetadata(memberInfo);
bool isPrimvar = Reflect.IsPrimvar(memberInfo);
bool isNewPrimvar = pvBase != null;
int primvarElementSize = Reflect.GetPrimvarElementSize(memberInfo);
string ns = IntrinsicTypeConverter.JoinNamespace(usdNamespace,
Reflect.GetNamespace(memberInfo));
// If holding a dictionary, immediately recurse and write keys as attributes.
if (csValue != null &&
csType.IsGenericType &&
csType.GetGenericTypeDefinition() == typeof(Dictionary <,>) &&
csType.GetGenericArguments()[0] == typeof(string))
{
isNewPrimvar = csType.GetGenericArguments()[1].IsGenericType &&
csType.GetGenericArguments()[1].GetGenericTypeDefinition() == typeof(Primvar <>);
// Ensure the immediate dictionary member is always namespaced.
if (string.IsNullOrEmpty(Reflect.GetNamespace(memberInfo)))
{
usdNamespace = IntrinsicTypeConverter.JoinNamespace(usdNamespace, attrName);
}
var dict = csValue as System.Collections.IDictionary;
foreach (System.Collections.DictionaryEntry kvp in dict)
{
object value = kvp.Value;
WriteAttr((string)kvp.Key, value.GetType(), value,
usdTime, prim, imgble, memberInfo, usdNamespace, srcObject: attrName);
}
return(true);
}
pxr.TfToken sdfAttrName = sm_tokenCache[attrName];
if (csType == typeof(Relationship) && csValue != null)
{
string[] targetStrings = ((Relationship)csValue).targetPaths;
if (targetStrings != null)
{
//
// Write Relationship
//
string[] arr = IntrinsicTypeConverter.JoinNamespace(ns, sdfAttrName).Split(':');
pxr.StdStringVector elts = new pxr.StdStringVector(arr.Length);
foreach (var s in arr)
{
elts.Add(s);
}
pxr.UsdRelationship rel = null;
lock (m_stageLock) {
rel = prim.CreateRelationship(elts, custom: false);
}
if (!rel.IsValid())
{
throw new ApplicationException("Failed to create relationship <"
+ prim.GetPath().AppendProperty(
new pxr.TfToken(
IntrinsicTypeConverter.JoinNamespace(ns, sdfAttrName))).ToString() + ">");
}
var targets = new pxr.SdfPathVector();
foreach (var path in ((Relationship)csValue).targetPaths)
{
targets.Add(new pxr.SdfPath(path));
}
lock (m_stageLock) {
rel.SetTargets(targets);
}
}
return(true);
}
//
// Write Attribute
//
// FUTURE: When writing sparse overrides, if the csValue is null exit here and avoid
// defining the target attribute. However, sparse authoring is not yet supported.
UsdTypeBinding binding;
// Extract the value and type from the connectable.
var conn = csValue as Connectable;
if (conn != null)
{
csType = conn.GetValueType();
csValue = conn.GetValue();
}
// Get the binding for the value about to be serialized.
if (!sm_bindings.GetBinding(csType, out binding) && !csType.IsEnum)
{
if (csValue == null)
{
return(true);
}
if (string.IsNullOrEmpty(ns))
{
return(false);
}
var sample = csValue as SampleBase;
if (sample == null && csValue != null)
{
throw new ArgumentException("Type does not inherit from SampleBase: " + attrName);
}
Serialize(csValue, prim, usdTime, usdNamespace: ns);
return(true);
}
// Determine metadata for the attribtue, note that in the case of connections and primvars
// these will be the attributes on the outter object, e.g. declared on the Connection<T> or
// Primvar<T>.
pxr.SdfVariability variability = Reflect.GetVariability(memberInfo);
pxr.SdfValueTypeName sdfTypeName = binding.sdfTypeName;
pxr.UsdTimeCode time = variability == pxr.SdfVariability.SdfVariabilityUniform
? pxr.UsdTimeCode.Default()
: usdTime;
bool custom = false;
pxr.UsdAttribute attr;
if (isCustomData || isMetaData)
{
// no-op
attr = null;
}
else if (!isPrimvar && !isNewPrimvar)
{
if (string.IsNullOrEmpty(ns))
{
//
// Create non-namespaced attribute.
//
lock (m_stageLock) {
attr = prim.CreateAttribute(sdfAttrName, csType.IsEnum ? SdfValueTypeNames.Token : sdfTypeName, custom, variability);
}
}
else
{
//
// Create namespaced attribute.
//
string[] arr = IntrinsicTypeConverter.JoinNamespace(ns, sdfAttrName).Split(':');
pxr.StdStringVector elts = new pxr.StdStringVector(arr.Length);
foreach (var s in arr)
{
elts.Add(s);
}
lock (m_stageLock) {
attr = prim.CreateAttribute(elts, sdfTypeName, custom, variability);
}
}
}
else
{
//
// Create Primvar attribute.
//
lock (m_stageLock) {
var fullAttrName = IntrinsicTypeConverter.JoinNamespace(ns, sdfAttrName);
var primvar = imgble.CreatePrimvar(new pxr.TfToken(fullAttrName), sdfTypeName,
VertexDataAttribute.Interpolation);
if (isNewPrimvar)
{
primvar.SetElementSize(pvBase.elementSize);
if (pvBase.indices != null)
{
var vtIndices = IntrinsicTypeConverter.ToVtArray(pvBase.indices);
primvar.SetIndices(vtIndices, time);
}
primvar.SetInterpolation(pvBase.GetInterpolationToken());
}
else
{
primvar.SetElementSize(primvarElementSize);
}
attr = primvar.GetAttr();
}
}
if (attr != null && conn != null && conn.GetConnectedPath() != null)
{
// TODO: Pool temp vector, possibly add a single item overload for SetConnections.
var paths = new pxr.SdfPathVector();
var connPath = conn.GetConnectedPath();
if (connPath != string.Empty)
{
paths.Add(new pxr.SdfPath(conn.GetConnectedPath()));
}
attr.SetConnections(paths);
}
// This may happen when a connection is present, but has a null default value.
// Because the connection is applied just before this point, this is the earliest possible
// exit point.
if (csValue == null)
{
return(true);
}
pxr.VtValue vtValue = binding.toVtValue(csValue);
lock (m_stageLock) {
if (isMetaData)
{
prim.SetMetadata(sdfAttrName, vtValue);
}
else if (isCustomData)
{
prim.SetCustomDataByKey(sdfAttrName, vtValue);
}
else if (Reflect.IsFusedDisplayColor(memberInfo))
{
pxr.UsdCs.SetFusedDisplayColor(prim, vtValue, time);
}
else
{
attr.Set(vtValue, time);
}
}
if (!isCustomData && srcObject != null)
{
lock (m_stageLock) {
attr.SetCustomDataByKey(sm_tokenCache["sourceMember"], srcObject);
}
}
return(true);
}
/// <summary>
/// Constructs Unity SerializedProperties from USD.
/// </summary>
static void PropertyFromUsd(pxr.UsdPrim prim,
SerializedProperty prop,
System.Text.StringBuilder sb,
string propPrefix)
{
if (prim == null)
{
Debug.LogError("Null prim - " + propPrefix);
}
if (!prim.IsValid())
{
Debug.LogError("Invalid prim: " + prim.GetPath().ToString());
}
string prefix = "";
try
{
var nameStack = new List <string>();
nameStack.Add("unity");
if (!string.IsNullOrEmpty(propPrefix))
{
nameStack.Add(propPrefix);
}
string lastName = "";
int lastDepth = 0;
while (prop.Next(prop.propertyType == SerializedPropertyType.Generic && !prop.isArray))
{
string tabIn = "";
for (int i = 0; i < prop.depth; i++)
{
tabIn += " ";
}
if (prop.depth > lastDepth)
{
Debug.Assert(lastName != "");
nameStack.Add(lastName);
}
else if (prop.depth < lastDepth)
{
nameStack.RemoveRange(nameStack.Count - (lastDepth - prop.depth), lastDepth - prop.depth);
}
lastDepth = prop.depth;
lastName = prop.name;
if (nameStack.Count > 0)
{
prefix = string.Join(":", nameStack.ToArray());
prefix += ":";
}
else
{
prefix = "";
}
sb.Append(tabIn + prefix + prop.name + "[" + prop.propertyType.ToString() + "] = ");
if (prop.isArray && prop.propertyType != SerializedPropertyType.String)
{
// TODO.
sb.AppendLine("ARRAY");
}
else if (prop.propertyType == SerializedPropertyType.Generic)
{
sb.AppendLine("Generic");
}
else if (prop.propertyType == SerializedPropertyType.AnimationCurve ||
prop.propertyType == SerializedPropertyType.Gradient)
{
// TODO.
sb.AppendLine(NativeSerialization.ValueToString(prop));
}
else
{
sb.AppendLine(NativeSerialization.ValueToString(prop));
var attrName = new pxr.TfToken(prefix + prop.name);
var attr = prim.GetAttribute(attrName);
if (attr == null)
{
Debug.LogError("Null attr: " + prim.GetPath().ToString() + "." + attrName.ToString());
}
if (!attr.IsValid())
{
Debug.LogError("Attribute not found:" + attr.GetPath().ToString());
}
NativeSerialization.VtValueToProp(prop, attr.Get(0));
}
}
}
catch
{
Debug.LogWarning("Failed on: " + prim.GetPath() + "." + prefix + prop.name);
throw;
}
}
/// <summary>
/// Internal helper for reading data from USD.
/// </summary>
/// <param name="attrName">The USD attribute name.</param>
/// <param name="csType">The C# type.</param>
/// <param name="csValue">The C# value to populate.</param>
/// <param name="usdTime">The time at which to sample key frames.</param>
/// <param name="prim">The USD prim from which to read data.</param>
/// <param name="memberInfo">The field/property providing serialization metadata.</param>
/// <param name="usdNamespace">The optional USD namespace at which values live.</param>
/// <param name="srcObject">The source object name, used when remapping names.</param>
/// <returns>True on success.</returns>
/// <remarks>
/// Note that "success" in the return value does not indicate data was read, rather it
/// indicates that no unexpected states were encountered. E.g. calling ReadAttr on a field
/// with no value stored in USD will not return false, since that is not considered a failure
/// state.
/// </remarks>
bool ReadAttr(string attrName, Type csType, ref object csValue, pxr.UsdTimeCode usdTime,
pxr.UsdPrim prim, MemberInfo memberInfo,
string usdNamespace, string srcObject = null)
{
bool isPrimvar = Reflect.IsPrimvar(memberInfo);
string ns = IntrinsicTypeConverter.JoinNamespace(usdNamespace,
Reflect.GetNamespace(memberInfo));
// If holding a dictionary, immediately recurse and write keys as attributes.
if (csType == typeof(Dictionary <string, object>))
{
string sourceMember;
if (isPrimvar)
{
ns = "primvars";
sourceMember = attrName;
}
else
{
ns = IntrinsicTypeConverter.JoinNamespace(ns, attrName);
sourceMember = null;
}
var dict = csValue as Dictionary <string, object>;
foreach (var prop in prim.GetAuthoredPropertiesInNamespace(ns))
{
object value = null;
if (!string.IsNullOrEmpty(sourceMember))
{
pxr.VtValue valSrcMember = prop.GetCustomDataByKey(sm_tokenCache["sourceMember"]);
if (valSrcMember.IsEmpty() || sourceMember != (string)valSrcMember)
{
continue;
}
}
if (isPrimvar)
{
// The recursive call will also discover that this is a primvar.
ns = "";
}
if (ReadAttr(prop.GetBaseName(), typeof(Object), ref value, usdTime, prim, memberInfo, ns, srcObject))
{
if (value != null)
{
dict.Add(prop.GetBaseName(), value);
}
}
}
return(true);
}
pxr.TfToken sdfAttrName = sm_tokenCache[ns, attrName];
if (csType == typeof(Relationship))
{
//
// Read Relationship
//
pxr.UsdRelationship rel = null;
lock (m_stageLock) {
rel = prim.GetRelationship(sm_tokenCache[sdfAttrName]);
}
var relationship = new Relationship();
csValue = relationship;
if (rel == null || !rel.IsValid())
{
return(true);
}
pxr.SdfPathVector paths = rel.GetTargets();
string[] result = new string[paths.Count];
for (int i = 0; i < paths.Count; i++)
{
result[i] = paths[i].ToString();
}
relationship.targetPaths = result;
return(true);
}
UsdTypeBinding binding;
Connectable conn = null;
if (csValue != null &&
csType.IsGenericType &&
csType.GetGenericTypeDefinition() == typeof(Connectable <>))
{
conn = csValue as Connectable;
if (conn != null)
{
csValue = conn.GetValue();
csType = conn.GetValueType();
}
}
if (!sm_bindings.GetBinding(csType, out binding) &&
!csType.IsEnum &&
csType != typeof(object))
{
if (string.IsNullOrEmpty(ns))
{
return(false);
}
var sample = csValue as SampleBase;
if (sample == null)
{
throw new Exception("Could not deserialize: Prim: " + prim.GetPath() + " namespace: " + ns);
}
Deserialize((SampleBase)csValue, prim, usdTime, usdNamespace: ns);
return(true);
}
if (conn != null)
{
csValue = conn;
}
pxr.SdfVariability variability = Reflect.GetVariability(memberInfo);
// Note that namespaced primvars are not supported, so "primvars" will replace the incoming
// namespace. This will happen if a nested/namespaced object has a member declared as a
// primvar.
if (isPrimvar)
{
System.Diagnostics.Debug.Assert(string.IsNullOrEmpty(ns));
sdfAttrName = sm_tokenCache["primvars", attrName];
}
pxr.UsdTimeCode time = variability == pxr.SdfVariability.SdfVariabilityUniform
? kDefaultUsdTime
: usdTime;
//using (var valWrapper = new PooledHandle<pxr.VtValue>(ArrayAllocator)) {
pxr.VtValue vtValue = (pxr.VtValue)ArrayAllocator.MallocHandle(typeof(pxr.VtValue));
try {
if (conn != null)
{
var sources = new pxr.SdfPathVector();
if (prim.GetAttribute(sdfAttrName).GetConnections(sources))
{
if (sources.Count > 0)
{
conn.SetConnectedPath(sources[0].ToString());
}
}
}
if (Reflect.IsCustomData(memberInfo))
{
vtValue = prim.GetCustomDataByKey(sdfAttrName);
}
else if (Reflect.IsFusedDisplayColor(memberInfo))
{
vtValue = pxr.UsdCs.GetFusedDisplayColor(prim, time);
}
else if (Reflect.IsFusedTransform(memberInfo))
{
vtValue = pxr.UsdCs.GetFusedTransform(prim, time);
}
else
{
if (!prim.GetAttributeValue(sdfAttrName, vtValue, time))
{
// Object has no value, still considered success.
return(true);
}
}
if (vtValue.IsEmpty())
{
// Object has no value, still considered success.
return(true);
}
if (csType == typeof(object))
{
// Blind object serialization needs special handling, since we won't know the C# type a priori.
// Instead, do a reverse lookup on the SdfTypeName and let USD dictate the C# type.
pxr.UsdAttribute attr = prim.GetAttribute(sdfAttrName);
if (attr != null && attr.IsValid())
{
// TODO: Assuming the reverse lookup is successful for the binding, the caller may be
// surprised by the result, since the USD <-> C# types are not 1-to-1. For example,
// a List<Vector2> may have been serialized, but Vector2[] may be read.
if (!sm_bindings.GetReverseBinding(attr.GetTypeName(), out binding))
{
if (string.IsNullOrEmpty(ns))
{
return(false);
}
// TODO: readback nested object declared as object -- maybe just disable this?
//Deserialize(ref csValue, prim, usdTime, usdNamespace: ns);
//return true;
return(false);
}
}
else
{
// TODO: Allow reading metadata declared as object in C#
return(false);
}
}
csValue = binding.toCsObject(vtValue);
if (conn != null && csValue != null)
{
conn.SetValue(csValue);
csValue = conn;
}
} finally {
// Would prefer RAII handle, but introduces garbage.
ArrayAllocator.FreeHandle(vtValue);
}
// Need to deal with this
//if (srcObject != null) {
// attr.SetCustomDataByKey(m_tokenCache["sourceMember"], srcObject);
//}
return(true);
}
/// <summary>
/// Internal helper for serializing data to USD.
/// </summary>
/// <param name="attrName">The USD attribute name.</param>
/// <param name="csType">The C# type.</param>
/// <param name="csValue">The C# value.</param>
/// <param name="usdTime">The time at which to sample key frames.</param>
/// <param name="prim">The USD prim at which to write values.</param>
/// <param name="imgble">The UsdGeomImagable attrbiute, used when writing PrimVars.</param>
/// <param name="memberInfo">The field/property providing serialization metadata.</param>
/// <param name="usdNamespace">The optional USD namespace at which values live.</param>
/// <param name="srcObject">The source object name, used when remapping names.</param>
/// <returns>True on success.</returns>
/// <remarks>
/// Note that "success" in the return value does not indicate data was written, rather it
/// indicates that no unexpected states were encountered. E.g. calling WriteAttr on a field
/// marked as [NotSerialized] does not cause this method to return false, since non-serialized
/// fields are an expected state this function may encounter.
/// </remarks>
bool WriteAttr(string attrName, Type csType, object csValue, pxr.UsdTimeCode usdTime,
pxr.UsdPrim prim, pxr.UsdGeomImageable imgble, MemberInfo memberInfo,
string usdNamespace, string srcObject = null)
{
if (Reflect.IsNonSerialized(memberInfo))
{
return(true);
}
// If holding a dictionary, immediately recurse and write keys as attributes.
if (csType == typeof(Dictionary <string, object>))
{
Dictionary <string, object> dict = csValue as Dictionary <string, object>;
foreach (var kvp in dict)
{
object value = kvp.Value;
WriteAttr(kvp.Key, value.GetType(), value,
usdTime, prim, imgble, memberInfo, usdNamespace, srcObject: attrName);
}
return(true);
}
string ns = IntrinsicTypeConverter.JoinNamespace(usdNamespace,
Reflect.GetNamespace(memberInfo));
pxr.TfToken sdfAttrName = sm_tokenCache[attrName];
if (csType == typeof(Relationship) && csValue != null)
{
string[] targetStrings = ((Relationship)csValue).targetPaths;
if (targetStrings != null)
{
//
// Write Relationship
//
string[] arr = IntrinsicTypeConverter.JoinNamespace(ns, sdfAttrName).Split(':');
pxr.StdStringVector elts = new pxr.StdStringVector(arr.Length);
foreach (var s in arr)
{
elts.Add(s);
}
pxr.UsdRelationship rel = null;
lock (m_stageLock) {
rel = prim.CreateRelationship(elts, custom: false);
}
if (!rel.IsValid())
{
throw new ApplicationException("Failed to create relationship <"
+ prim.GetPath().AppendProperty(
new pxr.TfToken(
IntrinsicTypeConverter.JoinNamespace(ns, sdfAttrName))).ToString() + ">");
}
var targets = new pxr.SdfPathVector();
foreach (var path in ((Relationship)csValue).targetPaths)
{
targets.Add(new pxr.SdfPath(path));
}
lock (m_stageLock) {
rel.SetTargets(targets);
}
}
return(true);
}
//
// Write Attribute
//
// Object not written, still considered success.
if (csValue == null)
{
return(true);
}
bool isCustomData = Reflect.IsCustomData(memberInfo);
bool isPrimvar = Reflect.IsPrimvar(memberInfo);
UsdTypeBinding binding;
var conn = csValue as Connectable;
if (conn != null)
{
csType = conn.GetValue().GetType();
csValue = conn.GetValue();
}
if (!sm_bindings.GetBinding(csType, out binding) && !csType.IsEnum)
{
if (string.IsNullOrEmpty(ns))
{
return(false);
}
Serialize(csValue, prim, usdTime, usdNamespace: ns);
return(true);
}
pxr.SdfVariability variability = Reflect.GetVariability(memberInfo);
pxr.SdfValueTypeName sdfTypeName = binding.sdfTypeName;
pxr.UsdTimeCode time = variability == pxr.SdfVariability.SdfVariabilityUniform
? pxr.UsdTimeCode.Default()
: usdTime;
bool custom = false;
pxr.UsdAttribute attr;
if (isCustomData)
{
// no-op
attr = null;
}
else if (!isPrimvar)
{
if (string.IsNullOrEmpty(ns))
{
lock (m_stageLock) {
attr = prim.CreateAttribute(sdfAttrName, csType.IsEnum ? SdfValueTypeNames.Token : sdfTypeName, custom, variability);
}
}
else
{
string[] arr = IntrinsicTypeConverter.JoinNamespace(ns, sdfAttrName).Split(':');
pxr.StdStringVector elts = new pxr.StdStringVector(arr.Length);
foreach (var s in arr)
{
elts.Add(s);
}
lock (m_stageLock) {
attr = prim.CreateAttribute(elts, sdfTypeName, custom, variability);
}
}
}
else
{
// Primvars do not support additional namespaces.
lock (m_stageLock) {
attr = imgble.CreatePrimvar(sdfAttrName, sdfTypeName,
VertexDataAttribute.Interpolation).GetAttr();
}
}
if (attr != null && conn != null && conn.GetConnectedPath() != null)
{
// TODO: Pool temp vector, possibly add a single item overload for SetConnections.
var paths = new pxr.SdfPathVector();
var connPath = conn.GetConnectedPath();
if (connPath != string.Empty)
{
paths.Add(new pxr.SdfPath(conn.GetConnectedPath()));
}
attr.SetConnections(paths);
}
pxr.VtValue vtValue = binding.toVtValue(csValue);
lock (m_stageLock) {
if (isCustomData)
{
prim.SetCustomDataByKey(sdfAttrName, vtValue);
}
else if (Reflect.IsFusedDisplayColor(memberInfo))
{
pxr.UsdCs.SetFusedDisplayColor(prim, vtValue, time);
}
else
{
attr.Set(vtValue, time);
}
}
if (!isCustomData && srcObject != null)
{
lock (m_stageLock) {
attr.SetCustomDataByKey(sm_tokenCache["sourceMember"], srcObject);
}
}
return(true);
}