コード例 #1
0
 internal static W3dMotionChannelAdaptiveDeltaData Parse(
     BinaryReader reader,
     uint numTimeCodes,
     W3dAnimationChannelType channelType,
     int vectorLen,
     W3dAdaptiveDeltaBitCount bitCount)
 {
     return(new W3dMotionChannelAdaptiveDeltaData
     {
         Scale = reader.ReadSingle(),
         Data = W3dAdaptiveDeltaData.Parse(
             reader,
             numTimeCodes,
             channelType,
             vectorLen,
             bitCount)
     });
 }
コード例 #2
0
        public sbyte[] GetDeltas(W3dAdaptiveDeltaBitCount bitCount)
        {
            var numBits = (int)bitCount;

            var deltas = new sbyte[16];

            for (var i = 0; i < DeltaBytes.Length; ++i)
            {
                switch (numBits)
                {
                case 4:
                    deltas[i * 2] = DeltaBytes[i];
                    if ((deltas[i * 2] & 8) != 0)
                    {
                        deltas[i * 2] = (sbyte)(deltas[i * 2] | 0xF0);
                    }
                    else
                    {
                        deltas[i * 2] &= 0x0F;
                    }
                    deltas[i * 2 + 1] = (sbyte)(DeltaBytes[i] >> 4);
                    break;

                case 8:
                    var val = (byte)DeltaBytes[i];
                    //do a bitflip
                    if ((val & 0x80) != 0)
                    {
                        val &= 0x7F;
                    }
                    else
                    {
                        val |= 0x80;
                    }
                    deltas[i] = (sbyte)val;
                    break;

                default:
                    throw new ArgumentOutOfRangeException(nameof(bitCount));
                }
            }

            return(deltas);
        }
コード例 #3
0
        internal static W3dAdaptiveDeltaData Parse(
            BinaryReader reader,
            uint numFrames,
            W3dAnimationChannelType type,
            int vectorLength,
            W3dAdaptiveDeltaBitCount bitCount)
        {
            var count = (numFrames + 15) >> 4;

            // First read all initial values
            var result = new W3dAdaptiveDeltaData
            {
                BitCount     = bitCount,
                VectorLength = vectorLength,
                InitialDatum = W3dAnimationChannelDatum.Parse(reader, type)
            };

            var numBits = (int)bitCount;

            // Then read the interleaved delta blocks
            var deltaBlocks = new W3dAdaptiveDeltaBlock[count * vectorLength];

            for (var i = 0; i < count; i++)
            {
                for (var j = 0; j < vectorLength; j++)
                {
                    deltaBlocks[(i * vectorLength) + j] = W3dAdaptiveDeltaBlock.Parse(
                        reader,
                        j,
                        numBits);
                }
            }
            result.DeltaBlocks = deltaBlocks;

            return(result);
        }
コード例 #4
0
        internal static W3dAdaptiveDeltaAnimationChannel Parse(BinaryReader reader, W3dParseContext context, W3dAdaptiveDeltaBitCount bitCount)
        {
            return(ParseChunk(reader, context, header =>
            {
                var result = new W3dAdaptiveDeltaAnimationChannel
                {
                    NumTimeCodes = reader.ReadUInt32(),
                    Pivot = reader.ReadUInt16(),
                    VectorLength = reader.ReadByte(),
                    ChannelType = reader.ReadByteAsEnum <W3dAnimationChannelType>(),
                    Scale = reader.ReadSingle(),
                };

                W3dAnimationChannel.ValidateChannelDataSize(result.ChannelType, result.VectorLength);

                result.Data = W3dAdaptiveDeltaData.Parse(
                    reader,
                    result.NumTimeCodes,
                    result.ChannelType,
                    result.VectorLength,
                    bitCount);

                // Skip 3 unknown bytes at chunk end.
                reader.BaseStream.Seek(3, SeekOrigin.Current);

                return result;
            }));
        }