private bool IsAcceptable(GXAnimDataFormat format, int scale)
        {
            foreach (var v in Values)
            {
                var value = Math.Pow(2, scale) * v;
                switch (format)
                {
                case GXAnimDataFormat.HSD_A_FRAC_U8:
                    if (v > byte.MaxValue)
                    {
                        return(false);
                    }
                    break;

                case GXAnimDataFormat.HSD_A_FRAC_S8:
                    if (v > sbyte.MaxValue)
                    {
                        return(false);
                    }
                    break;

                case GXAnimDataFormat.HSD_A_FRAC_S16:
                    if (v > short.MaxValue)
                    {
                        return(false);
                    }
                    break;

                case GXAnimDataFormat.HSD_A_FRAC_U16:
                    if (v > ushort.MaxValue)
                    {
                        return(false);
                    }
                    break;
                }
                float Estimated = (float)(Quantanize(v, format, (int)Math.Pow(2, scale)) / Math.Pow(2, scale));

                if (Math.Abs(v - Estimated) > Error)
                {
                    return(false);
                }
            }

            return(true);
        }
        private int Quantanize(float value, GXAnimDataFormat format, int scale)
        {
            switch (format)
            {
            case GXAnimDataFormat.HSD_A_FRAC_U8:
                return(Clamp((byte)(scale * value), byte.MinValue, byte.MaxValue));

            case GXAnimDataFormat.HSD_A_FRAC_S8:
                return(Clamp((sbyte)(scale * value), sbyte.MinValue, sbyte.MaxValue));

            case GXAnimDataFormat.HSD_A_FRAC_S16:
                return(Clamp((short)(scale * value), short.MinValue, short.MaxValue));

            case GXAnimDataFormat.HSD_A_FRAC_U16:
                return(Clamp((ushort)(scale * value), ushort.MinValue, ushort.MaxValue));
            }
            return(0);
        }
Exemplo n.º 3
0
        private int Quantanize(float value, GXAnimDataFormat format, int scale)
        {
            switch (format)
            {
            case GXAnimDataFormat.Byte:
                return(Clamp((byte)(scale * value), byte.MinValue, byte.MaxValue));

            case GXAnimDataFormat.SByte:
                return(Clamp((sbyte)(scale * value), sbyte.MinValue, sbyte.MaxValue));

            case GXAnimDataFormat.Short:
                return(Clamp((short)(scale * value), short.MinValue, short.MaxValue));

            case GXAnimDataFormat.UShort:
                return(Clamp((ushort)(scale * value), ushort.MinValue, ushort.MaxValue));
            }
            return(0);
        }
 private int QuantizeScaler()
 {
     if (ValueSigned)
     {
         ValueType = GXAnimDataFormat.HSD_A_FRAC_S8;
         for (int i = 0; i < 0x1F; i++)
         {
             if (IsAcceptable(ValueType, i))
             {
                 return((int)Math.Pow(2, i));
             }
         }
         ValueType = GXAnimDataFormat.HSD_A_FRAC_S16;
         for (int i = 0; i < 0x1F; i++)
         {
             if (IsAcceptable(ValueType, i))
             {
                 return((int)Math.Pow(2, i));
             }
         }
     }
     else
     {
         ValueType = GXAnimDataFormat.HSD_A_FRAC_U8;
         for (int i = 0; i < 0x1F; i++)
         {
             if (IsAcceptable(ValueType, i))
             {
                 return((int)Math.Pow(2, i));
             }
         }
         ValueType = GXAnimDataFormat.HSD_A_FRAC_U16;
         for (int i = 0; i < 0x1F; i++)
         {
             if (IsAcceptable(ValueType, i))
             {
                 return((int)Math.Pow(2, i));
             }
         }
     }
     ValueType = GXAnimDataFormat.HSD_A_FRAC_FLOAT;
     return((int)Math.Pow(2, 0));
 }
Exemplo n.º 5
0
 private int QuantizeScaler()
 {
     if (ValueSigned)
     {
         ValueType = GXAnimDataFormat.SByte;
         for (int i = 0; i < 0x1F; i++)
         {
             if (IsAcceptable(ValueType, i))
             {
                 return((int)Math.Pow(2, i));
             }
         }
         ValueType = GXAnimDataFormat.Short;
         for (int i = 0; i < 0x1F; i++)
         {
             if (IsAcceptable(ValueType, i))
             {
                 return((int)Math.Pow(2, i));
             }
         }
     }
     else
     {
         ValueType = GXAnimDataFormat.Byte;
         for (int i = 0; i < 0x1F; i++)
         {
             if (IsAcceptable(ValueType, i))
             {
                 return((int)Math.Pow(2, i));
             }
         }
         ValueType = GXAnimDataFormat.UShort;
         for (int i = 0; i < 0x1F; i++)
         {
             if (IsAcceptable(ValueType, i))
             {
                 return((int)Math.Pow(2, i));
             }
         }
     }
     ValueType = GXAnimDataFormat.Float;
     return((int)Math.Pow(2, 0));
 }
Exemplo n.º 6
0
        private static double ParseFloat(BinaryReaderExt d, GXAnimDataFormat Format, float Scale)
        {
            d.BigEndian = false;
            switch (Format)
            {
            case GXAnimDataFormat.HSD_A_FRAC_FLOAT:
                return(d.ReadSingle());

            case GXAnimDataFormat.HSD_A_FRAC_S16:
                return(d.ReadInt16() / (double)Scale);

            case GXAnimDataFormat.HSD_A_FRAC_U16:
                return(d.ReadUInt16() / (double)Scale);

            case GXAnimDataFormat.HSD_A_FRAC_S8:
                return(d.ReadSByte() / (double)Scale);

            case GXAnimDataFormat.HSD_A_FRAC_U8:
                return(d.ReadByte() / (double)Scale);

            default:
                return(0);
            }
        }
Exemplo n.º 7
0
        private static double ReadVal(HSDReader d, GXAnimDataFormat Format, float Scale)
        {
            d.BigEndian = false;
            switch (Format)
            {
            case GXAnimDataFormat.Float:
                return(d.ReadSingle());

            case GXAnimDataFormat.Short:
                return(d.ReadInt16() / (double)Scale);

            case GXAnimDataFormat.UShort:
                return(d.ReadUInt16() / (double)Scale);

            case GXAnimDataFormat.SByte:
                return(d.ReadSByte() / (double)Scale);

            case GXAnimDataFormat.Byte:
                return(d.ReadByte() / (double)Scale);

            default:
                return(0);
            }
        }