added preview

John Lim's Blend Modes/Add.shader

@@ -0,0 +1,100 @@
+Shader "Blendmodes/Add"
+{
+    Properties
+    {
+        [Header(Properties)]
+        _MainTex ("Blend Texture", 2D) = "white" {}
+        _Tint1 ("Tint on Texture", Color) = (1,1,1,0)
+        _Tint2 ("Tint on Blended Result", Color) = (1,1,1,0)
+        _Alpha ("Opacity of Blended Result", Range(0.0, 1.0)) = 1.0
+
+        //blending
+
+        [Header(Blending)]
+    		[Enum(UnityEngine.Rendering.BlendMode)] _BlendSrc ("Blend mode Source", Int) = 5
+    		[Enum(UnityEngine.Rendering.BlendMode)] _BlendDst ("Blend mode Destination", Int) = 10
+
+        // required for UI.Mask
+        [Header(Stencil)]
+        [Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("Stencil Comparison", Float) = 8
+        _Stencil ("Stencil ID", Float) = 0
+        [Enum(UnityEngine.Rendering.StencilOp)] _StencilOp ("Stencil Operation", Float) = 0
+        _StencilWriteMask ("Stencil Write Mask", Float) = 255
+        _StencilReadMask ("Stencil Read Mask", Float) = 255
+        [Enum(None,0,Alpha,1,Red,8,Green,4,Blue,2,RGB,14,RGBA,15)] _ColorMask("Color Mask", Int) = 15
+    }
+    SubShader
+    {
+        Tags { "Queue"="Transparent" "IgnoreProjector"="true" "RenderType"="Transparent" }
+        LOD 100
+        Blend [_BlendSrc] [_BlendDst]
+
+        // required for UI.Mask
+        Stencil
+        {
+            Ref [_Stencil]
+            Comp [_StencilComp]
+            Pass [_StencilOp]
+            ReadMask [_StencilReadMask]
+            WriteMask [_StencilWriteMask]
+        }
+
+        GrabPass
+        {
+            "_BackgroundTexture"
+        }
+
+        Pass
+        {
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+
+            #include "UnityCG.cginc"
+            #include "CGIncludes/PhotoshopBlendModes.cginc"
+
+            struct appdata
+            {
+                float4 vertex : POSITION;
+                float2 uv : TEXCOORD0;
+            };
+
+            struct v2f
+            {
+                float2 uv : TEXCOORD0;
+                float4 vertex : SV_POSITION;
+            };
+
+            sampler2D _MainTex;
+            fixed4 _MainTex_ST;
+            fixed4 _Tint1;
+            fixed4 _Tint2;
+            fixed _Alpha;
+
+            sampler2D _BackgroundTexture;
+
+            v2f vert (appdata v)
+            {
+                v2f o;
+                o.vertex = UnityObjectToClipPos(v.vertex);
+                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+                return o;
+            }
+
+            fixed4 frag (v2f i) : SV_Target
+            {
+                fixed4 mainColor = tex2D(_BackgroundTexture, i.uv);
+                fixed4 blendColor = tex2D(_MainTex, i.uv);
+                blendColor.xyz += _Tint1.xyz * _Tint1.a;
+
+                // perform blend
+                mainColor.xyz = Add(mainColor.xyz, blendColor.xyz);
+                mainColor.xyz += _Tint2.xyz * _Tint2.a;
+                mainColor.a = blendColor.a * _Alpha;
+
+                return mainColor;
+            }
+            ENDCG
+        }
+    }
+}

John Lim's Blend Modes/CGIncludes/PhotoshopBlendModes.cginc

@@ -0,0 +1,233 @@
+#ifndef PHOTOSHOP_BLENDMODES_INCLUDED
+#define PHOTOSHOP_BLENDMODES_INCLUDED
+
+//
+// Ported from https://www.shadertoy.com/view/XdS3RW
+//
+// Original License:
+//
+// Creative Commons CC0 1.0 Universal (CC-0) 
+//
+// 25 of the layer blending modes from Photoshop.
+//
+// The ones I couldn't figure out are from Nvidia's advanced blend equations extension spec -
+// http://www.opengl.org/registry/specs/NV/blend_equation_advanced.txt
+// 
+// ~bj.2013
+//
+
+// Helpers
+
+const fixed3 l = fixed3(0.3, 0.59, 0.11);
+
+/** @private */
+float pinLight(float s, float d)
+{
+    return (2.0*s - 1.0 > d) ? 2.0*s - 1.0 : (s < 0.5 * d) ? 2.0*s : d;
+}
+
+/** @private */
+float vividLight(float s, float d)
+{
+    return (s < 0.5) ? 1.0 - (1.0 - d) / (2.0 * s) : d / (2.0 * (1.0 - s));
+}
+
+/** @private */
+float hardLight(float s, float d)
+{
+    return (s < 0.5) ? 2.0*s*d : 1.0 - 2.0*(1.0 - s)*(1.0 - d);
+}
+
+/** @private */
+float softLight(float s, float d)
+{
+    return (s < 0.5) ? d - (1.0 - 2.0*s)*d*(1.0 - d) 
+                : (d < 0.25) ? d + (2.0*s - 1.0)*d*((16.0*d - 12.0)*d + 3.0) 
+                : d + (2.0*s - 1.0) * (sqrt(d) - d);
+}
+
+/** @private */
+float overlay( float s, float d )
+{
+    return (d < 0.5) ? 2.0*s*d : 1.0 - 2.0*(1.0 - s)*(1.0 - d);
+}
+
+//    rgb<-->hsv functions by Sam Hocevar
+//    http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
+/** @private */
+fixed3 rgb2hsv(fixed3 c)
+{
+    fixed4 K = fixed4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+    fixed4 p = lerp(fixed4(c.bg, K.wz), fixed4(c.gb, K.xy), step(c.b, c.g));
+    fixed4 q = lerp(fixed4(p.xyw, c.r), fixed4(c.r, p.yzx), step(p.x, c.r));
+
+    float d = q.x - min(q.w, q.y);
+    float e = 1.0e-10;
+    return fixed3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+/** @private */
+fixed3 hsv2rgb(fixed3 c)
+{
+    fixed4 K = fixed4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    fixed3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * lerp(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+// Public API Blend Modes
+
+fixed3 ColorBurn(fixed3 s, fixed3 d)
+{
+    return 1.0 - (1.0 - d) / s;
+}
+
+fixed3 LinearBurn(fixed3 s, fixed3 d )
+{
+    return s + d - 1.0;
+}
+
+fixed3 DarkerColor(fixed3 s, fixed3 d)
+{
+    return (s.x + s.y + s.z < d.x + d.y + d.z) ? s : d;
+}
+
+fixed3 Lighten(fixed3 s, fixed3 d)
+{
+    return max(s, d);
+}
+
+fixed3 Screen(fixed3 s, fixed3 d)
+{
+    return s + d - s * d;
+}
+
+fixed3 ColorDodge(fixed3 s, fixed3 d)
+{
+    return d / (1.0 - s);
+}
+
+fixed3 LinearDodge(fixed3 s, fixed3 d)
+{
+    return s + d;
+}
+
+fixed3 LighterColor(fixed3 s, fixed3 d)
+{
+    return (s.x + s.y + s.z > d.x + d.y + d.z) ? s : d;
+}
+
+fixed3 Overlay(fixed3 s, fixed3 d)
+{
+    fixed3 c;
+    c.x = overlay(s.x, d.x);
+    c.y = overlay(s.y, d.y);
+    c.z = overlay(s.z, d.z);
+    return c;
+}
+
+fixed3 SoftLight(fixed3 s, fixed3 d)
+{
+    fixed3 c;
+    c.x = softLight(s.x, d.x);
+    c.y = softLight(s.y, d.y);
+    c.z = softLight(s.z, d.z);
+    return c;
+}
+
+fixed3 HardLight(fixed3 s, fixed3 d)
+{
+    fixed3 c;
+    c.x = hardLight(s.x, d.x);
+    c.y = hardLight(s.y, d.y);
+    c.z = hardLight(s.z, d.z);
+    return c;
+}
+
+fixed3 VividLight(fixed3 s, fixed3 d)
+{
+    fixed3 c;
+    c.x = vividLight(s.x, d.x);
+    c.y = vividLight(s.y, d.y);
+    c.z = vividLight(s.z, d.z);
+    return c;
+}
+
+fixed3 LinearLight(fixed3 s, fixed3 d)
+{
+    return 2.0*s + d - 1.0;
+}
+
+fixed3 PinLight(fixed3 s, fixed3 d)
+{
+    fixed3 c;
+    c.x = pinLight(s.x, d.x);
+    c.y = pinLight(s.y, d.y);
+    c.z = pinLight(s.z, d.z);
+    return c;
+}
+
+fixed3 HardMix(fixed3 s, fixed3 d)
+{
+    return floor(s+d);
+}
+
+fixed3 Difference(fixed3 s, fixed3 d)
+{
+    return abs(d-s);
+}
+
+fixed3 Exclusion(fixed3 s, fixed3 d)
+{
+    return s + d - 2.0*s*d;
+}
+
+fixed3 Subtract(fixed3 s, fixed3 d)
+{
+    return s-d;
+}
+
+fixed3 Divide(fixed3 s, fixed3 d)
+{
+    return s/d;
+}
+
+fixed3 Add(fixed3 s, fixed3 d)
+{
+    return s+d;
+}
+
+fixed3 Hue(fixed3 s, fixed3 d)
+{
+    d = rgb2hsv(d);
+    d.x = rgb2hsv(s).x;
+    return hsv2rgb(d);
+}
+
+fixed3 Color(fixed3 s, fixed3 d)
+{
+    s = rgb2hsv(s);
+    s.z = rgb2hsv(d).z;
+    return hsv2rgb(s);
+}
+
+fixed3 Saturation(fixed3 s, fixed3 d)
+{
+    d = rgb2hsv(d);
+    d.y = rgb2hsv(s).y;
+    return hsv2rgb(d);
+}
+
+fixed3 Luminosity(fixed3 s, fixed3 d)
+{
+    float dLum = dot(d, l);
+    float sLum = dot(s, l);
+    float lum = sLum - dLum;
+    fixed3 c = d + lum;
+    float minC = min(min(c.x, c.y), c.z);
+    float maxC = max(max(c.x, c.y), c.z);
+    if(minC < 0.0) return sLum + ((c - sLum) * sLum) / (sLum - minC);
+    else if(maxC > 1.0) return sLum + ((c - sLum) * (1.0 - sLum)) / (maxC - sLum);
+    else return c;
+}
+
+#endif // PHOTOSHOP_BLENDMODES_INCLUDED