public static float GetValueScale(KeyFrameQuantization Quantization, float ValueScale = 1)
        {
            switch (Quantization)
            {
            case KeyFrameQuantization.Hermite128:       ValueScale = 1f;  break;

            case KeyFrameQuantization.Hermite64:        ValueScale *= q20; break;

            case KeyFrameQuantization.Hermite48:        ValueScale *= q16; break;

            case KeyFrameQuantization.UnifiedHermite96: ValueScale = 1f;  break;

            case KeyFrameQuantization.UnifiedHermite48: ValueScale *= q16; break;

            case KeyFrameQuantization.UnifiedHermite32: ValueScale *= q12; break;

            case KeyFrameQuantization.StepLinear64:     ValueScale = 1f;  break;

            case KeyFrameQuantization.StepLinear32:     ValueScale *= q20; break;

            default: throw new InvalidOperationException($"Invalid Segment quantization {Quantization}!");
            }

            return(ValueScale);
        }
Beispiel #2
0
        void ICustomSerialization.Deserialize(BinaryDeserializer Deserializer)
        {
            if (Deserializer.FileVersion < 0x20)
            {
                /*
                 * Older version have a pointer within the curve data,
                 * instead of storing it directly. So we read it below...
                 */
                Deserializer.BaseStream.Seek(Deserializer.Reader.ReadUInt32(), SeekOrigin.Begin);

                //We don't need this since it's already stored on Curve
                float StartFrame = Deserializer.Reader.ReadSingle();
                float EndFrame   = Deserializer.Reader.ReadSingle();

                InterpolationType = (H3DInterpolationType)Deserializer.Reader.ReadByte();
                Quantization      = (KeyFrameQuantization)Deserializer.Reader.ReadByte();

                Count = Deserializer.Reader.ReadUInt16();

                InvDuration = Deserializer.Reader.ReadSingle();
                ValueScale  = Deserializer.Reader.ReadSingle();
                ValueOffset = Deserializer.Reader.ReadSingle();
                FrameScale  = Deserializer.Reader.ReadSingle();
            }

            Deserializer.BaseStream.Seek(Deserializer.Reader.ReadUInt32(), SeekOrigin.Begin);

            for (int Index = 0; Index < Count; Index++)
            {
                KeyFrame KF;

                switch (Quantization)
                {
                case KeyFrameQuantization.Hermite128:       KF = Deserializer.Reader.ReadHermite128();       break;

                case KeyFrameQuantization.Hermite64:        KF = Deserializer.Reader.ReadHermite64();        break;

                case KeyFrameQuantization.Hermite48:        KF = Deserializer.Reader.ReadHermite48();        break;

                case KeyFrameQuantization.UnifiedHermite96: KF = Deserializer.Reader.ReadUnifiedHermite96(); break;

                case KeyFrameQuantization.UnifiedHermite48: KF = Deserializer.Reader.ReadUnifiedHermite48(); break;

                case KeyFrameQuantization.UnifiedHermite32: KF = Deserializer.Reader.ReadUnifiedHermite32(); break;

                case KeyFrameQuantization.StepLinear64:     KF = Deserializer.Reader.ReadStepLinear64();     break;

                case KeyFrameQuantization.StepLinear32:     KF = Deserializer.Reader.ReadStepLinear32();     break;

                default: throw new InvalidOperationException($"Invalid Segment quantization {Quantization}!");
                }

                KF.Frame = KF.Frame * FrameScale;
                KF.Value = KF.Value * ValueScale + ValueOffset;

                KeyFrames.Add(KF);
            }
        }
Beispiel #3
0
        void ICustomSerialization.Deserialize(BinaryDeserializer Deserializer)
        {
            if ((CurveFlags & KeyFrameCurveFlags.IsConstantValue) != 0)
            {
                float Value = Deserializer.Reader.ReadSingle();

                KeyFrames.Add(new KeyFrame(0, Value));

                return;
            }

            int CurveCount = Deserializer.Reader.ReadInt32();

            Deserializer.BaseStream.Seek(Deserializer.ReadPointer(), SeekOrigin.Begin);

            StartFrame = Deserializer.Reader.ReadSingle();
            EndFrame   = Deserializer.Reader.ReadSingle();

            uint  FormatFlags = Deserializer.Reader.ReadUInt32();
            int   KeysCount   = Deserializer.Reader.ReadInt32();
            float InvDuration = Deserializer.Reader.ReadSingle();

            Quantization = (KeyFrameQuantization)(FormatFlags >> 5);

            IsLinear = (FormatFlags & 4) != 0;

            float ValueScale  = 1;
            float ValueOffset = 0;
            float FrameScale  = 1;

            if (Quantization != KeyFrameQuantization.Hermite128 &&
                Quantization != KeyFrameQuantization.UnifiedHermite96 &&
                Quantization != KeyFrameQuantization.StepLinear64)
            {
                ValueScale  = Deserializer.Reader.ReadSingle();
                ValueOffset = Deserializer.Reader.ReadSingle();
                FrameScale  = Deserializer.Reader.ReadSingle();
            }

            for (int Index = 0; Index < KeysCount; Index++)
            {
                KeyFrame KF;

                switch (Quantization)
                {
                case KeyFrameQuantization.Hermite128:       KF = Deserializer.Reader.ReadHermite128();       break;

                case KeyFrameQuantization.Hermite64:        KF = Deserializer.Reader.ReadHermite64();        break;

                case KeyFrameQuantization.Hermite48:        KF = Deserializer.Reader.ReadHermite48();        break;

                case KeyFrameQuantization.UnifiedHermite96: KF = Deserializer.Reader.ReadUnifiedHermite96(); break;

                case KeyFrameQuantization.UnifiedHermite48: KF = Deserializer.Reader.ReadUnifiedHermite48(); break;

                case KeyFrameQuantization.UnifiedHermite32: KF = Deserializer.Reader.ReadUnifiedHermite32(); break;

                case KeyFrameQuantization.StepLinear64:     KF = Deserializer.Reader.ReadStepLinear64();     break;

                case KeyFrameQuantization.StepLinear32:     KF = Deserializer.Reader.ReadStepLinear32();     break;

                default: throw new InvalidOperationException($"Invalid Segment quantization {Quantization}!");
                }

                KF.Frame = KF.Frame * FrameScale;
                KF.Value = KF.Value * ValueScale + ValueOffset;

                KeyFrames.Add(KF);
            }
        }