自研引擎之动画遮罩（Animation Mask）

本文链接：https://blog.csdn.net/qq_33060405/article/details/144147253

在动画系统中，使用动画遮罩（Animation Mask）可以让我们控制哪些部分的动画受到影响。这在角色动画中非常有用，例如在角色行走时，可能希望手臂的动画不受行走动画的影响，而是独立地进行挥手或其他动作。

1. 动画遮罩的基本概念

动画遮罩通常是一个布尔值数组或位掩码，用于指示每个骨骼或动画部分是否应该受到当前动画的影响。通过这种方式，我们可以在同一时间播放多个动画，并选择性地应用它们。

2. 实现动画遮罩

以下是一个简单的动画遮罩实现示例：

public class AnimationMask
{
    private bool[] mask;

    public AnimationMask(int boneCount)
    {
        mask = new bool[boneCount];
    }

    public void SetMask(int boneIndex, bool value)
    {
        if (boneIndex >= 0 && boneIndex < mask.Length)
        {
            mask[boneIndex] = value;
        }
    }

    public bool IsBoneMasked(int boneIndex)
    {
        if (boneIndex >= 0 && boneIndex < mask.Length)
        {
            return mask[boneIndex];
        }
        return false;
    }
}

public class AnimationLayer
{
    public AnimationState AnimationState { get; private set; }
    public float Weight { get; set; } = 1.0f; // 默认权重为1.0
    public float CurrentTime { get; private set; } = 0f;
    public AnimationMask Mask { get; private set; }

    public AnimationLayer(AnimationState animationState, float weight, AnimationMask mask)
    {
        AnimationState = animationState;
        Weight = weight;
        Mask = mask;
    }

    public void Update(float deltaTime)
    {
        CurrentTime += deltaTime;
    }

    public float GetValue(int boneIndex)
    {
        if (Mask.IsBoneMasked(boneIndex))
        {
            return 0f; // 如果被遮罩，返回0
        }
        return AnimationState.Clip.GetValueAtTime(CurrentTime);
    }
}

public class AnimationController
{
    private List<AnimationLayer> layers = new List<AnimationLayer>();

    public void AddLayer(AnimationState state, float weight, AnimationMask mask)
    {
        layers.Add(new AnimationLayer(state, weight, mask));
    }

    public void Update(float deltaTime)
    {
        float[] blendedValues = new float[mask.Length];
        float[] totalWeights = new float[mask.Length];

        foreach (var layer in layers)
        {
            layer.Update(deltaTime);
            for (int i = 0; i < blendedValues.Length; i++)
            {
                float value = layer.GetValue(i);
                blendedValues[i] += value * layer.Weight;
                totalWeights[i] += layer.Weight;
            }
        }

        for (int i = 0; i < blendedValues.Length; i++)
        {
            if (totalWeights[i] > 0)
            {
                blendedValues[i] /= totalWeights[i]; // 归一化混合值
            }
        }

        ApplyAnimationValues(blendedValues);
    }

    private void ApplyAnimationValues(float[] values)
    {
        // 在这里应用动画值，例如更新角色的属性
        for (int i = 0; i < values.Length; i++)
        {
            Console.WriteLine($"Applying blended animation value for bone {i}: {values[i]}");
        }
    }
}

3. 使用示例

以下是如何使用上述动画遮罩系统的示例：

public class Program
{
    public static void Main(string[] args)
    {
        // 假设角色有5个骨骼
        int boneCount = 5;

        // 创建动画片段
        var walkClip = new AnimationClip();
        walkClip.AddKeyFrame(0f, 0f);
        walkClip.AddKeyFrame(1f, 1f);
        walkClip.AddKeyFrame(2f, 0f); // 假设走路动画在2秒时结束

        var waveClip = new AnimationClip();
        waveClip.AddKeyFrame(0f, 0f);
        waveClip.AddKeyFrame(0.5f, 1f);
        waveClip.AddKeyFrame(1f, 0f); // 假设挥手动画在1秒时结束

        // 创建动画状态
        var walkState = new AnimationState("Walk", walkClip);
        var waveState = new AnimationState("Wave", waveClip);

        // 创建动画控制器
        var animationController = new AnimationController();

        // 创建动画遮罩
        var mask = new AnimationMask(boneCount);
        mask.SetMask(0, true); // 第一个骨骼被遮罩
        mask.SetMask(1, false); // 第二个骨骼不被遮罩
        mask.SetMask(2, false); // 第三个骨骼不被遮罩
        mask.SetMask(3, true); // 第四个骨骼被遮罩
        mask.SetMask(4, false); // 第五个骨骼不被遮罩

        // 添加动画层
        animationController.AddLayer(walkState, 1.0f, mask); // 走路层
        animationController.AddLayer(waveState, 0.5f, mask); // 挥手层，权重较低

        // 更新动画
        for (float time = 0; time <= 2f; time += 0.1f)
        {
            animationController.Update(0.1f);
        }
    }
}

4. 扩展功能

可以根据需要扩展动画遮罩系统的功能，例如：

动态遮罩：在运行时根据游戏状态动态调整遮罩。
多种遮罩类型：支持不同类型的遮罩，例如基于权重的遮罩。
可视化编辑：在编辑器中提供可视化的遮罩编辑功能。

5. 总结

通过实现动画遮罩系统，我们可以在同一时间播放多个动画，并选择性地应用它们。这种方法在角色动画中非常有用，可以实现更复杂和丰富的动画效果。

我们可以进一步扩展动画遮罩系统的功能和实现细节，以便更好地满足复杂动画需求。以下是一些可以考虑的扩展和改进：

6. 动态遮罩

动态遮罩允许在运行时根据游戏状态或角色状态调整遮罩。这可以通过添加方法来实现，例如：

public void UpdateMask(int boneIndex, bool isMasked)
{
    if (boneIndex >= 0 && boneIndex < mask.Length)
    {
        mask[boneIndex] = isMasked;
    }
}

7. 多种遮罩类型

可以实现不同类型的遮罩，例如基于权重的遮罩。这样可以让每个骨骼在不同动画层中有不同的影响程度。以下是一个简单的实现示例：

public class WeightedAnimationMask
{
    private float[] weights;

    public WeightedAnimationMask(int boneCount)
    {
        weights = new float[boneCount];
    }

    public void SetWeight(int boneIndex, float weight)
    {
        if (boneIndex >= 0 && boneIndex < weights.Length)
        {
            weights[boneIndex] = weight;
        }
    }

    public float GetWeight(int boneIndex)
    {
        if (boneIndex >= 0 && boneIndex < weights.Length)
        {
            return weights[boneIndex];
        }
        return 0f; // 默认权重为0
    }
}

8. 可视化编辑

在游戏引擎中，提供可视化的遮罩编辑功能可以极大地提高开发效率。可以考虑在编辑器中实现一个界面，允许开发者通过拖放或选择来设置每个骨骼的遮罩状态。

9. 动画过渡

在层之间实现平滑过渡可以使动画看起来更加自然。可以通过插值来实现这一点。例如，在更新动画时，可以根据当前时间和目标时间来计算当前动画的权重。

public void BlendToLayer(int layerIndex, float targetWeight, float transitionTime)
{
    if (layerIndex >= 0 && layerIndex < layers.Count)
    {
        var layer = layers[layerIndex];
        float currentWeight = layer.Weight;
        float deltaWeight = (targetWeight - currentWeight) / transitionTime;

        // 在每次更新中逐渐调整权重
        layer.Weight += deltaWeight * Time.deltaTime; // Time.deltaTime 是每帧的时间
    }
}

10. 完整示例

以下是一个更完整的示例，结合了动态遮罩、权重遮罩和动画过渡：

public class AnimationLayer
{
    public AnimationState AnimationState { get; private set; }
    public float Weight { get; set; } = 1.0f;
    public float CurrentTime { get; private set; } = 0f;
    public WeightedAnimationMask Mask { get; private set; }

    public AnimationLayer(AnimationState animationState, float weight, WeightedAnimationMask mask)
    {
        AnimationState = animationState;
        Weight = weight;
        Mask = mask;
    }

    public void Update(float deltaTime)
    {
        CurrentTime += deltaTime;
    }

    public float GetValue(int boneIndex)
    {
        if (Mask.GetWeight(boneIndex) == 0f)
        {
            return 0f; // 如果被遮罩，返回0
        }
        return AnimationState.Clip.GetValueAtTime(CurrentTime) * Mask.GetWeight(boneIndex);
    }
}

public class AnimationController
{
    private List<AnimationLayer> layers = new List<AnimationLayer>();

    public void AddLayer(AnimationState state, float weight, WeightedAnimationMask mask)
    {
        layers.Add(new AnimationLayer(state, weight, mask));
    }

    public void Update(float deltaTime)
    {
        float[] blendedValues = new float[mask.Length];
        float[] totalWeights = new float[mask.Length];

        foreach (var layer in layers)
        {
            layer.Update(deltaTime);
            for (int i = 0; i < blendedValues.Length; i++)
            {
                float value = layer.GetValue(i);
                blendedValues[i] += value * layer.Weight;
                totalWeights[i] += layer.Weight;
            }
        }

        for (int i = 0; i < blendedValues.Length; i++)
        {
            if (totalWeights[i] > 0)
            {
                blendedValues[i] /= totalWeights[i]; // 归一化混合值
            }
        }

        ApplyAnimationValues(blendedValues);
    }

    private void ApplyAnimationValues(float[] values)
    {
        for (int i = 0; i < values.Length; i++)
        {
            Console.WriteLine($"Applying blended animation value for bone {i}: {values[i]}");
        }
    }
}