Unity Web Shader

1.UI流光

Shader "UI/Unlit/Flowlight"
{
	Properties
	{
		[PerRendererData] _MainTex("Sprite Texture", 2D) = "white" {}
		_Color("Tint", Color) = (1, 1, 1, 1)
		[MaterialToggle] _OffSet("OffSet", float) = 0
		[MaterialToggle] PixelSnap("Pixel snap", float) = 0
 
		/* Flowlight */
		_FlowlightMaskTex("Mask Texture", 2D) = "white" {}
		_FlowlightTex("Add Move Texture", 2D) = "white" {}
		_FlowlightColor("Flowlight Color", Color) = (0, 0, 0, 1)
		_Power("Power", float) = 1
		_SpeedX("SpeedX", float) = 1
		_SpeedY("SpeedY", float) = 0
		/* --------- */
 
		/* UI */
		_StencilComp("Stencil Comparison", Float) = 8
		_Stencil("Stencil ID", Float) = 0
		_StencilOp("Stencil Operation", Float) = 0
		_StencilWriteMask("Stencil Write Mask", Float) = 255
		_StencilReadMask("Stencil Read Mask", Float) = 255
		/* -- */
	}
 
	SubShader
	{
		Tags
		{
			"Queue" = "Transparent"
			"IgnoreProjector" = "True"
			"RenderType" = "Transparent"
			"PreviewType" = "Plane"
			"CanUseSpriteAtlas" = "True"
		}
 
		Cull Off
		Lighting Off
		ZWrite Off
		Blend One OneMinusSrcAlpha
 
		/* UI */
		Stencil
		{
			Ref[_Stencil]
			Comp[_StencilComp]
			Pass[_StencilOp]
			ReadMask[_StencilReadMask]
			WriteMask[_StencilWriteMask]
		}
		/* -- */
	Pass
	{
		CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile _ PIXELSNAP_ON
#include "UnityCG.cginc"
 
	struct appdata_t
	{
		float4 vertex : POSITION;
		float4 color : COLOR;
		float2 texcoord : TEXCOORD0;
	};
 
	struct v2f
	{
		float4 vertex : SV_POSITION;
		fixed4 color : COLOR;
		half2 texcoord : TEXCOORD0;
 
		/* Flowlight */
		half2 texflowlight : TEXCOORD1;
		/* --------- */
	};
 
	fixed4 _Color;
 
	/* Flowlight */
	fixed4 _FlowlightColor;
	float _Power;
	sampler2D _FlowlightTex;
	fixed4 _FlowlightTex_ST;
	sampler2D _FlowlightMaskTex;
	fixed4 _FlowlightMaskTex_ST;
	fixed _SpeedX;
	fixed _SpeedY;
	fixed x = 0;
	float _OffSet;
	/* --------- */
	v2f vert(appdata_t IN)
	{
		v2f OUT;
		OUT.vertex = UnityObjectToClipPos(IN.vertex);
		OUT.texcoord = IN.texcoord;
		/* Flowlight */
		OUT.texflowlight = TRANSFORM_TEX(IN.texcoord, _FlowlightTex);
		OUT.texflowlight.x += _Time * _SpeedX;
		OUT.texflowlight.y += _Time * _SpeedY;
		OUT.color = IN.color * _Color;
#ifdef PIXELSNAP_ON
		OUT.vertex = UnityPixelSnap(OUT.vertex);
#endif
		return OUT;
	}
 
	sampler2D _MainTex;
 
	fixed4 frag(v2f IN) : SV_Target
	{
		fixed4 c = tex2D(_MainTex, IN.texcoord)*IN.color;
		fixed4 cmask = tex2D(_FlowlightMaskTex, IN.texcoord);
	if (cmask.a != 0)
	{
		/* Flowlight */
		fixed4 cadd = tex2D(_FlowlightTex, IN.texflowlight) * _Power;
		cadd.rgb *= c.rgb;
		c.rgb += cadd.rgb;
	}
	c.rgb *= c.a;
	/* --------- */
 
	return c;
	}
		ENDCG
	}
	}
}

 顺箭头方向流光，可以更换贴图

2.烟雾：

Shader "effects/SmokeBlue"{
Properties {
	_MainTex ("Base layer (RGB)", 2D) = "white" {}
	_ScrollX ("Base layer Scroll speed X", Float) = 1.0
	_ScrollY ("Base layer Scroll speed Y", Float) = 0.0
	_brightness ("brightness", Float) = 2.0
	_color("color",color) = (1,1,1,1)
}
 
	
SubShader {
	
	Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
 
	pass {
 
	Zwrite Off 
	Cull Off 
	Blend SrcAlpha OneMinusSrcAlpha
	LOD 100
 
	CGPROGRAM
	#pragma vertex vert
	#pragma fragment frag
 	#include "UnityCG.cginc"
 
	sampler2D _MainTex;
	float4 _MainTex_ST;
	float _ScrollX;
	float _ScrollY;
	float _brightness;
	fixed4 _color;
 
struct appdata {
    float4 vertex : POSITION;
    float3 normal : NORMAL;
    float4 texcoord : TEXCOORD0;
    fixed4 color : COLOR;
 
};
	struct v2f {
		float4 pos : SV_POSITION;
		float2 uv : TEXCOORD0;
		fixed4 color : TEXCOORD1;
		float NdotV :TEXCOORD2;
	};
 
	
	v2f vert (appdata v)
	{
		v2f o;
		o.pos = UnityObjectToClipPos(v.vertex);
		o.uv = TRANSFORM_TEX(v.texcoord.xy,_MainTex) + frac(float2(_ScrollX, _ScrollY) * _Time);
		o.color =  v.color;
		float3 Normal =UnityObjectToWorldNormal( v.normal);
		float3 ViewDir =normalize( WorldSpaceViewDir( v.vertex));
	    o.NdotV =pow (abs(dot (Normal,ViewDir)),3);
		return o;
	}
 
 
	fixed4 frag (v2f i) : COLOR
		{
			fixed4 tex = tex2D (_MainTex, i.uv);
			fixed4 o = tex * i.color * _brightness * _color;
			o.a = tex.r * i.color.a * i.NdotV;
			return o;
		}
	ENDCG
	}
   }
}

贴图链接：https://www.aliyundrive.com/s/3ChKc9BcvHU 

 

·3.温度云图：

Shader "UChart/HeatMap/Peak"
{
    Properties
    {
        _HeatMapTex("HeatMapTex",2D) = "white"{}
        _Alpha("Alpha",range(0,1)) = 0.8
    }

    SubShader
    {
        Tags{"Queue"="Transparent"}
        Blend SrcAlpha OneMinusSrcAlpha

        Pass
        {
            CGPROGRAM

            #pragma vertex vert
            #pragma fragment frag
            #include "unitycg.cginc"

            sampler2D _HeatMapTex;
            half _Alpha;
            uniform int _FactorCount;
            uniform float4 _Factors[100];
            uniform float2 _FactorsProperties[100];

            struct a2v
            {
                float4 pos : POSITION;
            };

            struct v2f
            {
                float4 pos : POSITION;
                fixed3 worldPos : TEXCOORD1;
            };

            v2f vert(a2v input)
            {
                v2f o;
                half3 worldPos = mul(unity_ObjectToWorld,input.pos).xyz;
                half heat = 0;
                for( int i = 0 ; i < _FactorCount;i++ )
                {
                    half dis = distance(worldPos,_Factors[i].xyz);
                    float radius = _FactorsProperties[i].x;
                    float intensity = _FactorsProperties[i].y;
                    half ratio = 1 - saturate(dis/radius);
                    heat += intensity * ratio;
                }    
                o.pos = UnityObjectToClipPos(input.pos + half3(0,heat*3,0));
                o.worldPos = mul(unity_ObjectToWorld,input.pos).xyz;
                return o;
            }

            half4 frag(v2f input):COLOR
            {
                half heat = 0;
                for( int i = 0 ; i < _FactorCount;i++ )
                {
                    half dis = distance(input.worldPos,_Factors[i].xyz);
                    float radius = _FactorsProperties[i].x;
                    float intensity = _FactorsProperties[i].y;
                    half ratio = 1 - saturate(dis/radius);
                    heat += intensity * ratio;
                    heat = clamp(heat,0.05,0.95);
                }
                half4 color = tex2D(_HeatMapTex,fixed2(heat,0.5));
                color.a = _Alpha;
                return color;
            }

            ENDCG
        }
    }

    Fallback "Diffuse"
}

需要配合脚本使用：

父级脚本根据子物体位置和参数，控制shader的显示

父级脚本：

using UnityEngine;
using System.Collections.Generic;

public enum HeatMapMode
{
    RefreshEachFrame,//每帧更新
    RefreshByInterval//定时更新
}

public class HeatMapComponent : MonoBehaviour
{
    private Material m_material = null;

    public Material material
    {
        get
        {
            if (null == m_material)
            {
                var render = this.GetComponent<Renderer>();
                m_material = render.material;
            }
            return m_material;
        }
    }

    public HeatMapMode heatMapMode = HeatMapMode.RefreshEachFrame;

    public float interval = 0.02f;
    private float m_timer = 0.0f;

    public List<HeatMapFactor> impactFactors = new List<HeatMapFactor>();

    private void Update()
    {
        if (heatMapMode == HeatMapMode.RefreshEachFrame)
        {
            RefreshHeatmap();
            return;
        }
        m_timer += Time.deltaTime;
        if (m_timer > interval)
        {
            RefreshHeatmap();
            m_timer -= interval;
        }
    }

    private void RefreshHeatmap()
    {
        material.SetInt("_FactorCount", impactFactors.Count);

        var ifPosition = new Vector4[impactFactors.Count];
        for (int i = 0; i < impactFactors.Count; i++)
            ifPosition[i] = impactFactors[i].transform.position;
        material.SetVectorArray("_Factors", ifPosition);

        var properties = new Vector4[impactFactors.Count];
        for (int i = 0; i < impactFactors.Count; i++)
        {
            var factor = impactFactors[i];
            properties[i] = new Vector4(factor.influenceRadius, factor.intensity, factor.temperatureFactor, 0.0f);
        }
        material.SetVectorArray("_FactorsProperties", properties);

    }
}

子集脚本：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//挂载到空物体上
public class HeatMapFactor : MonoBehaviour
{
    public float influenceRadius = 3.0f;
    public float intensity = 3.0f;
    public float temperatureFactor = 1.0f;
}

脚本参数：

贴图链接： png https://www.aliyundrive.com/s/snUeGLVZDBJ