Пример #1
0
        public void Reload(VisibilityAnim anim)
        {
            Name       = anim.Name;
            FrameCount = anim.FrameCount;
            FrameRate  = 60.0f;
            Loop       = anim.Flags.HasFlag(VisibilityAnimFlags.Looping);

            if (anim.Names == null)
            {
                return;
            }

            AnimGroups.Clear();
            for (int i = 0; i < anim.Names.Count; i++)
            {
                var baseValue = anim.BaseDataList[i];

                BoneAnimGroup group = new BoneAnimGroup();
                group.Name = anim.Names[i];
                AnimGroups.Add(group);

                group.Track.KeyFrames.Add(new STKeyFrame()
                {
                    Frame = 0, Value = baseValue ? 1 : 0
                });

                foreach (var curve in anim.Curves)
                {
                    if (curve.AnimDataOffset == i)
                    {
                        BfresAnimations.GenerateKeys(group.Track, curve);
                    }
                }
            }
        }
Пример #2
0
        public void Reload(CameraAnim anim)
        {
            Name       = anim.Name;
            FrameCount = anim.FrameCount;
            FrameRate  = 60.0f;
            Loop       = anim.Flags.HasFlag(CameraAnimFlags.Looping);

            CameraAnimGroup group = new CameraAnimGroup();

            group.Name     = anim.Name;
            group.IsOrtho  = !anim.Flags.HasFlag(CameraAnimFlags.Perspective);
            group.IsLookat = !anim.Flags.HasFlag(CameraAnimFlags.EulerZXY);

            group.PositionX.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Position.X));
            group.PositionY.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Position.Y));
            group.PositionZ.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Position.Z));
            group.RotationX.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Rotation.X));
            group.RotationY.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Rotation.Y));
            group.RotationZ.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Rotation.Z));
            group.Twist.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Twist));
            group.ClipNear.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.ClipNear));
            group.ClipFar.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.ClipFar));
            group.AspectRatio.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.AspectRatio));
            group.FieldOfView.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.FieldOfView));

            AnimGroups.Clear();
            AnimGroups.Add(group);
            for (int i = 0; i < anim.Curves.Count; i++)
            {
                var curve = anim.Curves[i];
                switch ((CameraAnimDataOffset)curve.AnimDataOffset)
                {
                case CameraAnimDataOffset.PositionX: BfresAnimations.GenerateKeys(group.PositionX, curve); break;

                case CameraAnimDataOffset.PositionY: BfresAnimations.GenerateKeys(group.PositionY, curve); break;

                case CameraAnimDataOffset.PositionZ: BfresAnimations.GenerateKeys(group.PositionZ, curve); break;

                case CameraAnimDataOffset.RotationX: BfresAnimations.GenerateKeys(group.RotationX, curve); break;

                case CameraAnimDataOffset.RotationY: BfresAnimations.GenerateKeys(group.RotationY, curve); break;

                case CameraAnimDataOffset.RotationZ: BfresAnimations.GenerateKeys(group.RotationZ, curve); break;

                case CameraAnimDataOffset.Twist: BfresAnimations.GenerateKeys(group.Twist, curve); break;

                case CameraAnimDataOffset.ClipNear: BfresAnimations.GenerateKeys(group.ClipNear, curve); break;

                case CameraAnimDataOffset.ClipFar: BfresAnimations.GenerateKeys(group.ClipFar, curve); break;

                case CameraAnimDataOffset.AspectRatio: BfresAnimations.GenerateKeys(group.AspectRatio, curve); break;

                case CameraAnimDataOffset.FieldOFView: BfresAnimations.GenerateKeys(group.FieldOfView, curve); break;
                }
            }
        }
        public void Reload(ShapeAnim anim)
        {
            Name       = anim.Name;
            FrameCount = anim.FrameCount;
            FrameRate  = 60.0f;
            Loop       = anim.Flags.HasFlag(ShapeAnimFlags.Looping);

            AnimGroups.Clear();
            foreach (var shapeAnim in anim.VertexShapeAnims)
            {
                var group = new ShapeAnimGroup();
                AnimGroups.Add(group);
                group.Name = shapeAnim.Name;

                //Get the shape keys used for animating
                int baseIndex = 0;
                for (int i = 0; i < shapeAnim.KeyShapeAnimInfos.Count; i++)
                {
                    int startBaseIndex = shapeAnim.KeyShapeAnimInfos.Count - shapeAnim.BaseDataList.Length;

                    var keyShapeInfo = shapeAnim.KeyShapeAnimInfos[i];

                    //Get the curve index for animated indices
                    int curveIndex = keyShapeInfo.CurveIndex;

                    //Make a new sampler track using step interpolation
                    var track = new KeyShapeTrack();
                    track.InterpolationType = STInterpoaltionType.Step;
                    track.Name = keyShapeInfo.Name;

                    if (group.BaseTarget == null && curveIndex == -1)
                    {
                        group.BaseTarget = track;
                    }

                    if (curveIndex != -1)
                    {
                        BfresAnimations.GenerateKeys(track, shapeAnim.Curves[curveIndex]);
                    }
                    else if (i >= startBaseIndex)
                    {
                        float baseWeight = shapeAnim.BaseDataList[baseIndex];
                        track.KeyFrames.Add(new STKeyFrame(0, baseWeight));
                        baseIndex++;
                    }

                    group.Tracks.Add(track);
                }
            }
        }
        public void Reload(SkeletalAnim anim)
        {
            SkeletalAnim = anim;
            Name         = anim.Name;
            FrameCount   = anim.FrameCount;
            FrameRate    = 60.0f;
            Loop         = anim.Loop;

            AnimGroups.Clear();
            foreach (var boneAnim in anim.BoneAnims)
            {
                var group = new BoneAnimGroup();
                AnimGroups.Add(group);

                group.Name = boneAnim.Name;
                if (anim.FlagsRotate == SkeletalAnimFlagsRotate.Quaternion)
                {
                    group.UseQuaternion = true;
                }

                float scale = GLContext.PreviewScale;

                //Set the base data for the first set of keys if used
                if (boneAnim.FlagsBase.HasFlag(BoneAnimFlagsBase.Translate))
                {
                    group.Translate.X.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Translate.X));
                    group.Translate.Y.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Translate.Y));
                    group.Translate.Z.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Translate.Z));
                }
                if (boneAnim.FlagsBase.HasFlag(BoneAnimFlagsBase.Rotate))
                {
                    group.Rotate.X.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Rotate.X));
                    group.Rotate.Y.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Rotate.Y));
                    group.Rotate.Z.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Rotate.Z));
                    group.Rotate.W.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Rotate.Z));
                }
                if (boneAnim.FlagsBase.HasFlag(BoneAnimFlagsBase.Scale))
                {
                    group.Scale.X.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Scale.X));
                    group.Scale.Y.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Scale.Y));
                    group.Scale.Z.KeyFrames.Add(new STKeyFrame(0, boneAnim.BaseData.Scale.Z));
                }

                if (boneAnim.ApplySegmentScaleCompensate)
                {
                    group.UseSegmentScaleCompensate = true;
                }

                //Generate keyed data from the curves
                foreach (var curve in boneAnim.Curves)
                {
                    switch ((TrackType)curve.AnimDataOffset)
                    {
                    case TrackType.XPOS: BfresAnimations.GenerateKeys(group.Translate.X, curve); break;

                    case TrackType.YPOS: BfresAnimations.GenerateKeys(group.Translate.Y, curve); break;

                    case TrackType.ZPOS: BfresAnimations.GenerateKeys(group.Translate.Z, curve); break;

                    case TrackType.XROT: BfresAnimations.GenerateKeys(group.Rotate.X, curve); break;

                    case TrackType.YROT: BfresAnimations.GenerateKeys(group.Rotate.Y, curve); break;

                    case TrackType.ZROT: BfresAnimations.GenerateKeys(group.Rotate.Z, curve); break;

                    case TrackType.WROT: BfresAnimations.GenerateKeys(group.Rotate.W, curve); break;

                    case TrackType.XSCA: BfresAnimations.GenerateKeys(group.Scale.X, curve); break;

                    case TrackType.YSCA: BfresAnimations.GenerateKeys(group.Scale.Y, curve); break;

                    case TrackType.ZSCA: BfresAnimations.GenerateKeys(group.Scale.Z, curve); break;
                    }
                }
            }
        }
Пример #5
0
        public void Reload(MaterialAnim anim)
        {
            Name       = anim.Name;
            FrameCount = anim.FrameCount;
            FrameRate  = 60.0f;
            Loop       = anim.Loop;
            if (anim.TextureNames != null)
            {
                TextureList = anim.TextureNames.Keys.ToList();
            }

            if (anim.MaterialAnimDataList == null)
            {
                return;
            }

            AnimGroups.Clear();
            foreach (var matAnim in anim.MaterialAnimDataList)
            {
                var group = new MaterialAnimGroup();
                AnimGroups.Add(group);
                group.Name = matAnim.Name;

                //Get the material animation's texture pattern animation lists
                //Each sampler has their own info
                for (int i = 0; i < matAnim.PatternAnimInfos.Count; i++)
                {
                    var patternInfo = matAnim.PatternAnimInfos[i];

                    //Get the curve index for animated indices
                    int curveIndex = patternInfo.CurveIndex;
                    //Get the base index for starting values
                    int textureBaseIndex = matAnim.BaseDataList.Length > i ? matAnim.BaseDataList[i] : 0;

                    //Make a new sampler track using step interpolation
                    var samplerTrack = new SamplerTrack();
                    samplerTrack.InterpolationType = STInterpoaltionType.Step;
                    samplerTrack.Sampler           = patternInfo.Name;
                    group.Tracks.Add(samplerTrack);

                    if (curveIndex != -1)
                    {
                        BfresAnimations.GenerateKeys(samplerTrack, matAnim.Curves[curveIndex], true);
                    }
                    else //Use the base data and make a constant key
                    {
                        samplerTrack.KeyFrames.Add(new STKeyFrame(0, textureBaseIndex));
                    }
                }
                //Get the list of animated parameters
                for (int i = 0; i < matAnim.ParamAnimInfos.Count; i++)
                {
                    ParamAnimGroup paramGroup = new ParamAnimGroup();
                    paramGroup.Name = matAnim.ParamAnimInfos[i].Name;
                    group.SubAnimGroups.Add(paramGroup);

                    var paramInfo = matAnim.ParamAnimInfos[i];
                    //Params have int and float curves
                    int curveIndex    = paramInfo.BeginCurve;
                    int constantIndex = paramInfo.BeginConstant;
                    int numFloats     = paramInfo.FloatCurveCount;
                    int numInts       = paramInfo.IntCurveCount;
                    int numConstants  = paramInfo.ConstantCount;

                    //Each constant and curve get's their own value using a value offset
                    for (int j = 0; j < numConstants; j++)
                    {
                        var   constant = matAnim.Constants[constantIndex + j];
                        float value    = constant.Value;
                        //A bit hacky, convert int32 types by value range SRT modes use
                        if (constant.Value.Int32 > 0 && constant.Value.Int32 < 6)
                        {
                            value = constant.Value.Int32;
                        }

                        paramGroup.Tracks.Add(new ParamTrack()
                        {
                            Name        = constant.AnimDataOffset.ToString("X"),
                            ValueOffset = constant.AnimDataOffset,
                            //Not the best way, but 4 is typically the stride size for each value
                            ChannelIndex = (int)(constant.AnimDataOffset / 4),
                            KeyFrames    = new List <STKeyFrame>()
                            {
                                new STKeyFrame(0, value)
                            },
                            InterpolationType = STInterpoaltionType.Constant,
                        });
                    }
                    //Loop through all int and float curve values
                    for (int j = 0; j < numInts + numFloats; j++)
                    {
                        var curve      = matAnim.Curves[curveIndex + j];
                        var paramTrack = new ParamTrack()
                        {
                            Name = curve.AnimDataOffset.ToString("X")
                        };
                        paramTrack.ValueOffset = curve.AnimDataOffset;
                        //Not the best way, but 4 is typically the stride size for each value
                        paramTrack.ChannelIndex = (int)(curve.AnimDataOffset / 4);
                        paramGroup.Tracks.Add(paramTrack);

                        BfresAnimations.GenerateKeys(paramTrack, curve);
                    }
                }
            }
        }