Hexo

(?<=_region=)CN(?=&) url 307 JP
(?<=&mcc_mnc=)4 url 307 2
^(https?:\/\/(tnc|dm)[\w-]+\.\w+\.com\/.+)(\?)(.+) url 302  $1$3
(?<=\d\/\?\w{7}_\w{4}=)1[6-9]..(?=.?.?&) url 307 17

hostname = *.tiktokv.com, *byteoversea.com, *tik-tokapi.com

public void SetFloat(string name, float value, float dampTime, float deltaTime);
public void SetFloat(int id, float value, float dampTime, float deltaTime);

var layers = productController.layers;
layers[1].defaultWeight = 1;
layers[1].blendingMode = AnimatorLayerBlendingMode.Additive;
productController.layers = layers;

var layers = productController.layers;
var layer = new UnityEditor.Animations.AnimatorControllerLayer
    {
        name = "Face",
        defaultWeight = 1f,
        blendingMode = AnimatorLayerBlendingMode.Additive,
        stateMachine = new UnityEditor.Animations.AnimatorStateMachine()
     };
productController.AddLayer(layer);

public static void Notify2DMaskStateChanged(Component mask)
{
	var components = ListPool<Component>.Get();
	mask.GetComponentsInChildren(components);
	for (var i = 0; i < components.Count; i++)
	{
		if (components[i] == null || components[i].gameObject == mask.gameObject)
			continue;

		var toNotify = components[i] as IClippable;
		if (toNotify != null)
			toNotify.RecalculateClipping();
	}
	ListPool<Component>.Release(components);
}

public void Cull()
{
	for (var i = 0; i < m_Clippers.Count; ++i)
	{
		m_Clippers[i].PerformClipping();
	}
}

public static Rect FindCullAndClipWorldRect(List<RectMask2D> rectMaskParents, out bool validRect)
{
	if (rectMaskParents.Count == 0)
	{
		validRect = false;
		return new Rect();
	}

	var compoundRect = rectMaskParents[0].canvasRect;
	for (var i = 0; i < rectMaskParents.Count; ++i)
		compoundRect = RectIntersect(compoundRect, rectMaskParents[i].canvasRect);

	var cull = compoundRect.width <= 0 || compoundRect.height <= 0;
	if (cull)
	{
		validRect = false;
		return new Rect();
	}

	Vector3 point1 = new Vector3(compoundRect.x, compoundRect.y, 0.0f);
	Vector3 point2 = new Vector3(compoundRect.x + compoundRect.width, compoundRect.y + compoundRect.height, 0.0f);
	validRect = true;
	return new Rect(point1.x, point1.y, point2.x - point1.x, point2.y - point1.y);
}

private static Rect RectIntersect(Rect a, Rect b)
{
	float xMin = Mathf.Max(a.x, b.x);
	float xMax = Mathf.Min(a.x + a.width, b.x + b.width);
	float yMin = Mathf.Max(a.y, b.y);
	float yMax = Mathf.Min(a.y + a.height, b.y + b.height);
	if (xMax >= xMin && yMax >= yMin)
		return new Rect(xMin, yMin, xMax - xMin, yMax - yMin);
	return new Rect(0f, 0f, 0f, 0f);
}

using System;
using System.Collections.Generic;
using System.Reflection;

namespace UnityEngine.UI
{
    internal class ReflectionMethodsCache
    {
        public delegate bool Raycast3DCallback(Ray r, out RaycastHit hit, float f, int i);
        public delegate RaycastHit2D Raycast2DCallback(Vector2 p1, Vector2 p2, float f, int i);
        public delegate RaycastHit[] RaycastAllCallback(Ray r, float f, int i);
        public delegate RaycastHit2D[] GetRayIntersectionAllCallback(Ray r, float f, int i);
        public delegate int GetRayIntersectionAllNonAllocCallback(Ray r, RaycastHit2D[] results, float f, int i);
        public delegate int GetRaycastNonAllocCallback(Ray r, RaycastHit[] results, float f, int i);

        // We call Physics.Raycast and Physics2D.Raycast through reflection to avoid creating a hard dependency from
        // this class to the Physics/Physics2D modules, which would otherwise make it impossible to make content with UI
        // without force-including both modules.
        public ReflectionMethodsCache()
        {
            var raycast3DMethodInfo = typeof(Physics).GetMethod("Raycast", new[] {typeof(Ray), typeof(RaycastHit).MakeByRefType(), typeof(float), typeof(int)});
            if (raycast3DMethodInfo != null)
                raycast3D = (Raycast3DCallback)UnityEngineInternal.ScriptingUtils.CreateDelegate(typeof(Raycast3DCallback), raycast3DMethodInfo);
    
            var raycast2DMethodInfo = typeof(Physics2D).GetMethod("Raycast", new[] {typeof(Vector2), typeof(Vector2), typeof(float), typeof(int)});
            if (raycast2DMethodInfo != null)
                raycast2D = (Raycast2DCallback)UnityEngineInternal.ScriptingUtils.CreateDelegate(typeof(Raycast2DCallback), raycast2DMethodInfo);
    
            var raycastAllMethodInfo = typeof(Physics).GetMethod("RaycastAll", new[] {typeof(Ray), typeof(float), typeof(int)});
            if (raycastAllMethodInfo != null)
                raycast3DAll = (RaycastAllCallback)UnityEngineInternal.ScriptingUtils.CreateDelegate(typeof(RaycastAllCallback), raycastAllMethodInfo);
    
            var getRayIntersectionAllMethodInfo = typeof(Physics2D).GetMethod("GetRayIntersectionAll", new[] {typeof(Ray), typeof(float), typeof(int)});
            if (getRayIntersectionAllMethodInfo != null)
                getRayIntersectionAll = (GetRayIntersectionAllCallback)UnityEngineInternal.ScriptingUtils.CreateDelegate(typeof(GetRayIntersectionAllCallback), getRayIntersectionAllMethodInfo);
    
            var getRayIntersectionAllNonAllocMethodInfo = typeof(Physics2D).GetMethod("GetRayIntersectionNonAlloc", new[] { typeof(Ray), typeof(RaycastHit2D[]), typeof(float), typeof(int) });
            if (getRayIntersectionAllNonAllocMethodInfo != null)
                getRayIntersectionAllNonAlloc = (GetRayIntersectionAllNonAllocCallback)UnityEngineInternal.ScriptingUtils.CreateDelegate(typeof(GetRayIntersectionAllNonAllocCallback), getRayIntersectionAllNonAllocMethodInfo);
    
            var getRaycastAllNonAllocMethodInfo = typeof(Physics).GetMethod("RaycastNonAlloc", new[] { typeof(Ray), typeof(RaycastHit[]), typeof(float), typeof(int) });
            if (getRaycastAllNonAllocMethodInfo != null)
                getRaycastNonAlloc = (GetRaycastNonAllocCallback)UnityEngineInternal.ScriptingUtils.CreateDelegate(typeof(GetRaycastNonAllocCallback), getRaycastAllNonAllocMethodInfo);
        }
    
        public Raycast3DCallback raycast3D = null;
        public RaycastAllCallback raycast3DAll = null;
        public Raycast2DCallback raycast2D = null;
        public GetRayIntersectionAllCallback getRayIntersectionAll = null;
        public GetRayIntersectionAllNonAllocCallback getRayIntersectionAllNonAlloc = null;
        public GetRaycastNonAllocCallback getRaycastNonAlloc = null;
    
        private static ReflectionMethodsCache s_ReflectionMethodsCache = null;
    
        public static ReflectionMethodsCache Singleton
        {
            get
            {
                if (s_ReflectionMethodsCache == null)
                    s_ReflectionMethodsCache = new ReflectionMethodsCache();
                return s_ReflectionMethodsCache;
            }
        }
    };

}

//获取射线检测到的第一个3D物体
public Raycast3DCallback raycast3D = null;
//返回检测到的所有3D物体
public RaycastAllCallback raycast3DAll = null;
//获取射线检测到的第一个2D物体
public Raycast2DCallback raycast2D = null;
//返回检测到的所有2D游戏物体
public GetRayIntersectionAllCallback getRayIntersectionAll = null;
//返回检测到的所需2D游戏物体，即返回前n个结果，n可以自己定义
public GetRayIntersectionAllNonAllocCallback getRayIntersectionAllNonAlloc = null;
//返回检测到的所需3D游戏物体，即返回前n个结果，n可以自己定义
public GetRaycastNonAllocCallback getRaycastNonAlloc = null;

using UnityEngine;
using UnityEditor;
public class NodeEditor : EditorWindow
{
    Rect window1;
    Rect window2;
    [MenuItem("Window/Node editor")]
    static void ShowEditor()
    {
        NodeEditor editor = EditorWindow.GetWindow<NodeEditor>();
        editor.Init();
    }
    public void Init()
    {
        window1 = new Rect(10, 10, 100, 100);
        window2 = new Rect(210, 210, 100, 100);
    }
    void OnGUI()
    {
        DrawNodeCurve(window1, window2); 
        BeginWindows();
        window1 = GUI.Window(1, window1, DrawNodeWindow, "Window 1");   
        window2 = GUI.Window(2, window2, DrawNodeWindow, "Window 2");
        EndWindows();
    }
    void DrawNodeWindow(int id)
    {
        GUI.DragWindow();
    }
    void DrawNodeCurve(Rect start, Rect end)
    {
        Vector3 startPos = new Vector3(start.x + start.width, start.y + start.height / 2, 0);
        Vector3 endPos = new Vector3(end.x, end.y + end.height / 2, 0);
        Vector3 startTan = startPos + Vector3.right * 50;
        Vector3 endTan = endPos + Vector3.left * 50;
        Color shadowCol = new Color(0, 0, 0, 0.06f);
        for (int i = 0; i < 3; i++) // Draw a shadow
            Handles.DrawBezier(startPos, endPos, startTan, endTan, shadowCol, null, (i + 1) * 5);
        Handles.DrawBezier(startPos, endPos, startTan, endTan, Color.black, null, 1);
    }
}

using UnityEngine;
using UnityEngine.UI;

[ExecuteAlways]
//离线生成圆环 图片 缓存在预制体中
public class CircleSprite : MonoBehaviour
{
    //空白区域色值
    [Header("空白区域色值")]
    public Color emptyColor = new Color(0, 0, 0, 0);
    //圆环区域色值
    [Header("圆环区域色值")]
    public Color circleColor = Color.white;
    //圆环内径/外径
    [Header("圆环内径")]
    public int minRadius = 40;
    [Header("圆环外径[圆形尺寸]")]
    public int maxRadius = 50;
    //扇形角度
    [Header("扇形角度")]
    public float circleAngle = 90;

    Color lastColor = Color.black;
    Color lastCircleColor = Color.black;
    int lastMinRadius = 0;
    int lastMaxRadius = 0;
    float lastCircleAngle = 0;

    private void Update()
    {
        if (Application.isPlaying) return;
        if (lastColor != emptyColor || lastCircleColor != circleColor || minRadius != lastMinRadius || maxRadius != lastMaxRadius || circleAngle != lastCircleAngle || circleAngle != lastCircleAngle)
        {
            circleAngle = Mathf.Clamp(circleAngle, 0, 361);
            minRadius = minRadius > maxRadius ? maxRadius : minRadius;
            lastColor = emptyColor;
            lastCircleColor = circleColor;
            lastMinRadius = minRadius;
            lastMaxRadius = maxRadius;
            lastCircleAngle = circleAngle;
            var sprite = CreateSprite(minRadius, maxRadius, circleAngle / 2, circleColor);
            sprite.name = "cirlce";
            this.GetComponent<Image>().sprite = sprite;
        }
    }


    /// <summary>
    /// 绘制扇形圆环，生成Sprite
    /// </summary>
    /// <param name="minRadius">圆环内径，值为0即是实心圆</param>
    /// <param name="maxRadius">圆环外径</param>
    /// <param name="circleAngle">1/2扇形弧度，值>=180度即是整园</param>
    Sprite CreateSprite(int minRadius, int maxRadius, float halfAngle, Color circleColor)
    {
        //图片尺寸
        int spriteSize = maxRadius * 2;
        //创建Texture2D
        Texture2D texture2D = new Texture2D(spriteSize, spriteSize);
        //图片中心像素点坐标
        Vector2 centerPixel = new Vector2(spriteSize / 2, spriteSize / 2);
        //
        Vector2 tempPixel;
        float tempAngle, tempDisSqr;
        if (halfAngle > 0 && halfAngle < 360)
        {
            //遍历像素点，绘制扇形圆环
            for (int x = 0; x < spriteSize; x++)
            {
                for (int y = 0; y < spriteSize; y++)
                {
                    //以中心作为起点，获取像素点向量
                    tempPixel.x = x - centerPixel.x;
                    tempPixel.y = y - centerPixel.y;
                    //是否在半径范围内
                    tempDisSqr = tempPixel.sqrMagnitude;
                    if (tempDisSqr >= minRadius * minRadius && tempDisSqr <= maxRadius * maxRadius)
                    {
                        //是否在角度范围内
                        tempAngle = Vector2.Angle(Vector2.up, tempPixel);
                        if (tempAngle < halfAngle || tempAngle > 360 - halfAngle)
                        {
                            //设置像素色值
                            texture2D.SetPixel(x, y, circleColor);
                            continue;
                        }
                    }
                    //设置为透明
                    texture2D.SetPixel(x, y, emptyColor);
                }
            }
        }
        else
        {
            //遍历像素点，绘制圆环
            for (int x = 0; x < spriteSize; x++)
            {
                for (int y = 0; y < spriteSize; y++)
                {
                    //以中心作为起点，获取像素点向量
                    tempPixel.x = x - centerPixel.x;
                    tempPixel.y = y - centerPixel.y;
                    //是否在半径范围内
                    tempDisSqr = tempPixel.sqrMagnitude;
                    if (tempDisSqr >= minRadius * minRadius && tempDisSqr <= maxRadius * maxRadius)
                    {
                        //设置像素色值
                        texture2D.SetPixel(x, y, circleColor);
                        continue;
                    }
                    //设置为透明
                    texture2D.SetPixel(x, y, emptyColor);
                }
            }
        }
        texture2D.Apply();
        //创建Sprite
        return Sprite.Create(texture2D, new Rect(0, 0, spriteSize, spriteSize), new Vector2(0.5f, 0.5f));
    }
}

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Sprites;
using System;
using System.Collections;
using UnityEngine.Serialization;

//[AddComponentMenu("UI/Circle Image")]
public class CircleImage : MaskableGraphic, ISerializationCallbackReceiver, ILayoutElement, ICanvasRaycastFilter
{

    [FormerlySerializedAs("m_Frame")]
    [SerializeField]
    private Sprite m_Sprite;
    public Sprite sprite { get { return m_Sprite; } set { if (SetPropertyUtilityExt.SetClass(ref m_Sprite, value)) SetAllDirty(); } }

    [NonSerialized]
    private Sprite m_OverrideSprite;
    public Sprite overrideSprite { get { return m_OverrideSprite == null ? sprite : m_OverrideSprite; } set { if (SetPropertyUtilityExt.SetClass(ref m_OverrideSprite, value)) SetAllDirty(); } }

    [Header("圆形或扇形填充比例")]
    [Range(0, 1)]
    public float fillPercent = 1f;
    [Header("是否填充圆形")]
    public bool fill = true;
    [Header("圆环宽度")]
    public float thickness = 5;
    [Header("圆形精度")]
    [Range(3, 100)]
    public int segements = 20;

    private List<Vector3> innerVertices;
    private List<Vector3> outterVertices;

    // Use this for initialization
    void Awake()
    {
        innerVertices = new List<Vector3>();
        outterVertices = new List<Vector3>();
    }

    // Update is called once per frame
    void Update()
    {
        this.thickness = (float)Mathf.Clamp(this.thickness, 0, rectTransform.rect.width / 2);
    }



    protected override void OnPopulateMesh(VertexHelper vh)
    {
        vh.Clear();

        innerVertices.Clear();
        outterVertices.Clear();

        float degreeDelta = (float)(2 * Mathf.PI / segements);
        int curSegements = (int)(segements * fillPercent);

        float tw = rectTransform.rect.width;
        float th = rectTransform.rect.height;
        float outerRadius = rectTransform.pivot.x * tw;
        float innerRadius = rectTransform.pivot.x * tw - thickness;

        Vector4 uv = overrideSprite != null ? DataUtility.GetOuterUV(overrideSprite) : Vector4.zero;

        float uvCenterX = (uv.x + uv.z) * 0.5f;
        float uvCenterY = (uv.y + uv.w) * 0.5f;
        float uvScaleX = (uv.z - uv.x) / tw;
        float uvScaleY = (uv.w - uv.y) / th;

        float curDegree = 0;
        UIVertex uiVertex;
        int verticeCount;
        int triangleCount;
        Vector2 curVertice;

        if (fill) //圆形
        {
            curVertice = Vector2.zero;
            verticeCount = curSegements + 1;
            uiVertex = new UIVertex();
            uiVertex.color = color;
            uiVertex.position = curVertice;
            uiVertex.uv0 = new Vector2(curVertice.x * uvScaleX + uvCenterX, curVertice.y * uvScaleY + uvCenterY);
            vh.AddVert(uiVertex);

            for (int i = 1; i < verticeCount; i++)
            {
                float cosA = Mathf.Cos(curDegree);
                float sinA = Mathf.Sin(curDegree);
                curVertice = new Vector2(cosA * outerRadius, sinA * outerRadius);
                curDegree += degreeDelta;

                uiVertex = new UIVertex();
                uiVertex.color = color;
                uiVertex.position = curVertice;
                uiVertex.uv0 = new Vector2(curVertice.x * uvScaleX + uvCenterX, curVertice.y * uvScaleY + uvCenterY);
                vh.AddVert(uiVertex);

                outterVertices.Add(curVertice);
            }

            triangleCount = curSegements * 3;
            for (int i = 0, vIdx = 1; i < triangleCount - 3; i += 3, vIdx++)
            {
                vh.AddTriangle(vIdx, 0, vIdx + 1);
            }
            if (fillPercent == 1)
            {
                //首尾顶点相连
                vh.AddTriangle(verticeCount - 1, 0, 1);
            }
        }
        else//圆环
        {
            verticeCount = curSegements * 2;
            for (int i = 0; i < verticeCount; i += 2)
            {
                float cosA = Mathf.Cos(curDegree);
                float sinA = Mathf.Sin(curDegree);
                curDegree += degreeDelta;

                curVertice = new Vector3(cosA * innerRadius, sinA * innerRadius);
                uiVertex = new UIVertex();
                uiVertex.color = color;
                uiVertex.position = curVertice;
                uiVertex.uv0 = new Vector2(curVertice.x * uvScaleX + uvCenterX, curVertice.y * uvScaleY + uvCenterY);
                vh.AddVert(uiVertex);
                innerVertices.Add(curVertice);

                curVertice = new Vector3(cosA * outerRadius, sinA * outerRadius);
                uiVertex = new UIVertex();
                uiVertex.color = color;
                uiVertex.position = curVertice;
                uiVertex.uv0 = new Vector2(curVertice.x * uvScaleX + uvCenterX, curVertice.y * uvScaleY + uvCenterY);
                vh.AddVert(uiVertex);
                outterVertices.Add(curVertice);
            }

            triangleCount = curSegements * 3 * 2;
            for (int i = 0, vIdx = 0; i < triangleCount - 6; i += 6, vIdx += 2)
            {
                vh.AddTriangle(vIdx + 1, vIdx, vIdx + 3);
                vh.AddTriangle(vIdx, vIdx + 2, vIdx + 3);
            }
            if (fillPercent == 1)
            {
                //首尾顶点相连
                vh.AddTriangle(verticeCount - 1, verticeCount - 2, 1);
                vh.AddTriangle(verticeCount - 2, 0, 1);
            }
        }

    }

    public virtual bool IsRaycastLocationValid(Vector2 screenPoint, Camera eventCamera)
    {
        Sprite sprite = overrideSprite;
        if (sprite == null)
            return true;

        Vector2 local;
        RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform, screenPoint, eventCamera, out local);
        return Contains(local, outterVertices, innerVertices);
    }

    private bool Contains(Vector2 p, List<Vector3> outterVertices, List<Vector3> innerVertices)
    {
        var crossNumber = 0;
        RayCrossing(p, innerVertices, ref crossNumber);//检测内环
        RayCrossing(p, outterVertices, ref crossNumber);//检测外环
        return (crossNumber & 1) == 1;
    }

    /// <summary>
    /// 使用RayCrossing算法判断点击点是否在封闭多边形里
    /// </summary>
    /// <param name="p"></param>
    /// <param name="vertices"></param>
    /// <param name="crossNumber"></param>
    private void RayCrossing(Vector2 p, List<Vector3> vertices, ref int crossNumber)
    {
        for (int i = 0, count = vertices.Count; i < count; i++)
        {
            var v1 = vertices[i];
            var v2 = vertices[(i + 1) % count];

            //点击点水平线必须与两顶点线段相交
            if (((v1.y <= p.y) && (v2.y > p.y))
                || ((v1.y > p.y) && (v2.y <= p.y)))
            {
                //只考虑点击点右侧方向，点击点水平线与线段相交，且交点x > 点击点x，则crossNumber+1
                if (p.x < v1.x + (p.y - v1.y) / (v2.y - v1.y) * (v2.x - v1.x))
                {
                    crossNumber += 1;
                }
            }
        }
    }



    /// <summary>
    /// Image's texture comes from the UnityEngine.Image.
    /// </summary>
    public override Texture mainTexture
    {
        get
        {
            return overrideSprite == null ? s_WhiteTexture : overrideSprite.texture;
        }
    }

    public float pixelsPerUnit
    {
        get
        {
            float spritePixelsPerUnit = 100;
            if (sprite)
                spritePixelsPerUnit = sprite.pixelsPerUnit;

            float referencePixelsPerUnit = 100;
            if (canvas)
                referencePixelsPerUnit = canvas.referencePixelsPerUnit;

            return spritePixelsPerUnit / referencePixelsPerUnit;
        }
    }

    // /// <summary>
    // /// 子类需要重写该方法来自定义Image形状
    // /// </summary>
    // /// <param name="vh"></param>
    // protected override void OnPopulateMesh(VertexHelper vh)
    // {
    //     base.OnPopulateMesh(vh);
    // }

    #region ISerializationCallbackReceiver
    public void OnAfterDeserialize()
    {
    }

    //
    // 摘要: 
    //     Implement this method to receive a callback after unity serialized your object.
    public void OnBeforeSerialize()
    {
    }
    #endregion

    #region ILayoutElement
    public virtual void CalculateLayoutInputHorizontal() { }
    public virtual void CalculateLayoutInputVertical() { }

    public virtual float minWidth { get { return 0; } }

    public virtual float preferredWidth
    {
        get
        {
            if (overrideSprite == null)
                return 0;
            return overrideSprite.rect.size.x / pixelsPerUnit;
        }
    }

    public virtual float flexibleWidth { get { return -1; } }

    public virtual float minHeight { get { return 0; } }

    public virtual float preferredHeight
    {
        get
        {
            if (overrideSprite == null)
                return 0;
            return overrideSprite.rect.size.y / pixelsPerUnit;
        }
    }

    public virtual float flexibleHeight { get { return -1; } }

    public virtual int layoutPriority { get { return 0; } }
    #endregion

    #region ICanvasRaycastFilter
    // public virtual bool IsRaycastLocationValid(Vector2 screenPoint, Camera eventCamera)
    // {
    //     return true;
    // }
    #endregion



}

internal static class SetPropertyUtilityExt
{
    public static bool SetColor(ref Color currentValue, Color newValue)
    {
        if (currentValue.r == newValue.r && currentValue.g == newValue.g && currentValue.b == newValue.b && currentValue.a == newValue.a)
            return false;

        currentValue = newValue;
        return true;
    }

    public static bool SetStruct<T>(ref T currentValue, T newValue) where T : struct
    {
        if (currentValue.Equals(newValue))
            return false;

        currentValue = newValue;
        return true;
    }

    public static bool SetClass<T>(ref T currentValue, T newValue) where T : class
    {
        if ((currentValue == null && newValue == null) || (currentValue != null && currentValue.Equals(newValue)))
            return false;

        currentValue = newValue;
        return true;
    }
}