Exemple #1
0
        /// <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;
            }
        }
Exemple #2
0
        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;
            }
        }
Exemple #3
0
        /// <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);
        }
 /// <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;
 }
Exemple #5
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();
            this.updateCacheReset.Clear();

            int boneCount = this.bones.Items.Length;
            var bones     = this.bones;

            for (int i = 0; i < boneCount; i++)
            {
                Bone bone = bones.Items[i];
                bone.sorted = bone.data.skinRequired;
                bone.active = !bone.sorted;
            }
            if (skin != null)
            {
                Object[] skinBones = skin.bones.Items;
                for (int i = 0, n = skin.bones.Count; i < n; i++)
                {
                    Bone bone = (Bone)bones.Items[((BoneData)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;
            var ikConstraints        = this.ikConstraints;
            var transformConstraints = this.transformConstraints;
            var pathConstraints      = this.pathConstraints;
            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 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 : {}
            }

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