object UsdEnumToCs(pxr.VtValue vtValue, Type enumType)
{
//using (var t = new PooledHandle<pxr.TfToken>(UsdIo.ArrayAllocator)) {
var t = (pxr.TfToken)UsdIo.ArrayAllocator.MallocHandle(typeof(pxr.TfToken));
try
{
pxr.UsdCs.VtValueToTfToken(vtValue, t);
Enum enm;
Dictionary <pxr.TfToken, Enum> enumMap;
lock (UsdIo.Bindings) {
if (!enumMaps.TryGetValue(enumType, out enumMap))
{
enumMap = new Dictionary <pxr.TfToken, Enum>();
enumMaps.Add(enumType, enumMap);
}
if (!enumMap.TryGetValue(t, out enm))
{
string s = t.ToString();
System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(s));
enm = (Enum)Enum.Parse(enumType, string.Concat(char.ToUpper(s[0]), s.Substring(1)));
enumMap.Add(t, enm);
}
}
return(enm);
}
finally
{
UsdIo.ArrayAllocator.FreeHandle(t);
}
}
object GuidToCs_Bytes(pxr.VtValue vtValue)
{
var vtBytes = (pxr.VtUCharArray)UsdIo.ArrayAllocator.MallocHandle(typeof(pxr.VtUCharArray));
pxr.UsdCs.VtValueToVtUCharArray(vtValue, vtBytes);
byte[] bytes = IntrinsicTypeConverter.FromVtArray(vtBytes);
var ret = new Guid(bytes);
UsdIo.ArrayAllocator.FreeHandle(vtBytes.GetType(), vtBytes);
UsdIo.ArrayAllocator.Free(bytes.GetType(), (uint)bytes.Length, bytes);
return(ret);
}
/// <summary>
/// Converts a VtValue holding a VtArray of T to a C#-native array type, using a generated (fast) function, toCs.
/// </summary>
object ToCsConvertHelper(pxr.VtValue val, Type vtArrayType, ToCsCopyConverter toCs)
{
// Intentionally not tracking size here, since USD will resize the array for us.
object vtArrayObject = UsdIo.ArrayAllocator.MallocHandle(vtArrayType);
// Convert value to VtArray<T> and convert that to the target C# array type.
object csArray = toCs(val, vtArrayObject);
// Free the handle back to the allocator.
UsdIo.ArrayAllocator.FreeHandle(vtArrayType, vtArrayObject);
// Return the C# array.
return(csArray);
}
/// <summary>
/// Converts a VtValue holding a VtArray of T to a C#-native array type, using (slow) late binding.
/// </summary>
object ToCsDynamicConvertHelper(pxr.VtValue vtValue, Type vtArrayType, System.Reflection.MethodInfo valToVtArray, System.Reflection.MethodInfo vtToCsArray)
{
// Intentionally not tracking size here, since USD will resize the array for us.
object vtArrayObject = UsdIo.ArrayAllocator.MallocHandle(vtArrayType);
// Convert value to VtArray<T> and convert that to the target C# array type.
// For example:
// class UsdCs {
// public static void VtValueToVtTokenArray(VtValue value, VtTokenArray output);
valToVtArray.Invoke(null, new object[] { vtValue, vtArrayObject });
// For example:
// class IntrinsicTypeConverter {
// static public string[] FromVtArray(VtTokenArray input);
object csArray = vtToCsArray.Invoke(null, new object[] { vtArrayObject });
// Free the handle back to the allocator.
UsdIo.ArrayAllocator.FreeHandle(vtArrayType, vtArrayObject);
// Return the C# array.
return(csArray);
}
public static void VtValueEqualityTest()
{
var A = new pxr.VtValue(1);
var B = new pxr.VtValue(1);
var C = new pxr.VtValue(2);
AssertEqual(A, B);
AssertNotEqual(A, C);
A = new pxr.VtValue(1.1f);
B = new pxr.VtValue(1.1f);
C = new pxr.VtValue(1.3f);
AssertEqual(A, B);
AssertNotEqual(A, C);
A = new pxr.VtValue(1.1);
B = new pxr.VtValue(1.1);
C = new pxr.VtValue(1.2);
AssertEqual(A, B);
AssertNotEqual(A, C);
A = new pxr.VtValue(9L);
B = new pxr.VtValue(9L);
C = new pxr.VtValue(0L);
AssertEqual(A, B);
AssertNotEqual(A, C);
A = new pxr.VtValue("string");
B = new pxr.VtValue("string");
C = new pxr.VtValue("foo");
AssertEqual(A, B);
AssertNotEqual(A, C);
A = new pxr.VtValue(new pxr.TfToken("token"));
B = new pxr.VtValue(new pxr.TfToken("token"));
C = new pxr.VtValue(new pxr.TfToken("foo"));
AssertEqual(A, B);
AssertNotEqual(A, C);
A = new pxr.VtValue(new pxr.GfVec2f(1.1f, 2.2f));
B = new pxr.VtValue(new pxr.GfVec2f(1.1f, 2.2f));
C = new pxr.VtValue(new pxr.GfVec2f(1.1f, 3.3f));
AssertEqual(A, B);
AssertNotEqual(A, C);
A = new pxr.VtValue(new pxr.GfVec3f(1.1f, 2.2f, 3.3f));
B = new pxr.VtValue(new pxr.GfVec3f(1.1f, 2.2f, 3.3f));
C = new pxr.VtValue(new pxr.GfVec3f(1.1f, 2.2f, 3.1f));
AssertEqual(A, B);
AssertNotEqual(A, C);
A = new pxr.VtValue(new pxr.GfVec4f(1.1f, 2.2f, 3.3f, 4.4f));
B = new pxr.VtValue(new pxr.GfVec4f(1.1f, 2.2f, 3.3f, 4.4f));
C = new pxr.VtValue(new pxr.GfVec4f(1.1f, 2.2f, 3.3f, 4.1f));
AssertEqual(A, B);
AssertNotEqual(A, C);
A = new pxr.VtValue(new pxr.VtVec2fArray(2, new pxr.GfVec2f(1.1f, 2.2f)));
B = new pxr.VtValue(new pxr.VtVec2fArray(2, new pxr.GfVec2f(1.1f, 2.2f)));
C = new pxr.VtValue(new pxr.VtVec2fArray(2, new pxr.GfVec2f(1.1f, 2.1f)));
AssertEqual(A, B);
AssertNotEqual(A, C);
A = new pxr.VtValue(new pxr.VtVec3fArray(2, new pxr.GfVec3f(1.1f, 2.2f, 3.3f)));
B = new pxr.VtValue(new pxr.VtVec3fArray(2, new pxr.GfVec3f(1.1f, 2.2f, 3.3f)));
C = new pxr.VtValue(new pxr.VtVec3fArray(1, new pxr.GfVec3f(1.1f, 2.2f, 3.3f)));
AssertEqual(A, B);
AssertNotEqual(A, C);
A = new pxr.VtValue(new pxr.VtVec4fArray(2, new pxr.GfVec4f(1.1f, 2.2f, 3.3f, 4.4f)));
B = new pxr.VtValue(new pxr.VtVec4fArray(2, new pxr.GfVec4f(1.1f, 2.2f, 3.3f, 4.4f)));
C = new pxr.VtValue(new pxr.VtVec4fArray(2, new pxr.GfVec4f(1.1f, 2.1f, 3.1f, 4.4f)));
AssertEqual(A, B);
AssertNotEqual(A, C);
}
/// <summary>
/// Converts a VtValue to a SerializedProperty, to reconstruct the USD scene in Unity.
/// </summary>
static public void VtValueToProp(SerializedProperty prop, pxr.VtValue val)
{
switch (prop.propertyType)
{
case SerializedPropertyType.AnimationCurve:
// TODO: needs to be broken down into atoms.
throw new System.NotImplementedException();
case SerializedPropertyType.ArraySize:
//prop.intValue = (int)val;
break;
case SerializedPropertyType.Boolean:
prop.boolValue = (bool)val;
break;
case SerializedPropertyType.Bounds:
prop.boundsValue = UnityTypeConverter.BoundsFromVtArray(val);
break;
case SerializedPropertyType.BoundsInt:
// TODO: add this to UnityTypeConverter.
var bnds = UnityTypeConverter.BoundsFromVtArray(val);
var center = new Vector3Int((int)bnds.center.x, (int)bnds.center.y, (int)bnds.center.z);
var size = new Vector3Int((int)bnds.size.x, (int)bnds.size.y, (int)bnds.size.z);
prop.boundsIntValue = new BoundsInt(center, size);
break;
case SerializedPropertyType.Character:
prop.intValue = (int)val;
break;
case SerializedPropertyType.Color:
prop.colorValue = UnityTypeConverter.Vec4fToColor(val);
break;
case SerializedPropertyType.Enum:
prop.enumValueIndex = (int)val;
break;
case SerializedPropertyType.ExposedReference:
// TODO.
//prop.exposedReferenceValue;
throw new System.NotImplementedException();
case SerializedPropertyType.FixedBufferSize:
//prop.fixedBufferSize = (int)val;
// TODO.
throw new System.NotImplementedException();
case SerializedPropertyType.Float:
prop.floatValue = (float)val;
break;
case SerializedPropertyType.Generic:
throw new System.Exception();
case SerializedPropertyType.Gradient:
// TODO: gradientValue accessor is not public. wat?
throw new System.NotImplementedException();
case SerializedPropertyType.Integer:
prop.intValue = (int)val;
break;
case SerializedPropertyType.LayerMask:
prop.intValue = (int)val;
break;
case SerializedPropertyType.ObjectReference:
/*
* var v2i = (pxr.GfVec2i)val;
* if (v2i[0] == 0 && v2i[1] == 0) {
* break;
* }
* Debug.Log("FileID: " + v2i[0] + " PathID: " + v2i[1]);
*/
if (val.IsEmpty())
{
break;
}
string strValue = pxr.UsdCs.VtValueTostring(val);
if (string.IsNullOrEmpty(strValue))
{
break;
}
string[] names = strValue.Split(':');
int pathId = int.Parse(names[0]);
var guid = names[1];
int fileId = int.Parse(names[2]);
string assetPath = AssetDatabase.GUIDToAssetPath(guid);
Object[] objs = AssetDatabase.LoadAllAssetsAtPath(assetPath);
Object obj = objs[pathId];
Debug.Log("pathId: " + pathId
+ " fileId: " + fileId
+ " guid: " + guid.ToString()
+ " obj: " + obj.ToString());
//break;
/* TODO:
* string expectedName = names[2];
* if (objs[index].name != expectedName) {
* Debug.LogWarning("Expected name '" + expectedName + "' but found '" + objs[index].name + "'");
* }
*/
prop.FindPropertyRelative("m_PathID").intValue = pathId;
prop.FindPropertyRelative("m_FileID").intValue = fileId;
prop.objectReferenceValue = obj;
break;
case SerializedPropertyType.Quaternion:
prop.quaternionValue = UnityTypeConverter.QuatfToQuaternion(val);
break;
case SerializedPropertyType.Rect:
prop.rectValue = UnityTypeConverter.Vec4fToRect(val);
break;
case SerializedPropertyType.RectInt:
var rect = UnityTypeConverter.Vec4fToRect(val);
prop.rectIntValue = new RectInt((int)rect.xMin, (int)rect.yMin,
(int)rect.width, (int)rect.height);
break;
case SerializedPropertyType.String:
var s = (string)val;
if (s == null)
{
break;
}
prop.stringValue = (string)val;
break;
case SerializedPropertyType.Vector2:
prop.vector2Value = UnityTypeConverter.Vec2fToVector2(val);
break;
case SerializedPropertyType.Vector2Int:
// TODO: add this to UnityTypeConverter.
var v2 = (pxr.GfVec2i)val;
prop.vector2IntValue = new Vector2Int(v2[0], v2[1]);
break;
case SerializedPropertyType.Vector3:
prop.vector3Value = UnityTypeConverter.Vec3fToVector3(val);
break;
case SerializedPropertyType.Vector3Int:
// TODO: add this to UnityTypeConverter.
var v3 = (pxr.GfVec3i)val;
prop.vector3IntValue = new Vector3Int(v3[0], v3[1], v3[2]);
break;
case SerializedPropertyType.Vector4:
prop.vector4Value = UnityTypeConverter.Vec4fToVector4(val);
break;
}
}
object GuidToCs_String(pxr.VtValue vtValue)
{
return(new Guid(pxr.UsdCs.VtValueTostring(vtValue)));
}
/// <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="accessMap">A map of members to include when reading.</param>
/// <param name="mayVary">When not null, is populated with variability.</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,
HashSet <MemberInfo> accessMap, ref bool?mayVary,
string usdNamespace)
{
bool isNewPrimvar = csValue != null &&
csType.IsGenericType &&
csType.GetGenericTypeDefinition() == typeof(Primvar <>);
bool isPrimvar = Reflect.IsPrimvar(memberInfo) || isNewPrimvar;
string ns = IntrinsicTypeConverter.JoinNamespace(usdNamespace,
Reflect.GetNamespace(memberInfo));
// ----------------------------------------- //
// Dictionaries, read, early exit, recurse.
// ----------------------------------------- //
// 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))
{
Type genericTypeDef = csType.GetGenericArguments()[1].IsGenericType
? csType.GetGenericArguments()[1].GetGenericTypeDefinition()
: null;
isNewPrimvar = genericTypeDef == typeof(Primvar <>);
bool isRelationship = csType.GetGenericArguments()[1] == typeof(Relationship);
bool isConnection = genericTypeDef == typeof(Connectable <>);
// String dictionaries are unrolled directly into the object.
// So the namespace is either the incoming namespace or empty, meaning each string value in
// the dictionary becomes an attribute on the prim.
// Ensure there is always a namespace immediately around this member.
if (string.IsNullOrEmpty(Reflect.GetNamespace(memberInfo)))
{
ns = IntrinsicTypeConverter.JoinNamespace(ns, attrName);
usdNamespace = IntrinsicTypeConverter.JoinNamespace(usdNamespace, attrName);
}
// Unfortunately, the primvars prefixing logic must be replicated here so we can discover
// the dictionary member from USD.
if (isPrimvar || isNewPrimvar)
{
ns = IntrinsicTypeConverter.JoinNamespace("primvars", ns);
}
var dict = csValue as System.Collections.IDictionary;
ConstructorInfo ctor = (isNewPrimvar || isConnection || isRelationship)
? csType.GetGenericArguments()[1].GetConstructor(new Type[0])
: null;
dict.Clear();
foreach (var prop in prim.GetAuthoredPropertiesInNamespace(ns))
{
object value = null;
if (ctor != null)
{
value = ctor.Invoke(new object[0]);
}
// The recursive call will also discover that this is a primvar and any associated namespace.
if (ReadAttr(prop.GetBaseName(),
csType.GetGenericArguments()[1],
ref value,
usdTime,
prim,
memberInfo,
accessMap,
ref mayVary,
usdNamespace))
{
if (value != null)
{
dict.Add(prop.GetBaseName().ToString(), value);
}
}
}
return(true);
}
pxr.TfToken sdfAttrName = sm_tokenCache[ns, attrName];
// ----------------------------------------- //
// Relationship, read + early exit.
// ----------------------------------------- //
if (csType == typeof(Relationship))
{
// mayVary is explicitly not set here because it has accumulation semantics:
// mayVary = mayVary || false;
// Which is equivalent to the no-op:
// mayVary = mayVary;
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);
}
// ----------------------------------------- //
// Connection Setup.
// ----------------------------------------- //
Connectable conn = null;
if (csValue != null &&
csType.IsGenericType &&
csType.GetGenericTypeDefinition() == typeof(Connectable <>))
{
conn = csValue as Connectable;
if (conn != null)
{
// Since this is a Connectable<T>, the held value T is what's being read from USD,
// so replace csValue with the held T value itself. csValue must be restored before
// returning.
csValue = conn.GetValue();
// Same treatment for the type.
csType = conn.GetValueType();
}
}
// ----------------------------------------- //
// Primvar Setup.
// ----------------------------------------- //
ValueAccessor pvAccessor = null;
PrimvarBase pvBase = null;
if (isNewPrimvar)
{
pvAccessor = csValue as ValueAccessor;
pvBase = (PrimvarBase)csValue;
// Since this is a Primvar<T>, the held value T is what's being read from USD,
// so replace csVAlue with the held T value itself. csValue must be restored before
// returning.
csValue = pvAccessor.GetValue();
// Same treatment for the type.
csType = pvAccessor.GetValueType();
}
// ----------------------------------------- //
// Lookup Type Conversion Delegate.
// ----------------------------------------- //
UsdTypeBinding binding;
if (!sm_bindings.GetBinding(csType, out binding) &&
!csType.IsEnum &&
csType != typeof(object))
{
if (string.IsNullOrEmpty(ns))
{
return(false);
}
var sample = csValue as SampleBase;
if (csValue == null)
{
// This could attempt to automatically constuct the needed object, then nullable objects
// could be used instead to drive deserialization.
return(false);
}
else if (sample == null)
{
// In this case, csValue is not null, but also cannot be converted to SampleBase.
throw new ArgumentException("Type does not inherit from SampleBase: " + attrName);
}
Deserialize((SampleBase)csValue, prim, usdTime, accessMap, ref mayVary, usdNamespace: ns);
return(true);
}
// ----------------------------------------- //
// Prep to Read.
// ----------------------------------------- //
// Restore C# value to the actual property value.
if (conn != null)
{
csValue = conn;
}
else if (pvAccessor != null)
{
csValue = pvAccessor;
}
// Append "primvars:" namespace to primvars.
if (isPrimvar)
{
var joinedName = IntrinsicTypeConverter.JoinNamespace(ns, attrName);
sdfAttrName = sm_tokenCache["primvars", joinedName];
}
// Adjust time for variability.
pxr.SdfVariability variability = Reflect.GetVariability(memberInfo);
pxr.UsdTimeCode time = variability == pxr.SdfVariability.SdfVariabilityUniform
? kDefaultUsdTime
: usdTime;
// Allocate a temp VtValue.
pxr.VtValue vtValue = (pxr.VtValue)ArrayAllocator.MallocHandle(typeof(pxr.VtValue));
try {
// ----------------------------------------- //
// Read Connected Paths.
// ----------------------------------------- //
if (conn != null)
{
// Connection paths cannot be animated, so mayVary is not affected.
var sources = new pxr.SdfPathVector();
if (prim.GetAttribute(sdfAttrName).GetConnections(sources))
{
if (sources.Count > 0)
{
conn.SetConnectedPath(sources[0].ToString());
}
}
}
// ----------------------------------------- //
// Read Associated Primvar Data.
// ----------------------------------------- //
// If this is a Primvar<T>, read the associated primvar metadata and indices.
if (pvBase != null)
{
var attr = prim.GetAttribute(sdfAttrName);
if (attr)
{
var pv = new pxr.UsdGeomPrimvar(attr);
// ElementSize and Interpolation are not animatable, so they do not affect mayVary.
pvBase.elementSize = pv.GetElementSize();
pvBase.SetInterpolationToken(pv.GetInterpolation());
// Indices are a first class attribute and may vary over time.
var indices = pv.GetIndicesAttr();
if (indices)
{
if (accessMap != null)
{
if (indices.GetVariability() == pxr.SdfVariability.SdfVariabilityVarying ||
indices.ValueMightBeTimeVarying())
{
accessMap.Add(memberInfo);
mayVary |= true;
}
}
indices.Get(vtValue, time);
if (!vtValue.IsEmpty())
{
var vtIntArray = pxr.UsdCs.VtValueToVtIntArray(vtValue);
pvBase.indices = IntrinsicTypeConverter.FromVtArray(vtIntArray);
}
}
}
}
// ----------------------------------------- //
// Read the value of csValue.
// ----------------------------------------- //
if (Reflect.IsMetadata(memberInfo))
{
vtValue = prim.GetMetadata(sdfAttrName);
// Metadata cannot vary over time.
}
else if (Reflect.IsCustomData(memberInfo))
{
vtValue = prim.GetCustomDataByKey(sdfAttrName);
// Custom data is metadata, which cannot vary over time.
}
else if (Reflect.IsFusedDisplayColor(memberInfo))
{
vtValue = pxr.UsdCs.GetFusedDisplayColor(prim, time);
if (accessMap != null)
{
// Display color is actually two attributes, primvars:displayColor and
// primvars:displayOpacity.
var gprim = new pxr.UsdGeomGprim(prim);
if (gprim && gprim.GetDisplayColorAttr().ValueMightBeTimeVarying())
{
accessMap.Add(memberInfo);
mayVary |= true;
}
}
}
else if (Reflect.IsFusedTransform(memberInfo))
{
vtValue = pxr.UsdCs.GetFusedTransform(prim, time);
if (accessMap != null)
{
// Transforms are complicated :/
var xformable = new pxr.UsdGeomXformable(prim);
if (xformable)
{
bool dummy;
var orderAttr = xformable.GetXformOpOrderAttr();
if (orderAttr)
{
if (orderAttr.GetVariability() == pxr.SdfVariability.SdfVariabilityVarying &&
orderAttr.ValueMightBeTimeVarying())
{
mayVary |= true;
accessMap.Add(memberInfo);
}
else
{
foreach (var op in xformable.GetOrderedXformOps(out dummy))
{
var opAttr = op.GetAttr();
if (!opAttr)
{
continue;
}
if (opAttr.GetVariability() == pxr.SdfVariability.SdfVariabilityVarying &&
opAttr.ValueMightBeTimeVarying())
{
mayVary |= true;
accessMap.Add(memberInfo);
break;
}
} // foreach
}
} // orderAttr
} // xformable
} // mayVary
}
else
{
if (accessMap != null)
{
var attr = prim.GetAttribute(sdfAttrName);
if (attr.GetVariability() == pxr.SdfVariability.SdfVariabilityVarying &&
attr.ValueMightBeTimeVarying())
{
accessMap.Add(memberInfo);
mayVary |= true;
}
}
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);
}
// ------------------------------------------ //
// Infer C# type from USD when Type == Object
// ------------------------------------------ //
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);
}
}
// ------------------------------------------ //
// Convert USD's VtValue -> Strong C# Type.
// ------------------------------------------ //
csValue = binding.toCsObject(vtValue);
// ------------------------------------------ //
// Restore csValue.
// ------------------------------------------ //
if (conn != null && csValue != null)
{
conn.SetValue(csValue);
csValue = conn;
}
if (pvAccessor != null)
{
pvAccessor.SetValue(csValue);
csValue = pvAccessor;
}
} finally {
// Would prefer RAII handle, but introduces garbage.
ArrayAllocator.FreeHandle(vtValue);
}
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))
{
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>
/// 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);
}
