From 8bd4312c16c1d7971ac4f13ddefd28664d415621 Mon Sep 17 00:00:00 2001 From: Simon Jackson Date: Fri, 11 Aug 2017 13:15:42 +0100 Subject: [PATCH] UI Particle System update from forum thread --- Scripts/Effects/UIParticleSystem.cs | 310 ++++++++++-------- Shaders/UI Particle Add.shader | 104 ++++++ Shaders/UI Particle Add.shader.meta | 9 + Shaders/UI Particle AddMultiply.shader | 108 ++++++ Shaders/UI Particle AddMultiply.shader.meta | 9 + Shaders/UI Particle AddSmooth.shader | 104 ++++++ Shaders/UI Particle AddSmooth.shader.meta | 9 + Shaders/UI Particle Alpha Blend.shader | 104 ++++++ Shaders/UI Particle Alpha Blend.shader.meta | 9 + Shaders/UI Particle Blend.shader | 103 ++++++ Shaders/UI Particle Blend.shader.meta | 9 + Shaders/UI Particle Multiply.shader | 103 ++++++ Shaders/UI Particle Multiply.shader.meta | 9 + Shaders/UI Particle MultiplyDouble.shader | 107 ++++++ .../UI Particle MultiplyDouble.shader.meta | 9 + Shaders/UI Particle Premultiply Blend.shader | 104 ++++++ .../UI Particle Premultiply Blend.shader.meta | 9 + Shaders/UI Particle VertexLit Blended.shader | 42 +++ .../UI Particle VertexLit Blended.shader.meta | 9 + 19 files changed, 1131 insertions(+), 139 deletions(-) create mode 100644 Shaders/UI Particle Add.shader create mode 100644 Shaders/UI Particle Add.shader.meta create mode 100644 Shaders/UI Particle AddMultiply.shader create mode 100644 Shaders/UI Particle AddMultiply.shader.meta create mode 100644 Shaders/UI Particle AddSmooth.shader create mode 100644 Shaders/UI Particle AddSmooth.shader.meta create mode 100644 Shaders/UI Particle Alpha Blend.shader create mode 100644 Shaders/UI Particle Alpha Blend.shader.meta create mode 100644 Shaders/UI Particle Blend.shader create mode 100644 Shaders/UI Particle Blend.shader.meta create mode 100644 Shaders/UI Particle Multiply.shader create mode 100644 Shaders/UI Particle Multiply.shader.meta create mode 100644 Shaders/UI Particle MultiplyDouble.shader create mode 100644 Shaders/UI Particle MultiplyDouble.shader.meta create mode 100644 Shaders/UI Particle Premultiply Blend.shader create mode 100644 Shaders/UI Particle Premultiply Blend.shader.meta create mode 100644 Shaders/UI Particle VertexLit Blended.shader create mode 100644 Shaders/UI Particle VertexLit Blended.shader.meta diff --git a/Scripts/Effects/UIParticleSystem.cs b/Scripts/Effects/UIParticleSystem.cs index bb761f4..8bf9e96 100644 --- a/Scripts/Effects/UIParticleSystem.cs +++ b/Scripts/Effects/UIParticleSystem.cs @@ -6,38 +6,36 @@ namespace UnityEngine.UI.Extensions { #if UNITY_5_3_OR_NEWER [ExecuteInEditMode] - [RequireComponent(typeof(CanvasRenderer))] - [RequireComponent(typeof(ParticleSystem))] + [RequireComponent(typeof(CanvasRenderer), typeof(ParticleSystem))] + [AddComponentMenu("UI/Effects/Extensions/UIParticleSystem")] public class UIParticleSystem : MaskableGraphic { - - public Texture particleTexture; - public Sprite particleSprite; + [Tooltip("Having this enabled run the system in LateUpdate rather than in Update making it faster but less precise (more clunky)")] + public bool fixedTime = true; private Transform _transform; - private ParticleSystem _particleSystem; - private ParticleSystem.Particle[] _particles; + private ParticleSystem pSystem; + private ParticleSystem.Particle[] particles; private UIVertex[] _quad = new UIVertex[4]; - private Vector4 _uv = Vector4.zero; - private ParticleSystem.TextureSheetAnimationModule _textureSheetAnimation; - private int _textureSheetAnimationFrames; - private Vector2 _textureSheedAnimationFrameSize; + private Vector4 imageUV = Vector4.zero; + private ParticleSystem.TextureSheetAnimationModule textureSheetAnimation; + private int textureSheetAnimationFrames; + private Vector2 textureSheetAnimationFrameSize; + private ParticleSystemRenderer pRenderer; + + private Material currentMaterial; + + private Texture currentTexture; + +#if UNITY_5_5_OR_NEWER + private ParticleSystem.MainModule mainModule; +#endif public override Texture mainTexture { get { - if (particleTexture) - { - return particleTexture; - } - - if (particleSprite) - { - return particleSprite.texture; - } - - return null; + return currentTexture; } } @@ -48,93 +46,71 @@ namespace UnityEngine.UI.Extensions { _transform = transform; } - - // prepare particle system - ParticleSystemRenderer renderer = GetComponent(); - bool setParticleSystemMaterial = false; - - if (_particleSystem == null) + if (pSystem == null) { - _particleSystem = GetComponent(); + pSystem = GetComponent(); - if (_particleSystem == null) + if (pSystem == null) { return false; } - // get current particle texture - if (renderer == null) +#if UNITY_5_5_OR_NEWER + mainModule = pSystem.main; + if (pSystem.main.maxParticles > 14000) { - renderer = _particleSystem.gameObject.AddComponent(); + mainModule.maxParticles = 14000; } - Material currentMaterial = renderer.sharedMaterial; +#else + if (pSystem.maxParticles > 14000) + pSystem.maxParticles = 14000; +#endif + + pRenderer = pSystem.GetComponent(); + if (pRenderer != null) + pRenderer.enabled = false; + + Shader foundShader = Shader.Find("UI Extensions/Particles/Additive"); + Material pMaterial = new Material(foundShader); + + if (material == null) + material = pMaterial; + + currentMaterial = material; if (currentMaterial && currentMaterial.HasProperty("_MainTex")) { - particleTexture = currentMaterial.mainTexture; + currentTexture = currentMaterial.mainTexture; + if (currentTexture == null) + currentTexture = Texture2D.whiteTexture; } - + material = currentMaterial; // automatically set scaling - var main = _particleSystem.main; - main.scalingMode = ParticleSystemScalingMode.Local; - - _particles = null; - setParticleSystemMaterial = true; - } - else - { - if (Application.isPlaying) - { - setParticleSystemMaterial = (renderer.material == null); - } -#if UNITY_EDITOR - else - { - setParticleSystemMaterial = (renderer.sharedMaterial == null); - } +#if UNITY_5_5_OR_NEWER + mainModule.scalingMode = ParticleSystemScalingMode.Hierarchy; +#else + pSystem.scalingMode = ParticleSystemScalingMode.Hierarchy; #endif - } - // automatically set material to UI/Particles/Hidden shader, and get previous texture - if (setParticleSystemMaterial) - { - Material material = new Material(Shader.Find("UI/Particles/Hidden")); - if (Application.isPlaying) - { - renderer.material = material; - } -#if UNITY_EDITOR - else - { - material.hideFlags = HideFlags.DontSave; - renderer.sharedMaterial = material; - } + particles = null; + } +#if UNITY_5_5_OR_NEWER + if (particles == null) + particles = new ParticleSystem.Particle[pSystem.main.maxParticles]; +#else + if (particles == null) + particles = new ParticleSystem.Particle[pSystem.maxParticles]; #endif - } - // prepare particles array - if (_particles == null) - { - _particles = new ParticleSystem.Particle[_particleSystem.main.maxParticles]; - } - - // prepare uvs - if (particleTexture) - { - _uv = new Vector4(0, 0, 1, 1); - } - else if (particleSprite) - { - _uv = UnityEngine.Sprites.DataUtility.GetOuterUV(particleSprite); - } + imageUV = new Vector4(0, 0, 1, 1); // prepare texture sheet animation - _textureSheetAnimation = _particleSystem.textureSheetAnimation; - _textureSheetAnimationFrames = 0; - _textureSheedAnimationFrameSize = Vector2.zero; - if (_textureSheetAnimation.enabled) + textureSheetAnimation = pSystem.textureSheetAnimation; + textureSheetAnimationFrames = 0; + textureSheetAnimationFrameSize = Vector2.zero; + if (textureSheetAnimation.enabled) { - _textureSheetAnimationFrames = _textureSheetAnimation.numTilesX * _textureSheetAnimation.numTilesY; - _textureSheedAnimationFrameSize = new Vector2(1f / _textureSheetAnimation.numTilesX, 1f / _textureSheetAnimation.numTilesY); + textureSheetAnimationFrames = textureSheetAnimation.numTilesX * textureSheetAnimation.numTilesY; + textureSheetAnimationFrameSize = new Vector2(1f / textureSheetAnimation.numTilesX, 1f / textureSheetAnimation.numTilesY); } return true; @@ -143,13 +119,11 @@ namespace UnityEngine.UI.Extensions protected override void Awake() { base.Awake(); - if (!Initialize()) - { enabled = false; - } } + protected override void OnPopulateMesh(VertexHelper vh) { #if UNITY_EDITOR @@ -161,7 +135,6 @@ namespace UnityEngine.UI.Extensions } } #endif - // prepare vertices vh.Clear(); @@ -170,96 +143,134 @@ namespace UnityEngine.UI.Extensions return; } + Vector2 temp = Vector2.zero; + Vector2 corner1 = Vector2.zero; + Vector2 corner2 = Vector2.zero; // iterate through current particles - int count = _particleSystem.GetParticles(_particles); + int count = pSystem.GetParticles(particles); for (int i = 0; i < count; ++i) { - ParticleSystem.Particle particle = _particles[i]; + ParticleSystem.Particle particle = particles[i]; // get particle properties - Vector2 position = (_particleSystem.main.simulationSpace == ParticleSystemSimulationSpace.Local ? particle.position : _transform.InverseTransformPoint(particle.position)); +#if UNITY_5_5_OR_NEWER + Vector2 position = (mainModule.simulationSpace == ParticleSystemSimulationSpace.Local ? particle.position : _transform.InverseTransformPoint(particle.position)); +#else + Vector2 position = (pSystem.simulationSpace == ParticleSystemSimulationSpace.Local ? particle.position : _transform.InverseTransformPoint(particle.position)); +#endif float rotation = -particle.rotation * Mathf.Deg2Rad; float rotation90 = rotation + Mathf.PI / 2; - Color32 color = particle.GetCurrentColor(_particleSystem); - float size = particle.GetCurrentSize(_particleSystem) * 0.5f; + Color32 color = particle.GetCurrentColor(pSystem); + float size = particle.GetCurrentSize(pSystem) * 0.5f; // apply scale - if (_particleSystem.main.scalingMode == ParticleSystemScalingMode.Shape) - { +#if UNITY_5_5_OR_NEWER + if (mainModule.scalingMode == ParticleSystemScalingMode.Shape) position /= canvas.scaleFactor; - } +#else + if (pSystem.scalingMode == ParticleSystemScalingMode.Shape) + position /= canvas.scaleFactor; +#endif // apply texture sheet animation - Vector4 particleUV = _uv; - if (_textureSheetAnimation.enabled) + Vector4 particleUV = imageUV; + if (textureSheetAnimation.enabled) { #if UNITY_5_5_OR_NEWER float frameProgress = 1 - (particle.remainingLifetime / particle.startLifetime); - frameProgress = _textureSheetAnimation.frameOverTime.curveMin.Evaluate(1 - (particle.remainingLifetime / particle.startLifetime)); // TODO - once Unity allows MinMaxCurve reading + + if (textureSheetAnimation.frameOverTime.curveMin != null) + { + frameProgress = textureSheetAnimation.frameOverTime.curveMin.Evaluate(1 - (particle.remainingLifetime / particle.startLifetime)); + } + else if (textureSheetAnimation.frameOverTime.curve != null) + { + frameProgress = textureSheetAnimation.frameOverTime.curve.Evaluate(1 - (particle.remainingLifetime / particle.startLifetime)); + } + else if (textureSheetAnimation.frameOverTime.constant > 0) + { + frameProgress = textureSheetAnimation.frameOverTime.constant - (particle.remainingLifetime / particle.startLifetime); + } #else float frameProgress = 1 - (particle.lifetime / particle.startLifetime); - frameProgress = Mathf.Repeat(frameProgress * _textureSheetAnimation.cycleCount, 1); #endif + + frameProgress = Mathf.Repeat(frameProgress * textureSheetAnimation.cycleCount, 1); int frame = 0; - switch (_textureSheetAnimation.animation) + switch (textureSheetAnimation.animation) { case ParticleSystemAnimationType.WholeSheet: - frame = Mathf.FloorToInt(frameProgress * _textureSheetAnimationFrames); + frame = Mathf.FloorToInt(frameProgress * textureSheetAnimationFrames); break; case ParticleSystemAnimationType.SingleRow: - frame = Mathf.FloorToInt(frameProgress * _textureSheetAnimation.numTilesX); + frame = Mathf.FloorToInt(frameProgress * textureSheetAnimation.numTilesX); - int row = _textureSheetAnimation.rowIndex; -#if UNITY_5_5_OR_NEWER - if (_textureSheetAnimation.useRandomRow) - { - Random.InitState((int)particle.randomSeed); - row = Random.Range(0, _textureSheetAnimation.numTilesY); - } -#endif - frame += row * _textureSheetAnimation.numTilesX; + int row = textureSheetAnimation.rowIndex; + // if (textureSheetAnimation.useRandomRow) { // FIXME - is this handled internally by rowIndex? + // row = Random.Range(0, textureSheetAnimation.numTilesY, using: particle.randomSeed); + // } + frame += row * textureSheetAnimation.numTilesX; break; } - frame %= _textureSheetAnimationFrames; + frame %= textureSheetAnimationFrames; - particleUV.x = (frame % _textureSheetAnimation.numTilesX) * _textureSheedAnimationFrameSize.x; - particleUV.y = Mathf.FloorToInt(frame / _textureSheetAnimation.numTilesX) * _textureSheedAnimationFrameSize.y; - particleUV.z = particleUV.x + _textureSheedAnimationFrameSize.x; - particleUV.w = particleUV.y + _textureSheedAnimationFrameSize.y; + particleUV.x = (frame % textureSheetAnimation.numTilesX) * textureSheetAnimationFrameSize.x; + particleUV.y = Mathf.FloorToInt(frame / textureSheetAnimation.numTilesX) * textureSheetAnimationFrameSize.y; + particleUV.z = particleUV.x + textureSheetAnimationFrameSize.x; + particleUV.w = particleUV.y + textureSheetAnimationFrameSize.y; } + temp.x = particleUV.x; + temp.y = particleUV.y; + _quad[0] = UIVertex.simpleVert; _quad[0].color = color; - _quad[0].uv0 = new Vector2(particleUV.x, particleUV.y); + _quad[0].uv0 = temp; + temp.x = particleUV.x; + temp.y = particleUV.w; _quad[1] = UIVertex.simpleVert; _quad[1].color = color; - _quad[1].uv0 = new Vector2(particleUV.x, particleUV.w); + _quad[1].uv0 = temp; + temp.x = particleUV.z; + temp.y = particleUV.w; _quad[2] = UIVertex.simpleVert; _quad[2].color = color; - _quad[2].uv0 = new Vector2(particleUV.z, particleUV.w); + _quad[2].uv0 = temp; + temp.x = particleUV.z; + temp.y = particleUV.y; _quad[3] = UIVertex.simpleVert; _quad[3].color = color; - _quad[3].uv0 = new Vector2(particleUV.z, particleUV.y); + _quad[3].uv0 = temp; if (rotation == 0) { // no rotation - Vector2 corner1 = new Vector2(position.x - size, position.y - size); - Vector2 corner2 = new Vector2(position.x + size, position.y + size); + corner1.x = position.x - size; + corner1.y = position.y - size; + corner2.x = position.x + size; + corner2.y = position.y + size; - _quad[0].position = new Vector2(corner1.x, corner1.y); - _quad[1].position = new Vector2(corner1.x, corner2.y); - _quad[2].position = new Vector2(corner2.x, corner2.y); - _quad[3].position = new Vector2(corner2.x, corner1.y); + temp.x = corner1.x; + temp.y = corner1.y; + _quad[0].position = temp; + temp.x = corner1.x; + temp.y = corner2.y; + _quad[1].position = temp; + temp.x = corner2.x; + temp.y = corner2.y; + _quad[2].position = temp; + temp.x = corner2.x; + temp.y = corner1.y; + _quad[3].position = temp; } else { @@ -279,24 +290,45 @@ namespace UnityEngine.UI.Extensions void Update() { - if (Application.isPlaying) + if (!fixedTime && Application.isPlaying) { - // unscaled animation within UI - _particleSystem.Simulate(Time.unscaledDeltaTime, false, false); - + pSystem.Simulate(Time.unscaledDeltaTime, false, false, true); SetAllDirty(); + + if ((currentMaterial != null && currentTexture != currentMaterial.mainTexture) || + (material != null && currentMaterial != null && material.shader != currentMaterial.shader)) + { + pSystem = null; + Initialize(); + } } } -#if UNITY_EDITOR void LateUpdate() { if (!Application.isPlaying) { SetAllDirty(); } + else + { + if (fixedTime) + { + pSystem.Simulate(Time.unscaledDeltaTime, false, false, true); + SetAllDirty(); + if ((currentMaterial != null && currentTexture != currentMaterial.mainTexture) || + (material != null && currentMaterial != null && material.shader != currentMaterial.shader)) + { + pSystem = null; + Initialize(); + } + } + } + if (material == currentMaterial) + return; + pSystem = null; + Initialize(); } -#endif } #endif } \ No newline at end of file diff --git a/Shaders/UI Particle Add.shader b/Shaders/UI Particle Add.shader new file mode 100644 index 0000000..bc5a7c4 --- /dev/null +++ b/Shaders/UI Particle Add.shader @@ -0,0 +1,104 @@ +Shader "UI Extensions/Particles/Additive" { +Properties { + _TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5) + _MainTex ("Particle Texture", 2D) = "white" {} + _InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0 + + _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 + + _ColorMask ("Color Mask", Float) = 15 + + [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0 +} + +Category { + Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" "CanUseSpriteAtlas"="True" } + Blend SrcAlpha One + ColorMask RGB + Cull Off Lighting Off ZWrite Off + + SubShader { + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Pass { + + CGPROGRAM + #pragma vertex vert + #pragma fragment frag + #pragma target 2.0 + #pragma multi_compile_particles + #pragma multi_compile_fog + + #include "UnityCG.cginc" + #include "UnityUI.cginc" + + #pragma multi_compile __ UNITY_UI_ALPHACLIP + + sampler2D _MainTex; + fixed4 _TintColor; + + struct appdata_t { + float4 vertex : POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + }; + + struct v2f { + float4 vertex : SV_POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + UNITY_FOG_COORDS(1) + #ifdef SOFTPARTICLES_ON + float4 projPos : TEXCOORD2; + #endif + }; + + float4 _MainTex_ST; + + v2f vert (appdata_t IN) + { + v2f v; + v.vertex = UnityObjectToClipPos(IN.vertex); + #ifdef SOFTPARTICLES_ON + v.projPos = ComputeScreenPos (v.vertex); + COMPUTE_EYEDEPTH(v.projPos.z); + #endif + v.color = IN.color; + v.texcoord = TRANSFORM_TEX(IN.texcoord,_MainTex); + UNITY_TRANSFER_FOG(v,v.vertex); + return v; + } + + sampler2D_float _CameraDepthTexture; + float _InvFade; + + fixed4 frag (v2f IN) : SV_Target + { + #ifdef SOFTPARTICLES_ON + float sceneZ = LinearEyeDepth (SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(IN.projPos))); + float partZ = IN.projPos.z; + float fade = saturate (_InvFade * (sceneZ-partZ)); + IN.color.a *= fade; + #endif + + fixed4 col = 2.0f * IN.color * _TintColor * tex2D(_MainTex, IN.texcoord); + UNITY_APPLY_FOG_COLOR(IN.fogCoord, col, fixed4(0,0,0,0)); // fog towards black due to our blend mode + return col; + } + ENDCG + } + } +} +} diff --git a/Shaders/UI Particle Add.shader.meta b/Shaders/UI Particle Add.shader.meta new file mode 100644 index 0000000..4a220b1 --- /dev/null +++ b/Shaders/UI Particle Add.shader.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: e064104788d94b349ab13141a30b5660 +timeCreated: 1502443970 +licenseType: Free +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/UI Particle AddMultiply.shader b/Shaders/UI Particle AddMultiply.shader new file mode 100644 index 0000000..a872c7b --- /dev/null +++ b/Shaders/UI Particle AddMultiply.shader @@ -0,0 +1,108 @@ +Shader "UI Extensions/Particles/~Additive-Multiply" { +Properties { + _TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5) + _MainTex ("Particle Texture", 2D) = "white" {} + _InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0 + + _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 + + _ColorMask ("Color Mask", Float) = 15 + + [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0 +} + +Category { + Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" "CanUseSpriteAtlas"="True" } + Blend One OneMinusSrcAlpha + ColorMask RGB + Cull Off Lighting Off ZWrite Off + + SubShader { + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Pass { + + CGPROGRAM + #pragma vertex vert + #pragma fragment frag + #pragma target 2.0 + #pragma multi_compile_particles + #pragma multi_compile_fog + + #include "UnityCG.cginc" + #include "UnityUI.cginc" + + #pragma multi_compile __ UNITY_UI_ALPHACLIP + + sampler2D _MainTex; + fixed4 _TintColor; + + struct appdata_t { + float4 vertex : POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + }; + + struct v2f { + float4 vertex : SV_POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + UNITY_FOG_COORDS(1) + #ifdef SOFTPARTICLES_ON + float4 projPos : TEXCOORD2; + #endif + }; + + float4 _MainTex_ST; + + v2f vert (appdata_t IN) + { + v2f v; + v.vertex = UnityObjectToClipPos(IN.vertex); + #ifdef SOFTPARTICLES_ON + v.projPos = ComputeScreenPos (v.vertex); + COMPUTE_EYEDEPTH(v.projPos.z); + #endif + v.color = IN.color; + v.texcoord = TRANSFORM_TEX(IN.texcoord,_MainTex); + UNITY_TRANSFER_FOG(v,v.vertex); + return v; + } + + sampler2D_float _CameraDepthTexture; + float _InvFade; + + fixed4 frag (v2f i) : SV_Target + { + #ifdef SOFTPARTICLES_ON + float sceneZ = LinearEyeDepth (SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))); + float partZ = i.projPos.z; + float fade = saturate (_InvFade * (sceneZ-partZ)); + i.color *= fade; + #endif + + fixed4 tex = tex2D(_MainTex, i.texcoord); + fixed4 col; + col.rgb = _TintColor.rgb * tex.rgb * i.color.rgb * 2.0f; + col.a = (1 - tex.a) * (_TintColor.a * i.color.a * 2.0f); + UNITY_APPLY_FOG_COLOR(i.fogCoord, col, fixed4(0,0,0,0)); // fog towards black due to our blend mode + return col; + } + ENDCG + } + } + +} +} diff --git a/Shaders/UI Particle AddMultiply.shader.meta b/Shaders/UI Particle AddMultiply.shader.meta new file mode 100644 index 0000000..f4470c5 --- /dev/null +++ b/Shaders/UI Particle AddMultiply.shader.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 088bbfd9222ee044cb4e4699336e9ff1 +timeCreated: 1502443969 +licenseType: Free +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/UI Particle AddSmooth.shader b/Shaders/UI Particle AddSmooth.shader new file mode 100644 index 0000000..dc9fd9c --- /dev/null +++ b/Shaders/UI Particle AddSmooth.shader @@ -0,0 +1,104 @@ +Shader "UI Extensions/Particles/Additive (Soft)" { +Properties { + _MainTex ("Particle Texture", 2D) = "white" {} + _InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0 + + _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 + + _ColorMask ("Color Mask", Float) = 15 + + [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0 +} + +Category { + Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" "CanUseSpriteAtlas"="True" } + Blend One OneMinusSrcColor + ColorMask RGB + Cull Off Lighting Off ZWrite Off + + SubShader { + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Pass { + + CGPROGRAM + #pragma vertex vert + #pragma fragment frag + #pragma target 2.0 + #pragma multi_compile_particles + #pragma multi_compile_fog + + #include "UnityCG.cginc" + #include "UnityUI.cginc" + + #pragma multi_compile __ UNITY_UI_ALPHACLIP + + sampler2D _MainTex; + fixed4 _TintColor; + + struct appdata_t { + float4 vertex : POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + }; + + struct v2f { + float4 vertex : SV_POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + UNITY_FOG_COORDS(1) + #ifdef SOFTPARTICLES_ON + float4 projPos : TEXCOORD2; + #endif + }; + + float4 _MainTex_ST; + + v2f vert (appdata_t IN) + { + v2f v; + v.vertex = UnityObjectToClipPos(IN.vertex); + #ifdef SOFTPARTICLES_ON + v.projPos = ComputeScreenPos (v.vertex); + COMPUTE_EYEDEPTH(v.projPos.z); + #endif + v.color = IN.color; + v.texcoord = TRANSFORM_TEX(IN.texcoord,_MainTex); + UNITY_TRANSFER_FOG(v,v.vertex); + return v; + } + + sampler2D_float _CameraDepthTexture; + float _InvFade; + + fixed4 frag (v2f i) : SV_Target + { + #ifdef SOFTPARTICLES_ON + float sceneZ = LinearEyeDepth (SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))); + float partZ = i.projPos.z; + float fade = saturate (_InvFade * (sceneZ-partZ)); + i.color.a *= fade; + #endif + + half4 col = i.color * tex2D(_MainTex, i.texcoord); + col.rgb *= col.a; + UNITY_APPLY_FOG_COLOR(i.fogCoord, col, fixed4(0,0,0,0)); // fog towards black due to our blend mode + return col; + } + ENDCG + } + } +} +} diff --git a/Shaders/UI Particle AddSmooth.shader.meta b/Shaders/UI Particle AddSmooth.shader.meta new file mode 100644 index 0000000..5a37e95 --- /dev/null +++ b/Shaders/UI Particle AddSmooth.shader.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 4c2211b120168e44db4a3a8417013615 +timeCreated: 1502443969 +licenseType: Free +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/UI Particle Alpha Blend.shader b/Shaders/UI Particle Alpha Blend.shader new file mode 100644 index 0000000..b58ca0a --- /dev/null +++ b/Shaders/UI Particle Alpha Blend.shader @@ -0,0 +1,104 @@ +Shader "UI Extensions/Particles/Alpha Blended" { +Properties { + _TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5) + _MainTex ("Particle Texture", 2D) = "white" {} + _InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0 + + _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 + + _ColorMask ("Color Mask", Float) = 15 + + [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0 +} + +Category { + Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" "CanUseSpriteAtlas"="True" } + Blend SrcAlpha OneMinusSrcAlpha + ColorMask RGB + Cull Off Lighting Off ZWrite Off + + SubShader { + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Pass { + + CGPROGRAM + #pragma vertex vert + #pragma fragment frag + #pragma target 2.0 + #pragma multi_compile_particles + #pragma multi_compile_fog + + #include "UnityCG.cginc" + #include "UnityUI.cginc" + + #pragma multi_compile __ UNITY_UI_ALPHACLIP + + sampler2D _MainTex; + fixed4 _TintColor; + + struct appdata_t { + float4 vertex : POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + }; + + struct v2f { + float4 vertex : SV_POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + UNITY_FOG_COORDS(1) + #ifdef SOFTPARTICLES_ON + float4 projPos : TEXCOORD2; + #endif + }; + + float4 _MainTex_ST; + + v2f vert (appdata_t IN) + { + v2f v; + v.vertex = UnityObjectToClipPos(IN.vertex); + #ifdef SOFTPARTICLES_ON + v.projPos = ComputeScreenPos (v.vertex); + COMPUTE_EYEDEPTH(v.projPos.z); + #endif + v.color = IN.color; + v.texcoord = TRANSFORM_TEX(IN.texcoord,_MainTex); + UNITY_TRANSFER_FOG(v,v.vertex); + return v; + } + + sampler2D_float _CameraDepthTexture; + float _InvFade; + + fixed4 frag (v2f i) : SV_Target + { + #ifdef SOFTPARTICLES_ON + float sceneZ = LinearEyeDepth (SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))); + float partZ = i.projPos.z; + float fade = saturate (_InvFade * (sceneZ-partZ)); + i.color.a *= fade; + #endif + + fixed4 col = 2.0f * i.color * _TintColor * tex2D(_MainTex, i.texcoord); + UNITY_APPLY_FOG(i.fogCoord, col); + return col; + } + ENDCG + } + } +} +} diff --git a/Shaders/UI Particle Alpha Blend.shader.meta b/Shaders/UI Particle Alpha Blend.shader.meta new file mode 100644 index 0000000..ec71ecc --- /dev/null +++ b/Shaders/UI Particle Alpha Blend.shader.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: c3d7d8d71a91071469ad7019e77864d6 +timeCreated: 1502443970 +licenseType: Free +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/UI Particle Blend.shader b/Shaders/UI Particle Blend.shader new file mode 100644 index 0000000..3aac8f7 --- /dev/null +++ b/Shaders/UI Particle Blend.shader @@ -0,0 +1,103 @@ +Shader "UI Extensions/Particles/Blend" { +Properties { + _MainTex ("Particle Texture", 2D) = "white" {} + _InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0 + + _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 + + _ColorMask ("Color Mask", Float) = 15 + + [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0 +} + +Category { + Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" "CanUseSpriteAtlas"="True" } + Blend DstColor One + ColorMask RGB + Cull Off Lighting Off ZWrite Off + + SubShader { + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Pass { + + CGPROGRAM + #pragma vertex vert + #pragma fragment frag + #pragma target 2.0 + #pragma multi_compile_particles + #pragma multi_compile_fog + + #include "UnityCG.cginc" + #include "UnityUI.cginc" + + #pragma multi_compile __ UNITY_UI_ALPHACLIP + + sampler2D _MainTex; + fixed4 _TintColor; + + struct appdata_t { + float4 vertex : POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + }; + + struct v2f { + float4 vertex : SV_POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + UNITY_FOG_COORDS(1) + #ifdef SOFTPARTICLES_ON + float4 projPos : TEXCOORD2; + #endif + }; + + float4 _MainTex_ST; + + v2f vert (appdata_t IN) + { + v2f v; + v.vertex = UnityObjectToClipPos(IN.vertex); + #ifdef SOFTPARTICLES_ON + v.projPos = ComputeScreenPos (v.vertex); + COMPUTE_EYEDEPTH(v.projPos.z); + #endif + v.color = IN.color; + v.texcoord = TRANSFORM_TEX(IN.texcoord,_MainTex); + UNITY_TRANSFER_FOG(v,v.vertex); + return v; + } + + sampler2D_float _CameraDepthTexture; + float _InvFade; + + fixed4 frag (v2f i) : SV_Target + { + #ifdef SOFTPARTICLES_ON + float sceneZ = LinearEyeDepth (SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))); + float partZ = i.projPos.z; + float fade = saturate (_InvFade * (sceneZ-partZ)); + i.color *= fade; + #endif + + fixed4 col = i.color * tex2D(_MainTex, i.texcoord); + UNITY_APPLY_FOG_COLOR(i.fogCoord, col, fixed4(0,0,0,0)); // fog towards black due to our blend mode + return col; + } + ENDCG + } + } +} +} diff --git a/Shaders/UI Particle Blend.shader.meta b/Shaders/UI Particle Blend.shader.meta new file mode 100644 index 0000000..bbe0c4e --- /dev/null +++ b/Shaders/UI Particle Blend.shader.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 98fed5ba500a9a04a80325266b9911bb +timeCreated: 1502443970 +licenseType: Free +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/UI Particle Multiply.shader b/Shaders/UI Particle Multiply.shader new file mode 100644 index 0000000..62a62d9 --- /dev/null +++ b/Shaders/UI Particle Multiply.shader @@ -0,0 +1,103 @@ +Shader "UI Extensions/Particles/Multiply" { +Properties { + _MainTex ("Particle Texture", 2D) = "white" {} + _InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0 + + _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 + + _ColorMask ("Color Mask", Float) = 15 + + [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0 +} + +Category { + Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" "CanUseSpriteAtlas"="True" } + Blend Zero SrcColor + Cull Off Lighting Off ZWrite Off + + SubShader { + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Pass { + + CGPROGRAM + #pragma vertex vert + #pragma fragment frag + #pragma target 2.0 + #pragma multi_compile_particles + #pragma multi_compile_fog + + #include "UnityCG.cginc" + #include "UnityUI.cginc" + + #pragma multi_compile __ UNITY_UI_ALPHACLIP + + sampler2D _MainTex; + fixed4 _TintColor; + + struct appdata_t { + float4 vertex : POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + }; + + struct v2f { + float4 vertex : SV_POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + UNITY_FOG_COORDS(1) + #ifdef SOFTPARTICLES_ON + float4 projPos : TEXCOORD2; + #endif + }; + + float4 _MainTex_ST; + + v2f vert (appdata_t IN) + { + v2f v; + v.vertex = UnityObjectToClipPos(IN.vertex); + #ifdef SOFTPARTICLES_ON + v.projPos = ComputeScreenPos (v.vertex); + COMPUTE_EYEDEPTH(v.projPos.z); + #endif + v.color = IN.color; + v.texcoord = TRANSFORM_TEX(IN.texcoord,_MainTex); + UNITY_TRANSFER_FOG(v,v.vertex); + return v; + } + + sampler2D_float _CameraDepthTexture; + float _InvFade; + + fixed4 frag (v2f i) : SV_Target + { + #ifdef SOFTPARTICLES_ON + float sceneZ = LinearEyeDepth (SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))); + float partZ = i.projPos.z; + float fade = saturate (_InvFade * (sceneZ-partZ)); + i.color.a *= fade; + #endif + + half4 prev = i.color * tex2D(_MainTex, i.texcoord); + fixed4 col = lerp(half4(1,1,1,1), prev, prev.a); + UNITY_APPLY_FOG_COLOR(i.fogCoord, col, fixed4(1,1,1,1)); // fog towards white due to our blend mode + return col; + } + ENDCG + } + } +} +} diff --git a/Shaders/UI Particle Multiply.shader.meta b/Shaders/UI Particle Multiply.shader.meta new file mode 100644 index 0000000..75abfad --- /dev/null +++ b/Shaders/UI Particle Multiply.shader.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 320f6bb7bde369b4a85c9d89a9ba5268 +timeCreated: 1502443969 +licenseType: Free +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/UI Particle MultiplyDouble.shader b/Shaders/UI Particle MultiplyDouble.shader new file mode 100644 index 0000000..04118f5 --- /dev/null +++ b/Shaders/UI Particle MultiplyDouble.shader @@ -0,0 +1,107 @@ +Shader "UI Extensions/Particles/Multiply (Double)" { +Properties { + _MainTex ("Particle Texture", 2D) = "white" {} + _InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0 + + _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 + + _ColorMask ("Color Mask", Float) = 15 + + [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0 +} + +Category { + Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" "CanUseSpriteAtlas"="True" } + Blend DstColor SrcColor + ColorMask RGB + Cull Off Lighting Off ZWrite Off + + SubShader { + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Pass { + + CGPROGRAM + #pragma vertex vert + #pragma fragment frag + #pragma target 2.0 + #pragma multi_compile_particles + #pragma multi_compile_fog + + #include "UnityCG.cginc" + #include "UnityUI.cginc" + + #pragma multi_compile __ UNITY_UI_ALPHACLIP + + sampler2D _MainTex; + fixed4 _TintColor; + + struct appdata_t { + float4 vertex : POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + }; + + struct v2f { + float4 vertex : SV_POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + UNITY_FOG_COORDS(1) + #ifdef SOFTPARTICLES_ON + float4 projPos : TEXCOORD2; + #endif + }; + + float4 _MainTex_ST; + + v2f vert (appdata_t IN) + { + v2f v; + v.vertex = UnityObjectToClipPos(IN.vertex); + #ifdef SOFTPARTICLES_ON + v.projPos = ComputeScreenPos (v.vertex); + COMPUTE_EYEDEPTH(v.projPos.z); + #endif + v.color = IN.color; + v.texcoord = TRANSFORM_TEX(IN.texcoord,_MainTex); + UNITY_TRANSFER_FOG(v,v.vertex); + return v; + } + + sampler2D_float _CameraDepthTexture; + float _InvFade; + + fixed4 frag (v2f i) : SV_Target + { + #ifdef SOFTPARTICLES_ON + float sceneZ = LinearEyeDepth (SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))); + float partZ = i.projPos.z; + float fade = saturate (_InvFade * (sceneZ-partZ)); + i.color.a *= fade; + #endif + + fixed4 col; + fixed4 tex = tex2D(_MainTex, i.texcoord); + col.rgb = tex.rgb * i.color.rgb * 2; + col.a = i.color.a * tex.a; + col = lerp(fixed4(0.5f,0.5f,0.5f,0.5f), col, col.a); + UNITY_APPLY_FOG_COLOR(i.fogCoord, col, fixed4(0.5,0.5,0.5,0.5)); // fog towards gray due to our blend mode + return col; + } + ENDCG + } + } +} +} diff --git a/Shaders/UI Particle MultiplyDouble.shader.meta b/Shaders/UI Particle MultiplyDouble.shader.meta new file mode 100644 index 0000000..ec09b58 --- /dev/null +++ b/Shaders/UI Particle MultiplyDouble.shader.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 0765ecef58833c3429346a1fee45e4e0 +timeCreated: 1502443969 +licenseType: Free +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/UI Particle Premultiply Blend.shader b/Shaders/UI Particle Premultiply Blend.shader new file mode 100644 index 0000000..e6f8f74 --- /dev/null +++ b/Shaders/UI Particle Premultiply Blend.shader @@ -0,0 +1,104 @@ +Shader "UI Extensions/Particles/Alpha Blended Premultiply" { +Properties { + + _MainTex ("Particle Texture", 2D) = "white" {} + _InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0 + + _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 + + _ColorMask ("Color Mask", Float) = 15 + + [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0 +} + +Category { + Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" "CanUseSpriteAtlas"="True" } + Blend One OneMinusSrcAlpha + ColorMask RGB + Cull Off Lighting Off ZWrite Off + + SubShader { + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Pass { + + CGPROGRAM + #pragma vertex vert + #pragma fragment frag + #pragma target 2.0 + #pragma multi_compile_particles + + + #include "UnityCG.cginc" + #include "UnityUI.cginc" + + #pragma multi_compile __ UNITY_UI_ALPHACLIP + + sampler2D _MainTex; + fixed4 _TintColor; + + struct appdata_t { + float4 vertex : POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + }; + + struct v2f { + float4 vertex : SV_POSITION; + fixed4 color : COLOR; + float2 texcoord : TEXCOORD0; + + #ifdef SOFTPARTICLES_ON + float4 projPos : TEXCOORD1; + #endif + }; + + float4 _MainTex_ST; + + v2f vert (appdata_t IN) + { + v2f v; + v.vertex = UnityObjectToClipPos(IN.vertex); + #ifdef SOFTPARTICLES_ON + v.projPos = ComputeScreenPos (v.vertex); + COMPUTE_EYEDEPTH(v.projPos.z); + #endif + v.color = IN.color; + v.texcoord = TRANSFORM_TEX(IN.texcoord,_MainTex); + + return v; + } + + sampler2D_float _CameraDepthTexture; + float _InvFade; + + fixed4 frag (v2f IN) : SV_Target + { + #ifdef SOFTPARTICLES_ON + float sceneZ = LinearEyeDepth (SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(IN.projPos))); + float partZ = IN.projPos.z; + float fade = saturate (_InvFade * (sceneZ-partZ)); + IN.color.a *= fade; + #endif + + + + return IN.color * tex2D(_MainTex, IN.texcoord) * IN.color.a; + } + ENDCG + } + } +} +} diff --git a/Shaders/UI Particle Premultiply Blend.shader.meta b/Shaders/UI Particle Premultiply Blend.shader.meta new file mode 100644 index 0000000..7dd20ee --- /dev/null +++ b/Shaders/UI Particle Premultiply Blend.shader.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 0596a6838d78f624397b642817cf20bc +timeCreated: 1502443969 +licenseType: Free +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/Shaders/UI Particle VertexLit Blended.shader b/Shaders/UI Particle VertexLit Blended.shader new file mode 100644 index 0000000..4b5738e --- /dev/null +++ b/Shaders/UI Particle VertexLit Blended.shader @@ -0,0 +1,42 @@ +Shader "UI Extensions/Particles/VertexLit Blended" { +Properties { + _EmisColor ("Emissive Color", Color) = (.2,.2,.2,0) + _MainTex ("Particle Texture", 2D) = "white" {} + + _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 + + _ColorMask ("Color Mask", Float) = 15 + + [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0 +} + +SubShader { + Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Plane" "CanUseSpriteAtlas"="True" } + Tags { "LightMode" = "Vertex" } + Cull Off + Lighting On + Material { Emission [_EmisColor] } + ColorMaterial AmbientAndDiffuse + ZWrite Off + ColorMask RGB + Blend SrcAlpha OneMinusSrcAlpha + + Stencil + { + Ref [_Stencil] + Comp [_StencilComp] + Pass [_StencilOp] + ReadMask [_StencilReadMask] + WriteMask [_StencilWriteMask] + } + + Pass { + + SetTexture [_MainTex] { combine primary * texture } + } +} +} \ No newline at end of file diff --git a/Shaders/UI Particle VertexLit Blended.shader.meta b/Shaders/UI Particle VertexLit Blended.shader.meta new file mode 100644 index 0000000..34d0164 --- /dev/null +++ b/Shaders/UI Particle VertexLit Blended.shader.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 65bbb789ada58ab44aaedbe09687f089 +timeCreated: 1502443969 +licenseType: Free +ShaderImporter: + defaultTextures: [] + userData: + assetBundleName: + assetBundleVariant: