public static void PrimvarsTest() { var sample = PrimvarSample.GetTestSample(); var sample2 = new PrimvarSample(); var scene = USD.NET.Scene.Create(); scene.Write("/Foo", sample); PrintScene(scene); var prim = scene.Stage.GetPrimAtPath(new pxr.SdfPath("/Foo")); var garply = prim.GetAttribute(new pxr.TfToken("nested:foo:bar:garply")); AssertTrue(garply.GetNamespace() == new pxr.TfToken("nested:foo:bar")); var primvar = new pxr.UsdGeomPrimvar( prim.GetAttribute(new pxr.TfToken("primvars:somePrimvar"))); AssertEqual(primvar.GetElementSize(), 1); primvar = new pxr.UsdGeomPrimvar( prim.GetAttribute(new pxr.TfToken("primvars:somePrimvar1"))); AssertEqual(primvar.GetElementSize(), 1); primvar = new pxr.UsdGeomPrimvar( prim.GetAttribute(new pxr.TfToken("primvars:somePrimvar2"))); AssertEqual(primvar.GetElementSize(), 2); primvar = new pxr.UsdGeomPrimvar( prim.GetAttribute(new pxr.TfToken("primvars:skel:jointIndices"))); AssertEqual(primvar.GetElementSize(), 3); primvar = new pxr.UsdGeomPrimvar( prim.GetAttribute(new pxr.TfToken("primvars:nested:foo:bar:baz"))); AssertEqual(primvar.GetElementSize(), 4); sample2.nestedSample = new PrimvarSample.NestedSample(); scene.Read("/Foo", sample2); AssertEqual(sample.somePrimvar, sample2.somePrimvar); AssertEqual(sample.somePrimvar1, sample2.somePrimvar1); AssertEqual(sample.somePrimvar2, sample2.somePrimvar2); AssertEqual(sample.jointIndices, sample2.jointIndices); AssertEqual(sample.nestedSample.baz, sample2.nestedSample.baz); AssertEqual(sample.nestedSample.garply, sample2.nestedSample.garply); // // Test deserialization without nested object instantiated. // sample2 = new PrimvarSample(); sample2.nestedSample = null; scene.Read("/Foo", sample2); AssertEqual(sample.somePrimvar, sample2.somePrimvar); AssertEqual(sample.somePrimvar1, sample2.somePrimvar1); AssertEqual(sample.somePrimvar2, sample2.somePrimvar2); AssertEqual(sample.jointIndices, sample2.jointIndices); AssertEqual(null, sample2.nestedSample); }
static void ExportMesh(ObjectContext objContext, ExportContext exportContext, Mesh mesh, Material sharedMaterial, Material[] sharedMaterials, bool exportMeshPose = true) { string path = objContext.path; if (mesh == null) { Debug.LogWarning("Null mesh for: " + path, objContext.gameObject); return; } #if UNITY_EDITOR if (!CanReadMesh(mesh)) { #else if (!mesh.isReadable) { #endif Debug.LogError( "Mesh is not readable: " + objContext.path + ". To fix this, enable read/write in the inspector for the source asset that you are attempting to export.", objContext.gameObject); return; } var scene = exportContext.scene; bool unvarying = scene.Time == null; bool slowAndSafeConversion = exportContext.basisTransform == BasisTransformation.SlowAndSafe; var sample = (MeshSample)objContext.sample; var go = objContext.gameObject; if (mesh.bounds.center == Vector3.zero && mesh.bounds.extents == Vector3.zero) { mesh.RecalculateBounds(); } sample.extent = mesh.bounds; if (slowAndSafeConversion) { // Unity uses a forward vector that matches DirectX, but USD matches OpenGL, so a change of // basis is required. There are shortcuts, but this is fully general. sample.ConvertTransform(); sample.extent.center = UnityTypeConverter.ChangeBasis(sample.extent.center); } // Only export the mesh topology on the first frame. if (unvarying) { // TODO: Technically a mesh could be the root transform, which is not handled correctly here. // It should have the same logic for root prims as in ExportXform. sample.transform = XformExporter.GetLocalTransformMatrix( go.transform, scene.UpAxis == Scene.UpAxes.Z, new pxr.SdfPath(path).IsRootPrimPath(), exportContext.basisTransform); sample.normals = mesh.normals; sample.points = mesh.vertices; sample.tangents = mesh.tangents; sample.colors = mesh.colors; if (sample.colors != null && sample.colors.Length == 0) { sample.colors = null; } if ((sample.colors == null || sample.colors.Length == 0) && (sharedMaterial != null && sharedMaterial.HasProperty("_Color"))) { sample.colors = new Color[1]; sample.colors[0] = sharedMaterial.color.linear; } // Gah. There is no way to inspect a meshes UVs. sample.st = mesh.uv; // Set face vertex counts and indices. var tris = mesh.triangles; if (slowAndSafeConversion) { // Unity uses a forward vector that matches DirectX, but USD matches OpenGL, so a change // of basis is required. There are shortcuts, but this is fully general. for (int i = 0; i < sample.points.Length; i++) { sample.points[i] = UnityTypeConverter.ChangeBasis(sample.points[i]); if (sample.normals != null && sample.normals.Length == sample.points.Length) { sample.normals[i] = UnityTypeConverter.ChangeBasis(sample.normals[i]); } if (sample.tangents != null && sample.tangents.Length == sample.points.Length) { var w = sample.tangents[i].w; var t = UnityTypeConverter.ChangeBasis(sample.tangents[i]); sample.tangents[i] = new Vector4(t.x, t.y, t.z, w); } } for (int i = 0; i < tris.Length; i += 3) { var t = tris[i]; tris[i] = tris[i + 1]; tris[i + 1] = t; } } sample.SetTriangles(tris); UnityEngine.Profiling.Profiler.BeginSample("USD: Mesh Write"); scene.Write(path, sample); UnityEngine.Profiling.Profiler.EndSample(); // TODO: this is a bit of a half-measure, we need real support for primvar interpolation. // Set interpolation based on color count. if (sample.colors != null && sample.colors.Length == 1) { pxr.UsdPrim usdPrim = scene.GetPrimAtPath(path); var colorPrimvar = new pxr.UsdGeomPrimvar(usdPrim.GetAttribute(pxr.UsdGeomTokens.primvarsDisplayColor)); colorPrimvar.SetInterpolation(pxr.UsdGeomTokens.constant); var opacityPrimvar = new pxr.UsdGeomPrimvar(usdPrim.GetAttribute(pxr.UsdGeomTokens.primvarsDisplayOpacity)); opacityPrimvar.SetInterpolation(pxr.UsdGeomTokens.constant); } string usdMaterialPath; if (exportContext.exportMaterials && sharedMaterial != null) { if (!exportContext.matMap.TryGetValue(sharedMaterial, out usdMaterialPath)) { Debug.LogError("Invalid material bound for: " + path); } else { MaterialSample.Bind(scene, path, usdMaterialPath); } } // In USD subMeshes are represented as UsdGeomSubsets. // When there are multiple subMeshes, convert them into UsdGeomSubsets. if (mesh.subMeshCount > 1) { // Build a table of face indices, used to convert the subMesh triangles to face indices. var faceTable = new Dictionary <Vector3, int>(); for (int i = 0; i < tris.Length; i += 3) { if (!slowAndSafeConversion) { faceTable.Add(new Vector3(tris[i], tris[i + 1], tris[i + 2]), i / 3); } else { // Under slow and safe export, index 0 and 1 are swapped. // This swap will not be present in the subMesh indices, so must be undone here. faceTable.Add(new Vector3(tris[i + 1], tris[i], tris[i + 2]), i / 3); } } var usdPrim = scene.GetPrimAtPath(path); var usdGeomMesh = new pxr.UsdGeomMesh(usdPrim); // Process each subMesh and create a UsdGeomSubset of faces this subMesh targets. for (int si = 0; si < mesh.subMeshCount; si++) { int[] indices = mesh.GetTriangles(si); int[] faceIndices = new int[indices.Length / 3]; for (int i = 0; i < indices.Length; i += 3) { faceIndices[i / 3] = faceTable[new Vector3(indices[i], indices[i + 1], indices[i + 2])]; } var vtIndices = UnityTypeConverter.ToVtArray(faceIndices); var subset = pxr.UsdGeomSubset.CreateUniqueGeomSubset( usdGeomMesh, // The object of which this subset belongs. m_subMeshesToken, // An arbitrary name for the subset. pxr.UsdGeomTokens.face, // Indicator that these represent face indices vtIndices, // The actual face indices. m_materialBindToken // familyName = "materialBind" ); if (exportContext.exportMaterials) { if (si >= sharedMaterials.Length || !sharedMaterials[si] || !exportContext.matMap.TryGetValue(sharedMaterials[si], out usdMaterialPath)) { Debug.LogWarning("Invalid material bound for: " + path + "\n" + (si >= sharedMaterials.Length ? "More submeshes than materials assigned." : (!sharedMaterials[si] ? "Submesh " + si + " has null material" : "ExportMap can't map material"))); } else { MaterialSample.Bind(scene, subset.GetPath(), usdMaterialPath); } } } } } else { // Only write the transform when animating. var meshSample = new MeshSampleBase(); meshSample.extent = sample.extent; meshSample.transform = XformExporter.GetLocalTransformMatrix( go.transform, scene.UpAxis == Scene.UpAxes.Z, new pxr.SdfPath(path).IsRootPrimPath(), exportContext.basisTransform); if (exportMeshPose) { meshSample.points = mesh.vertices; // Set face vertex counts and indices. var tris = mesh.triangles; if (slowAndSafeConversion) { // Unity uses a forward vector that matches DirectX, but USD matches OpenGL, so a change // of basis is required. There are shortcuts, but this is fully general. for (int i = 0; i < meshSample.points.Length; i++) { meshSample.points[i] = UnityTypeConverter.ChangeBasis(meshSample.points[i]); } for (int i = 0; i < tris.Length; i += 3) { var t = tris[i]; tris[i] = tris[i + 1]; tris[i + 1] = t; } } sample.SetTriangles(tris); } UnityEngine.Profiling.Profiler.BeginSample("USD: Mesh Write"); scene.Write(path, meshSample); UnityEngine.Profiling.Profiler.EndSample(); } } }
/// <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); }