コード例 #1
0
ファイル: Skeleton.cs プロジェクト: renruoyu1989/rougelikeman
        public void UpdateCache()
        {
            this.updateCache.Clear(true);
            this.updateCacheReset.Clear(true);
            ExposedList <Bone> bones = this.bones;
            int index = 0;
            int count = bones.Count;

            while (index < count)
            {
                bones.Items[index].sorted = false;
                index++;
            }
            ExposedList <IkConstraint>        ikConstraints        = this.ikConstraints;
            ExposedList <TransformConstraint> transformConstraints = this.transformConstraints;
            ExposedList <PathConstraint>      pathConstraints      = this.pathConstraints;
            int num3 = this.IkConstraints.Count;
            int num4 = transformConstraints.Count;
            int num5 = pathConstraints.Count;
            int num6 = (num3 + num4) + num5;

            for (int i = 0; i < num6; i++)
            {
                for (int j = 0; j < num3; j++)
                {
                    IkConstraint constraint = ikConstraints.Items[j];
                    if (constraint.data.order == i)
                    {
                        this.SortIkConstraint(constraint);
                        continue;
                    }
                }
                for (int k = 0; k < num4; k++)
                {
                    TransformConstraint constraint = transformConstraints.Items[k];
                    if (constraint.data.order == i)
                    {
                        this.SortTransformConstraint(constraint);
                        continue;
                    }
                }
                for (int m = 0; m < num5; m++)
                {
                    PathConstraint constraint = pathConstraints.Items[m];
                    if (constraint.data.order == i)
                    {
                        this.SortPathConstraint(constraint);
                        break;
                    }
                }
            }
            int num11 = 0;
            int num12 = bones.Count;

            while (num11 < num12)
            {
                this.SortBone(bones.Items[num11]);
                num11++;
            }
        }
コード例 #2
0
        /// <summary>Caches information about bones and constraints. Must be called if bones or constraints are added
        /// or removed.</summary>
        public void UpdateCache()
        {
            ExposedList <Bone>                bones                = this.bones;
            ExposedList <IUpdatable>          updateCache          = this.updateCache;
            ExposedList <IkConstraint>        ikConstraints        = this.ikConstraints;
            ExposedList <TransformConstraint> transformConstraints = this.transformConstraints;
            int ikConstraintsCount        = ikConstraints.Count;
            int transformConstraintsCount = transformConstraints.Count;

            updateCache.Clear();
            for (int i = 0, n = bones.Count; i < n; i++)
            {
                Bone bone = bones.Items[i];
                updateCache.Add(bone);
                for (int ii = 0; ii < transformConstraintsCount; ii++)
                {
                    TransformConstraint transformConstraint = transformConstraints.Items[ii];
                    if (bone == transformConstraint.bone)
                    {
                        updateCache.Add(transformConstraint);
                        break;
                    }
                }
                for (int ii = 0; ii < ikConstraintsCount; ii++)
                {
                    IkConstraint ikConstraint = ikConstraints.Items[ii];
                    if (bone == ikConstraint.bones.Items[ikConstraint.bones.Count - 1])
                    {
                        updateCache.Add(ikConstraint);
                        break;
                    }
                }
            }
        }
コード例 #3
0
        private void SortTransformConstraint(TransformConstraint constraint)
        {
            SortBone(constraint.target);
            ExposedList <Bone> exposedList = constraint.bones;
            int count = exposedList.Count;

            if (constraint.data.local)
            {
                for (int i = 0; i < count; i++)
                {
                    Bone bone = exposedList.Items[i];
                    SortBone(bone.parent);
                    if (!updateCache.Contains(bone))
                    {
                        updateCacheReset.Add(bone);
                    }
                }
            }
            else
            {
                for (int j = 0; j < count; j++)
                {
                    SortBone(exposedList.Items[j]);
                }
            }
            updateCache.Add(constraint);
            for (int k = 0; k < count; k++)
            {
                SortReset(exposedList.Items[k].children);
            }
            for (int l = 0; l < count; l++)
            {
                exposedList.Items[l].sorted = true;
            }
        }
コード例 #4
0
        override public void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha)
        {
            float[] frames = this.frames;
            if (time < frames[0])
            {
                return;                               // Time is before first frame.
            }
            TransformConstraint constraint = skeleton.transformConstraints.Items[transformConstraintIndex];

            if (time >= frames[frames.Length - ENTRIES])               // Time is after last frame.
            {
                int i = frames.Length;
                constraint.rotateMix    += (frames[i + PREV_ROTATE] - constraint.rotateMix) * alpha;
                constraint.translateMix += (frames[i + PREV_TRANSLATE] - constraint.translateMix) * alpha;
                constraint.scaleMix     += (frames[i + PREV_SCALE] - constraint.scaleMix) * alpha;
                constraint.shearMix     += (frames[i + PREV_SHEAR] - constraint.shearMix) * alpha;
                return;
            }

            // Interpolate between the previous frame and the current frame.
            int   frame     = Animation.binarySearch(frames, time, ENTRIES);
            float frameTime = frames[frame];
            float percent   = GetCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));

            float rotate    = frames[frame + PREV_ROTATE];
            float translate = frames[frame + PREV_TRANSLATE];
            float scale     = frames[frame + PREV_SCALE];
            float shear     = frames[frame + PREV_SHEAR];

            constraint.rotateMix    += (rotate + (frames[frame + ROTATE] - rotate) * percent - constraint.rotateMix) * alpha;
            constraint.translateMix += (translate + (frames[frame + TRANSLATE] - translate) * percent - constraint.translateMix)
                                       * alpha;
            constraint.scaleMix += (scale + (frames[frame + SCALE] - scale) * percent - constraint.scaleMix) * alpha;
            constraint.shearMix += (shear + (frames[frame + SHEAR] - shear) * percent - constraint.shearMix) * alpha;
        }
コード例 #5
0
ファイル: Skeleton.cs プロジェクト: renruoyu1989/rougelikeman
        private void SortTransformConstraint(TransformConstraint constraint)
        {
            this.SortBone(constraint.target);
            ExposedList <Bone> bones = constraint.bones;
            int count = bones.Count;

            if (constraint.data.local)
            {
                for (int k = 0; k < count; k++)
                {
                    Bone item = bones.Items[k];
                    this.SortBone(item.parent);
                    if (!this.updateCache.Contains(item))
                    {
                        this.updateCacheReset.Add(item);
                    }
                }
            }
            else
            {
                for (int k = 0; k < count; k++)
                {
                    this.SortBone(bones.Items[k]);
                }
            }
            this.updateCache.Add(constraint);
            for (int i = 0; i < count; i++)
            {
                SortReset(bones.Items[i].children);
            }
            for (int j = 0; j < count; j++)
            {
                bones.Items[j].sorted = true;
            }
        }
コード例 #6
0
        /// <summary>Sets the bones and constraints to their setup pose values.</summary>
        public void SetBonesToSetupPose()
        {
            ExposedList <Bone> bones = this.bones;

            for (int i = 0, n = bones.Count; i < n; i++)
            {
                bones.Items[i].SetToSetupPose();
            }

            ExposedList <IkConstraint> ikConstraints = this.ikConstraints;

            for (int i = 0, n = ikConstraints.Count; i < n; i++)
            {
                IkConstraint constraint = ikConstraints.Items[i];
                constraint.bendDirection = constraint.data.bendDirection;
                constraint.mix           = constraint.data.mix;
            }

            ExposedList <TransformConstraint> transformConstraints = this.transformConstraints;

            for (int i = 0, n = transformConstraints.Count; i < n; i++)
            {
                TransformConstraint constraint = transformConstraints.Items[i];
                constraint.translateMix = constraint.data.translateMix;
                constraint.x            = constraint.data.x;
                constraint.y            = constraint.data.y;
            }
        }
コード例 #7
0
ファイル: Skeleton.cs プロジェクト: rickymm3/explorers-mobile
        /// <summary>Caches information about bones and constraints. Must be called if bones, constraints or weighted path attachments are added
        /// or removed.</summary>
        public void UpdateCache()
        {
            ExposedList <IUpdatable> updateCache = this.updateCache;

            updateCache.Clear();
            this.updateCacheReset.Clear();

            ExposedList <Bone> bones = this.bones;

            for (int i = 0, n = bones.Count; i < n; i++)
            {
                bones.Items[i].sorted = false;
            }

            ExposedList <IkConstraint> ikConstraints = this.ikConstraints;
            var transformConstraints = this.transformConstraints;
            var pathConstraints = this.pathConstraints;
            int ikCount = IkConstraints.Count, transformCount = transformConstraints.Count, pathCount = pathConstraints.Count;
            int constraintCount = ikCount + transformCount + pathCount;

            //outer:
            for (int i = 0; i < constraintCount; i++)
            {
                for (int ii = 0; ii < ikCount; ii++)
                {
                    IkConstraint constraint = ikConstraints.Items[ii];
                    if (constraint.data.order == i)
                    {
                        SortIkConstraint(constraint);
                        goto outer;                         //continue outer;
                    }
                }
                for (int ii = 0; ii < transformCount; ii++)
                {
                    TransformConstraint constraint = transformConstraints.Items[ii];
                    if (constraint.data.order == i)
                    {
                        SortTransformConstraint(constraint);
                        goto outer;                         //continue outer;
                    }
                }
                for (int ii = 0; ii < pathCount; ii++)
                {
                    PathConstraint constraint = pathConstraints.Items[ii];
                    if (constraint.data.order == i)
                    {
                        SortPathConstraint(constraint);
                        goto outer;                         //continue outer;
                    }
                }
                outer : {}
            }

            for (int i = 0, n = bones.Count; i < n; i++)
            {
                SortBone(bones.Items[i]);
            }
        }
コード例 #8
0
ファイル: Skeleton.cs プロジェクト: renruoyu1989/rougelikeman
        public void SetBonesToSetupPose()
        {
            Bone[] items = this.bones.Items;
            int    index = 0;
            int    count = this.bones.Count;

            while (index < count)
            {
                items[index].SetToSetupPose();
                index++;
            }
            IkConstraint[] constraintArray = this.ikConstraints.Items;
            int            num3            = 0;
            int            num4            = this.ikConstraints.Count;

            while (num3 < num4)
            {
                IkConstraint constraint = constraintArray[num3];
                constraint.bendDirection = constraint.data.bendDirection;
                constraint.mix           = constraint.data.mix;
                num3++;
            }
            TransformConstraint[] constraintArray2 = this.transformConstraints.Items;
            int num5 = 0;
            int num6 = this.transformConstraints.Count;

            while (num5 < num6)
            {
                TransformConstraint     constraint2 = constraintArray2[num5];
                TransformConstraintData data        = constraint2.data;
                constraint2.rotateMix    = data.rotateMix;
                constraint2.translateMix = data.translateMix;
                constraint2.scaleMix     = data.scaleMix;
                constraint2.shearMix     = data.shearMix;
                num5++;
            }
            PathConstraint[] constraintArray3 = this.pathConstraints.Items;
            int num7 = 0;
            int num8 = this.pathConstraints.Count;

            while (num7 < num8)
            {
                PathConstraint     constraint3 = constraintArray3[num7];
                PathConstraintData data        = constraint3.data;
                constraint3.position     = data.position;
                constraint3.spacing      = data.spacing;
                constraint3.rotateMix    = data.rotateMix;
                constraint3.translateMix = data.translateMix;
                num7++;
            }
        }
コード例 #9
0
        public void SetBonesToSetupPose()
        {
            Bone[] items = this.bones.Items;
            int    i     = 0;
            int    count = this.bones.Count;

            while (i < count)
            {
                items[i].SetToSetupPose();
                i++;
            }
            IkConstraint[] items2 = this.ikConstraints.Items;
            int            j      = 0;
            int            count2 = this.ikConstraints.Count;

            while (j < count2)
            {
                IkConstraint ikConstraint = items2[j];
                ikConstraint.bendDirection = ikConstraint.data.bendDirection;
                ikConstraint.mix           = ikConstraint.data.mix;
                j++;
            }
            TransformConstraint[] items3 = this.transformConstraints.Items;
            int k      = 0;
            int count3 = this.transformConstraints.Count;

            while (k < count3)
            {
                TransformConstraint     transformConstraint     = items3[k];
                TransformConstraintData transformConstraintData = transformConstraint.data;
                transformConstraint.rotateMix    = transformConstraintData.rotateMix;
                transformConstraint.translateMix = transformConstraintData.translateMix;
                transformConstraint.scaleMix     = transformConstraintData.scaleMix;
                transformConstraint.shearMix     = transformConstraintData.shearMix;
                k++;
            }
            PathConstraint[] items4 = this.pathConstraints.Items;
            int l      = 0;
            int count4 = this.pathConstraints.Count;

            while (l < count4)
            {
                PathConstraint     pathConstraint     = items4[l];
                PathConstraintData pathConstraintData = pathConstraint.data;
                pathConstraint.position     = pathConstraintData.position;
                pathConstraint.spacing      = pathConstraintData.spacing;
                pathConstraint.rotateMix    = pathConstraintData.rotateMix;
                pathConstraint.translateMix = pathConstraintData.translateMix;
                l++;
            }
        }
コード例 #10
0
        /// <summary>Sets the bones and constraints to their setup pose values.</summary>
        public void SetBonesToSetupPose()
        {
            var bones = this.bones.Items;

            for (int i = 0, n = this.bones.Count; i < n; i++)
            {
                bones[i].SetToSetupPose();
            }

            var ikConstraints = this.ikConstraints.Items;

            for (int i = 0, n = this.ikConstraints.Count; i < n; i++)
            {
                IkConstraint     constraint = ikConstraints[i];
                IkConstraintData data       = constraint.data;
                constraint.mix           = data.mix;
                constraint.softness      = data.softness;
                constraint.bendDirection = data.bendDirection;
                constraint.compress      = data.compress;
                constraint.stretch       = data.stretch;
            }

            var transformConstraints = this.transformConstraints.Items;

            for (int i = 0, n = this.transformConstraints.Count; i < n; i++)
            {
                TransformConstraint     constraint = transformConstraints[i];
                TransformConstraintData data       = constraint.data;
                constraint.mixRotate = data.mixRotate;
                constraint.mixX      = data.mixX;
                constraint.mixY      = data.mixY;
                constraint.mixScaleX = data.mixScaleX;
                constraint.mixScaleY = data.mixScaleY;
                constraint.mixShearY = data.mixShearY;
            }

            var pathConstraints = this.pathConstraints.Items;

            for (int i = 0, n = this.pathConstraints.Count; i < n; i++)
            {
                PathConstraint     constraint = pathConstraints[i];
                PathConstraintData data       = constraint.data;
                constraint.position  = data.position;
                constraint.spacing   = data.spacing;
                constraint.mixRotate = data.mixRotate;
                constraint.mixX      = data.mixX;
                constraint.mixY      = data.mixY;
            }
        }
コード例 #11
0
 static int FindTransformConstraint(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 2);
         Spine.Skeleton            obj  = (Spine.Skeleton)ToLua.CheckObject <Spine.Skeleton>(L, 1);
         string                    arg0 = ToLua.CheckString(L, 2);
         Spine.TransformConstraint o    = obj.FindTransformConstraint(arg0);
         ToLua.PushObject(L, o);
         return(1);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
コード例 #12
0
ファイル: Skeleton.cs プロジェクト: DeStiCap/Dim-Mind
        private void SortTransformConstraint(TransformConstraint constraint)
        {
            constraint.active = constraint.target.active &&
                                (!constraint.data.skinRequired || (skin != null && skin.constraints.Contains(constraint.data)));
            if (!constraint.active)
            {
                return;
            }

            SortBone(constraint.target);

            var constrained = constraint.bones;
            int boneCount   = constrained.Count;

            if (constraint.data.local)
            {
                for (int i = 0; i < boneCount; i++)
                {
                    Bone child = constrained.Items[i];
                    SortBone(child.parent);
                    if (!updateCache.Contains(child))
                    {
                        updateCacheReset.Add(child);
                    }
                }
            }
            else
            {
                for (int i = 0; i < boneCount; i++)
                {
                    SortBone(constrained.Items[i]);
                }
            }

            updateCache.Add(constraint);

            for (int i = 0; i < boneCount; i++)
            {
                SortReset(constrained.Items[i].children);
            }
            for (int i = 0; i < boneCount; i++)
            {
                constrained.Items[i].sorted = true;
            }
        }
コード例 #13
0
ファイル: Skeleton.cs プロジェクト: DeStiCap/Dim-Mind
        /// <summary>Sets the bones and constraints to their setup pose values.</summary>
        public void SetBonesToSetupPose()
        {
            var bonesItems = this.bones.Items;

            for (int i = 0, n = bones.Count; i < n; i++)
            {
                bonesItems[i].SetToSetupPose();
            }

            var ikConstraintsItems = this.ikConstraints.Items;

            for (int i = 0, n = ikConstraints.Count; i < n; i++)
            {
                IkConstraint constraint = ikConstraintsItems[i];
                constraint.mix           = constraint.data.mix;
                constraint.softness      = constraint.data.softness;
                constraint.bendDirection = constraint.data.bendDirection;
                constraint.compress      = constraint.data.compress;
                constraint.stretch       = constraint.data.stretch;
            }

            var transformConstraintsItems = this.transformConstraints.Items;

            for (int i = 0, n = transformConstraints.Count; i < n; i++)
            {
                TransformConstraint     constraint     = transformConstraintsItems[i];
                TransformConstraintData constraintData = constraint.data;
                constraint.rotateMix    = constraintData.rotateMix;
                constraint.translateMix = constraintData.translateMix;
                constraint.scaleMix     = constraintData.scaleMix;
                constraint.shearMix     = constraintData.shearMix;
            }

            var pathConstraintItems = this.pathConstraints.Items;

            for (int i = 0, n = pathConstraints.Count; i < n; i++)
            {
                PathConstraint     constraint     = pathConstraintItems[i];
                PathConstraintData constraintData = constraint.data;
                constraint.position     = constraintData.position;
                constraint.spacing      = constraintData.spacing;
                constraint.rotateMix    = constraintData.rotateMix;
                constraint.translateMix = constraintData.translateMix;
            }
        }
コード例 #14
0
ファイル: Skeleton.cs プロジェクト: rickymm3/explorers-mobile
        /// <returns>May be null.</returns>
        public TransformConstraint FindTransformConstraint(string constraintName)
        {
            if (constraintName == null)
            {
                throw new ArgumentNullException("constraintName", "constraintName cannot be null.");
            }
            ExposedList <TransformConstraint> transformConstraints = this.transformConstraints;

            for (int i = 0, n = transformConstraints.Count; i < n; i++)
            {
                TransformConstraint transformConstraint = transformConstraints.Items[i];
                if (transformConstraint.data.name == constraintName)
                {
                    return(transformConstraint);
                }
            }
            return(null);
        }
コード例 #15
0
        public void SetBonesToSetupPose()
        {
            Bone[] items = bones.Items;
            int    i     = 0;

            for (int count = bones.Count; i < count; i++)
            {
                items[i].SetToSetupPose();
            }
            IkConstraint[] items2 = ikConstraints.Items;
            int            j      = 0;

            for (int count2 = ikConstraints.Count; j < count2; j++)
            {
                IkConstraint ikConstraint = items2[j];
                ikConstraint.bendDirection = ikConstraint.data.bendDirection;
                ikConstraint.mix           = ikConstraint.data.mix;
            }
            TransformConstraint[] items3 = transformConstraints.Items;
            int k = 0;

            for (int count3 = transformConstraints.Count; k < count3; k++)
            {
                TransformConstraint     transformConstraint     = items3[k];
                TransformConstraintData transformConstraintData = transformConstraint.data;
                transformConstraint.rotateMix    = transformConstraintData.rotateMix;
                transformConstraint.translateMix = transformConstraintData.translateMix;
                transformConstraint.scaleMix     = transformConstraintData.scaleMix;
                transformConstraint.shearMix     = transformConstraintData.shearMix;
            }
            PathConstraint[] items4 = pathConstraints.Items;
            int l = 0;

            for (int count4 = pathConstraints.Count; l < count4; l++)
            {
                PathConstraint     pathConstraint     = items4[l];
                PathConstraintData pathConstraintData = pathConstraint.data;
                pathConstraint.position     = pathConstraintData.position;
                pathConstraint.spacing      = pathConstraintData.spacing;
                pathConstraint.rotateMix    = pathConstraintData.rotateMix;
                pathConstraint.translateMix = pathConstraintData.translateMix;
            }
        }
コード例 #16
0
        public TransformConstraint FindTransformConstraint(string constraintName)
        {
            if (constraintName == null)
            {
                throw new ArgumentNullException("constraintName", "constraintName cannot be null.");
            }
            ExposedList <TransformConstraint> exposedList = this.transformConstraints;
            int i     = 0;
            int count = exposedList.Count;

            while (i < count)
            {
                TransformConstraint transformConstraint = exposedList.Items[i];
                if (transformConstraint.data.name == constraintName)
                {
                    return(transformConstraint);
                }
                i++;
            }
            return(null);
        }
コード例 #17
0
 /// <summary>Copy constructor.</summary>
 public TransformConstraint(TransformConstraint constraint, Skeleton skeleton)
 {
     if (constraint == null)
     {
         throw new ArgumentNullException("constraint cannot be null.");
     }
     if (skeleton == null)
     {
         throw new ArgumentNullException("skeleton cannot be null.");
     }
     data  = constraint.data;
     bones = new ExposedList <Bone>(constraint.Bones.Count);
     foreach (Bone bone in constraint.Bones)
     {
         bones.Add(skeleton.Bones.Items[bone.data.index]);
     }
     target       = skeleton.Bones.Items[constraint.target.data.index];
     rotateMix    = constraint.rotateMix;
     translateMix = constraint.translateMix;
     scaleMix     = constraint.scaleMix;
     shearMix     = constraint.shearMix;
 }
コード例 #18
0
ファイル: Skeleton.cs プロジェクト: rickymm3/explorers-mobile
        private void SortTransformConstraint(TransformConstraint constraint)
        {
            SortBone(constraint.target);

            var constrained = constraint.bones;
            int boneCount   = constrained.Count;

            if (constraint.data.local)
            {
                for (int i = 0; i < boneCount; i++)
                {
                    Bone child = constrained.Items[i];
                    SortBone(child.parent);
                    if (!updateCache.Contains(child))
                    {
                        updateCacheReset.Add(child);
                    }
                }
            }
            else
            {
                for (int i = 0; i < boneCount; i++)
                {
                    SortBone(constrained.Items[i]);
                }
            }

            updateCache.Add(constraint);

            for (int i = 0; i < boneCount; i++)
            {
                SortReset(constrained.Items[i].children);
            }
            for (int i = 0; i < boneCount; i++)
            {
                constrained.Items[i].sorted = true;
            }
        }
コード例 #19
0
        private void SortTransformConstraint(TransformConstraint constraint)
        {
            SortBone(constraint.target);

            var constrained = constraint.bones;
            int boneCount   = constrained.Count;

            for (int ii = 0; ii < boneCount; ii++)
            {
                SortBone(constrained.Items[ii]);
            }

            updateCache.Add(constraint);

            for (int ii = 0; ii < boneCount; ii++)
            {
                SortReset(constrained.Items[ii].children);
            }
            for (int ii = 0; ii < boneCount; ii++)
            {
                constrained.Items[ii].sorted = true;
            }
        }
コード例 #20
0
 /// <summary>Copy constructor.</summary>
 public TransformConstraint(TransformConstraint constraint, Skeleton skeleton)
 {
     if (constraint == null)
     {
         throw new ArgumentNullException("constraint cannot be null.");
     }
     if (skeleton == null)
     {
         throw new ArgumentNullException("skeleton cannot be null.");
     }
     data  = constraint.data;
     bones = new ExposedList <Bone>(constraint.Bones.Count);
     foreach (Bone bone in constraint.Bones)
     {
         bones.Add(skeleton.Bones.Items[bone.data.index]);
     }
     target    = skeleton.Bones.Items[constraint.target.data.index];
     mixRotate = constraint.mixRotate;
     mixX      = constraint.mixX;
     mixY      = constraint.mixY;
     mixScaleX = constraint.mixScaleX;
     mixScaleY = constraint.mixScaleY;
     mixShearY = constraint.mixShearY;
 }
コード例 #21
0
        public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction)
        {
            TransformConstraint constraint = skeleton.transformConstraints.Items[this.transformConstraintIndex];

            float[] frames = this.frames;
            if (time < frames[0])
            {
                TransformConstraintData data = constraint.data;
                if (pose != MixPose.Setup)
                {
                    if (pose != MixPose.Current)
                    {
                        return;
                    }
                }
                else
                {
                    constraint.rotateMix    = data.rotateMix;
                    constraint.translateMix = data.translateMix;
                    constraint.scaleMix     = data.scaleMix;
                    constraint.shearMix     = data.shearMix;
                    return;
                }
                constraint.rotateMix    += (data.rotateMix - constraint.rotateMix) * alpha;
                constraint.translateMix += (data.translateMix - constraint.translateMix) * alpha;
                constraint.scaleMix     += (data.scaleMix - constraint.scaleMix) * alpha;
                constraint.shearMix     += (data.shearMix - constraint.shearMix) * alpha;
            }
            else
            {
                float num;
                float num2;
                float num3;
                float num4;
                if (time >= frames[frames.Length - 5])
                {
                    int length = frames.Length;
                    num  = frames[length + -4];
                    num2 = frames[length + -3];
                    num3 = frames[length + -2];
                    num4 = frames[length + -1];
                }
                else
                {
                    int index = Animation.BinarySearch(frames, time, 5);
                    num  = frames[index + -4];
                    num2 = frames[index + -3];
                    num3 = frames[index + -2];
                    num4 = frames[index + -1];
                    float num7         = frames[index];
                    float curvePercent = base.GetCurvePercent((index / 5) - 1, 1f - ((time - num7) / (frames[index + -5] - num7)));
                    num  += (frames[index + 1] - num) * curvePercent;
                    num2 += (frames[index + 2] - num2) * curvePercent;
                    num3 += (frames[index + 3] - num3) * curvePercent;
                    num4 += (frames[index + 4] - num4) * curvePercent;
                }
                if (pose == MixPose.Setup)
                {
                    TransformConstraintData data = constraint.data;
                    constraint.rotateMix    = data.rotateMix + ((num - data.rotateMix) * alpha);
                    constraint.translateMix = data.translateMix + ((num2 - data.translateMix) * alpha);
                    constraint.scaleMix     = data.scaleMix + ((num3 - data.scaleMix) * alpha);
                    constraint.shearMix     = data.shearMix + ((num4 - data.shearMix) * alpha);
                }
                else
                {
                    constraint.rotateMix    += (num - constraint.rotateMix) * alpha;
                    constraint.translateMix += (num2 - constraint.translateMix) * alpha;
                    constraint.scaleMix     += (num3 - constraint.scaleMix) * alpha;
                    constraint.shearMix     += (num4 - constraint.shearMix) * alpha;
                }
            }
        }
コード例 #22
0
		private void SortTransformConstraint (TransformConstraint constraint) {
			SortBone(constraint.target);

			var constrained = constraint.bones;
			int boneCount = constrained.Count;
			for (int ii = 0; ii < boneCount; ii++)
				SortBone(constrained.Items[ii]);

			updateCache.Add(constraint);

			for (int ii = 0; ii < boneCount; ii++)
				SortReset(constrained.Items[ii].children);
			for (int ii = 0; ii < boneCount; ii++)
				constrained.Items[ii].sorted = true;
		}
コード例 #23
0
        /// <summary>Caches information about bones and constraints. Must be called if bones, constraints or weighted path attachments are added
        /// or removed.</summary>
        public void UpdateCache()
        {
            ExposedList <IUpdatable> updateCache = this.updateCache;

            updateCache.Clear();

            ExposedList <Bone> bones = this.bones;

            for (int i = 0, n = bones.Count; i < n; i++)
            {
                bones.Items[i].sorted = false;
            }

            ExposedList <IkConstraint> ikConstraints = this.ikConstraintsSorted;

            ikConstraints.Clear();
            ikConstraints.AddRange(this.ikConstraints);
            int ikCount = ikConstraints.Count;

            for (int i = 0, level, n = ikCount; i < n; i++)
            {
                IkConstraint ik   = ikConstraints.Items[i];
                Bone         bone = ik.bones.Items[0].parent;
                for (level = 0; bone != null; level++)
                {
                    bone = bone.parent;
                }
                ik.level = level;
            }
            for (int i = 1, ii; i < ikCount; i++)
            {
                IkConstraint ik    = ikConstraints.Items[i];
                int          level = ik.level;
                for (ii = i - 1; ii >= 0; ii--)
                {
                    IkConstraint other = ikConstraints.Items[ii];
                    if (other.level < level)
                    {
                        break;
                    }
                    ikConstraints.Items[ii + 1] = other;
                }
                ikConstraints.Items[ii + 1] = ik;
            }
            for (int i = 0, n = ikConstraints.Count; i < n; i++)
            {
                IkConstraint constraint = ikConstraints.Items[i];
                Bone         target     = constraint.target;
                SortBone(target);

                ExposedList <Bone> constrained = constraint.bones;
                Bone parent = constrained.Items[0];
                SortBone(parent);

                updateCache.Add(constraint);

                SortReset(parent.children);
                constrained.Items[constrained.Count - 1].sorted = true;
            }

            ExposedList <PathConstraint> pathConstraints = this.pathConstraints;

            for (int i = 0, n = pathConstraints.Count; i < n; i++)
            {
                PathConstraint constraint = pathConstraints.Items[i];

                Slot slot      = constraint.target;
                int  slotIndex = slot.data.index;
                Bone slotBone  = slot.bone;
                if (skin != null)
                {
                    SortPathConstraintAttachment(skin, slotIndex, slotBone);
                }
                if (data.defaultSkin != null && data.defaultSkin != skin)
                {
                    SortPathConstraintAttachment(data.defaultSkin, slotIndex, slotBone);
                }
                for (int ii = 0, nn = data.skins.Count; ii < nn; ii++)
                {
                    SortPathConstraintAttachment(data.skins.Items[ii], slotIndex, slotBone);
                }

                PathAttachment attachment = slot.Attachment as PathAttachment;
                if (attachment != null)
                {
                    SortPathConstraintAttachment(attachment, slotBone);
                }

                ExposedList <Bone> constrained = constraint.bones;
                int boneCount = constrained.Count;
                for (int ii = 0; ii < boneCount; ii++)
                {
                    SortBone(constrained.Items[ii]);
                }

                updateCache.Add(constraint);

                for (int ii = 0; ii < boneCount; ii++)
                {
                    SortReset(constrained.Items[ii].children);
                }
                for (int ii = 0; ii < boneCount; ii++)
                {
                    constrained.Items[ii].sorted = true;
                }
            }

            ExposedList <TransformConstraint> transformConstraints = this.transformConstraints;

            for (int i = 0, n = transformConstraints.Count; i < n; i++)
            {
                TransformConstraint constraint = transformConstraints.Items[i];

                SortBone(constraint.target);

                ExposedList <Bone> constrained = constraint.bones;
                int boneCount = constrained.Count;
                for (int ii = 0; ii < boneCount; ii++)
                {
                    SortBone(constrained.Items[ii]);
                }

                updateCache.Add(constraint);

                for (int ii = 0; ii < boneCount; ii++)
                {
                    SortReset(constrained.Items[ii].children);
                }
                for (int ii = 0; ii < boneCount; ii++)
                {
                    constrained.Items[ii].sorted = true;
                }
            }

            for (int i = 0, n = bones.Count; i < n; i++)
            {
                SortBone(bones.Items[i]);
            }
        }
コード例 #24
0
        internal static void SetPropertyToSetupPose(this Skeleton skeleton, int propertyID)
        {
            Bone           bone;
            PathConstraint constraint2;
            int            num   = propertyID >> 0x18;
            TimelineType   type  = (TimelineType)num;
            int            index = propertyID - (num << 0x18);

            switch (type)
            {
            case TimelineType.Rotate:
                bone          = skeleton.bones.Items[index];
                bone.rotation = bone.data.rotation;
                break;

            case TimelineType.Translate:
                bone   = skeleton.bones.Items[index];
                bone.x = bone.data.x;
                bone.y = bone.data.y;
                break;

            case TimelineType.Scale:
                bone        = skeleton.bones.Items[index];
                bone.scaleX = bone.data.scaleX;
                bone.scaleY = bone.data.scaleY;
                break;

            case TimelineType.Shear:
                bone        = skeleton.bones.Items[index];
                bone.shearX = bone.data.shearX;
                bone.shearY = bone.data.shearY;
                break;

            case TimelineType.Attachment:
                skeleton.SetSlotAttachmentToSetupPose(index);
                break;

            case TimelineType.Color:
                skeleton.slots.Items[index].SetColorToSetupPose();
                break;

            case TimelineType.Deform:
                skeleton.slots.Items[index].attachmentVertices.Clear(true);
                break;

            case TimelineType.DrawOrder:
                skeleton.SetDrawOrderToSetupPose();
                break;

            case TimelineType.IkConstraint:
            {
                IkConstraint constraint = skeleton.ikConstraints.Items[index];
                constraint.mix           = constraint.data.mix;
                constraint.bendDirection = constraint.data.bendDirection;
                break;
            }

            case TimelineType.TransformConstraint:
            {
                TransformConstraint     constraint3 = skeleton.transformConstraints.Items[index];
                TransformConstraintData data        = constraint3.data;
                constraint3.rotateMix    = data.rotateMix;
                constraint3.translateMix = data.translateMix;
                constraint3.scaleMix     = data.scaleMix;
                constraint3.shearMix     = data.shearMix;
                break;
            }

            case TimelineType.PathConstraintPosition:
                constraint2          = skeleton.pathConstraints.Items[index];
                constraint2.position = constraint2.data.position;
                break;

            case TimelineType.PathConstraintSpacing:
                constraint2         = skeleton.pathConstraints.Items[index];
                constraint2.spacing = constraint2.data.spacing;
                break;

            case TimelineType.PathConstraintMix:
                constraint2              = skeleton.pathConstraints.Items[index];
                constraint2.rotateMix    = constraint2.data.rotateMix;
                constraint2.translateMix = constraint2.data.translateMix;
                break;

            case TimelineType.TwoColor:
                skeleton.slots.Items[index].SetColorToSetupPose();
                break;
            }
        }
コード例 #25
0
        public void UpdateCache()
        {
            ExposedList <IUpdatable> exposedList = this.updateCache;

            exposedList.Clear(true);
            ExposedList <Bone> exposedList2 = this.bones;
            int i     = 0;
            int count = exposedList2.Count;

            while (i < count)
            {
                exposedList2.Items[i].sorted = false;
                i++;
            }
            ExposedList <IkConstraint> exposedList3 = this.ikConstraintsSorted;

            exposedList3.Clear(true);
            exposedList3.AddRange(this.ikConstraints);
            int count2 = exposedList3.Count;
            int j      = 0;
            int num    = count2;

            while (j < num)
            {
                IkConstraint ikConstraint = exposedList3.Items[j];
                Bone         parent       = ikConstraint.bones.Items[0].parent;
                int          num2         = 0;
                while (parent != null)
                {
                    parent = parent.parent;
                    num2++;
                }
                ikConstraint.level = num2;
                j++;
            }
            for (int k = 1; k < count2; k++)
            {
                IkConstraint ikConstraint2 = exposedList3.Items[k];
                int          level         = ikConstraint2.level;
                int          l;
                for (l = k - 1; l >= 0; l--)
                {
                    IkConstraint ikConstraint3 = exposedList3.Items[l];
                    if (ikConstraint3.level < level)
                    {
                        break;
                    }
                    exposedList3.Items[l + 1] = ikConstraint3;
                }
                exposedList3.Items[l + 1] = ikConstraint2;
            }
            int m      = 0;
            int count3 = exposedList3.Count;

            while (m < count3)
            {
                IkConstraint ikConstraint4 = exposedList3.Items[m];
                Bone         target        = ikConstraint4.target;
                this.SortBone(target);
                ExposedList <Bone> exposedList4 = ikConstraint4.bones;
                Bone bone = exposedList4.Items[0];
                this.SortBone(bone);
                exposedList.Add(ikConstraint4);
                this.SortReset(bone.children);
                exposedList4.Items[exposedList4.Count - 1].sorted = true;
                m++;
            }
            ExposedList <PathConstraint> exposedList5 = this.pathConstraints;
            int n      = 0;
            int count4 = exposedList5.Count;

            while (n < count4)
            {
                PathConstraint pathConstraint = exposedList5.Items[n];
                Slot           target2        = pathConstraint.target;
                int            index          = target2.data.index;
                Bone           bone2          = target2.bone;
                if (this.skin != null)
                {
                    this.SortPathConstraintAttachment(this.skin, index, bone2);
                }
                if (this.data.defaultSkin != null && this.data.defaultSkin != this.skin)
                {
                    this.SortPathConstraintAttachment(this.data.defaultSkin, index, bone2);
                }
                int num3   = 0;
                int count5 = this.data.skins.Count;
                while (num3 < count5)
                {
                    this.SortPathConstraintAttachment(this.data.skins.Items[num3], index, bone2);
                    num3++;
                }
                PathAttachment pathAttachment = target2.Attachment as PathAttachment;
                if (pathAttachment != null)
                {
                    this.SortPathConstraintAttachment(pathAttachment, bone2);
                }
                ExposedList <Bone> exposedList6 = pathConstraint.bones;
                int count6 = exposedList6.Count;
                for (int num4 = 0; num4 < count6; num4++)
                {
                    this.SortBone(exposedList6.Items[num4]);
                }
                exposedList.Add(pathConstraint);
                for (int num5 = 0; num5 < count6; num5++)
                {
                    this.SortReset(exposedList6.Items[num5].children);
                }
                for (int num6 = 0; num6 < count6; num6++)
                {
                    exposedList6.Items[num6].sorted = true;
                }
                n++;
            }
            ExposedList <TransformConstraint> exposedList7 = this.transformConstraints;
            int num7   = 0;
            int count7 = exposedList7.Count;

            while (num7 < count7)
            {
                TransformConstraint transformConstraint = exposedList7.Items[num7];
                this.SortBone(transformConstraint.target);
                ExposedList <Bone> exposedList8 = transformConstraint.bones;
                int count8 = exposedList8.Count;
                for (int num8 = 0; num8 < count8; num8++)
                {
                    this.SortBone(exposedList8.Items[num8]);
                }
                exposedList.Add(transformConstraint);
                for (int num9 = 0; num9 < count8; num9++)
                {
                    this.SortReset(exposedList8.Items[num9].children);
                }
                for (int num10 = 0; num10 < count8; num10++)
                {
                    exposedList8.Items[num10].sorted = true;
                }
                num7++;
            }
            int num11  = 0;
            int count9 = exposedList2.Count;

            while (num11 < count9)
            {
                this.SortBone(exposedList2.Items[num11]);
                num11++;
            }
        }
コード例 #26
0
        internal static void SetPropertyToSetupPose(this Skeleton skeleton, int propertyID)
        {
            int          num          = propertyID >> 24;
            TimelineType timelineType = (TimelineType)num;
            int          num2         = propertyID - (num << 24);

            switch (timelineType)
            {
            case TimelineType.Event:
                break;

            case TimelineType.Rotate:
            {
                Bone bone = skeleton.bones.Items[num2];
                bone.rotation = bone.data.rotation;
                break;
            }

            case TimelineType.Translate:
            {
                Bone bone = skeleton.bones.Items[num2];
                bone.x = bone.data.x;
                bone.y = bone.data.y;
                break;
            }

            case TimelineType.Scale:
            {
                Bone bone = skeleton.bones.Items[num2];
                bone.scaleX = bone.data.scaleX;
                bone.scaleY = bone.data.scaleY;
                break;
            }

            case TimelineType.Shear:
            {
                Bone bone = skeleton.bones.Items[num2];
                bone.shearX = bone.data.shearX;
                bone.shearY = bone.data.shearY;
                break;
            }

            case TimelineType.Attachment:
                skeleton.SetSlotAttachmentToSetupPose(num2);
                break;

            case TimelineType.Color:
                skeleton.slots.Items[num2].SetColorToSetupPose();
                break;

            case TimelineType.TwoColor:
                skeleton.slots.Items[num2].SetColorToSetupPose();
                break;

            case TimelineType.Deform:
                skeleton.slots.Items[num2].attachmentVertices.Clear();
                break;

            case TimelineType.DrawOrder:
                skeleton.SetDrawOrderToSetupPose();
                break;

            case TimelineType.IkConstraint:
            {
                IkConstraint ikConstraint = skeleton.ikConstraints.Items[num2];
                ikConstraint.mix           = ikConstraint.data.mix;
                ikConstraint.bendDirection = ikConstraint.data.bendDirection;
                break;
            }

            case TimelineType.TransformConstraint:
            {
                TransformConstraint     transformConstraint = skeleton.transformConstraints.Items[num2];
                TransformConstraintData data = transformConstraint.data;
                transformConstraint.rotateMix    = data.rotateMix;
                transformConstraint.translateMix = data.translateMix;
                transformConstraint.scaleMix     = data.scaleMix;
                transformConstraint.shearMix     = data.shearMix;
                break;
            }

            case TimelineType.PathConstraintPosition:
            {
                PathConstraint pathConstraint = skeleton.pathConstraints.Items[num2];
                pathConstraint.position = pathConstraint.data.position;
                break;
            }

            case TimelineType.PathConstraintSpacing:
            {
                PathConstraint pathConstraint = skeleton.pathConstraints.Items[num2];
                pathConstraint.spacing = pathConstraint.data.spacing;
                break;
            }

            case TimelineType.PathConstraintMix:
            {
                PathConstraint pathConstraint = skeleton.pathConstraints.Items[num2];
                pathConstraint.rotateMix    = pathConstraint.data.rotateMix;
                pathConstraint.translateMix = pathConstraint.data.translateMix;
                break;
            }
            }
        }
コード例 #27
0
ファイル: Skeleton.cs プロジェクト: aazzxin/spine-runtimes
        /// <summary>Caches information about bones and constraints. Must be called if bones, constraints or weighted path attachments are added
        /// or removed.</summary>
        public void UpdateCache()
        {
            ExposedList <IUpdatable> updateCache = this.updateCache;

            updateCache.Clear();
            this.updateCacheReset.Clear();

            ExposedList <IkConstraint> ikConstraints = this.ikConstraints;
            var transformConstraints = this.transformConstraints;
            var pathConstraints = this.pathConstraints;
            int ikCount = IkConstraints.Count, transformCount = transformConstraints.Count, pathCount = pathConstraints.Count;
            int constraintCount = ikCount + transformCount + pathCount;

            ExposedList <Bone> bones = this.bones;

            //旧版的设置骨骼方式
            for (int i = 0, n = bones.Count; i < n; i++)
            {
                Bone bone = bones.Items[i];
                updateCache.Add(bone);
                for (int ii = 0; ii < ikCount; ii++)
                {
                    IkConstraint ikConstraint = ikConstraints.Items[ii];
                    if (bone == ikConstraint.bones.Items[ikConstraint.bones.Count - 1])
                    {
                        updateCache.Add(ikConstraint);
                        break;
                    }
                }
            }

            //outer:
            for (int i = 0; i < constraintCount; i++)
            {
                for (int ii = 0; ii < ikCount; ii++)
                {
                    IkConstraint constraint = ikConstraints.Items[ii];
                    if (constraint.data.order == i)
                    {
                        SortIkConstraint(constraint);
                        goto continue_outer;                         //continue outer;
                    }
                }
                for (int ii = 0; ii < transformCount; ii++)
                {
                    TransformConstraint constraint = transformConstraints.Items[ii];
                    if (constraint.data.order == i)
                    {
                        SortTransformConstraint(constraint);
                        goto continue_outer; //continue outer;
                    }
                }
                for (int ii = 0; ii < pathCount; ii++)
                {
                    PathConstraint constraint = pathConstraints.Items[ii];
                    if (constraint.data.order == i)
                    {
                        SortPathConstraint(constraint);
                        goto continue_outer;                         //continue outer;
                    }
                }
                continue_outer : {}
            }

            //3.6版本运行库使用的设置骨骼方式,这会使一些动画的某些部位异常(无动作)
            //for (int i = 0, n = bones.Count; i < n; i++)
            //	SortBone(bones.Items[i]);
        }
コード例 #28
0
        /// <summary>Caches information about bones and constraints. Must be called if the <see cref="Skin"/> is modified or if bones, constraints, or
        /// constraints, or weighted path attachments are added or removed.</summary>
        public void UpdateCache()
        {
            var updateCache = this.updateCache;

            updateCache.Clear();

            int boneCount = this.bones.Count;

            Bone[] bones = this.bones.Items;
            for (int i = 0; i < boneCount; i++)
            {
                Bone bone = bones[i];
                bone.sorted = bone.data.skinRequired;
                bone.active = !bone.sorted;
            }
            if (skin != null)
            {
                BoneData[] skinBones = skin.bones.Items;
                for (int i = 0, n = skin.bones.Count; i < n; i++)
                {
                    var bone = bones[skinBones[i].index];
                    do
                    {
                        bone.sorted = false;
                        bone.active = true;
                        bone        = bone.parent;
                    } while (bone != null);
                }
            }

            int ikCount = this.ikConstraints.Count, transformCount = this.transformConstraints.Count, pathCount = this.pathConstraints.Count;

            IkConstraint[]        ikConstraints        = this.ikConstraints.Items;
            TransformConstraint[] transformConstraints = this.transformConstraints.Items;
            PathConstraint[]      pathConstraints      = this.pathConstraints.Items;
            int constraintCount = ikCount + transformCount + pathCount;

            for (int i = 0; i < constraintCount; i++)
            {
                for (int ii = 0; ii < ikCount; ii++)
                {
                    IkConstraint constraint = ikConstraints[ii];
                    if (constraint.data.order == i)
                    {
                        SortIkConstraint(constraint);
                        goto continue_outer;
                    }
                }
                for (int ii = 0; ii < transformCount; ii++)
                {
                    TransformConstraint constraint = transformConstraints[ii];
                    if (constraint.data.order == i)
                    {
                        SortTransformConstraint(constraint);
                        goto continue_outer;
                    }
                }
                for (int ii = 0; ii < pathCount; ii++)
                {
                    PathConstraint constraint = pathConstraints[ii];
                    if (constraint.data.order == i)
                    {
                        SortPathConstraint(constraint);
                        goto continue_outer;
                    }
                }
                continue_outer : { }
            }

            for (int i = 0; i < boneCount; i++)
            {
                SortBone(bones[i]);
            }
        }
コード例 #29
0
        public void UpdateCache()
        {
            ExposedList <IUpdatable> exposedList = updateCache;

            exposedList.Clear();
            updateCacheReset.Clear();
            ExposedList <Bone> exposedList2 = bones;
            int i = 0;

            for (int count = exposedList2.Count; i < count; i++)
            {
                exposedList2.Items[i].sorted = false;
            }
            ExposedList <IkConstraint>        exposedList3 = ikConstraints;
            ExposedList <TransformConstraint> exposedList4 = transformConstraints;
            ExposedList <PathConstraint>      exposedList5 = pathConstraints;
            int count2 = IkConstraints.Count;
            int count3 = exposedList4.Count;
            int count4 = exposedList5.Count;
            int num    = count2 + count3 + count4;

            for (int j = 0; j < num; j++)
            {
                int num2 = 0;
                while (true)
                {
                    if (num2 < count2)
                    {
                        IkConstraint ikConstraint = exposedList3.Items[num2];
                        if (ikConstraint.data.order == j)
                        {
                            SortIkConstraint(ikConstraint);
                            break;
                        }
                        num2++;
                        continue;
                    }
                    int num3 = 0;
                    while (true)
                    {
                        if (num3 < count3)
                        {
                            TransformConstraint transformConstraint = exposedList4.Items[num3];
                            if (transformConstraint.data.order == j)
                            {
                                SortTransformConstraint(transformConstraint);
                                break;
                            }
                            num3++;
                            continue;
                        }
                        for (int k = 0; k < count4; k++)
                        {
                            PathConstraint pathConstraint = exposedList5.Items[k];
                            if (pathConstraint.data.order == j)
                            {
                                SortPathConstraint(pathConstraint);
                                break;
                            }
                        }
                        break;
                    }
                    break;
                }
            }
            int l = 0;

            for (int count5 = exposedList2.Count; l < count5; l++)
            {
                SortBone(exposedList2.Items[l]);
            }
        }