Unity流体效果_unity pipeflow

一：TrailRenderer模拟管道流体

效果如图所示：

首先，先构造流体因子

构造流体因子：创建一个空物体，挂载TrailRenderer组件，创建一个材质球，命名为Trail1，将其Shader设为Mobile/Particles/Additive,然后将下面所示的纹理图片赋值给Trail1，作为其的Particle Texture。

纹理图片素材：

然后挂载FlowItem脚本，完整脚本如下所示：
流体因子类：FlowItem.cs

using UnityEngine;

public class FlowItem : MonoBehaviour {

    public float DelayDestroy = 0.5f;

    private bool _isFlowing = false;
    private PipeFlow _pipeFlow;
    private int _flowIndex = 0;
    private int _nextIndex = 1;
    private float _flowPosition = 0f;
    private Coroutine _stopCoroutine;

    private void Reset()
    {
        transform.position = _pipeFlow.FlowPath[0];

        TrailRenderer[] trails = GetComponentsInChildren<TrailRenderer>();
        for (int i = 0; i < trails.Length; i++)
        {
            trails[i].Clear();
        }

        ParticleSystem[] pss = GetComponentsInChildren<ParticleSystem>();
        for (int i = 0; i < pss.Length; i++)
        {
            pss[i].SetParticles(null, 0);
        }
    }

    private void Update()
    {
        if (_isFlowing)
        {
            _flowPosition += _pipeFlow.FlowSpeeds[_flowIndex];
            transform.position = Vector3.Lerp(_pipeFlow.FlowPath[_flowIndex], _pipeFlow.FlowPath[_nextIndex], _flowPosition);

            if (_flowPosition >= 1f)
            {
                if (_nextIndex >= _pipeFlow.FlowPath.Count - 1)
                {
                    _isFlowing = false;

                    _stopCoroutine = StartCoroutine(PipeFlow.DelayExecute(() => {
                        Stop();
                    }, DelayDestroy));
                }
                else
                {
                    _flowIndex += 1;
                    _nextIndex = _flowIndex + 1;
                    _flowPosition = 0f;
                }
            }
        }
    }

    public void Shoot(PipeFlow pipeFlow)
    {
        _pipeFlow = pipeFlow;
        Reset();

        gameObject.SetActive(true);
        _isFlowing = true;
        _flowIndex = 0;
        _nextIndex = 1;
        _flowPosition = 0f;

        if (_stopCoroutine != null)
        {
            StopCoroutine(_stopCoroutine);
            _stopCoroutine = null;
        }
    }

    public void Stop()
    {
        gameObject.SetActive(false);
        _isFlowing = false;

        if (!_pipeFlow.Items.Contains(this))
        {
            _pipeFlow.Items.Add(this);
        }

        if (_stopCoroutine != null)
        {
            StopCoroutine(_stopCoroutine);
            _stopCoroutine = null;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

最后将其做成预制体即可。
然后可以看下我TrailRenderer的属性设置，FlowItem的Delay Destroy属性为此流体因子延时消亡的时间，最好跟TrailRenderer的Time属性保持一致，这样的话才不会看到整条TrailRenderer突然消失的情况：

每一个流体因子携带一个拖尾渲染器，由PipeFlow根据其属性FlowInterval（间隔发射时间）进行持续发射（如果不是OnlyOnce模式），每一个流体因子从路径起点抵达路径终点的时间为FlowTime。

//PipeFlow.cs
public void Flow(Action endAction);

1
2
3

外部调用Flow方法为开启流体，参数endAction当第一个流体因子抵达管道路径终点时触发，可以为空。

其次，实现管道路径

因为TrailRenderer可以通过设置Corner Vertices（拐角处顶点数量）来自动圆角，所以不用考虑使用任何曲线算法，这样还能保证我们的路径点绝对的贴合管道，毕竟管道模型可能会有你意想不到的弯曲复杂度。
不过我们为了要保证流体在管道的每一个位置都保持相同速度流动，所以必须为每一个路段指定不同的流动速度。
管道流体实例类：PipeFlow.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PipeFlow : MonoBehaviour {

    public FlowItem ItemTemplate;
    public float FlowTime = 1f;
    public float FlowInterval = 0.5f;
    public bool OnlyOnce = false;

    [HideInInspector]
    public List<Vector3> FlowPath = new List<Vector3>();
    [HideInInspector]
    public List<float> FlowSpeeds = new List<float>();
    [HideInInspector]
    public List<FlowItem> Items = new List<FlowItem>();

    private bool _isInit = false;
    private bool _isFlowing = false;
    private float _flowInterval = 0f;
    private Action _actionTrigger;
    private Coroutine _actionCoroutine;

    private void Awake()
    {
        if (!_isInit)
        {
            Init();
        }
    }

    private void Init()
    {
        float tatol = 0f;
        for (int i = 0; i < FlowPath.Count - 1; i++)
        {
            tatol += Vector3.Distance(FlowPath[i], FlowPath[i + 1]);
        }
        for (int i = 0; i < FlowPath.Count - 1; i++)
        {
            float dis = Vector3.Distance(FlowPath[i], FlowPath[i + 1]);
            float time = dis / tatol * (FlowTime * 50);
            FlowSpeeds.Add(1f / time);
        }

        _isInit = true;
    }

    private void Update()
    {
        if (_isFlowing)
        {
            _flowInterval += Time.deltaTime;
            if (_flowInterval >= FlowInterval)
            {
                _flowInterval = 0f;
                ShootItem();

                if (OnlyOnce)
                {
                    _isFlowing = false;
                }
            }
        }
    }

    private void ShootItem()
    {
        if (Items.Count > 0)
        {
            Items[0].Shoot(this);
            Items.RemoveAt(0);
        }
        else
        {
            GameObject item = Instantiate(ItemTemplate.gameObject);
            item.transform.parent = transform;
            item.GetComponent<FlowItem>().Shoot(this);
        }
    }

    public void Flow(Action endAction)
    {
        if (FlowPath.Count < 2)
        {
            Debug.LogWarning("路径点数量必须大于等于2！");
            return;
        }
        if (!ItemTemplate)
        {
            Debug.LogWarning("ItemTemplate不能为空！");
            return;
        }

        if (!_isInit)
        {
            Init();
        }

        _isFlowing = true;
        _flowInterval = FlowInterval;

        _actionTrigger = endAction;
        if (_actionCoroutine != null)
        {
            StopCoroutine(_actionCoroutine);
            _actionCoroutine = null;
        }
        if (_actionTrigger != null)
        {
            _actionCoroutine = StartCoroutine(DelayExecute(_actionTrigger, FlowTime));
        }
    }

    public void Stop()
    {
        _isFlowing = false;

        if (_actionCoroutine != null)
        {
            StopCoroutine(_actionCoroutine);
            _actionCoroutine = null;
        }

        FlowItem[] fis = transform.GetComponentsInChildren<FlowItem>();
        foreach (FlowItem fi in fis)
        {
            fi.Stop();
        }
    }

    public static IEnumerator DelayExecute(Action action, float delaySeconds)
    {
        yield return new WaitForSeconds(delaySeconds);
        action();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

该类的编辑器重写：PipeFlowEditor.cs
这个编辑器方法主要是实现在面板上可视化、自定义编辑炉体路径点功能，此类脚本不需要被挂载在某个物体上。

using UnityEngine;
using UnityEditor;
[CustomEditor(typeof(PipeFlow)), CanEditMultipleObjects]
public class PipeFlowEditor : Editor
{
    private PipeFlow _pipeFlow;
    private int _currentIndex = -1;
    private bool _showInEditor = true;

    private void OnEnable()
    {
        _pipeFlow = target as PipeFlow;
    }

    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();

        EditorGUILayout.BeginVertical("HelpBox");

        EditorGUILayout.BeginHorizontal();
        GUILayout.Label("FlowPath");
        _showInEditor = GUILayout.Toggle(_showInEditor, "Show In Editor");
        EditorGUILayout.EndHorizontal();

        if (_showInEditor)
        {
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("路径倒置", "ButtonLeft"))
            {
                if (EditorUtility.DisplayDialog("提示", "是否将整条路径倒置？", "是的", "我再想想"))
                {
                    if (_pipeFlow.FlowPath.Count > 1)
                    {
                        _pipeFlow.FlowPath.Reverse();
                    }
                }
            }
            if (GUILayout.Button("清空路径点", "ButtonRight"))
            {
                if (EditorUtility.DisplayDialog("提示", "是否清空路径点？", "是的", "我再想想"))
                {
                    _pipeFlow.FlowPath.Clear();
                    _currentIndex = -1;
                }
            }
            EditorGUILayout.EndHorizontal();

            for (int i = 0; i < _pipeFlow.FlowPath.Count; i++)
            {
                EditorGUILayout.BeginHorizontal();
                GUI.backgroundColor = _currentIndex == i ? Color.cyan : Color.white;
                if (GUILayout.Button("path point" + (i + 1), "prebutton"))
                {
                    _currentIndex = i;
                    Tools.current = Tool.None;
                }
                GUI.backgroundColor = Color.white;
                if (GUILayout.Button("", "OL Minus", GUILayout.Width(16)))
                {
                    _pipeFlow.FlowPath.RemoveAt(i);
                    _currentIndex = -1;
                }
                EditorGUILayout.EndHorizontal();
            }

            EditorGUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            if (GUILayout.Button("", "OL Plus", GUILayout.Width(16)))
            {
                if (_currentIndex != -1)
                {
                    _pipeFlow.FlowPath.Add(_pipeFlow.FlowPath[_currentIndex]);
                }
                else
                {
                    _pipeFlow.FlowPath.Add(new Vector3(0, 0, 0));
                }
            }
            EditorGUILayout.EndHorizontal();
        }

        EditorGUILayout.EndVertical();
    }

    private void OnSceneGUI()
    {
        if (_showInEditor)
        {
            Handles.color = Color.cyan;
            if (_pipeFlow.FlowPath.Count > 0)
            {
                Handles.Label(_pipeFlow.FlowPath[0], "[" + _pipeFlow.transform.name + "]起点", "ErrorLabel");
            }
            if (_pipeFlow.FlowPath.Count > 1)
            {
                Handles.Label(_pipeFlow.FlowPath[_pipeFlow.FlowPath.Count - 1], "[" + _pipeFlow.transform.name + "]终点", "ErrorLabel");
            }

            for (int i = 0; i < _pipeFlow.FlowPath.Count; i++)
            {
                //每一个操作手柄添加位移功能
                _pipeFlow.FlowPath[i] = Handles.PositionHandle(_pipeFlow.FlowPath[i], Quaternion.identity);
                //重新为每一个操作手柄添加序号标签（i+1）可以在scene看到从1开始，与监视面板的“path point1”对应
                Handles.Label(_pipeFlow.FlowPath[i] + new Vector3(0, 0.025f, 0), "[" + (i + 1) + "]", "ErrorLabel");

                if (i < _pipeFlow.FlowPath.Count - 1)
                    Handles.DrawLine(_pipeFlow.FlowPath[i], _pipeFlow.FlowPath[i + 1]);
            }

            if (_currentIndex != -1)
            {
                _pipeFlow.FlowPath[_currentIndex] = Handles.PositionHandle(_pipeFlow.FlowPath[_currentIndex], Quaternion.identity);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

创建好上面两个脚本类之后，然后在unity中创建一个空物体，挂载PipeFlow脚本，然后将上面所创建的流体因子赋值，设置好合适的时间参数，最后，搭建路径点即可。如图所示：

最后，再强调一下外部调用PipeFlow类里Flow（）方法为开启流体，参数endAction当第一个流体因子抵达管道路径终点时触发，可以为空；调用PipeFlow里Stop（）方法为停止流体。

二：箭头指引效果

效果图如下：

用到的素材如下：

实现步骤如下：
首先：创建一个Cube，然后将如下脚本挂载在Cube上，脚本如下：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class UVMoves : MonoBehaviour
{
    
    public float ScrollSpeed = 10;
    public int countX = 1;
    public float countY = 2;

    private float offsetX = 0.0f;
    private float offsetY = 0.0f;
    // private GameObject singleTexSize;
    // Use this for initialization
    void Start()
    {
        float x_1 = 1.0f / countX;
        float y_1 = 1.0f * countY;
       GetComponent<Renderer>().material.mainTextureScale = new Vector2(x_1, y_1);

    }

    // Update is called once per frame
    void Update()
    {      
    }

    private void FixedUpdate()
    {      
        float frame = (Time.time * ScrollSpeed);
        //offsetX = frame / countX;
        //水平方向运动
        //offsetY = -(frame - frame % countX) / countY / countX;       
        //offsetX = frame / countX;
        //垂直方向运动
        offsetY = frame / countY;
        offsetX = -(frame - frame % countY) / countY / countX;
        GetComponent<Renderer>().material.SetTextureOffset("_MainTex", new Vector2(offsetX, -offsetY));
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

然后，创建一个材质球，Shader类型选择为Unlit/Transparent,然后将箭头的图片素材赋值上去，如下图所示：

然后，将该材质赋值给创建的Cube上，即可。
原理：这种方法就是通过代码控制贴图的UV以一定的速度朝着一定的方向运动。

上述两种方法，过程都比较详细，素材资源也都提供了，基本上可以自行实现，如还不能实现的，可下载这个原工程文件：
https://download.csdn.net/download/qq_44718259/21749562?spm=1001.2014.3001.5501

暂时就这两个方法，后续接触到新的流体效果实现方式再更新。