备份CatanBuilding瘦身独立工程

Assets/Scripts/EventWashing/Tools/BHitScreenBase.cs

@@ -0,0 +1,360 @@
+using CW.Common;
+using PaintCore;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace game
+{
+    /// <summary>This class contains common code for screen based mouse/finger hit components.</summary>
+    public abstract class BHitScreenBase : CwHitPointers
+    {
+        public enum RotationType
+        {
+            Normal,
+            World,
+            ThisRotation,
+            ThisLocalRotation,
+            CustomRotation,
+            CustomLocalRotation
+        }
+
+        public enum RelativeType
+        {
+            WorldUp,
+            CameraUp,
+            DrawAngle
+        }
+
+        public enum DirectionType
+        {
+            HitNormal,
+            RayDirection,
+            CameraDirection
+        }
+
+        public enum EmitType
+        {
+            PointsIn3D = 0,
+            PointsOnUV = 20,
+            TrianglesIn3D = 30
+        }
+
+        [System.Flags]
+        public enum ButtonTypes
+        {
+            LeftMouse = 1 << 0,
+            RightMouse = 1 << 1,
+            MiddleMouse = 1 << 2,
+            Touch = 1 << 5
+        }
+
+        /// <summary>Orient to a specific camera?
+        /// None = MainCamera.</summary>
+        public Camera Camera { set { _camera = value; } get { return _camera; } }
+        [SerializeField] private Camera _camera;
+
+        /// <summary>The layers you want the raycast to hit.</summary>
+        public LayerMask Layers { set { layers = value; } get { return layers; } }
+        [SerializeField] private LayerMask layers = Physics.DefaultRaycastLayers;
+
+        /// <summary>This allows you to control the hit data this component sends out.
+        /// PointsIn3D = Point drawing in 3D.
+        /// PointsOnUV = Point drawing on UV (requires non-convex <b>MeshCollider</b>).
+        /// TrianglesIn3D = Triangle drawing in 3D (requires non-convex <b>MeshCollider</b>).</summary>
+        public EmitType Emit { set { emit = value; } get { return emit; } }
+        [UnityEngine.Serialization.FormerlySerializedAs("draw")][SerializeField] private EmitType emit;
+
+        /// <summary>This allows you to control how the paint is rotated.
+        /// Normal = The rotation will be based on a normal direction, and rolled relative to an up axis.
+        /// World = The rotation will be aligned to the world, or given no rotation.
+        /// ThisRotation = The current <b>Transform.rotation</b> will be used.
+        /// ThisLocalRotation = The current <b>Transform.localRotation</b> will be used.
+        /// CustomRotation = The specified <b>CustomTransform.rotation</b> will be used.
+        /// CustomLocalRotation = The specified <b>CustomTransform.localRotation</b> will be used.</summary>
+        public RotationType RotateTo { set { rotateTo = value; } get { return rotateTo; } }
+        [SerializeField] private RotationType rotateTo;
+
+        /// <summary>Which direction should the hit point rotation be based on?</summary>
+        public DirectionType NormalDirection { set { normalDirection = value; } get { return normalDirection; } }
+        [UnityEngine.Serialization.FormerlySerializedAs("normal")][SerializeField] private DirectionType normalDirection = DirectionType.CameraDirection;
+
+        /// <summary>Based on the normal direction, what should the rotation be rolled relative to?
+        /// WorldUp = It will be rolled so the up vector is world up.
+        /// CameraUp = It will be rolled so the up vector is camera up.
+        /// DrawAngle = It will be rolled according to the mouse/finger movement on screen.</summary>
+        public RelativeType NormalRelativeTo { set { normalRelativeTo = value; } get { return normalRelativeTo; } }
+        [UnityEngine.Serialization.FormerlySerializedAs("orientation")][SerializeField] private RelativeType normalRelativeTo = RelativeType.CameraUp;
+
+        /// <summary>This allows you to specify the <b>Transform</b> when using <b>RotateTo = CustomRotation/CustomLocalRotation</b>.</summary>
+        public Transform CustomTransform { set { customTransform = value; } get { return customTransform; } }
+        [SerializeField] private Transform customTransform;
+
+        /// <summary>Should painting triggered from this component be eligible for being undone?</summary>
+        public bool StoreStates { set { storeStates = value; } get { return storeStates; } }
+        [SerializeField] protected bool storeStates = true;
+
+        /// <summary>This allows you to override the order this paint gets applied to the object during the current frame.</summary>
+        public int Priority { set { priority = value; } get { return priority; } }
+        [SerializeField] private int priority;
+
+        /// <summary>If you want the raycast hit point to be offset from the surface a bit, this allows you to set by how much in world space.</summary>
+        public float NormalOffset { set { normalOffset = value; } get { return normalOffset; } }
+        [SerializeField] private float normalOffset;
+
+        // No longer used
+        [SerializeField] private ButtonTypes requiredButtons;
+
+        // No longer used
+        [SerializeField] private KeyCode requiredKey;
+
+        // No longer used
+        [SerializeField] private float mouseOffset;
+
+        // No longer used
+        [SerializeField] private float touchOffset;
+
+        // No longer used
+        [SerializeField] private bool showPreview;
+
+        private static Transform m_TargetTransform = null;
+        public static void SetTargetTransform(Transform targetTransform)
+        {
+            m_TargetTransform = targetTransform;
+        }
+
+        public bool NeedsDrawAngle
+        {
+            get
+            {
+                return rotateTo == RotationType.Normal && normalRelativeTo == RelativeType.DrawAngle;
+            }
+        }
+
+        private bool m_IsAuthorizedDrawing = false;
+        public void AuthorizedDrawing()
+        {
+            m_IsAuthorizedDrawing = true;
+        }
+        public void NotAuthorizedDrawing()
+        {
+            m_IsAuthorizedDrawing = false;
+        }
+
+#if UNITY_EDITOR
+        protected virtual void Reset()
+        {
+            if (GetComponent<CwPointerMouse>() == null)
+            {
+                requiredButtons &= ~ButtonTypes.LeftMouse;
+                requiredButtons &= ~ButtonTypes.RightMouse;
+                requiredButtons &= ~ButtonTypes.MiddleMouse;
+
+                gameObject.AddComponent<CwPointerMouse>();
+            }
+
+            if (GetComponent<CwPointerTouch>() == null)
+            {
+                requiredButtons &= ~ButtonTypes.Touch;
+
+                gameObject.AddComponent<CwPointerTouch>();
+            }
+
+            if (GetComponent<CwPointerPen>() == null)
+            {
+                gameObject.AddComponent<CwPointerPen>();
+            }
+        }
+#endif
+
+        public bool ShouldUpgradePointers()
+        {
+            return (requiredButtons & ButtonTypes.LeftMouse) != 0
+                || (requiredButtons & ButtonTypes.RightMouse) != 0
+                || (requiredButtons & ButtonTypes.MiddleMouse) != 0
+                || (requiredButtons & ButtonTypes.Touch) != 0;
+        }
+
+        public void TryUpgradePointers()
+        {
+            var lmb = (requiredButtons & ButtonTypes.LeftMouse) != 0;
+            var rmb = (requiredButtons & ButtonTypes.RightMouse) != 0;
+            var mmb = (requiredButtons & ButtonTypes.MiddleMouse) != 0;
+
+            if (lmb == true || rmb == true || mmb == true)
+            {
+                requiredButtons &= ~ButtonTypes.LeftMouse;
+                requiredButtons &= ~ButtonTypes.RightMouse;
+                requiredButtons &= ~ButtonTypes.MiddleMouse;
+
+                var pointerMouse = gameObject.AddComponent<CwPointerMouse>();
+
+                pointerMouse.Preview = showPreview;
+
+                if (lmb == true)
+                {
+                    pointerMouse.TryAddKey(KeyCode.Mouse0);
+                }
+
+                if (rmb == true)
+                {
+                    pointerMouse.TryAddKey(KeyCode.Mouse1);
+                }
+
+                if (mmb == true)
+                {
+                    pointerMouse.TryAddKey(KeyCode.Mouse2);
+                }
+            }
+
+            if ((requiredButtons & ButtonTypes.Touch) != 0)
+            {
+                requiredButtons &= ~ButtonTypes.Touch;
+
+                var pointerTouch = gameObject.AddComponent<CwPointerTouch>();
+
+                pointerTouch.Offset = touchOffset;
+            }
+        }
+
+        protected virtual void DoQuery(Vector2 screenPosition, ref Camera camera, ref Ray ray, ref CwHit hit3D, ref RaycastHit2D hit2D)
+        {
+            var hit = default(RaycastHit);
+
+            camera = CwHelper.GetCamera(_camera);
+            ray = camera.ScreenPointToRay(screenPosition);
+            hit2D = Physics2D.GetRayIntersection(ray, float.PositiveInfinity, layers);
+
+            Physics.Raycast(ray, out hit, float.PositiveInfinity, layers);
+
+            hit3D = new CwHit(hit);
+        }
+
+        protected void PaintAt(CwPointConnector connector, CwHitCache hitCache, Vector2 screenPosition, Vector2 screenPositionOld, bool preview, float pressure, object owner)
+        {
+            var camera = default(Camera);
+            var ray = default(Ray);
+            var hit2D = default(RaycastHit2D);
+            var hit3D = default(CwHit);
+            var finalPosition = default(Vector3);
+            var finalRotation = default(Quaternion);
+
+            DoQuery(screenPosition, ref camera, ref ray, ref hit3D, ref hit2D);
+
+            var valid2D = hit2D.distance > 0.0f;
+            var valid3D = hit3D.Distance > 0.0f;
+
+            // Hit 3D?
+            if (valid3D == true && (valid2D == false || hit3D.Distance < hit2D.distance))
+            {
+                CalcHitData(hit3D.Position, hit3D.Normal, ray, camera, screenPositionOld, ref finalPosition, ref finalRotation);
+
+                if (emit == EmitType.PointsIn3D)
+                {
+                    if (connector != null)
+                    {
+                        if (m_TargetTransform != null && hit3D.Transform != m_TargetTransform) { return; }
+                        if (m_IsAuthorizedDrawing)
+                        {
+                            connector.SubmitPoint(gameObject, preview, priority, pressure, finalPosition, finalRotation, owner);
+                        }
+                        FishingYachtAct.Publish<EventWashingCleanerFollowPositionData>(new EventWashingCleanerFollowPositionData(finalPosition, hit3D.Normal));
+                    }
+                    else
+                    {
+                        hitCache.InvokePoint(gameObject, preview, priority, pressure, finalPosition, finalRotation);
+                    }
+
+                    return;
+                }
+                else if (emit == EmitType.PointsOnUV)
+                {
+                    hitCache.InvokeCoord(gameObject, preview, priority, pressure, hit3D, finalRotation);
+
+                    return;
+                }
+                else if (emit == EmitType.TrianglesIn3D)
+                {
+                    hitCache.InvokeTriangle(gameObject, preview, priority, pressure, hit3D, finalRotation);
+
+                    return;
+                }
+            }
+            // Hit 2D?
+            else if (valid2D == true)
+            {
+                CalcHitData(hit2D.point, new Vector3(0.0f, 0.0f, -1.0f), ray, camera, screenPositionOld, ref finalPosition, ref finalRotation);
+
+                if (emit == EmitType.PointsIn3D)
+                {
+                    if (connector != null)
+                    {
+                        connector.SubmitPoint(gameObject, preview, priority, pressure, finalPosition, finalRotation, owner);
+                    }
+                    else
+                    {
+                        hitCache.InvokePoint(gameObject, preview, priority, pressure, finalPosition, finalRotation);
+                    }
+
+                    return;
+                }
+            }
+
+            if (connector != null)
+            {
+                connector.BreakHits(owner);
+            }
+        }
+
+        private void CalcHitData(Vector3 hitPoint, Vector3 hitNormal, Ray ray, Camera camera, Vector2 screenPositionOld, ref Vector3 finalPosition, ref Quaternion finalRotation)
+        {
+            finalPosition = hitPoint + hitNormal * normalOffset;
+            finalRotation = Quaternion.identity;
+
+            switch (rotateTo)
+            {
+                case RotationType.Normal:
+                    {
+                        var finalNormal = default(Vector3);
+
+                        switch (normalDirection)
+                        {
+                            case DirectionType.HitNormal: finalNormal = hitNormal; break;
+                            case DirectionType.RayDirection: finalNormal = -ray.direction; break;
+                            case DirectionType.CameraDirection: finalNormal = -camera.transform.forward; break;
+                        }
+
+                        var finalUp = Vector3.up;
+
+                        switch (normalRelativeTo)
+                        {
+                            case RelativeType.CameraUp: finalUp = camera.transform.up; break;
+                            case RelativeType.DrawAngle:
+                                {
+                                    var rayOld = camera.ScreenPointToRay(screenPositionOld);
+
+                                    if (camera.orthographic == true)
+                                    {
+                                        finalUp = Vector3.Cross(rayOld.GetPoint(1.0f) - ray.origin, ray.GetPoint(1.0f) - ray.origin);
+                                    }
+                                    else
+                                    {
+                                        finalUp = Vector3.Cross(rayOld.direction, ray.direction);
+                                    }
+                                }
+
+                                break;
+                        }
+
+                        finalRotation = Quaternion.LookRotation(-finalNormal, finalUp);
+                    }
+                    break;
+                case RotationType.World: finalRotation = Quaternion.identity; break;
+                case RotationType.ThisRotation: finalRotation = transform.rotation; break;
+                case RotationType.ThisLocalRotation: finalRotation = transform.localRotation; break;
+                case RotationType.CustomRotation: if (customTransform != null) finalRotation = customTransform.rotation; break;
+                case RotationType.CustomLocalRotation: if (customTransform != null) finalRotation = customTransform.localRotation; break;
+            }
+        }
+    }
+}