VirtualFramework/Assets/Scripts/Item/Show3DCamera.cs

using DG.Tweening;
using QFramework;
using System;
using UnityEngine;
using UnityEngine.EventSystems;

public class Show3DCamera : MonoBehaviour
{
    public Vector3 targetPos; // Χ<><CEA7><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>Ŀ<EFBFBD><C4BF><EFBFBD><EFBFBD>
    public float rotateSpeed; // <20><>ת<EFBFBD>ٶ<EFBFBD>
    public float moveSpeed; // <20>ƶ<EFBFBD><C6B6>ٶ<EFBFBD>
    public float distance; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD>ľ<EFBFBD><C4BE><EFBFBD>
    public float distanceMin;
    public float distanceMax;
    public Vector2 pitchMinMax/* = new Vector2(-20, 80)*/; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>Χ

    private Vector3 offset; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD><EFBFBD>ƫ<EFBFBD><C6AB><EFBFBD><EFBFBD>
    private float yaw = 0f; // ƫ<><C6AB><EFBFBD>ǣ<EFBFBD><C7A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>
    private float pitch = 0f; // <20><><EFBFBD><EFBFBD><EFBFBD>ǣ<EFBFBD><C7A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>

    public static Show3DCamera instance;

    RectTransform inputRect;
    Camera self;

    private GameObject lastHitObject = null;

    public RenderTexture texture;
    public bool lockMove = false;
    private const float DRAG_THRESHOLD = 1f; // <20><>ק<EFBFBD><D7A7>ֵ

    private Vector2 mouseDownPosition; // <20><>¼<EFBFBD><C2BC><EFBFBD>갴<EFBFBD><EAB0B4>ʱ<EFBFBD><CAB1>λ<EFBFBD><CEBB>

    private bool isDoubleTouching = false; // <20><>¼˫ָ<CBAB><D6B8><EFBFBD><EFBFBD>״̬
    private bool isZooming = false; // <20><>¼˫ָ<CBAB><D6B8><EFBFBD><EFBFBD>״̬

    public enum RotationType
    {
        Orbit,      // ԭ<><D4AD><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD>ת
        Spherical   // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת
    }

    public RotationType type = RotationType.Orbit;

    Transform target;
    Vector3 targetPosition;
    Vector3 targetRotate;
    private float prevTouchDistance; // <20>洢<EFBFBD><E6B4A2>һ֡˫ָ<CBAB><D6B8><EFBFBD><EFBFBD>

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ٵ<EFBFBD>ǰ<EFBFBD><C7B0>ת״̬
    private Quaternion currentRotation;

    private void Awake()
    {
        instance = this;
        self = transform.GetComponent<Camera>();
        DontDestroyOnLoad(this);
        gameObject.SetActive(false);
        TypeEventSystem.Global.Register<OnLock>(OnLockEvent).UnRegisterWhenDisabled(this);
    }

    private void OnEnable()
    {
#if Turing
        gameObject.SetActive(false);
#endif
    }

    private void OnLockEvent(OnLock islock)
    {
        this.lockMove = islock.isLock;
    }

    public void Set(Transform target, float rotateSpeed = 10, float moveSpeed = 0.1f, float distance = 0.1f, float pitchMin = -20, float pitchMax = 80, float distanceMin = 0.2f, float distanceMax = 20f, RectTransform inputRect = null, bool isRenderTexture = true, float moveTime = -1)
    {
        if (target == null)
        {
            Debug.LogError("Target is not assigned!");
            return;
        }

        this.target = target;
        this.targetPosition = target.position;
        this.targetRotate = target.eulerAngles;
        yaw = 0;
        pitch = 0;
        this.inputRect = inputRect;
        this.targetPos = target.transform.position;
        offset = new Vector3(0, 0, -distance);

        if (isRenderTexture)
        {
            self.targetTexture = texture;
        }
        else
        {
            self.targetTexture = null;
        }

        // <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>ת״̬
        currentRotation = Quaternion.Euler(pitch, yaw, 0);
        UpdateCameraPosition(moveTime);
    }

    public void ResetCamera(Transform target, RectTransform inputRect = null, bool isRenderTexture = false)
    {
        if (target == null)
        {
            Debug.LogError("Target is not assigned!");
            return;
        }
        this.target = target;
        this.targetPosition = target.position;
        this.targetRotate = target.eulerAngles;
        yaw = 0;
        pitch = 0;
        this.inputRect = inputRect;
        this.targetPos = target.transform.position;
        offset = new Vector3(0, 0, -distance);

        if (isRenderTexture)
        {
            self.targetTexture = texture;
        }
        else
        {
            self.targetTexture = null;
        }

        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת״̬
        currentRotation = Quaternion.Euler(pitch, yaw, 0);
        UpdateCameraPosition(-1);
    }

    void Update()
    {
        if (targetPos != null && lockMove == false && EventSystem.current.IsPointerOverGameObject() == false)
        {
            // <20><><EFBFBD>ȴ<EFBFBD><C8B4><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>
            if (HandleThreeFingerDrag()) return;

            bool isTouching = Input.touchCount > 0;

            // <20><><EFBFBD><EFBFBD>˫ָ<CBAB><D6B8><EFBFBD><EFBFBD>
            if (isTouching && Input.touchCount == 2)
            {
                HandleTouchZoom();
                isZooming = true;
                isDoubleTouching = true;
                return;
            }
            else if (Input.touchCount == 0)
            {
                isDoubleTouching = false;
                isZooming = false;
            }

            bool shouldRotate = false;
            // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD>ų<EFBFBD>˫ָ<CBAB><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            if (isTouching && Input.touchCount == 1 && !isDoubleTouching)
            {
                if (Input.GetTouch(0).phase == TouchPhase.Began)
                {
                    mouseDownPosition = Input.GetTouch(0).position;

                    // <20><>¼<EFBFBD><C2BC>ǰ<EFBFBD><C7B0>ת״̬
                    if (type == RotationType.Orbit)
                    {
                        currentRotation = Quaternion.Euler(pitch, yaw, 0);
                    }
                }
                if (Input.GetTouch(0).phase == TouchPhase.Moved)
                {
                    float dragDistance = Vector2.Distance(Input.mousePosition, mouseDownPosition);
                    shouldRotate = dragDistance > DRAG_THRESHOLD;
                }
            }
            // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>갴<EFBFBD><EAB0B4>
            else if (Input.GetMouseButtonDown(0) && !isDoubleTouching)
            {
                mouseDownPosition = Input.mousePosition;

                // <20><>¼<EFBFBD><C2BC>ǰ<EFBFBD><C7B0>ת״̬
                if (type == RotationType.Orbit)
                {
                    currentRotation = Quaternion.Euler(pitch, yaw, 0);
                }
            }

            if (Input.GetMouseButton(0) && !isDoubleTouching)
            {
                float dragDistance = Vector2.Distance(Input.mousePosition, mouseDownPosition);
                shouldRotate = dragDistance > DRAG_THRESHOLD;
            }

            // <20><>ת<EFBFBD><D7AA><EFBFBD><EFBFBD>
            if (!isZooming && shouldRotate)
            {
                RotateCamera();
            }

            // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            float scroll = Input.GetAxis("Mouse ScrollWheel");
            if (scroll != 0)
            {
                ZoomCamera(scroll);
            }

            // <20><>ס<EFBFBD><D7A1><EFBFBD><EFBFBD><EFBFBD>Ҽ<EFBFBD>ʱ<EFBFBD>ƶ<EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD><EFBFBD>
            if (Input.GetMouseButton(1))
            {
                MoveTarget();
            }

            DetectHoveredObject();
        }
    }

    // Ψһ<CEA8><D2BB><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>bool<6F><6C><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    private bool HandleThreeFingerDrag()
    {
        if (Input.touchCount == 3)
        {
            // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƽ<EFBFBD><C6BD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD>
            Vector2 totalDelta = Vector2.zero;
            foreach (Touch t in Input.touches)
            {
                totalDelta += t.deltaPosition;
            }
            Vector2 delta = totalDelta / 3f;

            // DPI<50><49><EFBFBD><EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD>
            float dpiScale = Screen.dpi == 0 ? 1 : Screen.dpi / 160f;
            float sensitivity = moveSpeed * 0.1f / dpiScale;

            // Ӧ<><D3A6><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD>ֵ<EFBFBD><D6B5>2<EFBFBD><32><EFBFBD>أ<EFBFBD>
            if (delta.magnitude > 2f)
            {
                // <20><><EFBFBD><EFBFBD><EFBFBD>޸ĺ<DEB8><C4BA><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD>
                MoveTarget(delta.x * sensitivity, delta.y * sensitivity);
            }

            // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            return true;
        }
        return false;
    }

    // ˫ָ<CBAB><D6B8><EFBFBD>Ŵ<EFBFBD><C5B4><EFBFBD>
    private void HandleTouchZoom()
    {
        if (Input.touchCount == 2)
        {
            Touch touch0 = Input.GetTouch(0);
            Touch touch1 = Input.GetTouch(1);

            Vector2 touch0Pos = touch0.position;
            Vector2 touch1Pos = touch1.position;
            float currentDistance = Vector2.Distance(touch0Pos, touch1Pos);

            // DPI<50><49><EFBFBD><EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD>
            float dpi = Screen.dpi == 0 ? 200 : Screen.dpi;
            float zoomFactor = 0.01f * (200 / dpi);

            if (touch0.phase == TouchPhase.Began || touch1.phase == TouchPhase.Began)
            {
                prevTouchDistance = currentDistance;
            }
            else if (touch0.phase == TouchPhase.Moved || touch1.phase == TouchPhase.Moved)
            {
                float deltaDistance = currentDistance - prevTouchDistance;
                // <20><><EFBFBD><EFBFBD><EFBFBD>жϣ<D0B6><CFA3><EFBFBD><EFBFBD><EFBFBD>˫ָ<CBAB><D6B8><EFBFBD><EFBFBD><EFBFBD>仯С<E4BBAF><D0A1>ij<EFBFBD><C4B3><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD>򲻽<EFBFBD><F2B2BBBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ų<EFBFBD><C5B2><EFBFBD>
                if (Mathf.Abs(deltaDistance) > 1f)
                {
                    float scroll = deltaDistance * zoomFactor;
                    ZoomCamera(scroll);
                }
                prevTouchDistance = currentDistance;
            }
        }
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͣ<EFBFBD><CDA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    public void DetectHoveredObject()
    {
        GameObject obj = null;
        Vector2 mousePosition = Input.mousePosition;
        if (inputRect != null)
        {
            var pos = (mousePosition - (Vector2)inputRect.position) / inputRect.lossyScale - inputRect.rect.position;
            mousePosition = pos / inputRect.rect.size;
        }

        var ray = self.ViewportPointToRay(mousePosition);
        RaycastHit raycastHit;
        if (Physics.Raycast(ray, out raycastHit))
        {
            obj = raycastHit.transform.gameObject;

            if (obj != lastHitObject)
            {
                OnMouseEnterObj(obj);

                if (lastHitObject != null && lastHitObject != obj)
                {
                    OnMouseExitObj(lastHitObject);
                    lastHitObject = obj;
                }
            }
        }
        else
        {
            if (lastHitObject != null)
            {
                OnMouseExitObj(lastHitObject);
                lastHitObject = null;
            }
        }
    }

    /// <summary>
    /// <20>۽<EFBFBD>ij<EFBFBD><C4B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    /// </summary>
    public void FocusObj(Vector3 target, float distance = 1f, float moveTime = -1)
    {
        Vector3 cameraPos = target - transform.forward * distance;

        targetPos = target;
        this.distance = distance;
        offset = new Vector3(0, 0, -distance);
        if (moveTime != -1)
        {
            transform.DOMove(cameraPos, moveTime);
        }
        else
        {
            transform.position = cameraPos;
        }
    }

    public void OnMouseEnterObj(GameObject obj)
    {
        TipItem tip = obj.GetComponent<TipItem>();
        if (tip != null)
        {
            tip.OnEnter();
        }
    }

    public void OnMouseExitObj(GameObject obj)
    {
        TipItem tip = obj.GetComponent<TipItem>();
        if (tip != null)
        {
            tip.OnExit();
        }
    }

    // <20>޸ĺ<DEB8><C4BA><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͳһ<CDB3><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4>
    private void MoveTarget(float mouseX = 0, float mouseY = 0)
    {
        if (Mathf.Approximately(mouseX, 0) && Mathf.Approximately(mouseY, 0))
        {
            mouseX = Input.GetAxis("Mouse X") * moveSpeed;
            mouseY = Input.GetAxis("Mouse Y") * moveSpeed;
        }

        transform.Translate(new Vector3(-mouseX, -mouseY, 0));
        targetPos += new Vector3(-mouseX, -mouseY, 0);
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    private void ZoomCamera(float scroll)
    {
        distance -= scroll * 5f;
        distance = Mathf.Clamp(distance, distanceMin, distanceMax);
        offset = new Vector3(0, 0, -distance);
        UpdateCameraPosition();
    }

    // <20>޸<EFBFBD>RotateCamera<72><61><EFBFBD><EFBFBD>
    private void RotateCamera()
    {
        float deltaX = 0, deltaY = 0;

        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        if (Input.touchCount == 1)
        {
            Touch touch = Input.GetTouch(0);
            deltaX = touch.deltaPosition.x;
            deltaY = touch.deltaPosition.y;
        }
        // <20><><EFBFBD>괦<EFBFBD><EAB4A6>
        else
        {
            deltaX = Input.GetAxis("Mouse X") * 10;
            deltaY = Input.GetAxis("Mouse Y") * 10;
            if (Mathf.Abs(deltaX) < DRAG_THRESHOLD && Mathf.Abs(deltaY) < DRAG_THRESHOLD)
                return;
        }

        // Ӧ<><D3A6>DPI<50><49><EFBFBD><EFBFBD>
        float dpiScale = Screen.dpi == 0 ? 1 : Screen.dpi / 160f;
        deltaX *= rotateSpeed * Time.deltaTime / dpiScale;
        deltaY *= rotateSpeed * Time.deltaTime / dpiScale;

        switch (type)
        {
            case RotationType.Orbit:
                yaw += deltaX;
                pitch -= deltaY;
                pitch = Mathf.Clamp(pitch, pitchMinMax.x, pitchMinMax.y);
                UpdateCameraPosition();
                break;
            case RotationType.Spherical:
                target.Rotate(Vector3.up, deltaX, Space.World);
                target.Rotate(Vector3.right, -deltaY, Space.Self);
                break;
        }
    }

    public void ChangeMode(RotationType type)
    {
        this.type = type;
        target.position = targetPosition;
        target.eulerAngles = targetRotate;
        ResetCamera(this.target);
    }

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD>úͳ<C3BA><CDB3><EFBFBD>
    private void UpdateCameraPosition(float moveTime = -1)
    {
        if (type == RotationType.Orbit)
        {
            // ʹ<><CAB9><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD>ƫ<EFBFBD><C6AB><EFBFBD><EFBFBD>
            Quaternion rotation = Quaternion.Euler(pitch, yaw, 0);
            Vector3 rotatedOffset = rotation * offset;

            if (moveTime != -1)
            {
                transform.DOMove(targetPos + rotatedOffset, moveTime).onUpdate = () =>
                    transform.LookAt(targetPos);
            }
            else
            {
                transform.position = targetPos + rotatedOffset;
                transform.LookAt(targetPos);
            }
        }
        else if (type == RotationType.Spherical)
        {
            // <20><><EFBFBD><EFBFBD>ģʽ<C4A3>µ<EFBFBD><C2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
            if (moveTime != -1)
            {
                transform.DOMove(targetPos + offset, moveTime).onUpdate = () =>
                    transform.LookAt(targetPos);
            }
            else
            {
                transform.position = targetPos + offset;
                transform.LookAt(targetPos);
            }
        }
    }
}