Esempio n. 1
0
        /// <summary>
        /// Get a binding from a USD type
        /// </summary>
        /// <remarks>
        /// Used the C# type needs to be derived from the USD type.
        /// Example: UVs can be of type float2, float3, texcoord2f, texcoord2f
        /// </remarks>
        public bool GetReverseBinding(pxr.SdfValueTypeName key, out UsdTypeBinding binding)
        {
            // Check if the given sdf type name is an alias
            // https://graphics.pixar.com/usd/docs/api/_usd__page__datatypes.html#Usd_Roles
            string name;
            bool   match = true;

            if (!typeAliases.TryGetValue(key.GetAsToken(), out name))
            {
                name  = key.GetAsToken();
                match = false;
            }

            // TODO: we could keep a reverse mapping, but waiting for deeper performance analysis first.
            foreach (var kvp in bindings)
            {
                if (kvp.Value.sdfTypeName.GetAsToken() == name)
                {
                    binding = kvp.Value;
                    return(true);
                }
            }
            binding = new UsdTypeBinding();
            return(false);
        }
Esempio n. 2
0
        public bool GetBinding(Type key, out UsdTypeBinding binding)
        {
            lock (UsdIo.Bindings) {
                if (bindings.TryGetValue(key, out binding))
                {
                    return(true);
                }

                if (!key.IsEnum)
                {
                    return(false);
                }

                //
                // Enumerations.
                // To reduce special cases of client code, all enums are special cased into a single
                // converter. This converter is only selected if no specific type has been registered.
                //
                binding = BindEnum(key);

                // Memoize the binding so it doesn't get regenerated on every call.

                bindings.Add(key, binding);
            }

            return(true);
        }
 public bool GetReverseBinding(Type key, out UsdTypeBinding binding)
 {
     // TODO: we could keep a reverse mapping, but waiting for deeper performance analysis first.
     foreach (var kvp in bindings)
     {
         if (kvp.Value.toCsObject.Method.GetParameters()[0].ParameterType == key)
         {
             binding = kvp.Value;
             return(true);
         }
     }
     binding = new UsdTypeBinding();
     return(false);
 }
 public bool GetReverseBinding(pxr.SdfValueTypeName key, out UsdTypeBinding binding)
 {
     // TODO: we could keep a reverse mapping, but waiting for deeper performance analysis first.
     foreach (var kvp in bindings)
     {
         if (kvp.Value.sdfTypeName == key)
         {
             binding = kvp.Value;
             return(true);
         }
     }
     binding = new UsdTypeBinding();
     return(false);
 }
        public void BindNativeType(Type csType, pxr.SdfValueTypeName sdfName)
        {
            string name;

            if (!typeNameMapping.TryGetValue(csType.Name, out name))
            {
                name = csType.Name;
            }
            var converter = typeof(pxr.UsdCs).GetMethod("VtValueTo" + name,
                                                        new Type[] { typeof(pxr.VtValue) });

            if (converter == null)
            {
                throw new ArgumentException(string.Format("No VtValueTo... converter found for type {0}, VtValueTo{1}",
                                                          csType.ToString(), name));
            }
            bindings[csType] = new UsdTypeBinding(DefaultConversions.ToVtValue,
                                                  (x) => converter.Invoke(null, new object[] { x }),
                                                  sdfName);
        }
Esempio n. 6
0
        /// <summary>
        /// Binds the specified C# type to the given USD array and scene description (Sdf) types,
        /// looking for ConverterT.ToVtArray(csType) and ConverterT.FromVtArray(vtArrayType).
        /// </summary>
        ///
        /// <typeparam name="ConverterT">
        /// The C# class type providing type conversion rules ToVtArray and FromVtArray.
        /// </typeparam>
        ///
        /// <param name="csType">The C# type to be mapped to USD</param>
        /// <param name="vtArrayType">The USD C++ value type (Vt)</param>
        /// <param name="sdfName">The USD scene description (Sdf) type</param>
        ///
        /// TODO: The C++ type can be inferred from the Sdf type, so vtArrayType is not needed.
        ///
        public void BindArrayType <ConverterT>(Type csType,
                                               Type vtArrayType,
                                               pxr.SdfValueTypeName sdfName,
                                               string methodNamePrefix = "")
        {
            var csToVtArray = typeof(ConverterT)
                              .GetMethod(methodNamePrefix + "ToVtArray", new Type[] { csType });

            if (csToVtArray == null)
            {
                throw new ArgumentException(string.Format("No ToVtArray overload found for type {0}",
                                                          csType.ToString()));
            }

            var vtToCsArray = typeof(ConverterT)
                              .GetMethod(methodNamePrefix + "FromVtArray", new Type[] { vtArrayType });

            if (vtToCsArray == null)
            {
                throw new ArgumentException(string.Format("No FromVtArray overload found for type {0}",
                                                          vtArrayType.ToString()));
            }

            var valToVtArray = typeof(pxr.UsdCs).GetMethod("VtValueTo" + vtArrayType.Name,
                                                           new Type[] { typeof(pxr.VtValue), vtArrayType });

            if (valToVtArray == null)
            {
                throw new ArgumentException(string.Format("No VtValueTo{...} converter found for type {0}",
                                                          vtArrayType.ToString()));
            }

            var           copyConverter = (ToCsCopyConverter)CodeGen.EmitToCs <ToCsCopyConverter>(valToVtArray, vtToCsArray);
            ToCsConverter toCs          = (vtValue) => ToCsConvertHelper(vtValue, vtArrayType, copyConverter);
            ToVtConverter toVt          =
                (ToVtConverter)CodeGen.EmitToVt <ToVtConverter>(csToVtArray, csType, vtArrayType);

            bindings[csType] = new UsdTypeBinding(toVt, toCs, sdfName);
        }
        public bool GetBinding(Type key, out UsdTypeBinding binding)
        {
            lock (UsdIo.Bindings) {
                // First try the exact type requested.
                if (bindings.TryGetValue(key, out binding))
                {
                    return(true);
                }

                // If the first lookup failed, perhaps this is a nullable type?
                if (key.IsGenericType && key.GetGenericTypeDefinition() == typeof(Nullable <>) &&
                    bindings.TryGetValue(key.GetGenericArguments()[0], out binding))
                {
                    return(true);
                }

                // If this is an Enum type, then use the generic Enum handler.
                if (!key.IsEnum)
                {
                    return(false);
                }

                //
                // Enumerations.
                // To reduce special cases of client code, all enums are special cased into a single
                // converter. This converter is only selected if no specific type has been registered.
                //
                binding = BindEnum(key);

                // Memoize the binding so it doesn't get regenerated on every call.

                bindings.Add(key, binding);
            }

            return(true);
        }
        private void RegisterIntrinsicTypes()
        {
            // --------------------------------------------------------------------------------------- //
            // Establish bindings from intrinsic C# type -> USD C++ type -> USD Type
            // --------------------------------------------------------------------------------------- //

            // TODO: The C++ -> USD type could probably be discovered at runtime.
            //       Note that multiple USD types map to a single C++ type, so the mapping
            //       needs to be discovered from USD type -> C++ type. The C++ type is known
            //       by the TfType system, but it's unclear how to go from C++ type to C# type.

            // --------------------------------------------------------------------------------------- //

            //
            // Custom C# conversions
            //

            // The bytes version of Guid, which generates less garbage, can't be used until versioning is
            // more fully supported.

            //bindings[typeof(Guid)] = new UsdTypeBinding(GuidToVt_Bytes, GuidToCs_Bytes, SdfValueTypeNames.UCharArray);
            bindings[typeof(Guid)] = new UsdTypeBinding(GuidToVt_String, GuidToCs_String, SdfValueTypeNames.String);

            /*
             * These throw exceptions because there is no VtValueTo...ListOp, because those types are not declared in
             * SdfValueTypeNames. Bug filed: https://github.com/PixarAnimationStudios/USD/issues/639
             *
             * BindNativeType(typeof(pxr.SdfInt64ListOp), SdfValueTypeNames.Int64);
             * BindNativeType(typeof(pxr.SdfUInt64ListOp), SdfValueTypeNames.UInt64);
             * BindNativeType(typeof(pxr.SdfIntListOp), SdfValueTypeNames.Int);
             * BindNativeType(typeof(pxr.SdfUIntListOp), SdfValueTypeNames.UInt);
             * BindNativeType(typeof(pxr.SdfStringListOp), SdfValueTypeNames.String);
             * BindNativeType(typeof(pxr.SdfTokenListOp), SdfValueTypeNames.Token);
             * BindNativeType(typeof(pxr.SdfReferenceListOp), SdfValueTypeNames.Asset);
             * BindNativeType(typeof(pxr.SdfPathListOp), SdfValueTypeNames.String);
             */

            //
            // Bool
            //
            BindNativeType(typeof(bool), SdfValueTypeNames.Bool);
            BindNativeType(typeof(pxr.VtBoolArray), SdfValueTypeNames.BoolArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(bool[]), typeof(pxr.VtBoolArray), SdfValueTypeNames.BoolArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(List <bool>), typeof(pxr.VtBoolArray), SdfValueTypeNames.BoolArray, "List");

            //
            // UChar/byte
            //
            BindNativeType(typeof(byte), SdfValueTypeNames.UChar);
            BindNativeType(typeof(pxr.VtUCharArray), SdfValueTypeNames.UCharArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(byte[]), typeof(pxr.VtUCharArray), SdfValueTypeNames.UCharArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(List <byte>), typeof(pxr.VtUCharArray), SdfValueTypeNames.UCharArray, "List");

            //
            // String
            //
            BindNativeType(typeof(string), SdfValueTypeNames.String);
            BindNativeType(typeof(pxr.TfToken), SdfValueTypeNames.Token);
            BindNativeType(typeof(pxr.VtStringArray), SdfValueTypeNames.StringArray);
            BindNativeType(typeof(pxr.VtTokenArray), SdfValueTypeNames.TokenArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(string[]), typeof(pxr.VtTokenArray), SdfValueTypeNames.TokenArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(List <string>), typeof(pxr.VtTokenArray), SdfValueTypeNames.TokenArray, "List");

            //
            // SdfAssetPath
            //
            //BindType(typeof(pxr.SdfAssetPath), new UsdTypeBinding((obj) => new pxr.VtValue((pxr.SdfAssetPath)obj), (obj) => (pxr.SdfAssetPath)obj, SdfValueTypeNames.Asset));
            BindNativeType(typeof(pxr.SdfAssetPath), SdfValueTypeNames.Asset);
            BindArrayType <IntrinsicTypeConverter>(typeof(pxr.SdfAssetPath[]), typeof(pxr.SdfAssetPathArray), SdfValueTypeNames.AssetArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(List <pxr.SdfAssetPath>), typeof(pxr.SdfAssetPathArray), SdfValueTypeNames.AssetArray, "List");

            //
            // Int
            //
            BindNativeType(typeof(int), SdfValueTypeNames.Int);
            BindNativeType(typeof(pxr.VtIntArray), SdfValueTypeNames.IntArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(int[]), typeof(pxr.VtIntArray), SdfValueTypeNames.IntArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(List <int>), typeof(pxr.VtIntArray), SdfValueTypeNames.IntArray, "List");

            //
            // UInt
            //
            BindNativeType(typeof(uint), SdfValueTypeNames.UInt);
            BindNativeType(typeof(pxr.VtUIntArray), SdfValueTypeNames.UIntArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(uint[]), typeof(pxr.VtUIntArray), SdfValueTypeNames.UIntArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(List <uint>), typeof(pxr.VtUIntArray), SdfValueTypeNames.UIntArray, "List");

            //
            // Long
            //
            BindNativeType(typeof(long), SdfValueTypeNames.Int64);
            BindNativeType(typeof(pxr.VtInt64Array), SdfValueTypeNames.Int64Array);
            BindArrayType <IntrinsicTypeConverter>(typeof(long[]), typeof(pxr.VtInt64Array), SdfValueTypeNames.Int64Array);
            BindArrayType <IntrinsicTypeConverter>(typeof(List <long>), typeof(pxr.VtInt64Array), SdfValueTypeNames.Int64Array, "List");

            //
            // ULong
            //
            BindNativeType(typeof(ulong), SdfValueTypeNames.UInt64);
            BindNativeType(typeof(pxr.VtUInt64Array), SdfValueTypeNames.UInt64Array);
            BindArrayType <IntrinsicTypeConverter>(typeof(ulong[]), typeof(pxr.VtUInt64Array), SdfValueTypeNames.UInt64Array);
            BindArrayType <IntrinsicTypeConverter>(typeof(List <ulong>), typeof(pxr.VtUInt64Array), SdfValueTypeNames.UInt64Array, "List");

            //
            // Half
            //
            BindNativeType(typeof(pxr.GfHalf), SdfValueTypeNames.Half);
            BindNativeType(typeof(pxr.VtHalfArray), SdfValueTypeNames.HalfArray);
            BindNativeType(typeof(pxr.VtVec2hArray), SdfValueTypeNames.Half2Array);
            BindNativeType(typeof(pxr.VtVec3hArray), SdfValueTypeNames.Half3Array);
            BindNativeType(typeof(pxr.VtVec4hArray), SdfValueTypeNames.Half4Array);

            //
            // Float
            //
            BindNativeType(typeof(float), SdfValueTypeNames.Float);
            BindNativeType(typeof(pxr.VtFloatArray), SdfValueTypeNames.FloatArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(float[]), typeof(pxr.VtFloatArray), SdfValueTypeNames.FloatArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(List <float>), typeof(pxr.VtFloatArray), SdfValueTypeNames.FloatArray, "List");

            //
            // Double
            //
            BindNativeType(typeof(double), SdfValueTypeNames.Double);
            BindNativeType(typeof(pxr.VtDoubleArray), SdfValueTypeNames.DoubleArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(double[]), typeof(pxr.VtDoubleArray), SdfValueTypeNames.DoubleArray);
            BindArrayType <IntrinsicTypeConverter>(typeof(List <double>), typeof(pxr.VtDoubleArray), SdfValueTypeNames.DoubleArray, "List");

            //
            // Quaternion
            //
            BindNativeType(typeof(pxr.GfQuath), SdfValueTypeNames.Quath);
            BindNativeType(typeof(pxr.VtQuathArray), SdfValueTypeNames.QuathArray);

            BindNativeType(typeof(pxr.GfQuatf), SdfValueTypeNames.Quatf);
            BindNativeType(typeof(pxr.VtQuatfArray), SdfValueTypeNames.QuatfArray);

            BindNativeType(typeof(pxr.GfQuatd), SdfValueTypeNames.Quatd);
            BindNativeType(typeof(pxr.VtQuatdArray), SdfValueTypeNames.QuatdArray);

            // Below the Vt array types are commented out, because they will be found in reverse
            // binding searches, which we don't want. Still, it is desireable to be able to
            // serialize these types, though not a primary use case.

            //
            // Vec2
            //
            BindNativeType(typeof(pxr.GfVec2i), SdfValueTypeNames.Int2);
            BindNativeType(typeof(pxr.GfVec2h), SdfValueTypeNames.Half2);
            //BindNativeType(typeof(pxr.VtVec2hArray), SdfValueTypeNames.Half2Array);

            BindNativeType(typeof(pxr.GfVec2f), SdfValueTypeNames.Float2);
            //BindNativeType(typeof(pxr.VtVec2fArray), SdfValueTypeNames.Float2Array);

            //
            // Vec3
            //
            BindNativeType(typeof(pxr.GfVec3i), SdfValueTypeNames.Int3);
            //BindNativeType(typeof(pxr.VtVec3iArray), SdfValueTypeNames.Int3Array);
            BindNativeType(typeof(pxr.GfVec3h), SdfValueTypeNames.Half3);
            //BindNativeType(typeof(pxr.VtVec3hArray), SdfValueTypeNames.Half3Array);

            BindNativeType(typeof(pxr.GfVec3f), SdfValueTypeNames.Float3);
            //BindNativeType(typeof(pxr.VtVec3fArray), SdfValueTypeNames.Float3Array);

            //
            // Vec4
            //
            BindNativeType(typeof(pxr.GfVec4i), SdfValueTypeNames.Int4);
            //BindNativeType(typeof(pxr.VtVec4iArray), SdfValueTypeNames.Int4Array);
            BindNativeType(typeof(pxr.GfVec4h), SdfValueTypeNames.Half4);
            //BindNativeType(typeof(pxr.VtVec4hArray), SdfValueTypeNames.Half4Array);

            BindNativeType(typeof(pxr.GfVec4f), SdfValueTypeNames.Float4);
            //BindNativeType(typeof(pxr.VtVec4fArray), SdfValueTypeNames.Float4Array);

            // --------------------------------------------------------------------------------------- //
        }
        /// <summary>
        /// Binds the specified C# type to the given USD array and scene description (Sdf) types,
        /// looking for ConverterT.ToVtArray(csType) and ConverterT.FromVtArray(vtArrayType).
        /// </summary>
        ///
        /// <typeparam name="ConverterT">
        /// The C# class type providing type conversion rules ToVtArray and FromVtArray.
        /// </typeparam>
        ///
        /// <param name="csType">The C# type to be mapped to USD</param>
        /// <param name="vtArrayType">The USD C++ value type (Vt)</param>
        /// <param name="sdfName">The USD scene description (Sdf) type</param>
        ///
        /// TODO: The C++ type can be inferred from the Sdf type, so vtArrayType is not needed.
        ///
        public void BindArrayType <ConverterT>(Type csType,
                                               Type vtArrayType,
                                               pxr.SdfValueTypeName sdfName,
                                               string methodNamePrefix = "")
        {
            // ConverterT and the function being found will be something like:
            //   class IntrinsicTypeConverter {
            //     static public VtTokenArray ToVtArray(string[] input);
            //
            var csToVtArray = typeof(ConverterT)
                              .GetMethod(methodNamePrefix + "ToVtArray", new Type[] { csType });

            if (csToVtArray == null)
            {
                throw new ArgumentException(string.Format("No ToVtArray overload found for type {0}",
                                                          csType.ToString()));
            }

            // ConverterT and the function being found will be something like:
            //   class IntrinsicTypeConverter {
            //     static public string[] FromVtArray(VtTokenArray input);
            //
            var vtToCsArray = typeof(ConverterT)
                              .GetMethod(methodNamePrefix + "FromVtArray", new Type[] { vtArrayType });

            if (vtToCsArray == null)
            {
                throw new ArgumentException(string.Format("No FromVtArray overload found for type {0}",
                                                          vtArrayType.ToString()));
            }

            // The specific UsdCs method being located here will be somthing like:
            //   class UsdCs {
            //     public static void VtValueToVtTokenArray(VtValue value, VtTokenArray output);
            //
            var valToVtArray = typeof(pxr.UsdCs).GetMethod("VtValueTo" + vtArrayType.Name,
                                                           new Type[] { typeof(pxr.VtValue), vtArrayType });

            if (valToVtArray == null)
            {
                throw new ArgumentException(string.Format("No VtValueTo{...} converter found for type {0}",
                                                          vtArrayType.ToString()));
            }

            // The following code constructs functions to:
            //
            //   1) Convert the VtValue (type-erased container) to a specific VtArray<T> type and then
            //      convert the VtArray<T> to a native C# type.
            //
            //   2) Convert a strongly typed C# array to a strongly typed VtArray<T> and then
            //      convert the VtArray<T> to a type-erased VtValue.
            //
            // For example, to will convert:
            //
            //   1) VtValue -> VtArray<TfToken> -> string[]
            //   2) string[] -> VtArray<TfToken> -> VtValue
            //

            ToCsConverter toCs = null;
            ToVtConverter toVt = null;


            if (IsCodeGenEnabled())
            {
                // EmitToCs and EmitToVt are not defined when not using NET_4_6
#if NET_4_6
                var copyConverter = (ToCsCopyConverter)CodeGen.EmitToCs <ToCsCopyConverter>(valToVtArray, vtToCsArray);
                toCs = (vtValue) => ToCsConvertHelper(vtValue, vtArrayType, copyConverter);
                toVt = (ToVtConverter)CodeGen.EmitToVt <ToVtConverter>(csToVtArray, csType, vtArrayType);
#endif
            }
            else
            {
                // In .NET2 or when IL2CPP is enabled , we cannot dynamically emit code.
                // Instead, we use late binding, which is slower, but also doesn't crash.
                // In the future, we should generate code to do these conversions, rather than using late binding.
                toCs = (vtValue) => ToCsDynamicConvertHelper(vtValue, vtArrayType, valToVtArray, vtToCsArray);
                toVt = CsArrayToVtValue(csToVtArray, csType, vtArrayType);
            }

            bindings[csType] = new UsdTypeBinding(toVt, toCs, sdfName);
        }
 public void BindType(Type csType, UsdTypeBinding binding)
 {
     bindings[csType] = binding;
 }