Shader "OutlineShader/sdfOutline"
{
    Properties
    {
        _Color ("Color", Color) = (1, 1, 1, 1)
        _BackgroundColor ("BackgroundColor", Color) = (0, 0, 0, 1)
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
 #pragma vertex vert
 #pragma fragment frag
 #include "UnityCG. cginc"

            float sdfCircle(float2 coord, float2 center, float radius)
            {
                float2 offset = coord - center;
                return sqrt((offset.x * offset.x) + (offset.y * offset.y)) - radius;
            }

            float4 render(float d, float3 color, float stroke) 
            {
                float anti = fwidth(d) * 1.0;
                float4 colorLayer = float4(color, 1.0 - smoothstep(-anti, anti, d));
                bool flag = step(0.000001, stroke);
                float4 strokeLayer = float4(float3(0.05, 0.05, 0.05), 1.0 - smoothstep(-anti, anti, d - stroke));
                return float4(lerp(strokeLayer.rgb, colorLayer.rgb, colorLayer.a), strokeLayer.a) * flag + colorLayer * (1 - flag);
            }

            struct appdata
            {
                float4 vertex : POSITION;
            };

            struct v2f
            {
                float4 pos : SV_POSITION;
                float4 screenPos : TEXCOORD0;
            };

            fixed4 _Color;
            fixed4 _BackgroundColor;

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos (v.vertex);
                o.screenPos = ComputeScreenPos(o.pos);
                return o;
            }

            fixed4 frag(v2f i) : SV_Target
            {
                float2 pixelPos = (i.screenPos.xy / i.screenPos.w) * _ScreenParams.xy;
                float a = sdfCircle(pixelPos, float2(0.5, 0.5) * _ScreenParams.xy, 100);
                float4 layer1 = render(a, _Color, fwidth(a) * 2.0);
                return lerp(_BackgroundColor, layer1, layer1.a);
            }
            ENDCG
        }
    }
}

Shader "Unlit/019"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Diffuse ("漫反射", Color) = (1,1,1,1)
        _Outline ("外廓粗细", Range(0,0.05)) = 0.02
        _OutlineColor ("外廓颜色", Color) = (0,0,0,0)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            //定义Pass名，用于重复使用该Pass
            Name "Outline"
            //渲染前面
            Cull Front
            
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            float _Outline;
            fixed4 _OutlineColor;

            struct v2f
            {
                float4 vertex :SV_POSITION;
            };

            v2f vert(appdata_base v)
            {
                v2f o;
                //描边=顶点在法线上偏移 * 颜色
                
                //物体空间法线外拓
                //v.vertex.xyz += v.normal * _Outline;
                //o.vertex = UnityObjectToClipPos(v.vertex);

                //视角空间法线外拓
                //float4 pos = mul(UNITY_MATRIX_V,mul(unity_ObjectToWorld,v.vertex));
                //float3 normal = normalize (mul((float3x3)UNITY_MATRIX_IT_MV,v.normal));
                //pos = pos + float4(normal,0) * _Outline;
                //o.vertex = mul(UNITY_MATRIX_P,pos);

                //裁剪空间法线外拓
                o.vertex = UnityObjectToClipPos(v.vertex);
                float3 normal = normalize (mul((float3x3)UNITY_MATRIX_IT_MV,v.normal));
                float2 viewNoraml = TransformViewToProjection(normal.xy);
                o.vertex.xy += viewNoraml * _Outline;

                return o;
            }

            float4 frag(v2f i):SV_Target
            {
                return _OutlineColor;
            }

            ENDCG
        }

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
        //引入光照
        #include "Lighting.cginc" 
             
            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
                fixed3 worldNormal : TEXCOORD1;
                float3 worldPos : TEXCOORD2;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
        float4 _Diffuse;

            v2f vert (appdata_base v)
            {
                v2f o;
                //顶点位置
                o.vertex = UnityObjectToClipPos(v.vertex);
                //法线方向
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                //世界坐标
                o.worldPos = mul(unity_ObjectToWorld,v.vertex);
                //纹理坐标缩放偏移
                o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
              
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // 纹理采样
                fixed4 albedo = tex2D(_MainTex, i.uv);

                //光源方向
                fixed3 worldLightDir = UnityWorldSpaceLightDir (i.worldPos);

                //漫反射光=入射光线强度*纹素值*材质的漫反射系数* 映射值为正数(表面法线方向 · 光源方向)
                fixed3 diffuse = _LightColor0.rgb * albedo * _Diffuse.rgb * (dot(worldLightDir,i.worldNormal)*0.5+0.5);

                //环境光
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;

                fixed3 color = ambient + diffuse;
                return fixed4(color,1);
            }
            ENDCG
        }
    }
}

struct a2v
{
	half3 positionOS : POSITION;
	half3 normalOS:NORMAL;
};

struct v2f
{
	float4 positionCS:SV_POSITION;
};

v2f vert(a2v v) {
    v2f o;
    half3 positionOS=v.positionOS;
    half3 normalOS=normalize(v.normalOS);
    positionOS+=normalOS*_OutlineWidth;
    o.positionCS=TransformObjectToHClip(positionOS);
}

float4 frag(v2f i)
{
    return _OutlineColor;
}

public static Vector3[] GenerateSmoothNormals(Mesh _srcMesh)
{
    Vector3[] verticies = _srcMesh.vertices;
    Vector3[] normals = _srcMesh.normals;
    Vector3[] smoothNormals = normals.DeepCopy();
    var groups = verticies.Select((vertex, index) => new KeyValuePair<Vector3, int>(vertex, index)).GroupBy(pair => pair.Key);
    foreach (var group in groups)
    {
        if (group.Count() == 1)
            continue;
        Vector3 smoothNormal = Vector3.zero;
        foreach (var index in group)
            smoothNormal += normals[index.Value];
        smoothNormal = smoothNormal.normalized;
        foreach (var index in group)
            smoothNormals[index.Value] = smoothNormal;
    }
    return smoothNormals;
}

normalOS=normalize(v.tangentOS.xyz);

static Vector3[]RenegerateNormals(int[] _indices, Vector3[] _verticies)
{
    Vector3[] normals = new Vector3[_verticies.Length];
    GTrianglePolygon[] polygons = GetPolygons(_indices);
    foreach(var polygon in polygons)
    {
        GTriangle triangle = new GTriangle(polygon.GetVertices(_verticies));
        Vector3 normal = triangle.normal;
        foreach (var index in polygon)
            normals[index] += normal;
    }
    normals=normals.Select(normal => normal.normalized).ToArray();
    return normals;
}

static GTrianglePolygon[] GetPolygons(int[] _indices)
{
    GTrianglePolygon[] polygons = new GTrianglePolygon[_indices.Length / 3];
    for (int i = 0; i < polygons.Length; i++)
    {
        int startIndex = i * 3;
        int triangle0 = _indices[startIndex];
        int triangle1 = _indices[startIndex + 1];
        int triangle2 = _indices[startIndex + 2];
        polygons[i] = new GTrianglePolygon(triangle0, triangle1, triangle2);
    }
    return polygons;
}

public struct GTrianglePolygon
{
    public int index0;
    public int index1;
    public int index2;

    public GTrianglePolygon(int _index0, int _index1, int _index2)
    {
        index0 = _index0;
        index1 = _index1;
        index2 = _index2;
    }
    public (T v0, T v1, T v2) GetVertices<T>(IList<T> _vertices) => (_vertices[index0], _vertices[index1],_vertices[index2]);
}

public struct GTriangle
{
    public Triangle<Vector3> triangle;
    public Vector3 normal;
    public Vector3 uOffset;
    public Vector3 vOffset;
    public GTriangle((Vector3 v0,Vector3 v1,Vector3 v2) _tuple) : this(_tuple.v0,_tuple.v1,_tuple.v2)
    {
    }

    public GTriangle(Vector3 _vertex0, Vector3 _vertex1, Vector3 _vertex2)
    {
        triangle = new Triangle<Vector3>(_vertex0, _vertex1, _vertex2);
        uOffset = _vertex1-_vertex0;
        vOffset = _vertex2-_vertex0;
        normal= Vector3.Cross(uOffset,vOffset);
    }
 }

public static Vector3[] GenerateSmoothNormals(Mesh _srcMesh, bool _convertToTangentSpace)
{
    Vector3[] verticies = _srcMesh.vertices;
    var groups = verticies.Select((vertex, index) => new KeyValuePair<Vector3, int>(vertex, index)).GroupBy(pair => pair.Key);
    Vector3[] normals =  RenegerateNormals(_srcMesh.triangles,verticies);
    Vector3[] smoothNormals = normals.DeepCopy();
    foreach (var group in groups)
    {
        if (group.Count() == 1)
            continue;
        Vector3 smoothNormal = Vector3.zero;
        foreach (var index in group)
            smoothNormal += normals[index.Value];
        smoothNormal = smoothNormal.normalized;
        foreach (var index in group)
            smoothNormals[index.Value] = smoothNormal;
    }
    //通过构建TBN矩阵,将平滑法线数据转到切线空间内
    if (_convertToTangentSpace)
    {
        Vector4[] tangents = _srcMesh.tangents;
        for (int i = 0; i < smoothNormals.Length; i++)
        {
            Vector3 tangent = tangents[i].ToVector3().normalized;
            Vector3 normal = normals[i].normalized;
            Vector3 biNormal = Vector3.Cross(normal, tangent).normalized * tangents[i].w;
            Matrix3x3 tbnMatrix = Matrix3x3.identity;
            tbnMatrix.SetRow(0, tangent);
            tbnMatrix.SetRow(1, biNormal);
            tbnMatrix.SetRow(2, normal);
            smoothNormals[i] = tbnMatrix * smoothNormals[i].normalized;
        }
    }
    return smoothNormals;
}

float3 normalOS=0;
#if _NORMALSAMPLE_UV1
normalOS=normalize(v.uv1);
#elif _NORMALSAMPLE_UV2
normalOS=normalize(v.uv2);
//34567...
#endif

float3x3 TBNOS=float3x3(v.tangentOS.xyz,cross(v.normalOS,v.tangentOS.xyz)*v.tangentOS.w,v.normalOS);
normalOS=mul(normalOS,TBNOS);

//模型Shader的Stencil参考
Stencil
{
	Ref 1
	Comp Always
	Pass Replace
}

//描边Shader的Stencil参考
Stencil
{
	Ref 1
	Comp NotEqual
	Pass Keep
}

float4 clipPosition=TransformObjectToHClip(positionOS);
float3 normalCS =  mul((float3x3)UNITY_MATRIX_MVP, normalOS);
float2 screenOffset =normalize(normalCS.xy)/_ScreenParams.xy*clipPosition.w;
clipPosition.xy+=screenOffset*INSTANCE(_OutlineWidth);
o.positionCS = clipPosition;

float4 positionVS=TransformObjectToView(positionOS).z;
float eyeDepth=positionVS.z*positionVS.w;
float depthAlpha=saturate(invlerp(5,100,eyeDepth));
float finalWidth=lerp(5,1,depthAlpha)*INSTANCE(_OutlineWidth);
o.positionCS=TransformObjectToHClip( positionOS+normalOS*finalWidth);

v2f vert (appdata_base v)
{
    v2f o;
    float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
    float3 worldNormal = UnityObjectToWorldNormal(v.normal);
    //世界空间，背面延法线方向扩充
    worldPos += worldNormal *_OutlineWidth;

    o.vertex = UnityWorldToClipPos(worldPos);
    return o;
}

v2f vert (appdata_base v)
{
    v2f o;
    float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
    half3 worldNormal = normalize(mul((float3x3)unity_WorldToObject, v.normal));
    half3 scaleFactor = float3(length(unity_ObjectToWorld._m00_m10_m20), length(unity_ObjectToWorld._m01_m11_m21), length(unity_ObjectToWorld._m02_m12_m22));
    worldPos += worldNormal *_OutlineWidth * scaleFactor;

    o.vertex = UnityWorldToClipPos(worldPos);
    return o;
}

v2f vert (appdata_base v)
{
    v2f o;
    o.vertex = UnityObjectToClipPos(v.vertex);
    float3 worldNormal = UnityObjectToWorldNormal(v.normal);
    //裁剪空间，需要乘以o.vertex.w，避免归一化带来的影响；
    float3 ndcNormal = normalize(mul(UNITY_MATRIX_VP, worldNormal)) * o.vertex.w;

    o.vertex.xy += ndcNormal.xy * _OutlineWidth;
    return o;
}

v2f vert (appdata_base v)
{
    v2f o;
    o.vertex = UnityObjectToClipPos(v.vertex);
    float3 worldNormal = UnityObjectToWorldNormal(v.normal);
    float3 ndcNormal = normalize(mul(UNITY_MATRIX_VP, worldNormal)) * o.vertex.w;

    //考虑屏幕长宽比
    o.vertex.xy += ndcNormal.xy * _OutlineWidth*_ScreenParams.y*rcp(_ScreenParams.xy);
    return o;
}

v2f vert (appdata_base v)
{
    v2f o;
    o.vertex = UnityObjectToClipPos(v.vertex);
    float3 worldNormal = UnityObjectToWorldNormal(v.normal);
    float3 ndcNormal = normalize(mul(UNITY_MATRIX_VP, worldNormal)) * o.vertex.w;

    o.vertex.xy += ndcNormal.xy * _OutlineWidth*_ScreenParams.y*rcp(_ScreenParams.xy);

    float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
    worldPos += worldNormal *_OutlineWidth;
    
    //相机到物体的距离
    float dist = distance(unity_ObjectToWorld._m03_m13_m23, _WorldSpaceCameraPos);

    float4 farVertex = UnityWorldToClipPos(worldPos);
    //0.2 is magical number
    o.vertex = lerp(o.vertex, farVertex, saturate(dist*0.2));
    return o;
}