TysonWu's Blog

public static bool LinesIntersect(Vector2 line0_start, Vector2 line0_end, Vector2 line1_start, Vector2 line1_end, out float line0_cross_line1, out float along_line0, out along_line1, out Vector2 intersect_point)
{
	var dir_line0 = line0_end - line0_start;
	var dir_line1 = line1_end - line1_start;
	line0_cross_line1 = dir_line0.x * dir_line1.y - dir_line0.y * dir_line1.x;
	along_line0 = 0;
	along_line1 = 0;
	intersect_point = Vector2.zero;
	if(line0_cross_line1 == 0) return false;
	var dir_line_start01 = line0_start - line1_start;
	along_line0 = (dir_line1.x * dir_line_start01.y - dir_line1.y * dir_line_start01.x) / line0_cross_line1;
	along_line1 = (dir_line0.x * dir_line_start01.y - dir_line0.y * dir_line_start01.x) / line0_cross_line1;
	// if (along_line0 < 0 || along_line0 > 1 || along_line1 < 0 || along_line1 > 1) return false;
	return true;
}

public WaterFeature :ScriptableRendererFeature
{
    [Serializable]
    public class Settings
    {
        public string TextureName = "_NormalGrabTexture";
        public LayerMask LayerMask;
        public Material normalGrabMaterial;
        public int normalGrabMaterialPassIndex = 0;
        public LayerMask WaterLayerMask;
    }
    class NormalGrabPass : ScriptableRenderPass
    {
        Settings settings;
        Material normalGrabMaterial;
        int normalGrabMaterialPassIndex = 0;
        RenderTargetHandle tempNormalTarget;
        List<ShaderTagId> m_ShaderTagIdList = new List<ShaderTagId>();
        FilteringSettings m_FilteringSettings;
        RenderStateBlock m_RenderStateBlock;
        public NormalGrabPass(Settings settings)
        {
            this.settings = settings;
            normalGrabMaterial = new Material(Shader.Find("Unlit/NormalTexture"));
            normalGrabMaterialPassIndex = 0;
            renderPassEvent = RenderPassEvent.AfterRenderingOpaques;
            tempNormalTarget.Init(settings.TextureName);
            m_ShaderTagIdList.Add(new ShaderTagId("UniversalForward"));
            m_ShaderTagIdList.Add(new ShaderTagId("LightweightForward"));
            m_ShaderTagIdList.Add(new ShaderTagId("SPRDefaultUnlit"));
            m_FilteringSettings = new FilteringSettings(RenderQueueRange.all, settings.LayerMask);
            m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
        }
        public overide void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
        {
            cmd.GetTemporaryRT(tempNormalTarget.id, cameraTextureDescriptor);
            cmd.SetGlobalTexture(settings.TextureName, tempNormalTarget.Identifier());
            ConfigureTarget(tempNormalTarget.Identifier()); //sceen view
            cmd.SetRenderTarget(tempNormalTarget.Identifier()); // game view
        }
        public overrider void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            CommandBuffer cmd = CommandBufferPool.Get();
            context.ExecuteCommandBuffer(cmd);
            cmd.Clear();
            Matrix4x4 viewMatrix = renderingData.cameraData.camera.worldToCameraMatrix;
            Vector3 normal = viewMatrix.MultiplyVector(new Vector3(0,1,0));
            cmd.ClearRenderTarget(false, true, new Color(normal.x, normal.y, normal.z));
            context.ExecuteCommandBuffer(cmd);
            cmd.Clear();

            DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, SortingCriteria.CommonOpaque);
            drawingSettings.overrideMaterial = normalGrabMaterial;
            drawingSettings.overrideMaterialPassIndex = normalGrabMaterialPassIndex;
            contex.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref m_FilteringSettings, ref m_RenderStateBlock);

            context.ExecuteCommandBuffer(cmd);
            CommandBufferPool.Release(cmd);
        }
        public override void FrameCleanup(CommandBuffer cmd)
        {
            cmd.ReleaseTemporaryRT(tempNormalTarget.id);
        }
    }
    class WaterPass : ScriptableRenderPass
    {
        List<ShaderTagId> m_ShaderTagIdList = new List<ShaderTagId>();
        RenderStateBlock m_RenderStateBlock;
        FilteringSettings m_FilteringSettings;
        public WaterPass(Settings settings)
        {
            renderPassEvent = RenderPassEvent.BeforeRenderingTransparents;
            m_ShaderTagIdList.Add(new ShaderTagId("Water"));
            m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
            m_FilteringSettings = new FilteringSettings(RenderQueueRange.transparent, settings.WaterLayerMask);
        }
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            CommandBuffer cmd = CommandBufferPool.Get();
            context.ExecuteCommandBuffer(cmd);
            cmd.Clear();

            DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, SortingCriteria.CommonOpaque);
            contex.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref m_FilteringSettings, ref m_RenderStateBlock);

            context.ExecuteCommandBuffer(cmd);
            CommandBufferPool.Release(cmd);
        }
    }
    [SerializeField] Settings settings = new Settings();
    NormalGrabPass normalGrabPass;
    WaterPass waterPass;
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        renderer.EnqueuePass(normalGrabPass);
        renderer.EnqueuePass(waterPass);
    }
    public override void Create()
    {
        normalGrabPass = new NormalGrabPass(settings);
        waterPass = new WaterPass(settings);
    }
}

Shader "Unlit/NormalTexture"
{
    Properties{}
    SubShader
    {
        Tags {"RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline"}
        ZWrite Off
        ZTest Always
        Pass
        {
            Name "NormalTexture"
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Corel.hlsl"
            struct VertexInput
            {
                float4 posotionCS : POSITION;
                float3 normal : NORMAL;
            };
            struct FragInput
            {
                float4 positionCS : SV_POSITION;
                float3 normal : TEXCOORD0;
            };
            FragInput vert(VertexInput i)
            {
                FragInput o;
                float3 worldPos = TransformObjectToWorld(i.positionOS.xyz);
                float4 clipPos = TransformWorldToHClip(worldPos);
                o.positionCS = clipPos;
                float3 worldNormal = TransformObjectToWorldNormal(i.normal);
                o.normal = TransformWorldToViewDir(worldNormal);
                return o;
            }
            half4 frag(FragInput i) : SV_TARGET
            {
                return half4(i.normal, 1);
            }
            ENDHLSL
        }
    }
}

Shader "Unlit/ToonWater"
{
    Properties
    {
        _DepthGradientShallow("Depth Gradient Shallow", Color) = (0,3,0.8,0.9,0.4)
        _DepthGradientDeep("Depth Gradient Deep", Color) = (0.08, 0.4, 0.1, 0.7)
        _DepthMaxDistance("Depth Maximum Distance", Float) = 1

        _SurfaceNoise("Surface Noise", 2D) = "white"{}
        _SurfaceNoiseCutoff("Surface Noise Cutoff", Range(0,1)) = 0.77
        _FoamColor("Foam Color", Color) = (1,1,1,1)
        _FoamMaxDistance("Foam Max Distance", Float) = 1
        _FoamMinDistance("Foam Min Distance", Float) = 0.4
        _SurfaceNoiseScroll("Surface Noise Scroll Amount", Vector) = (0.03, 0.03, 0, 0)
        _SurfaceDistortion("Surface Distortion", 2D) = "white"{}
        _SurfaceDistortionAmount("Surface Distortion Amount", Range(0,1)) = 0.27
    }
    SubShader
    {
        Tags { "RenderType" = "Transparent" "Queue" = "Transparent" "RenderPipeline" = "UniversalPipeline" }
        Blend SrcAlpha OneMinusSrcAlpha
        ZWrite Off
        Pass
        {
            Tags {"LightMode" = "Water" }
            HLSLPROGRAM
            #define SMOOTHSTEP_AA 0.01
            #pragma vertex vert
            #pragma fragment frag
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
            float4 _DepthGradientShallow;
            float4 _DepthGradientDeep;
            float _DepthMaxDistance;
            TEXTURE2D(_SurfaceNoise);   SAMPLER(sampler_SurfaceNoise);
            float4 _SurfaceNoise_ST;
            float _SurfaceNoiseCutoff;
            float _FoamMaxDistance;
            float _FoamMinDistance;
            float2 _SurfaceNoiseScroll;
            TEXTURE2D(_SurfaceDistortion);  SAMPLER(sampler_SurfaceDistortion);
            float4 _SurfaceDistortion_ST;
            float _SurfaceDistortionAmount;
            TEXTURE2D(_NormalGrabTexture); SAMPLER(sampler_NormalGrabTexture);
            float4 _FoamColor;
            struct VertexInput
            {
                float4 positionOS : POSITION;
                float2 uv : TEXCOORD0;
                float3 normal : NORMAL;
            };
            struct FragInput
            {
                float4 positionCS : SV_POSITION;
                float4 screenPos : TEXCOORD0;
                float3 viewPos : TEXCOORD1;
                float2 noiseUV : TEXCOORD2;
                float2 distortUV : TEXCOORD3;
                float3 viewNormal : NORMAL;
            };
            FragInput vert(VertexInput i)
            {
                FragInput o;
                float3 worldPos = TransformObjectToWorld(i.positionOS.xyz);
                float4 clipPos= TransformWorldToHClip(worldPos);
                float4 screenPos = ConputeScreenPos(clipPos);
                float3 viewPos = TransformWorldToView(worldPos);
                o.positionCS = clipPos;
                o.screenPos = screenPos;
                o.viewPos = viewPos;
                o.noiseUV = TRANSFORM_TEX(i.uv, _SurfaceNoise);
                o.distortUV = TRANSORM_TEX(i.uv, _SurfaceDistortion);
                float3 worldNormal = TransformObjectToWorldNormal(i.normal);
                o.viewNormal = TransformWorldToViewDir(worldNormal);
                return o;
            }
            float4 AlpahBelnd(float4 top, float4 bottom)
            {
                float3 color = top.rgb * top.a + (1 - top.a) * bottom.rgb;
                float alpha = top.a + bottom.a * (1 - top.a);
                return float4(color, alpha);
            }
            half4 frag(FragInput i) : SV_TARGET
            {
                half4 color = float4(1,1,1,1);
                float2 screenUV = i.screenPos.xy / i.screenPos.w;
                float sceeneRawDepth = SampleSceneDepth(sceenUV);
                float sceenEyeDepth = LinearEyeDepth(sceneRawDepth, _ZBufferParams);
                float depthDifference = sceneEyeDepth - i.scenePos.w;

                float waterDephtDifference01 = saturate(depthDifference / _DepthMaxDistance);
                float4 waterColor = lerp(_DepthGradientShallow, _DepthGradientDeep, waterDepthDifference01);

                float2 distortSample = SAMPLE_TEXTURE2D(_SurfaceDistortion, sampler_SurfaceDistortion, i.distorUV).xy;
                distortSample = (distortSample * 2 - 1) * _SurfaceDIstortionAmount;

                float noiseUV = float2(i.noiseUV.x + _Time.y * _SurfaceNoiseScroll.x,
                                        i.noiseUV.y + _Time.y * _SurfaceNoiseScroll.y);
                float surfaceNoiseSample = SAMPLE_TEXTURE2D(_SurfaceNoise, sampler_SurfaceNoise, noiseUV);

                float3 existingNormal = SAMPLE_TEXTURE2D(_NormalGrabTexture, sampler_NormalGrabTexture, screenUV).rgb;
                float normalDot = saturate(do(existingNormal, i.viewNormal));
                float foamDistance = lerp(_FoamMaxDistance, _FoamMinDistance, normalDot);
                float foamDipthDifference01 = saturate(depthDifference / foamDistance);

                float surfaceNoiseCutoff = foamDepthDifference01 * _surfaceNoiseCutoff;
                float surfaceNoise = smoothstep(surfaceNoiseCutoff - SMOOTHSTEP_AA, surfaceNoiseCutoff + SMOOTHSTEP_AA, surfaceNoiseSample);

                float4 surfaceNoiseColor = _FoamColor * surfaceNoise;
                color = ALphaBlend(surfaceNoiseColor, waterColor);
                return color;
            }
            ENDHLSL
        }
    }
}

public static string GetCurrentAssetDirectory()
{
	foreach(var obj in Selection.GetFiltered<Object>(SelectionMode.Assets))
	{
		var path = AssetDataBase.GetAssetPath(obj);
		if(string.IsNullOrEmpty(path))
		{
			return path;
		}
		else if(System.IO.File.Exists(path))
		{
			return System.IO.Path.GetDirectory(path);
		}
	}
	return "Assets";
}

public static class AssetsMenu
{
	[MenuItem("Assets/Create HLSL")]
	public static void CreateHLSL()
	{
		//string projectPath = Path.GetDirectoryName(Application.dataPath);
		
		string assetPath = Path.Combine(GetCurrentAssetDirectory(), "temp.hlsl");
		assetPath = AssetDataBase.generateuniqueAssetPath(assetPath);
		
		AssetDataBase.CreateAsset(new TextAsset("--", assetPath);
		File.WriteAllText(assetPath, ""); // clean
		
		AssetDataBase.SaveAssets();
		AssetDataBase.Refresh();
	}
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 用于UI区域判定
/// </summary>
public class TriggerAreaHandler : MonoBehaviour
{
    RectTransform[] _triggerArea = null;//触发区域
    Camera _camera = null;//画布摄像机
    Canvas _canvas = null;//画布
    void InitTriggerArea()
    {//初始化区域
        if (_triggerArea != null) return;
        _triggerArea = GetComponentsInChildren<RectTransform>();
        _canvas = GetComponentInParent<Canvas>();
        _camera = _canvas.worldCamera;
    }
    /// <summary>
    /// 计算屏幕区域是否在当前区域内
    /// </summary>
    /// <param name="screenPos">屏幕坐标</param>
    /// <returns></returns>
    public bool CheckScreenPosInArea(Vector2 screenPos)
    {
        InitTriggerArea();
        for (int i=0;i< _triggerArea.Length;++i)
        {
            if (RectTransformUtility.RectangleContainsScreenPoint(_triggerArea[i], screenPos, _camera))
                return true;
        }
        return false;
    }
    /// <summary>
    /// 将屏幕点夹紧到该区域
    /// </summary>
    /// <param name="screenPos"></param>
    /// <returns></returns>
    public Vector2 Clamp(Vector2 screenPos)
    {
        InitTriggerArea();
        Vector2 clampPos = _camera.WorldToScreenPoint(_triggerArea[0].position);
        float len = float.MaxValue;
        InitTriggerArea();
        for (int i = 0; i < _triggerArea.Length; ++i)
        {
            RectTransform rectTransform = _triggerArea[i];
            if (RectTransformUtility.RectangleContainsScreenPoint(_triggerArea[i], screenPos, _camera))
            {
                return screenPos;
            }
            else
            {

                Vector2 rectPos = _camera.WorldToScreenPoint(rectTransform.position);
                Rect rect = RectTransformUtility.PixelAdjustRect(rectTransform, _canvas);
                Vector2 clampPos_temp = Clamp(screenPos, rectPos, new Vector2(rect.width/2, rect.height/2));
                float distance = (clampPos_temp - screenPos).sqrMagnitude;
                if (distance < len)
                {
                    len = distance;
                    clampPos = clampPos_temp;
                }
            }
        }
        return clampPos;
    }
    Vector2 Clamp(Vector2 value,Vector2 center, Vector2 halfSize)
    {
        return new Vector2(Clamp(value.x, center.x - halfSize.x, center.x + halfSize.x),
            Clamp(value.y, center.y - halfSize.y, center.y + halfSize.y));
    }
    float Clamp(float value, float min, float max)
    {
        value = value > min ? value : min;
        value = value < max ? value : max;
        return value;
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 控制摇杆显示
/// </summary>
public class JoyStickView : MonoBehaviour
{
    [SerializeField] RectTransform _joyStickCenter;//摇杆的端点
    [SerializeField] RectTransform _joyStickOutline;//摇杆端点区域背景,设置为摇杆端点的父节点
    [SerializeField] float _joyStickAreaScale = 1;//在背景区域的基础上进行缩放，得到一个活动区域

    bool _initSize = false;
    Canvas _canvas = null;
    Vector3 _joyStickOriginScreenPos0 = Vector3.zero; //摇杆初始原点
    Vector3 _joyStickOriginScreenPos = Vector3.zero; //摇杆原点
    float _joyStickRadius = 0;//摇杆真实的屏幕活动半径
    /// <summary>
    /// 获取摇杆屏幕活动半径
    /// </summary>
    /// <returns></returns>
    public float GetJoyStickRadius()
    {
        return _joyStickRadius;
    }
    /// <summary>
    /// 计算背景区域的屏幕尺寸
    /// 在所有函数之前调用
    /// </summary>
    public void CalculateAreaSize()
    {
        if (_initSize) return; 
        _initSize = true;
        if(_canvas==null)  _canvas = GetComponentInParent<Canvas>();
        _joyStickOriginScreenPos0 = _canvas.worldCamera.WorldToScreenPoint(_joyStickOutline.position);
        _joyStickOriginScreenPos = _joyStickOriginScreenPos0;
        SetJoyStickOriginPos(_joyStickOriginScreenPos0);
        Rect rect = RectTransformUtility.PixelAdjustRect(_joyStickOutline, _canvas);
        _joyStickRadius = _joyStickAreaScale * rect.width / 2;
    }
    /// <summary>
    /// 重置摇杆原点为初始原点
    /// </summary>
    /// <returns>摇杆中心点在屏幕上的位置</returns>
    public Vector2 ResetJoyStickOrigionPos()
    {
        SetJoyStickOriginPos(_joyStickOriginScreenPos0);
        return _joyStickOriginScreenPos0;
    }
    /// <summary>
    /// 设置整个摇杆的位置
    /// </summary>
    /// <param name="screenPos">屏幕坐标</param>
    public void SetJoyStickOriginPos(Vector3 screenPos)
    {
        _joyStickOriginScreenPos.x = screenPos.x;
        _joyStickOriginScreenPos.y = screenPos.y;
        _joyStickOutline.position = _canvas.worldCamera.ScreenToWorldPoint(_joyStickOriginScreenPos);
    }
    /// <summary>
    /// 基于偏移向量，设置摇杆显示位置
    /// </summary>
    /// <param name="dir">移动向量</param>
    public void SetJoyStick(Vector2 dir)
    {
        Vector3 dir3 = dir.sqrMagnitude > 1 ? dir.normalized : dir;
        Vector3 joyStickScreenPos = dir3 * _joyStickRadius + _joyStickOriginScreenPos;
        _joyStickCenter.position = _canvas.worldCamera.ScreenToWorldPoint(joyStickScreenPos);
    }
    /// <summary>
    /// 判断屏幕坐标是否在摇杆触发区域里
    /// </summary>
    /// <param name="screenPos">屏幕坐标</param>
    /// <returns></returns>
    public bool InJoyStickArea(Vector2 screenPos)
    {
        float len = Vector2.Distance(screenPos, _joyStickOriginScreenPos);
        return  len < _joyStickRadius;
    }
}

using UnityEngine;
using UnityEngine.EventSystems;
/// <summary>
/// 摇杆控制模块
/// </summary>
public class JoyStickTrigger : MonoBehaviour, IPointerDownHandler, IPointerUpHandler, IDragHandler
{
    public static JoyStickTrigger instance;
    [SerializeField] TriggerAreaHandler _joyStickCenterArea;//摇杆背景中心点活动区域
    [SerializeField] TriggerAreaHandler _joyStickTriggerArea;//可激活摇杆的区域
    [SerializeField] JoyStickView _joyStick;//摇杆
    [SerializeField] float _sensitivity = 1;//摇杆灵敏度
    [SerializeField] float _triggerAreaScale = 1;//摇杆控制区域
    /// <summary>
    /// 摇杆偏移方向
    /// </summary>
    public Vector2 MoveDir { get; private set; }
    /// <summary>
    /// 摇杆偏移长度[0-1]
    /// </summary>
    public float MoveLen { get; private set; }
    /// <summary>
    /// 是否在操控摇杆
    /// </summary>
    public bool IsDraging { get { return _onJoyStickActive; } }
    /// <summary>
    /// 摇杆横向偏移量
    /// </summary>
    public float Horizontal { get { return MoveDir.x * MoveLen; } }
    /// <summary>
    /// 摇杆纵向偏移量
    /// </summary>
    public float Vertical { get { return MoveDir.y * MoveLen; } }

    Vector2 _originScreenPos = Vector2.zero;//激活摇杆的手指点击位置
    Vector2 _dragScreenPos = Vector2.zero;//实时拖动手指位置
    Vector2 _interpolateScreenPos = Vector2.zero;//实时摇杆位置
    bool _onJoyStickActive = false;//摇杆是否激活
    void Awake()
    {
        instance = this;
    }
    void OnEnable()
    {
        _joyStick.CalculateAreaSize();
    }
    void OnDisable()
    {
        OnPointerUp(null);
    }

    public void OnPointerDown(PointerEventData eventData)
    {
        if (!_joyStickTriggerArea.CheckScreenPosInArea(eventData.position))
            return;
        _onJoyStickActive = true;
        //_originScreenPos = eventData.position;
        _originScreenPos = _joyStickCenterArea.Clamp(eventData.position);
        _interpolateScreenPos = _dragScreenPos = eventData.position;
        _joyStick.SetJoyStickOriginPos(_originScreenPos);
    }
    public void OnDrag(PointerEventData eventData)
    {
        if (!_onJoyStickActive) return;
        _dragScreenPos = eventData.position;
    }

    public void OnPointerUp(PointerEventData eventData)
    {
        _onJoyStickActive = false;
        _dragScreenPos = _joyStick.ResetJoyStickOrigionPos();//手指位置归于原点
        //_interpolateScreenPos += _dragScreenPos - _originScreenPos;//将插值点随摇杆位置一起归位
        _interpolateScreenPos = _dragScreenPos;//
        _originScreenPos = _dragScreenPos;//
    }

    private void Update()
    {
        _interpolateScreenPos = Vector2.Lerp(_interpolateScreenPos, _dragScreenPos, Time.deltaTime * _sensitivity);
        Vector2 dir = _interpolateScreenPos - _originScreenPos;
        dir /= _joyStick.GetJoyStickRadius();
        dir = dir.sqrMagnitude > 1 ? dir.normalized : dir;
        MoveDir = dir;
        MoveLen = dir.magnitude;
        _joyStick.SetJoyStick(dir);
    }
}

using UnityEngine;
using UnityEngine.EventSystems;
using System;

/// <summary>
/// UGUI游戏摇杆
/// </summary>
public class Joystick : MonoBehaviour, IPointerDownHandler, IPointerUpHandler, IDragHandler
{
    public static Joystick instance;
    [SerializeField] Camera uiCamera;//摇杆对应的ui摄像机
    [SerializeField] RectTransform _triggerArea;//触发启动摇杆区域
    [SerializeField] RectTransform _joyStickArea;//摇杆活动区域
    [SerializeField] RectTransform centerTrans;//摇杆图标
    [SerializeField] float sensitivity = 1;//摇杆灵敏度
    [SerializeField] float triggerAreaScale = 1;//摇杆控制区域
    /// <summary>
    /// 摇杆偏移方向
    /// </summary>
    public Vector2 moveDir { get; private set; }
    /// <summary>
    /// 摇杆偏移长度[0-1]
    /// </summary>
    public float moveLen { get; private set; }
    /// <summary>
    /// 是否在操控摇杆
    /// </summary>
    public bool isDraging { get; private set; }
    /// <summary>
    /// 摇杆横向偏移量
    /// </summary>
    public float Horizontal { get { return moveDir.x * moveLen; } }
    /// <summary>
    /// 摇杆纵向偏移量
    /// </summary>
    public float Vertical { get { return moveDir.y * moveLen; } }

    Canvas _canvas;
    Canvas canvas { get { if (_canvas == null) _canvas = transform.GetComponentInParent<Canvas>(); return _canvas; } }
    Vector3 targetScreenPointPos = Vector3.zero;
    

    float radius = 0f;
    Vector3 centerScreenPos;
    float depth { get { return centerScreenPos.z; } }
    bool hasInit = false;

    public Action onJoyStickPointerUp;
    private void Start()
    {
        instance = this;

    }
    void OnEnable()
    {
        InitParam();
    }
    void OnDisable()
    {
        isDraging = false;
        targetScreenPointPos = centerScreenPos;
        centerTrans.localPosition = Vector3.zero;
    }
    void InitParam()
    {
        if (hasInit) return;
        hasInit = true;
        centerScreenPos = uiCamera.WorldToScreenPoint(_joyStickArea.position);
        Rect rect = RectTransformUtility.PixelAdjustRect(_joyStickArea, canvas);
        radius = triggerAreaScale * rect.width/2;
        targetScreenPointPos = centerScreenPos;
    }
    public void OnPointerDown(PointerEventData eventData)
    {
        InitParam();
        Vector2 pointScreenPos = eventData.position;
        //if (Vector2.Distance(pointScreenPos, centerScreenPos) > radius) return;

        isDraging = true;
        
        
        //targetScreenPointPos = uiCamera.WorldToScreenPoint(eventData.pointerCurrentRaycast.worldPosition);

    }
    public void OnDrag(PointerEventData eventData)
    {
        if (!isDraging) return;
        Vector3 pointScreenPos = eventData.position;
        pointScreenPos.z = depth;
        Vector3 dir = pointScreenPos - centerScreenPos;
        float len = dir.magnitude;
        len = len > radius ? radius : len;
        dir = len * dir.normalized;
        targetScreenPointPos = centerScreenPos + dir;
    }

    public void OnPointerUp(PointerEventData eventData)
    {
        isDraging = false;
        targetScreenPointPos = centerScreenPos;
        onJoyStickPointerUp?.Invoke();
    }
    
    private void Update()
    {
        Vector3 screenPointPos = uiCamera.WorldToScreenPoint(centerTrans.position);
        if(Vector3.Distance(screenPointPos, targetScreenPointPos)<4)
        {
            screenPointPos = targetScreenPointPos;
        }
        else
        {
            screenPointPos = Vector3.Lerp(screenPointPos, targetScreenPointPos, sensitivity * Time.deltaTime);
        }

        centerTrans.position = uiCamera.ScreenToWorldPoint(screenPointPos);
        moveDir = screenPointPos - centerScreenPos;
        moveDir /= radius;
        moveLen = moveDir.magnitude;
        moveLen = moveLen > 1 ? 1 : moveLen;
    }
}