1

Packages/com.jbooth.microsplat.core/Scripts/Editor/InternalShaders/ClearNonNormalData.shader

@@ -0,0 +1,54 @@
+//////////////////////////////////////////////////////
+// MicroSplat
+// Copyright (c) Jason Booth
+//////////////////////////////////////////////////////
+
+Shader "Hidden/MicroSplat/ClearNonNormalData" 
+{
+   Properties {
+      _MainTex ("Base (RGB)", 2D) = "bump" {}
+   }
+
+
+
+   SubShader {
+      Pass {
+         ZTest Always Cull Off ZWrite Off
+            
+         CGPROGRAM
+         #pragma vertex vert_img
+         #pragma fragment frag
+         #include "UnityCG.cginc"
+         #include "UnityCG.cginc"
+   
+      struct v2f {
+         float4 pos : SV_POSITION;
+         float2 uv : TEXCOORD0;
+      };
+      
+      sampler2D _MainTex;
+      float _Swizzle;
+
+
+      half BlendOverlay(half base, half blend) { return (base < 0.5 ? (2.0 * base * blend) : (1.0 - 2.0 * (1.0 - base) * (1.0 - blend))); }
+         
+          
+      fixed4 frag(v2f_img i) : SV_Target
+      {
+         half4 data = tex2D(_MainTex, i.uv);
+         if (_Swizzle > 0.5)
+         {
+            data.ga = data.gr;
+         }
+         data.r = 0;
+         data.b = 1;
+         return data;
+      }
+         ENDCG
+      }
+
+   }
+
+   Fallback off
+
+}

Packages/com.jbooth.microsplat.core/Scripts/Editor/InternalShaders/HeightFromNormal.shader

@@ -0,0 +1,51 @@
+//////////////////////////////////////////////////////
+// MicroSplat
+// Copyright (c) Jason Booth
+//////////////////////////////////////////////////////
+
+Shader "Hidden/MicroSplat/HeightFromNormal" 
+{
+   // generate a height map from a normalSAO map
+   Properties {
+      _MainTex ("Base (RGB)", 2D) = "bump" {}
+   }
+
+
+
+   SubShader {
+      Pass {
+         ZTest Always Cull Off ZWrite Off
+            
+         CGPROGRAM
+         #pragma vertex vert_img
+         #pragma fragment frag
+         #include "UnityCG.cginc"
+         #include "UnityCG.cginc"
+   
+      struct v2f {
+         float4 pos : SV_POSITION;
+         float2 uv : TEXCOORD0;
+      };
+      
+      sampler2D _MainTex;
+
+      float4 _MainTex_TexelSize;
+
+
+      half BlendOverlay(half base, half blend) { return (base < 0.5 ? (2.0 * base * blend) : (1.0 - 2.0 * (1.0 - base) * (1.0 - blend))); }
+         
+          
+      fixed4 frag(v2f_img i) : SV_Target
+      {
+         half2 n0 = tex2Dbias(_MainTex, float4(i.uv, 0, 0)).ga;
+         half n = BlendOverlay(n0.x, n0.y);
+         return fixed4(n,n,n,n);
+      }
+         ENDCG
+      }
+
+   }
+
+   Fallback off
+
+}

Packages/com.jbooth.microsplat.core/Scripts/Editor/InternalShaders/MergeInChannel.shader

@@ -0,0 +1,110 @@
+//////////////////////////////////////////////////////
+// MicroSplat
+// Copyright (c) Jason Booth
+//////////////////////////////////////////////////////
+
+Shader "Hidden/MicroSplat/MergeInChannel" 
+{
+
+   Properties
+   {
+      _MainTex ("Base (RGB)", 2D) = "white" {}
+      _TargetTex("Target", 2D) = "white" {}
+      _TargetChannel("Target Channel", Int) = 0
+      _MergeChannel("Merge Channel", Int) = 0
+      _Invert("Invert", Int) = 0
+   }
+
+   SubShader {
+      Pass {
+         ZTest Always Cull Off ZWrite Off
+            
+         CGPROGRAM
+         #pragma vertex vert_img
+         #pragma fragment frag
+         #include "UnityCG.cginc"
+         #include "UnityCG.cginc"
+
+          sampler2D _MainTex;
+          sampler2D _TargetTex;
+          float4 _MainTex_TexelSize;
+          int _TargetChannel;
+          int _MergeChannel;
+          int _Invert;
+
+         float4 frag(v2f_img i) : SV_Target
+         {
+             float4 main = tex2D(_MainTex, i.uv);
+             float4 target = tex2D(_TargetTex, i.uv);
+
+             // why not array access? Throws compile error!
+             // target[_TargetChannel] = main[_MergeChannel];
+
+             if (_TargetChannel == 0)
+             {
+                if (_MergeChannel == 0)
+                    target.r = main.r;
+                else if (_MergeChannel == 1)
+                    target.r = main.g;
+                else if (_MergeChannel == 2)
+                    target.r = main.b;
+                else
+                    target.r = main.a;
+             }
+             else if (_TargetChannel == 1)
+             {
+                if (_MergeChannel == 0)
+                    target.g = main.r;
+                else if (_MergeChannel == 1)
+                    target.g = main.g;
+                else if (_MergeChannel == 2)
+                    target.g = main.b;
+                else
+                    target.g = main.a;
+             }
+             else if (_TargetChannel == 2)
+             {
+                if (_MergeChannel == 0)
+                    target.b = main.r;
+                else if (_MergeChannel == 1)
+                    target.b = main.g;
+                else if (_MergeChannel == 2)
+                    target.b = main.b;
+                else
+                    target.b = main.a;
+             }
+             else
+             {
+                if (_MergeChannel == 0)
+                    target.a = main.r;
+                else if (_MergeChannel == 1)
+                    target.a = main.g;
+                else if (_MergeChannel == 2)
+                    target.a = main.b;
+                else
+                    target.a = main.a;
+             }
+
+             
+             if (_Invert > 0.5)
+             {
+                if (_TargetChannel == 0)
+                   target.r = 1.0 - target.r;
+                else if (_TargetChannel == 1)
+                   target.g = 1.0 - target.g;
+                else if (_TargetChannel == 1)
+                   target.b = 1.0 - target.b;
+                else
+                   target.a = 1.0 - target.a;
+             }
+
+             return target;
+         }
+         ENDCG
+      }
+
+   }
+
+   Fallback off
+
+}

Packages/com.jbooth.microsplat.core/Scripts/Editor/InternalShaders/NormalSAOFromDiffuse.shader

@@ -0,0 +1,102 @@
+//////////////////////////////////////////////////////
+// MicroSplat
+// Copyright (c) Jason Booth
+//////////////////////////////////////////////////////
+
+Shader "Hidden/MicroSplat/NormalSAOFromDiffuse" 
+{
+   // generate a full NormalSAO texture from just a diffuse image
+   Properties {
+      _MainTex ("Base (RGB)", 2D) = "white" {}
+   }
+
+   SubShader {
+      Pass {
+         ZTest Always Cull Off ZWrite Off
+            
+         CGPROGRAM
+         #pragma vertex vert_img
+         #pragma fragment frag
+         #include "UnityCG.cginc"
+         #include "UnityCG.cginc"
+   
+      struct v2f {
+         float4 pos : SV_POSITION;
+         float2 uv : TEXCOORD0;
+      };
+      
+      sampler2D _MainTex;
+   
+    
+      float4 _MainTex_TexelSize;
+
+      float4 GenerateNormal(float2 uv, float uvOffset, float amplitude, float bias)
+      {
+         float pixX = _MainTex_TexelSize.x;
+         float pixY = _MainTex_TexelSize.y;
+
+         float3 gx = tex2Dbias(_MainTex, float4(uv + float2(pixX, 0), 0, bias)).rgb;
+         float3 gy = tex2Dbias(_MainTex, float4(uv + float2(0, pixY), 0, bias)).rgb; 
+         float3 gxb = tex2Dbias(_MainTex, float4(uv + float2(-pixX, 0), 0, bias)).rgb;
+         float3 gyb = tex2Dbias(_MainTex, float4(uv + float2(0, -pixY), 0, bias)).rgb;
+
+         gx  = saturate( Luminance(gx + uvOffset));
+         gy  = saturate( Luminance(gy + uvOffset));
+         gxb = saturate( Luminance(gxb + uvOffset));
+         gyb = saturate( Luminance(gyb + uvOffset));
+
+
+         gx = (gx - gxb) * -1;
+         gy = (gy - gyb) * -1;
+
+         half4 ret = half4(0.5, 0.5, 0, 1);
+
+         float len = sqrt( gx * gx + gy * gy + 1 );
+
+         if(len > 0)
+         {
+            ret.r = 10*amplitude*gx/len * 0.5 + 0.5;
+            ret.g = 10*amplitude*gy/len * 0.5 + 0.5;
+            ret.b = 1.0 / len;
+         } 
+         return ret;
+      }
+          
+      fixed4 frag(v2f_img i) : SV_Target
+      {
+         float4 finalNorm = 0;
+         finalNorm += GenerateNormal(i.uv, 0.1, 0.8, 6) * 6;
+         finalNorm += GenerateNormal(i.uv, 0.2, 0.7, 5) * 5;
+         finalNorm += GenerateNormal(i.uv, 0.3, 0.6, 4) * 4;
+         finalNorm += GenerateNormal(i.uv, 0.4, 0.5, 3) * 3;
+         finalNorm += GenerateNormal(i.uv, 0.5, 0.4, 2) * 2;
+         finalNorm += GenerateNormal(i.uv, 0.6, 0.3, 1);
+         finalNorm += GenerateNormal(i.uv, 0.7, 0.2, 0) * 2;
+         finalNorm /= 23.0;
+
+         finalNorm.xy -= 0.5;
+         finalNorm.xy *= 12;
+         finalNorm.xy += 0.5;
+
+         // ao is just the normal maps length
+         finalNorm.w = sqrt(1 - saturate(dot(finalNorm.xy - 0.5, finalNorm.xy - 0.5)));
+
+         // smoothness, be conservative
+         //finalNorm.b = 0.1 * (finalNorm.b + ((finalNorm.x + finalNorm.y)/2));
+         // Nope, people can't seem to understand that it generates a smoothness
+         // value, yet can totally understand it generates a normal, so fuck it,
+         // no smoothness it is. 
+         finalNorm.b = 0;
+         // swizzle to Smoothness/NormalY/AO/NormalX format, which looks better for most cases
+
+         finalNorm.rgba = finalNorm.bgar;
+         return finalNorm;
+      }
+         ENDCG
+      }
+
+   }
+
+   Fallback off
+
+}

Packages/com.jbooth.microsplat.core/Scripts/Editor/InternalShaders/NormalSAOFromHeight.shader

@@ -0,0 +1,107 @@
+//////////////////////////////////////////////////////
+// MicroSplat
+// Copyright (c) Jason Booth
+//////////////////////////////////////////////////////
+
+Shader "Hidden/MicroSplat/NormalSAOFromHeight" 
+{
+   // generate a full NormalSAO texture from just a diffuse image
+   Properties {
+      _MainTex ("Base (RGB)", 2D) = "white" {}
+   }
+
+
+   SubShader {
+      Pass {
+         ZTest Always Cull Off ZWrite Off
+            
+         CGPROGRAM
+         #pragma vertex vert_img
+         #pragma fragment frag
+         #include "UnityCG.cginc"
+         #include "UnityCG.cginc"
+   
+      struct v2f {
+         float4 pos : SV_POSITION;
+         float2 uv : TEXCOORD0;
+      };
+      
+      sampler2D _MainTex;
+   
+      int _Channel;
+
+      float4 _MainTex_TexelSize;
+
+      float4 GenerateNormal(float2 uv, float uvOffset, float amplitude, float bias)
+      {
+         float pixX = _MainTex_TexelSize.x;
+         float pixY = _MainTex_TexelSize.y;
+
+         float3 gx = tex2Dbias(_MainTex, float4(uv + float2(pixX, 0), 0, bias))[_Channel];
+         float3 gy = tex2Dbias(_MainTex, float4(uv + float2(0, pixY), 0, bias))[_Channel]; 
+         float3 gxb = tex2Dbias(_MainTex, float4(uv + float2(-pixX, 0), 0, bias))[_Channel];
+         float3 gyb = tex2Dbias(_MainTex, float4(uv + float2(0, -pixY), 0, bias))[_Channel];
+
+         gx  = saturate( Luminance(gx + uvOffset));
+         gy  = saturate( Luminance(gy + uvOffset));
+         gxb = saturate( Luminance(gxb + uvOffset));
+         gyb = saturate( Luminance(gyb + uvOffset));
+
+
+         gx = (gx - gxb) * -1;
+         gy = (gy - gyb) * -1;
+
+         half4 ret = half4(0.5, 0.5, 0, 1);
+
+         float len = sqrt( gx * gx + gy * gy + 1 );
+
+         if(len > 0)
+         {
+            ret.r = 10*amplitude*gx/len * 0.5 + 0.5;
+            ret.g = 10*amplitude*gy/len * 0.5 + 0.5;
+            ret.b = 1.0 / len;
+         } 
+         return ret;
+      }
+          
+      fixed4 frag(v2f_img i) : SV_Target
+      {
+         float4 finalNorm = 0;
+         finalNorm += GenerateNormal(i.uv, 0.1, 0.8, 6) * 6;
+         finalNorm += GenerateNormal(i.uv, 0.2, 0.7, 5) * 5;
+         finalNorm += GenerateNormal(i.uv, 0.3, 0.6, 4) * 4;
+         finalNorm += GenerateNormal(i.uv, 0.4, 0.5, 3) * 3;
+         finalNorm += GenerateNormal(i.uv, 0.5, 0.4, 2) * 2;
+         finalNorm += GenerateNormal(i.uv, 0.6, 0.3, 1);
+         finalNorm += GenerateNormal(i.uv, 0.7, 0.2, 0) * 2;
+         finalNorm /= 23.0;
+
+         finalNorm.xy -= 0.5;
+         finalNorm.xy *= 10;
+         finalNorm.xy += 0.5;
+         finalNorm.xy = saturate(finalNorm.xy);
+
+         // ao is just the normal maps length
+         finalNorm.w = sqrt(1 - saturate(dot(finalNorm.xy - 0.5, finalNorm.xy - 0.5)));
+
+         // smoothness, be conservative
+         //finalNorm.b = 0.1 * (finalNorm.b + ((finalNorm.x + finalNorm.y)/2));
+
+         // Nope, people can't seem to understand that it generates a smoothness
+         // value, yet can totally understand it generates a normal, so fuck it,
+         // no smoothness it is. 
+         finalNorm.b = 0;
+
+         // swizzle to better format.
+         finalNorm.rgba = finalNorm.bgar;
+
+         return finalNorm;
+      }
+         ENDCG
+      }
+
+   }
+
+   Fallback off
+
+}

Packages/com.jbooth.microsplat.core/Scripts/Editor/InternalShaders/NormalSAOFromNormal.shader

@@ -0,0 +1,60 @@
+//////////////////////////////////////////////////////
+// MicroSplat
+// Copyright (c) Jason Booth
+//////////////////////////////////////////////////////
+
+Shader "Hidden/MicroSplat/NormalSAOFromNormal" 
+{
+   // generate a full NormalSAO texture from just a diffuse image
+   Properties {
+      _MainTex ("Base (RGB)", 2D) = "bump" {}
+   }
+
+   SubShader {
+      Pass {
+         ZTest Always Cull Off ZWrite Off
+            
+         CGPROGRAM
+         #pragma vertex vert_img
+         #pragma fragment frag
+         #include "UnityCG.cginc"
+         #include "UnityCG.cginc"
+   
+      struct v2f {
+         float4 pos : SV_POSITION;
+         float2 uv : TEXCOORD0;
+      };
+      
+      sampler2D _MainTex;
+
+      fixed4 frag(v2f_img i) : SV_Target
+      {
+         half4 norm = tex2D(_MainTex, i.uv);
+
+
+         half3 un = UnpackNormal(norm);
+         un.xy *= 0.5;
+         un.xy += 0.5;
+         half4 nsao = 0;
+         nsao.xy = un.xy;
+         // ao is just the normal maps length
+         nsao.w = un.b * un.b;
+         // smoothness, be conservative
+         //nsao.z = un.b * 0.07;
+
+         // Nope, people can't seem to understand that it generates a smoothness
+         // value, yet can totally understand it generates a normal, so fuck it,
+         // no smoothness it is.
+
+         nsao.z = 0;
+
+         return nsao.bgar;
+      }
+         ENDCG
+      }
+
+   }
+
+   Fallback off
+
+}