Exemple #1
0
        public static void UnifyChannelsWithSameBoneIndex(this EditableBoneWeight editableBoneWeight)
        {
            int channelCount = editableBoneWeight.GetChannelCount();

            for (int i = 0; i < channelCount; ++i)
            {
                BoneWeightData data = editableBoneWeight.GetBoneWeightData(i);

                if (!editableBoneWeight.IsChannelEnabled(i))
                {
                    continue;
                }

                bool weightChanged = false;

                for (int j = i + 1; j < channelCount; ++j)
                {
                    BoneWeightData otherData = editableBoneWeight.GetBoneWeightData(j);

                    if (otherData.boneIndex == data.boneIndex)
                    {
                        weightChanged = true;
                        data.weight  += otherData.weight;
                        editableBoneWeight.EnableChannel(j, false);
                    }
                }

                if (weightChanged)
                {
                    editableBoneWeight.SetBoneWeightData(i, data);
                    editableBoneWeight.CompensateOtherChannels(i);
                }
            }
        }
        public static void UnifyChannelsWithSameBoneIndex(this EditableBoneWeight editableBoneWeight)
        {
            for (var i = 0; i < editableBoneWeight.Count; ++i)
            {
                if (!editableBoneWeight[i].enabled)
                {
                    continue;
                }

                bool weightChanged = false;

                for (var j = i + 1; j < editableBoneWeight.Count; ++j)
                {
                    if (editableBoneWeight[j].boneIndex == editableBoneWeight[i].boneIndex)
                    {
                        weightChanged = true;
                        editableBoneWeight[i].weight += editableBoneWeight[j].weight;
                        editableBoneWeight[j].enabled = false;
                    }
                }

                if (weightChanged)
                {
                    editableBoneWeight.CompensateOtherChannels(i);
                }
            }
        }
        private void SetWeight(float value, bool createNewChannel = true)
        {
            if (boneIndex == -1)
            {
                return;
            }

            Debug.Assert(selection != null);

            for (int i = 0; i < spriteMeshData.vertices.Count; ++i)
            {
                if (selection.Count == 0 && emptySelectionEditsAll ||
                    selection.Count > 0 && selection.IsSelected(i))
                {
                    EditableBoneWeight editableBoneWeight = spriteMeshData.vertices[i].editableBoneWeight;

                    int channel = editableBoneWeight.GetChannelFromBoneIndex(boneIndex);

                    if (channel == -1)
                    {
                        if (createNewChannel)
                        {
                            editableBoneWeight.AddChannel(new BoneWeightData(boneIndex, 0f), true);
                            channel = editableBoneWeight.GetChannelFromBoneIndex(boneIndex);
                        }
                        else
                        {
                            continue;
                        }
                    }

                    BoneWeightData data = editableBoneWeight.GetBoneWeightData(channel);
                    data.weight += value;

                    editableBoneWeight.SetBoneWeightData(channel, data);

                    if (editableBoneWeight.GetWeightSum() > 1f)
                    {
                        editableBoneWeight.CompensateOtherChannels(channel);
                    }

                    editableBoneWeight.FilterChannels(0f);
                }
            }
        }
Exemple #4
0
        public static void SetMultiEditChannelData(this SpriteMeshData spriteMeshData, ISelection selection, int channelIndex,
                                                   bool referenceChannelEnabled, bool newChannelEnabled, BoneWeightData referenceData, BoneWeightData newData)
        {
            if (selection == null)
            {
                throw new ArgumentNullException("selection is null");
            }

            bool channelEnabledChanged = referenceChannelEnabled != newChannelEnabled;
            bool boneIndexChanged      = referenceData.boneIndex != newData.boneIndex;
            bool weightChanged         = referenceData.weight != newData.weight;

            foreach (int i in selection)
            {
                EditableBoneWeight editableBoneWeight = spriteMeshData.vertices[i].editableBoneWeight;
                BoneWeightData     data = editableBoneWeight.GetBoneWeightData(channelIndex);

                if (channelEnabledChanged)
                {
                    editableBoneWeight.EnableChannel(channelIndex, newChannelEnabled);
                }

                if (boneIndexChanged)
                {
                    data.boneIndex = newData.boneIndex;
                }

                if (weightChanged)
                {
                    data.weight = newData.weight;
                }

                editableBoneWeight.SetBoneWeightData(channelIndex, data);

                if (channelEnabledChanged || weightChanged)
                {
                    editableBoneWeight.CompensateOtherChannels(channelIndex);
                }
            }
        }