从0开始学Unity做SLG系列（主场景移动, EasyTouch）_unity制作slg场景插件

主场景（拖动/缓动/缩放/边界）

  文章链接贴在这里，防止丢失把代码转过来,这里有两篇，分别是移动镜头和移动场景。
  需要提示的是，这个需要下载一个easytouch5的第三方库(我这里是unity2019)，已经不维护了，官方下不到，需要自己找，然后在Hierarchy里创建个EasyToch，不然代码不生效。

参考资料：
EasyTouch基本用法
https://www.cnblogs.com/chinarbolg/p/9601477.html
Unity3D EasyTouch 初步使用教程（详细）
http://blog.csdn.net/lifeonelive/article/details/47974905
【Unity插件】EasyTouch5教程
http://blog.csdn.net/weixin_38158625/article/details/72673294
Unity插件——EasyTouch的使用
http://blog.csdn.net/u014086857/article/details/52087379
Unity3d 插件研究之EasyTouch插件
https://blog.csdn.net/qq_23377827/article/details/80820679

using UnityEngine;
using HedgehogTeam.EasyTouch;
#if UNITY_EDITOR
using UnityEditor;
#endif

namespace DCG
{
    /// <summary>
    /// 摄像机管理类.
    /// 挂载到摄像机所在的GameObject.
    /// @Author:Danny Yan
    /// </summary>
    public class SceneCameraView : MonoBehaviour
    {
        /// 摄像机距离
        private float distance = 100;
        [Tooltip("边界,顺序:左上->右上->右下->左下")]
        public Vector3[] rect = new Vector3[4]{
            new Vector3(70.0f, 160.0f, -65.1f),
            new Vector3(324.6f, 160.0f, -65.1f),
            new Vector3(324.6f, 160.0f, -182.5f),
            new Vector3(70.0f, 160.0f, -182.5f)
        };

        [Tooltip("缩放时的最高高度")]
        public float scaleMaxY = 160;
        [Tooltip("缩放时的最低高度")]
        public float scaleMinY = 100;

        private Camera mainCamera;

        [Tooltip("摄像机移动到的目标点"),SerializeField]
        private Vector3 lerpMoveTarget = Vector3.zero;

        /// swipe结束后需要继续滑动的系数,是对swipe的gesture.deltaPosition的缩放,值越大滑动得越远
        [Tooltip("手势滑动结束后,需要继续移动的系数,值越大移动得越远")]
        public float lerpGoOnMoveScale = 6f;
        /// lerpMove速度,值越大滑动得越快
        [Tooltip("手势滑动结束后,继续(减速)移动的速度,值越大移动得越快")]
        public float lerpMoveSpeed = 10f;
        [Tooltip("射线最大检测距离")]
        public float rayDistance = 2000;

        /// 是否要进行lerpMove
        internal bool lerpMove = false;
        [SerializeField]
        internal bool showDebugLines = false;

        private bool isPinching = false;

        private void Awake()
        {
            this.mainCamera = this.gameObject.GetComponent<Camera>();
            this.lerpMove = false;

            lerpMoveTarget = this.transform.localPosition;

            this.GetCameraToTargetDistance();

            EasyTouch.On_Pinch += EasyTouch_On_Pinch;
            EasyTouch.On_DragStart += EasyTouch_On_DragStart;
            EasyTouch.On_SwipeStart += EasyTouch_On_SwipeStart;
            EasyTouch.On_Drag += EasyTouch_On_Drag;
            EasyTouch.On_Swipe += EasyTouch_On_Swipe;
            EasyTouch.On_DragEnd += EasyTouch_On_DragEnd;
            EasyTouch.On_SwipeEnd += EasyTouch_On_SwipeEnd;

            EasyTouch.On_TouchUp2Fingers += EasyTouch_On_TouchUp2Fingers;
        }

        private void OnDestroy()
        {
            EasyTouch.On_DragStart -= EasyTouch_On_DragStart;
            EasyTouch.On_SwipeStart -= EasyTouch_On_SwipeStart;
            EasyTouch.On_Drag -= EasyTouch_On_Drag;
            EasyTouch.On_Swipe -= EasyTouch_On_Swipe;
            EasyTouch.On_DragEnd -= EasyTouch_On_DragEnd;
            EasyTouch.On_SwipeEnd -= EasyTouch_On_SwipeEnd;
            EasyTouch.On_TouchUp2Fingers -= EasyTouch_On_TouchUp2Fingers;
        }

        /// <summary>
        /// 缩放
        /// </summary>
        /// <param name="gesture"></param>
        private void EasyTouch_On_Pinch(Gesture gesture)
        {
            this.isPinching = true;

            // 往外扩(放大)是负数,往内聚(缩小)是整数
            float scaleDelta = gesture.deltaPinch * UnityEngine.Time.deltaTime;

            // 缩放中心点(相对于屏幕左下角)
            Vector2 scaleCenterPos = gesture.position;

            // 计算摄像机视口(摄像机显示画面)的宽高
            float halfFOV = (this.mainCamera.fieldOfView * 0.5f) * Mathf.Deg2Rad;
            float aspect = this.mainCamera.aspect;

            // 视口在Z轴上变化时(相当于缩放效果),对应的宽高变化量,相当于直接使用scaleDelta作为Z轴的变化距离
            float scaleH = scaleDelta * Mathf.Tan(halfFOV) * 2;
            float scaleW = scaleH * aspect;

            // 缩放中心点在屏幕中的比例,减0.5f,因为世界坐标是相对于屏幕的中心
            float cpRateX = scaleCenterPos.x / Screen.width - 0.5f;
            float cpRateY = scaleCenterPos.y / Screen.height - 0.5f;

            Vector3 pos = this.transform.localPosition;
            // scaleW*cpRateX 表示视口画面宽度变化偏移度.
            // 如果cpRateX,cpRateY都为0,表示X轴,Y轴上无变化,则只以transform.forward为实际变化,效果为沿着视口中心的路径上(Z轴)前进/后退.
            // 比如cpRateX为0.2f,表示在屏幕中心右侧20%位置处作为手势缩放中心点进行操作,
            // scaleW此时假如为-5(表示放大),则transform.right就还需要往左走-1f,
            // 最终效果为transform.forward按scaleDelta前进,同时X轴往左移动,这样视觉上20%位置处没有发生任何偏移. Y轴同理
            pos += transform.right * (scaleW * cpRateX);
            pos += transform.up * (scaleH * cpRateY);
            pos += transform.forward * scaleDelta;

            if (pos.y <= scaleMaxY && pos.y >= scaleMinY)
            {
                this.transform.localPosition = pos;
                var borderScVec = new Vector3(scaleW * .5f, 0, scaleH * .5f);
                // 边界跟随
                for (int i = 0; i < rect.Length; i++)
                {
                    rect[i] += transform.right * (scaleW * cpRateX);
                    rect[i] += transform.up * (scaleH * cpRateY);
                    rect[i] += transform.forward * scaleDelta;
                }
            }

            this.GetCameraToTargetDistance();
        }

        private void EasyTouch_On_TouchUp2Fingers(Gesture gesture)
        {
            this.isPinching = false;
        }


        /// <summary>
        /// 开始拖
        /// </summary>
        /// <param name="gesture"></param>
        private void EasyTouch_On_DragStart(Gesture gesture)
        {
            EasyTouch_On_SwipeStart(gesture);
        }

        /// <summary>
        /// 开始划
        /// </summary>
        /// <param name="gesture"></param>
        private void EasyTouch_On_SwipeStart(Gesture gesture)
        {
            this.lerpMoveTarget = Vector3.zero;
            this.lerpMove = false;
        }

        /// <summary>
        /// 拖
        /// </summary>
        /// <param name="gesture"></param>
        private void EasyTouch_On_Drag(Gesture gesture)
        {
            EasyTouch_On_Swipe(gesture);
        }

        /// <summary>
        /// 划
        /// </summary>
        /// <param name="gesture"></param>
        private void EasyTouch_On_Swipe(Gesture gesture)
        {
            if (this.isPinching) return;

            this.lerpMoveTarget = Vector3.zero;
            this.lerpMove = false;

            // 计算摄像机视口(摄像机显示画面)的宽高
            float halfFOV = (this.mainCamera.fieldOfView * 0.5f) * Mathf.Deg2Rad;
            float aspect = this.mainCamera.aspect;

            // 从camera开始到当前屏幕点击点对应世界坐标下的distance
            var screenPosition = gesture.position;
            var ray = this.mainCamera.ScreenPointToRay(screenPosition);
            RaycastHit hit;
            var screenPointDistance = this.distance;
            if (Physics.Raycast(ray, out hit, this.rayDistance))
            {
                screenPointDistance = hit.distance;
            }

            // float halfH = this.distance * Mathf.Tan(halfFOV);
            float halfH = screenPointDistance * Mathf.Tan(halfFOV);
            float halfW = halfH * aspect;
            // gesturePos是相对于屏幕的操作偏移,通过与Screen的比例乘以halfW,halfH,得到最终在视口上的位移
            // 通过这个计算,最终效果是在拖动时也不能做到完全同步:即拖动场景中某个点到屏幕任意位置,该点依然精确的位于鼠标(手指)处.
            var offx = (-gesture.deltaPosition.x / Screen.width) * halfW;
            var offy = (-gesture.deltaPosition.y / Screen.height) * halfH;

            var v3pos = new Vector3(offx, 0, offy);

            // 只使用y的旋转信息构建一个新的四元数
            var qua = Quaternion.identity;
            qua.y = this.transform.rotation.y;
            // 旋转vector:vector3的各分量被四元数按旋转角度计算新值
            v3pos = qua * v3pos;

            var tagPos = this.transform.localPosition + v3pos;

            if (tagPos.x < rect[0].x)
            {
                tagPos.x = rect[0].x; v3pos.x = 0;
            }
            else
            {
                if (tagPos.x > rect[1].x)
                {
                    tagPos.x = rect[1].x; v3pos.x = 0;
                }
            }

            if (tagPos.z < rect[3].z)
            {
                tagPos.z = rect[3].z; v3pos.z = 0;
            }
            else
            {
                if (tagPos.z > rect[0].z)
                {
                    tagPos.z = rect[0].z; v3pos.z = 0;
                }
            }

            this.transform.Translate(v3pos, Space.World);
            // 额外增加一个分量来,使得lerpMove时进行更多偏移, 效果为:减速滑动得更远
            var extPos = v3pos * lerpGoOnMoveScale; // new Vector3(offx * lerpGoOnScale, 0, offy * lerpGoOnScale);
            extPos = qua * extPos;
            this.lerpMoveTarget = this.WrapPosInRect(tagPos + extPos);
        }


        private void EasyTouch_On_DragEnd(Gesture gesture)
        {
            EasyTouch_On_SwipeEnd(gesture);
        }

        /// <summary>
        /// 开始划
        /// </summary>
        /// <param name="gesture"></param>
        private void EasyTouch_On_SwipeEnd(Gesture gesture)
        {
            this.lerpMove = true;
        }

        private void LateUpdate()
        {
            if (this.lerpMove && this.lerpMoveTarget != Vector3.zero)
            {
                var dist = Vector3.Distance(this.transform.position, this.lerpMoveTarget);
                if (dist >= 0.01f)
                {
                    // var curPos = this.WrapPosInRect(Vector3.Lerp(this.transform.position, this.lerpMoveTarget, Time.deltaTime * this.lerpMoveSpeed));
                    var curPos = Vector3.Lerp(this.transform.position, this.lerpMoveTarget, Time.deltaTime * this.lerpMoveSpeed);
                    this.transform.position = curPos;
                }
                else
                {
                    this.lerpMove = false;
                }
            }

#if UNITY_EDITOR
            if (!showDebugLines) return;

            // 可拖动区域
            Debug.DrawLine(rect[0], rect[1], Color.blue);
            Debug.DrawLine(rect[1], rect[2], Color.blue);
            Debug.DrawLine(rect[2], rect[3], Color.blue);
            Debug.DrawLine(rect[3], rect[0], Color.blue);

            // 视口
            Debug.DrawLine(transform.position, transform.position + transform.forward * 1000, Color.red);

            Vector3[] corners = GetCorners(this.distance);
            Debug.DrawLine(corners[0], corners[1], Color.red); // UpperLeft -> UpperRight
            Debug.DrawLine(corners[1], corners[3], Color.red); // UpperRight -> LowerRight
            Debug.DrawLine(corners[3], corners[2], Color.red); // LowerRight -> LowerLeft
            Debug.DrawLine(corners[2], corners[0], Color.red); // LowerLeft -> UpperLeft
#endif
        }

        private Vector3 WrapPosInRect(Vector3 pos)
        {
            if (pos.x < rect[0].x) pos.x = rect[0].x;
            else
                if (pos.x > rect[1].x) pos.x = rect[1].x;

            if (pos.z < rect[3].z) pos.z = rect[3].z;
            else
                if (pos.z > rect[0].z) pos.z = rect[0].z;

            return pos;
        }


        ///<summary>移动到目标位置,并使其与摄像机中心位置对齐</summary>
        public void LookAt(Vector3 tagV3)
        {
            this.lerpMove = false;
            this.lerpMoveTarget = Vector3.zero;

            // 要lookAt指定目标点,使用向量减法,向量减法常用于取得一个对象到另一个对象之间的方向和距离
            var qua = Quaternion.Euler(transform.eulerAngles);
            var tagPos = tagV3 - (qua * Vector3.forward * this.distance + qua * Vector3.right + qua * Vector3.up);

            if (Vector3.Distance(this.transform.position, tagPos) < 0.01) return;

            this.lerpMove = true;
            this.lerpMoveTarget = this.WrapPosInRect(tagPos);
        }

        /// 得到摄像机与指定对象的距离
        private float GetCameraToTargetDistance()
        {
            Ray ray = new Ray(transform.position, transform.forward);
            RaycastHit hit;
            if (Physics.Raycast(ray, out hit, 1000))
            {
                distance = hit.distance;
            }
            return distance;
        }

        ///<summary>
        /// 计算一个点是否在一个多边形范围内
        /// 如果过该点的线段与多边形的交点不为零且距该点左右方向交点数量都为奇数时  该点再多边形范围内
        /// <summary>
        /// <param name="point">测试点</param>
        /// <param name="vertexs">多边形的顶点集合</param>
        /// <returns><returns>
        public static bool PolygonIsContainPoint(Vector3 point, Vector3[] vertexs)
        {
            //判断测试点和横坐标方向与多边形的边的交叉点
            int leftNum = 0;  //左方向上的交叉点数
            int rightNum = 0;  //右方向上的交叉点数
            int index = 1;
            for (int i = 0; i < vertexs.Length; i++)
            {
                if (i == vertexs.Length - 1) { index = -i; }
                //找到相交的线段 
                if (point.z >= vertexs[i].z && point.z < vertexs[i + index].z || point.z < vertexs[i].z && point.z >= vertexs[i + index].z)
                {
                    Vector3 vecNor = (vertexs[i + index] - vertexs[i]);

                    //处理直线方程为常数的情况
                    if (vecNor.x == 0.0f)
                    {
                        if (vertexs[i].x < point.x)
                        {
                            leftNum++;
                        }
                        else if (vertexs[i].x == point.x)
                        { }
                        else
                        {
                            rightNum++;
                        }
                    }
                    else
                    {
                        vecNor = vecNor.normalized;
                        float k = vecNor.z / vecNor.x;
                        float b = vertexs[i].z - k * vertexs[i].x;

                        if ((point.z - b) / k < point.x)
                        {
                            leftNum++;
                        }
                        else if ((point.z - b) / k == point.x)
                        { }
                        else
                        {
                            rightNum++;
                        }
                    }
                }
            }

            if (leftNum % 2 != 0 || rightNum % 2 != 0)
            {
                return true;
            }
            return false;
        }


#if UNITY_EDITOR
        private Vector3[] GetCorners(float distance)
        {
            Vector3[] corners = new Vector3[4];

            float halfFOV = (mainCamera.fieldOfView * 0.5f) * Mathf.Deg2Rad;
            float aspect = mainCamera.aspect;
            float halfHeight = distance * Mathf.Tan(halfFOV);
            float halfWidth = halfHeight * aspect;

            var tx = this.transform;
            // UpperLeft
            corners[0] = tx.position - (tx.right * halfWidth);
            corners[0] += tx.up * halfHeight;
            corners[0] += tx.forward * distance;

            // UpperRight
            corners[1] = tx.position + (tx.right * halfWidth);
            corners[1] += tx.up * halfHeight;
            corners[1] += tx.forward * distance;

            // LowerLeft
            corners[2] = tx.position - (tx.right * halfWidth);
            corners[2] -= tx.up * halfHeight;
            corners[2] += tx.forward * distance;

            // LowerRight
            corners[3] = tx.position + (tx.right * halfWidth);
            corners[3] -= tx.up * halfHeight;
            corners[3] += tx.forward * distance;

            return corners;
        }
#endif
    }

#if UNITY_EDITOR
    [CustomEditor(typeof(SceneCameraView))]
    public class DCGSceneCameraViewEditor : Editor
    {
        private Vector3 lookAtPos;
        public override void OnInspectorGUI()
        {
            base.OnInspectorGUI();

            var scview = this.target as DCG.SceneCameraView;

            GUILayout.Space(5);
            if (GUILayout.Button("跳转到moveTarget", GUILayout.Height(25)))
            {
                scview.lerpMove = true;
            }
            GUILayout.Space(5);
            lookAtPos = EditorGUILayout.Vector3Field("LookAt坐标点", lookAtPos);
            if (GUILayout.Button("LookAt", GUILayout.Height(25)))
            {
                scview.LookAt(lookAtPos); //new Vector3(122.4f, 5.3f, 132.2f)
            }
        }
    }
#endif
}
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461