/// <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); }