static void DecomposeSingle(XmbVariant v, out RawVariantType t, out uint data)
        {
            t = RawVariantType.Single;
            float single = v.Single;

            if (SingleFixedPoint.InRange(single))
            {
                t    = RawVariantType.FixedPoint;
                data = SingleFixedPoint.FromSingle(single);
            }
            else if (Bitwise.Single24.InRange(single))
            {
                t    = RawVariantType.Single24;
                data = Bitwise.Single24.FromSingle(single);
            }
            else
            {
                data = v.Offset;
            }
        }
        static void Compose(out XmbVariant v, uint data)
        {
            v = XmbVariant.Empty;

            RawVariantType   type   = GetType(data);
            RawVariantLength length = GetLength(data);
            RawVariantFlags  flags  = GetFlags(data);

            // Get the actual data value
            data &= kValueBitMask;

            switch (type)
            {
                #region Single
            case RawVariantType.Single24:
                v.Type   = XmbVariantType.Single;
                v.Single = Bitwise.Single24.ToSingle(data);
                break;

            case RawVariantType.Single:
                v.Type       = XmbVariantType.Single;
                v.IsIndirect = (flags & RawVariantFlags.Offset) != 0;                         // should always be true
                v.Offset     = data;
                break;

            case RawVariantType.FixedPoint:
                v.Type   = XmbVariantType.Single;
                v.Single = SingleFixedPoint.ToSingle(data);
                break;
                #endregion

                #region Int
            case RawVariantType.Int24:
                Int24ToVariant(ref v, flags, data);
                break;

            case RawVariantType.Int:
                v.Type       = XmbVariantType.Int;
                v.IsUnsigned = (flags & RawVariantFlags.Unsigned) != 0;
                v.IsIndirect = (flags & RawVariantFlags.Offset) != 0;                         // should always be true
                v.Offset     = data;
                break;
                #endregion

                #region Double
            case RawVariantType.Double:
                v.Type       = XmbVariantType.Double;
                v.IsIndirect = (flags & RawVariantFlags.Offset) != 0;                         // should always be true
                v.Offset     = data;
                break;
                #endregion

                #region Bool
            case RawVariantType.Bool:
                v.Type = XmbVariantType.Bool;
                v.Bool = data != 0;
                break;
                #endregion

                #region String
            case RawVariantType.StringAnsi:
                v.Type       = XmbVariantType.String;
                v.IsIndirect = (flags & RawVariantFlags.Offset) != 0;
                v.IsUnicode  = false;
                break;

            case RawVariantType.StringUnicode:
                v.Type       = XmbVariantType.String;
                v.IsIndirect = (flags & RawVariantFlags.Offset) != 0;
                v.IsUnicode  = true;
                break;
                #endregion

                #region Vector
            case RawVariantType.Vector:
                v.Type         = XmbVariantType.Vector;
                v.VectorLength = RawLengthToByte(length);
                v.IsIndirect   = (flags & RawVariantFlags.Offset) != 0;                       // should always be true
                v.Offset       = data;
                break;
                #endregion
            }

            if (v.Type == XmbVariantType.String)
            {
                StringToVariant(ref v, data);
            }
        }
 public static bool SingleRequiresIndirectStorage(float single)
 {
     return(!SingleFixedPoint.InRange(single) && !Bitwise.Single24.InRange(single));
 }