Amplify vs Shader Forge

I've been wibble wobbling with what I want to spend my Christmas bonus on. I've researched both Shader Forge and Amplify:

Shader Forge - $95
https://www.assetstore.unity3d.com/en/#!/content/14147

Amplify - $25
https://www.assetstore.unity3d.com/en/#!/content/68570

Shader Forge looks like the most fully featured shader editor, and it looks impressive. Amplify looks a bit rough, but it has the potential to kill Shader Forge, and it's $70 cheaper.

Is there any major disadvantage to going with the plugin that's $70 cheaper?

 

Fixed that for you. Full source code available. Shader Forge is closed source. That makes it a winner in my opinion.

 

Well, that pretty well sold me.

 

I have shaderforge (from a sale I think) and do get some value out of it. But I'm gonna be honest, I wouldn't buy it again at full price because it is closed source (something I didn't notice before purchase) and can't do half the stuff I'd want to make with it, like complex multipass shaders (which I also didn't realize beforehand). And although I'd say it is a lot faster to make a shader with it (if you can make the shader in question with it) through trial and error, I kind of feel I'm missing out on learning-opportunities and the satisfaction that I get with manual shader writing. Also I think that shaderforge removes a lot less of the complexity of making your own shaders, than people generally anticipate. You still need to understand the math and operations you are using, there's no way around that imho.

I haven't bought the amplify editor yet. My question is, is there anything that would really be a reason for me to buy it too and stop using shaderforge? I'm having my doubts that any node-based solution will reach the freedom you get with writing shaders from scratch (or modifying existing ones). But maybe I'm wrong?

P.S.: also how likely is it that Unity make these tools redundant soon, like they did with ngui or Scion by offering very similar solutions themselves? I don't know about the UI stuff but imho the new post stack is way better than Scion.

 

I just picked up a copy but I haven't done much more than fiddle with the interface and search for opinions and articles. Back when it was announced on Reddit the author didn't seem very eager to compare it with Shader Forge which is understandable because at the time the only real differences were the cost and that it included source.

https://www.reddit.com/r/Unity3D/comments/52lkyl/new_amplify_shader_editor_nodebased_shader/

They mentioned that the user interface was one of the advantages but I have to disagree with that as the icons they selected for tasks like saving the shader, viewing the source code, and so on don't make any sense whatsoever. If it wasn't for the tool tips I would have had to experiment or read the source to understand their purpose.

One other aspect I looked at was the state of the code generated. It produces very minimalistic code compared to SF which generates a few hundred lines for even a very basic shader.

Thinking back on a statement from the developer that the Shader Forge binary was more akin to a folder used to keep the asset clean I ran a quick decompile of it and discovered that it isn't obfuscated in the slightest.

 

As much as I understand where this stance normally comes from, I'm really not sure why anyone would try to fix the asset over writing their own shaders at that point. They must really love the workflow if they are that committed to not learning how to write shaders.

 

Because in a team the person modding the tool might not be the person making the shaders. I've often added features for tools so that someone in a different role can do their job more effectively.

 

That's a big minus for amplify, I always prefer text over icons. Shaderforge has some nicely streamlined workflows for adding nodes with hotkeys, although some things about the editor annoy me too.

Minimalistic in a good or a bad way?

 

I give a shout out to ushader... https://www.assetstore.unity3d.com/en/#!/search/page=1/sortby=relevance/query=ushader
https://forum.unity3d.com/threads/ushader.409038/

surprisingly alot more features included already,
feature wise it beats amplify currently and price wise it beats shaderforge... ofc there is more to it than that

I actually only noticed them in the asset store after purchasing amplify shaders myself, good forum presence and website helps alot... and if that means having a good indie price to get forum activity up well then ... all things considered active development, where its at, cheaper early buy in price to something that may offer much better featureset later on.. yeh I went with amplify and I'm happy with it. I given up waiting on Unity to sort that sht out with a native and more interactive node based shader creating solution. ofc that's my just entitlement showing boohoo

For shaderforge, the price doesn't appeal to me knowing how much I would/wouldn't be utilizing it and the development is not exactly going anywhere.. closed source.. ya nope.

I don't even want it for doing complex shaders either, its really just to tailor shaders to be less generic with some extra effects on them for things..with an editor that can be quicker to do (amplify is not there yet but active development is encouraging to be involved). And afteral it is getting easy to tell Unreal game from a Unity ones.. that later ones all look the same and tend to have same static material shaders with zero effects.. I can't effng imagine why ofc, other than I don't think many indies enjoy messing with shader syntax language when a default toolset set consisting of a material/shader editor makes it less of a hassle to tailor up new shader materials and effects for them.

"I'm having my doubts that any node-based solution will reach the freedom you get with writing shaders from scratch (or modifying existing ones). But maybe I'm wrong?"

I think if you're really get into making your own shaders you would just end up wanting to see and work with the code, but that isn't for me, and not why I went for a node editor for it.. its literately one of the few things I know a node editor makes sense ..Unity should be ashamed, they copy Maya like viewport controls and other aspects for Unity.. and don't even bother to include the hypershade editor for doing shaders with.. terrible

"P.S.: also how likely is it that Unity make these tools redundant soon, like they did with ngui"

I imagine if I had gotten into using Unity 3years ago instead 1 year and started using ngui, I wouldn't touch ugui, its like half baked solution that falls short of ngui in many aspects from what I looked at into it. Which is disappointing really, 5.5 had literally no new additions or improvements to ugui components. You practically have to fix them yourself to improve them, as they all seem tested for mobile, mousewheel scroll on the scrollbar component.. yeh S*** until u fix it yourself. And find third party enhancements still.. previous 5.x releases have just been fixing bugs for ugui.. not much else. But you end up using it as is its the native solution and so yeah I have less interest to purchase ngui but you can't knock the asset as its still holds some value I guess..

Unity kinda sit on these things and just mess third party asset developers and end users around by not being clear on what they will be adding in any meaningful timeframe. At this point if they hire some developers to work on a native node shader, I'll just remind myself that whatever solution gets built in.. it will be inferior to an asset store version because it seems to hold true for most things so far.

 

But even then, you've still got a case where someone knows exactly what they want, but have to take this roundabout method to get there. Unless it's to add a feature that will be used all over the place (why was this not something shopped for?), it just seems like it's patching the workflow and not the problem.

 

Check out this example shader implemented in both assets from the following website. Notice that the Shader Forge node data is a single line whereas Amplify is multiple lines but still far shorter. Keep in mind that I have little to no experience writing shader code so my choice of words might be off and there may be a reason for them being this long that I'm not aware of.

http://blog.kjinteractive.net/2016/shader-forge-vs-amplify-shader-editor/

Amplify Shader

Code (csharp):

1. Shader "EcoTales/EcoTales_PBR_Test_Amplify"
2. {
3.     Properties
4.     {
5.         _LerpTex("LerpTex", 2D) = "white" {}
6.         _MainTex("MainTex", 2D) = "white" {}
7.         [HideInInspector] __dirty( "", Int ) = 1
8.         _NormalMap("NormalMap", 2D) = "bump" {}
9.         _ColorWhite("ColorWhite", Color) = (0,0,0,0)
10.         _ColorBlack("ColorBlack", Color) = (1,1,1,0)
11.     }
12.  
13.     SubShader
14.     {
15.         Tags{ "RenderType" = "Opaque"  "Queue" = "Geometry0" }
16.         Cull Back
17.         CGPROGRAM
18.         #pragma target 3.0
19.         #pragma surface surf Standard keepalpha addshadow fullforwardshadows
20.         struct Input
21.         {
22.             float2 uv_NormalMap;
23.             float2 uv_LerpTex;
24.             float2 uv_MainTex;
25.         };
26.  
27.         uniform sampler2D _NormalMap;
28.         uniform float4 _ColorWhite;
29.         uniform float4 _ColorBlack;
30.         uniform sampler2D _LerpTex;
31.         uniform sampler2D _MainTex;
32.  
33.         void surf( Input input , inout SurfaceOutputStandard output )
34.         {
35.             output.Normal = UnpackNormal( tex2D( _NormalMap,input.uv_NormalMap) );
36.             output.Albedo = ( lerp( _ColorWhite , _ColorBlack , tex2D( _LerpTex,input.uv_LerpTex).r ) * tex2D( _MainTex,input.uv_MainTex) ).xyz;
37.             float3 _Vector0 = float3(0,0,0);
38.             output.Metallic = _Vector0.x;
39.             output.Smoothness = _Vector0.x;
40.         }
41.  
42.         ENDCG
43.     }
44.     Fallback "Diffuse"
45. }
46. /*ASEBEGIN
47. Version=10
48. 0;678;934;350;716.2492;-115.1004;1.6;True;False
49. Node;AmplifyShaderEditor.LerpOp;8;-57.45016,92.30013;0.0,0,0,0;0.0,0,0,0;0.0
50. Node;AmplifyShaderEditor.SimpleMultiplyOpNode;10;234.3494,117.0001;0.0,0,0,0;0.0,0,0,0
51. Node;AmplifyShaderEditor.StandardSurfaceOutputNode;0;559.8005,58.89998;True;Standard;EcoTales/EcoTales_PBR_Test_Amplify;False;False;False;False;False;False;False;False;False;False;False;False;Back;On;LEqual;Opaque;0.5;True;True;0;0,0,0;0,0,0;0,0,0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0,0,0
52. Node;AmplifyShaderEditor.ColorNode;6;-445.9497,-9.900023;Property;_ColorBlack;ColorBlack;1,1,1,0
53. Node;AmplifyShaderEditor.SamplerNode;7;-444.6508,212.2997;Property;_LerpTex;LerpTex;None;True;0;False;white;Auto;False;0,0;1.0
54. Node;AmplifyShaderEditor.SamplerNode;9;-302.9506,446.3002;Property;_MainTex;MainTex;None;True;0;False;white;Auto;False;0,0;1.0
55. Node;AmplifyShaderEditor.SamplerNode;12;-259.7502,676.7004;Property;_NormalMap;NormalMap;None;True;0;True;bump;Auto;True;0,0;1.0
56. Node;AmplifyShaderEditor.ColorNode;5;-444.649,-189.3003;Property;_ColorWhite;ColorWhite;0,0,0,0
57. Node;AmplifyShaderEditor.Vector3Node;17;183.3508,304.4001;Constant;_Vector0;Vector 0;0,0,0
58. WireConnection;8;0;5;0
59. WireConnection;8;1;6;0
60. WireConnection;8;2;7;1
61. WireConnection;10;0;8;0
62. WireConnection;10;1;9;0
63. WireConnection;0;0;10;0
64. WireConnection;0;1;12;0
65. WireConnection;0;3;17;0
66. WireConnection;0;4;17;0
67. ASEEND*/
68. //CHKSM=9173DEF0D32FC428CFFEA7A13AECBF946DB306D8

Shader Forge - Forward Shader

Code (csharp):

1. // Upgrade NOTE: replaced '_Object2World' with 'unity_ObjectToWorld'
2.  
3. // Shader created with Shader Forge v1.28
4. // Shader Forge (c) Neat Corporation / Joachim Holmer - http://www.acegikmo.com/shaderforge/
5. // Note: Manually altering this data may prevent you from opening it in Shader Forge
6. /*SF_DATA;ver:1.28;sub:START;pass:START;ps:flbk:,iptp:0,cusa:False,bamd:0,lico:1,lgpr:1,limd:3,spmd:1,trmd:0,grmd:0,uamb:True,mssp:True,bkdf:True,hqlp:False,rprd:True,enco:False,rmgx:True,rpth:0,vtps:0,hqsc:True,nrmq:1,nrsp:0,vomd:0,spxs:False,tesm:0,olmd:1,culm:0,bsrc:0,bdst:1,dpts:2,wrdp:True,dith:0,rfrpo:True,rfrpn:Refraction,coma:15,ufog:True,aust:True,igpj:False,qofs:0,qpre:1,rntp:1,fgom:False,fgoc:False,fgod:False,fgor:False,fgmd:0,fgcr:0.5,fgcg:0.5,fgcb:0.5,fgca:1,fgde:0.01,fgrn:0,fgrf:300,stcl:False,stva:128,stmr:255,stmw:255,stcp:6,stps:0,stfa:0,stfz:0,ofsf:0,ofsu:0,f2p0:False,fnsp:False,fnfb:False;n:type:ShaderForge.SFN_Final,id:2865,x:32719,y:32712,varname:node_2865,prsc:2|diff-6343-OUT,spec-383-OUT,gloss-383-OUT,normal-5964-RGB;n:type:ShaderForge.SFN_Multiply,id:6343,x:32399,y:32683,varname:node_6343,prsc:2|A-8466-OUT,B-7736-RGB;n:type:ShaderForge.SFN_Tex2d,id:7736,x:31710,y:32879,ptovrint:True,ptlb:Base Color,ptin:_MainTex,varname:_MainTex,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,ntxv:0,isnm:False;n:type:ShaderForge.SFN_Tex2d,id:5964,x:32055,y:32936,ptovrint:True,ptlb:Normal Map,ptin:_BumpMap,varname:_BumpMap,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,ntxv:3,isnm:True;n:type:ShaderForge.SFN_Lerp,id:8466,x:31852,y:32462,varname:node_8466,prsc:2|A-1185-RGB,B-626-RGB,T-5966-R;n:type:ShaderForge.SFN_Color,id:1185,x:31592,y:32244,ptovrint:False,ptlb:ColorWhite,ptin:_ColorWhite,varname:node_1185,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,c1:0.5,c2:0.5,c3:0.5,c4:1;n:type:ShaderForge.SFN_Color,id:626,x:31592,y:32420,ptovrint:False,ptlb:ColorBlack,ptin:_ColorBlack,varname:node_626,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,c1:0.5,c2:0.5,c3:0.5,c4:1;n:type:ShaderForge.SFN_Tex2d,id:5966,x:31592,y:32652,ptovrint:False,ptlb:LerpTex,ptin:_LerpTex,varname:node_5966,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,ntxv:0,isnm:False;n:type:ShaderForge.SFN_Vector1,id:383,x:32459,y:32494,varname:node_383,prsc:2,v1:0;proporder:5964-7736-1185-626-5966;pass:END;sub:END;*/
7.  
8. Shader "EcoTales/EcoTales_PBR_Test_ShaderForge" {
9.     Properties {
10.         _BumpMap ("Normal Map", 2D) = "bump" {}
11.         _MainTex ("Base Color", 2D) = "white" {}
12.         _ColorWhite ("ColorWhite", Color) = (0.5,0.5,0.5,1)
13.         _ColorBlack ("ColorBlack", Color) = (0.5,0.5,0.5,1)
14.         _LerpTex ("LerpTex", 2D) = "white" {}
15.     }
16.     SubShader {
17.         Tags {
18.             "RenderType"="Opaque"
19.         }
20.         Pass {
21.             Name "FORWARD"
22.             Tags {
23.                 "LightMode"="ForwardBase"
24.             }
25.      
26.      
27.             CGPROGRAM
28.             #pragma vertex vert
29.             #pragma fragment frag
30.             #define UNITY_PASS_FORWARDBASE
31.             #define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )
32.             #define _GLOSSYENV 1
33.             #include "UnityCG.cginc"
34.             #include "AutoLight.cginc"
35.             #include "Lighting.cginc"
36.             #include "UnityPBSLighting.cginc"
37.             #include "UnityStandardBRDF.cginc"
38.             #pragma multi_compile_fwdbase_fullshadows
39.             #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
40.             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
41.             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
42.             #pragma multi_compile_fog
43.             #pragma exclude_renderers gles3 metal d3d11_9x xbox360 xboxone ps3 ps4 psp2
44.             #pragma target 3.0
45.             uniform sampler2D _MainTex; uniform float4 _MainTex_ST;
46.             uniform sampler2D _BumpMap; uniform float4 _BumpMap_ST;
47.             uniform float4 _ColorWhite;
48.             uniform float4 _ColorBlack;
49.             uniform sampler2D _LerpTex; uniform float4 _LerpTex_ST;
50.             struct VertexInput {
51.                 float4 vertex : POSITION;
52.                 float3 normal : NORMAL;
53.                 float4 tangent : TANGENT;
54.                 float2 texcoord0 : TEXCOORD0;
55.                 float2 texcoord1 : TEXCOORD1;
56.                 float2 texcoord2 : TEXCOORD2;
57.             };
58.             struct VertexOutput {
59.                 float4 pos : SV_POSITION;
60.                 float2 uv0 : TEXCOORD0;
61.                 float2 uv1 : TEXCOORD1;
62.                 float2 uv2 : TEXCOORD2;
63.                 float4 posWorld : TEXCOORD3;
64.                 float3 normalDir : TEXCOORD4;
65.                 float3 tangentDir : TEXCOORD5;
66.                 float3 bitangentDir : TEXCOORD6;
67.                 LIGHTING_COORDS(7,8)
68.                 UNITY_FOG_COORDS(9)
69.                 #if defined(LIGHTMAP_ON) || defined(UNITY_SHOULD_SAMPLE_SH)
70.                     float4 ambientOrLightmapUV : TEXCOORD10;
71.                 #endif
72.             };
73.             VertexOutput vert (VertexInput v) {
74.                 VertexOutput o = (VertexOutput)0;
75.                 o.uv0 = v.texcoord0;
76.                 o.uv1 = v.texcoord1;
77.                 o.uv2 = v.texcoord2;
78.                 #ifdef LIGHTMAP_ON
79.                     o.ambientOrLightmapUV.xy = v.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
80.                     o.ambientOrLightmapUV.zw = 0;
81.                 #elif UNITY_SHOULD_SAMPLE_SH
82.                 #endif
83.                 #ifdef DYNAMICLIGHTMAP_ON
84.                     o.ambientOrLightmapUV.zw = v.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
85.                 #endif
86.                 o.normalDir = UnityObjectToWorldNormal(v.normal);
87.                 o.tangentDir = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );
88.                 o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);
89.                 o.posWorld = mul(unity_ObjectToWorld, v.vertex);
90.                 float3 lightColor = _LightColor0.rgb;
91.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex );
92.                 UNITY_TRANSFER_FOG(o,o.pos);
93.                 TRANSFER_VERTEX_TO_FRAGMENT(o)
94.                 return o;
95.             }
96.             float4 frag(VertexOutput i) : COLOR {
97.                 i.normalDir = normalize(i.normalDir);
98.                 float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);
99.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
100.                 float3 _BumpMap_var = UnpackNormal(tex2D(_BumpMap,TRANSFORM_TEX(i.uv0, _BumpMap)));
101.                 float3 normalLocal = _BumpMap_var.rgb;
102.                 float3 normalDirection = normalize(mul( normalLocal, tangentTransform )); // Perturbed normals
103.                 float3 viewReflectDirection = reflect( -viewDirection, normalDirection );
104.                 float3 lightDirection = normalize(_WorldSpaceLightPos0.xyz);
105.                 float3 lightColor = _LightColor0.rgb;
106.                 float3 halfDirection = normalize(viewDirection+lightDirection);
107. ////// Lighting:
108.                 float attenuation = LIGHT_ATTENUATION(i);
109.                 float3 attenColor = attenuation * _LightColor0.xyz;
110.                 float Pi = 3.141592654;
111.                 float InvPi = 0.31830988618;
112. ///////// Gloss:
113.                 float node_383 = 0.0;
114.                 float gloss = node_383;
115.                 float specPow = exp2( gloss * 10.0+1.0);
116. /////// GI Data:
117.                 UnityLight light;
118.                 #ifdef LIGHTMAP_OFF
119.                     light.color = lightColor;
120.                     light.dir = lightDirection;
121.                     light.ndotl = LambertTerm (normalDirection, light.dir);
122.                 #else
123.                     light.color = half3(0.f, 0.f, 0.f);
124.                     light.ndotl = 0.0f;
125.                     light.dir = half3(0.f, 0.f, 0.f);
126.                 #endif
127.                 UnityGIInput d;
128.                 d.light = light;
129.                 d.worldPos = i.posWorld.xyz;
130.                 d.worldViewDir = viewDirection;
131.                 d.atten = attenuation;
132.                 #if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON)
133.                     d.ambient = 0;
134.                     d.lightmapUV = i.ambientOrLightmapUV;
135.                 #else
136.                     d.ambient = i.ambientOrLightmapUV;
137.                 #endif
138.                 d.boxMax[0] = unity_SpecCube0_BoxMax;
139.                 d.boxMin[0] = unity_SpecCube0_BoxMin;
140.                 d.probePosition[0] = unity_SpecCube0_ProbePosition;
141.                 d.probeHDR[0] = unity_SpecCube0_HDR;
142.                 d.boxMax[1] = unity_SpecCube1_BoxMax;
143.                 d.boxMin[1] = unity_SpecCube1_BoxMin;
144.                 d.probePosition[1] = unity_SpecCube1_ProbePosition;
145.                 d.probeHDR[1] = unity_SpecCube1_HDR;
146.                 Unity_GlossyEnvironmentData ugls_en_data;
147.                 ugls_en_data.roughness = 1.0 - gloss;
148.                 ugls_en_data.reflUVW = viewReflectDirection;
149.                 UnityGI gi = UnityGlobalIllumination(d, 1, normalDirection, ugls_en_data );
150.                 lightDirection = gi.light.dir;
151.                 lightColor = gi.light.color;
152. ////// Specular:
153.                 float NdotL = max(0, dot( normalDirection, lightDirection ));
154.                 float LdotH = max(0.0,dot(lightDirection, halfDirection));
155.                 float3 specularColor = node_383;
156.                 float specularMonochrome;
157.                 float4 _LerpTex_var = tex2D(_LerpTex,TRANSFORM_TEX(i.uv0, _LerpTex));
158.                 float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));
159.                 float3 diffuseColor = (lerp(_ColorWhite.rgb,_ColorBlack.rgb,_LerpTex_var.r)*_MainTex_var.rgb); // Need this for specular when using metallic
160.                 diffuseColor = DiffuseAndSpecularFromMetallic( diffuseColor, specularColor, specularColor, specularMonochrome );
161.                 specularMonochrome = 1.0-specularMonochrome;
162.                 float NdotV = max(0.0,dot( normalDirection, viewDirection ));
163.                 float NdotH = max(0.0,dot( normalDirection, halfDirection ));
164.                 float VdotH = max(0.0,dot( viewDirection, halfDirection ));
165.                 float visTerm = SmithJointGGXVisibilityTerm( NdotL, NdotV, 1.0-gloss );
166.                 float normTerm = max(0.0, GGXTerm(NdotH, 1.0-gloss));
167.                 float specularPBL = (NdotL*visTerm*normTerm) * (UNITY_PI / 4);
168.                 if (IsGammaSpace())
169.                     specularPBL = sqrt(max(1e-4h, specularPBL));
170.                 specularPBL = max(0, specularPBL * NdotL);
171.                 float3 directSpecular = (floor(attenuation) * _LightColor0.xyz)*specularPBL*FresnelTerm(specularColor, LdotH);
172.                 half grazingTerm = saturate( gloss + specularMonochrome );
173.                 float3 indirectSpecular = (gi.indirect.specular);
174.                 indirectSpecular *= FresnelLerp (specularColor, grazingTerm, NdotV);
175.                 float3 specular = (directSpecular + indirectSpecular);
176. /////// Diffuse:
177.                 NdotL = max(0.0,dot( normalDirection, lightDirection ));
178.                 half fd90 = 0.5 + 2 * LdotH * LdotH * (1-gloss);
179.                 float nlPow5 = Pow5(1-NdotL);
180.                 float nvPow5 = Pow5(1-NdotV);
181.                 float3 directDiffuse = ((1 +(fd90 - 1)*nlPow5) * (1 + (fd90 - 1)*nvPow5) * NdotL) * attenColor;
182.                 float3 indirectDiffuse = float3(0,0,0);
183.                 indirectDiffuse += gi.indirect.diffuse;
184.                 float3 diffuse = (directDiffuse + indirectDiffuse) * diffuseColor;
185. /// Final Color:
186.                 float3 finalColor = diffuse + specular;
187.                 fixed4 finalRGBA = fixed4(finalColor,1);
188.                 UNITY_APPLY_FOG(i.fogCoord, finalRGBA);
189.                 return finalRGBA;
190.             }
191.             ENDCG
192.         }
193.         Pass {
194.             Name "FORWARD_DELTA"
195.             Tags {
196.                 "LightMode"="ForwardAdd"
197.             }
198.             Blend One One
199.      
200.      
201.             CGPROGRAM
202.             #pragma vertex vert
203.             #pragma fragment frag
204.             #define UNITY_PASS_FORWARDADD
205.             #define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )
206.             #define _GLOSSYENV 1
207.             #include "UnityCG.cginc"
208.             #include "AutoLight.cginc"
209.             #include "Lighting.cginc"
210.             #include "UnityPBSLighting.cginc"
211.             #include "UnityStandardBRDF.cginc"
212.             #pragma multi_compile_fwdadd_fullshadows
213.             #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
214.             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
215.             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
216.             #pragma multi_compile_fog
217.             #pragma exclude_renderers gles3 metal d3d11_9x xbox360 xboxone ps3 ps4 psp2
218.             #pragma target 3.0
219.             uniform sampler2D _MainTex; uniform float4 _MainTex_ST;
220.             uniform sampler2D _BumpMap; uniform float4 _BumpMap_ST;
221.             uniform float4 _ColorWhite;
222.             uniform float4 _ColorBlack;
223.             uniform sampler2D _LerpTex; uniform float4 _LerpTex_ST;
224.             struct VertexInput {
225.                 float4 vertex : POSITION;
226.                 float3 normal : NORMAL;
227.                 float4 tangent : TANGENT;
228.                 float2 texcoord0 : TEXCOORD0;
229.                 float2 texcoord1 : TEXCOORD1;
230.                 float2 texcoord2 : TEXCOORD2;
231.             };
232.             struct VertexOutput {
233.                 float4 pos : SV_POSITION;
234.                 float2 uv0 : TEXCOORD0;
235.                 float2 uv1 : TEXCOORD1;
236.                 float2 uv2 : TEXCOORD2;
237.                 float4 posWorld : TEXCOORD3;
238.                 float3 normalDir : TEXCOORD4;
239.                 float3 tangentDir : TEXCOORD5;
240.                 float3 bitangentDir : TEXCOORD6;
241.                 LIGHTING_COORDS(7,8)
242.                 UNITY_FOG_COORDS(9)
243.             };
244.             VertexOutput vert (VertexInput v) {
245.                 VertexOutput o = (VertexOutput)0;
246.                 o.uv0 = v.texcoord0;
247.                 o.uv1 = v.texcoord1;
248.                 o.uv2 = v.texcoord2;
249.                 o.normalDir = UnityObjectToWorldNormal(v.normal);
250.                 o.tangentDir = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );
251.                 o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);
252.                 o.posWorld = mul(unity_ObjectToWorld, v.vertex);
253.                 float3 lightColor = _LightColor0.rgb;
254.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex );
255.                 UNITY_TRANSFER_FOG(o,o.pos);
256.                 TRANSFER_VERTEX_TO_FRAGMENT(o)
257.                 return o;
258.             }
259.             float4 frag(VertexOutput i) : COLOR {
260.                 i.normalDir = normalize(i.normalDir);
261.                 float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);
262.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
263.                 float3 _BumpMap_var = UnpackNormal(tex2D(_BumpMap,TRANSFORM_TEX(i.uv0, _BumpMap)));
264.                 float3 normalLocal = _BumpMap_var.rgb;
265.                 float3 normalDirection = normalize(mul( normalLocal, tangentTransform )); // Perturbed normals
266.                 float3 lightDirection = normalize(lerp(_WorldSpaceLightPos0.xyz, _WorldSpaceLightPos0.xyz - i.posWorld.xyz,_WorldSpaceLightPos0.w));
267.                 float3 lightColor = _LightColor0.rgb;
268.                 float3 halfDirection = normalize(viewDirection+lightDirection);
269. ////// Lighting:
270.                 float attenuation = LIGHT_ATTENUATION(i);
271.                 float3 attenColor = attenuation * _LightColor0.xyz;
272.                 float Pi = 3.141592654;
273.                 float InvPi = 0.31830988618;
274. ///////// Gloss:
275.                 float node_383 = 0.0;
276.                 float gloss = node_383;
277.                 float specPow = exp2( gloss * 10.0+1.0);
278. ////// Specular:
279.                 float NdotL = max(0, dot( normalDirection, lightDirection ));
280.                 float LdotH = max(0.0,dot(lightDirection, halfDirection));
281.                 float3 specularColor = node_383;
282.                 float specularMonochrome;
283.                 float4 _LerpTex_var = tex2D(_LerpTex,TRANSFORM_TEX(i.uv0, _LerpTex));
284.                 float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));
285.                 float3 diffuseColor = (lerp(_ColorWhite.rgb,_ColorBlack.rgb,_LerpTex_var.r)*_MainTex_var.rgb); // Need this for specular when using metallic
286.                 diffuseColor = DiffuseAndSpecularFromMetallic( diffuseColor, specularColor, specularColor, specularMonochrome );
287.                 specularMonochrome = 1.0-specularMonochrome;
288.                 float NdotV = max(0.0,dot( normalDirection, viewDirection ));
289.                 float NdotH = max(0.0,dot( normalDirection, halfDirection ));
290.                 float VdotH = max(0.0,dot( viewDirection, halfDirection ));
291.                 float visTerm = SmithJointGGXVisibilityTerm( NdotL, NdotV, 1.0-gloss );
292.                 float normTerm = max(0.0, GGXTerm(NdotH, 1.0-gloss));
293.                 float specularPBL = (NdotL*visTerm*normTerm) * (UNITY_PI / 4);
294.                 if (IsGammaSpace())
295.                     specularPBL = sqrt(max(1e-4h, specularPBL));
296.                 specularPBL = max(0, specularPBL * NdotL);
297.                 float3 directSpecular = attenColor*specularPBL*FresnelTerm(specularColor, LdotH);
298.                 float3 specular = directSpecular;
299. /////// Diffuse:
300.                 NdotL = max(0.0,dot( normalDirection, lightDirection ));
301.                 half fd90 = 0.5 + 2 * LdotH * LdotH * (1-gloss);
302.                 float nlPow5 = Pow5(1-NdotL);
303.                 float nvPow5 = Pow5(1-NdotV);
304.                 float3 directDiffuse = ((1 +(fd90 - 1)*nlPow5) * (1 + (fd90 - 1)*nvPow5) * NdotL) * attenColor;
305.                 float3 diffuse = directDiffuse * diffuseColor;
306. /// Final Color:
307.                 float3 finalColor = diffuse + specular;
308.                 fixed4 finalRGBA = fixed4(finalColor * 1,0);
309.                 UNITY_APPLY_FOG(i.fogCoord, finalRGBA);
310.                 return finalRGBA;
311.             }
312.             ENDCG
313.         }
314.         Pass {
315.             Name "Meta"
316.             Tags {
317.                 "LightMode"="Meta"
318.             }
319.             Cull Off
320.      
321.             CGPROGRAM
322.             #pragma vertex vert
323.             #pragma fragment frag
324.             #define UNITY_PASS_META 1
325.             #define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )
326.             #define _GLOSSYENV 1
327.             #include "UnityCG.cginc"
328.             #include "Lighting.cginc"
329.             #include "UnityPBSLighting.cginc"
330.             #include "UnityStandardBRDF.cginc"
331.             #include "UnityMetaPass.cginc"
332.             #pragma fragmentoption ARB_precision_hint_fastest
333.             #pragma multi_compile_shadowcaster
334.             #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
335.             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
336.             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
337.             #pragma multi_compile_fog
338.             #pragma exclude_renderers gles3 metal d3d11_9x xbox360 xboxone ps3 ps4 psp2
339.             #pragma target 3.0
340.             uniform sampler2D _MainTex; uniform float4 _MainTex_ST;
341.             uniform float4 _ColorWhite;
342.             uniform float4 _ColorBlack;
343.             uniform sampler2D _LerpTex; uniform float4 _LerpTex_ST;
344.             struct VertexInput {
345.                 float4 vertex : POSITION;
346.                 float2 texcoord0 : TEXCOORD0;
347.                 float2 texcoord1 : TEXCOORD1;
348.                 float2 texcoord2 : TEXCOORD2;
349.             };
350.             struct VertexOutput {
351.                 float4 pos : SV_POSITION;
352.                 float2 uv0 : TEXCOORD0;
353.                 float2 uv1 : TEXCOORD1;
354.                 float2 uv2 : TEXCOORD2;
355.                 float4 posWorld : TEXCOORD3;
356.             };
357.             VertexOutput vert (VertexInput v) {
358.                 VertexOutput o = (VertexOutput)0;
359.                 o.uv0 = v.texcoord0;
360.                 o.uv1 = v.texcoord1;
361.                 o.uv2 = v.texcoord2;
362.                 o.posWorld = mul(unity_ObjectToWorld, v.vertex);
363.                 o.pos = UnityMetaVertexPosition(v.vertex, v.texcoord1.xy, v.texcoord2.xy, unity_LightmapST, unity_DynamicLightmapST );
364.                 return o;
365.             }
366.             float4 frag(VertexOutput i) : SV_Target {
367.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
368.                 UnityMetaInput o;
369.                 UNITY_INITIALIZE_OUTPUT( UnityMetaInput, o );
370.          
371.                 o.Emission = 0;
372.          
373.                 float4 _LerpTex_var = tex2D(_LerpTex,TRANSFORM_TEX(i.uv0, _LerpTex));
374.                 float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));
375.                 float3 diffColor = (lerp(_ColorWhite.rgb,_ColorBlack.rgb,_LerpTex_var.r)*_MainTex_var.rgb);
376.                 float specularMonochrome;
377.                 float3 specColor;
378.                 float node_383 = 0.0;
379.                 diffColor = DiffuseAndSpecularFromMetallic( diffColor, node_383, specColor, specularMonochrome );
380.                 float roughness = 1.0 - node_383;
381.                 o.Albedo = diffColor + specColor * roughness * roughness * 0.5;
382.          
383.                 return UnityMetaFragment( o );
384.             }
385.             ENDCG
386.         }
387.     }
388.     FallBack "Diffuse"
389.     CustomEditor "ShaderForgeMaterialInspector"
390. }

Shader Forge - Deferred Shader

Code (csharp):

1. // Upgrade NOTE: replaced '_Object2World' with 'unity_ObjectToWorld'
2.  
3. // Shader created with Shader Forge v1.29
4. // Shader Forge (c) Neat Corporation / Joachim Holmer - http://www.acegikmo.com/shaderforge/
5. // Note: Manually altering this data may prevent you from opening it in Shader Forge
6. /*SF_DATA;ver:1.29;sub:START;pass:START;ps:flbk:,iptp:0,cusa:False,bamd:0,lico:1,lgpr:1,limd:3,spmd:1,trmd:0,grmd:0,uamb:True,mssp:True,bkdf:True,hqlp:False,rprd:True,enco:False,rmgx:True,rpth:1,vtps:0,hqsc:True,nrmq:1,nrsp:0,vomd:0,spxs:False,tesm:0,olmd:1,culm:0,bsrc:0,bdst:1,dpts:2,wrdp:True,dith:0,rfrpo:True,rfrpn:Refraction,coma:15,ufog:True,aust:True,igpj:False,qofs:0,qpre:1,rntp:1,fgom:False,fgoc:False,fgod:False,fgor:False,fgmd:0,fgcr:0.5,fgcg:0.5,fgcb:0.5,fgca:1,fgde:0.01,fgrn:0,fgrf:300,stcl:False,stva:128,stmr:255,stmw:255,stcp:6,stps:0,stfa:0,stfz:0,ofsf:0,ofsu:0,f2p0:False,fnsp:False,fnfb:False;n:type:ShaderForge.SFN_Final,id:2865,x:32719,y:32712,varname:node_2865,prsc:2|diff-6343-OUT,spec-383-OUT,gloss-383-OUT,normal-5964-RGB;n:type:ShaderForge.SFN_Multiply,id:6343,x:32399,y:32683,varname:node_6343,prsc:2|A-8466-OUT,B-7736-RGB;n:type:ShaderForge.SFN_Tex2d,id:7736,x:31710,y:32879,ptovrint:True,ptlb:Base Color,ptin:_MainTex,varname:_MainTex,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,ntxv:0,isnm:False;n:type:ShaderForge.SFN_Tex2d,id:5964,x:32055,y:32936,ptovrint:True,ptlb:Normal Map,ptin:_BumpMap,varname:_BumpMap,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,ntxv:3,isnm:True;n:type:ShaderForge.SFN_Lerp,id:8466,x:31852,y:32462,varname:node_8466,prsc:2|A-1185-RGB,B-626-RGB,T-5966-R;n:type:ShaderForge.SFN_Color,id:1185,x:31592,y:32244,ptovrint:False,ptlb:ColorWhite,ptin:_ColorWhite,varname:node_1185,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,c1:0.5,c2:0.5,c3:0.5,c4:1;n:type:ShaderForge.SFN_Color,id:626,x:31592,y:32420,ptovrint:False,ptlb:ColorBlack,ptin:_ColorBlack,varname:node_626,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,c1:0.5,c2:0.5,c3:0.5,c4:1;n:type:ShaderForge.SFN_Tex2d,id:5966,x:31592,y:32652,ptovrint:False,ptlb:LerpTex,ptin:_LerpTex,varname:node_5966,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,ntxv:0,isnm:False;n:type:ShaderForge.SFN_Vector1,id:383,x:32459,y:32494,varname:node_383,prsc:2,v1:0;proporder:5964-7736-1185-626-5966;pass:END;sub:END;*/
7.  
8. Shader "EcoTales/EcoTales_PBR_Test_ShaderForge_Def" {
9.     Properties {
10.         _BumpMap ("Normal Map", 2D) = "bump" {}
11.         _MainTex ("Base Color", 2D) = "white" {}
12.         _ColorWhite ("ColorWhite", Color) = (0.5,0.5,0.5,1)
13.         _ColorBlack ("ColorBlack", Color) = (0.5,0.5,0.5,1)
14.         _LerpTex ("LerpTex", 2D) = "white" {}
15.     }
16.     SubShader {
17.         Tags {
18.             "RenderType"="Opaque"
19.         }
20.         Pass {
21.             Name "DEFERRED"
22.             Tags {
23.                 "LightMode"="Deferred"
24.             }
25.        
26.        
27.             CGPROGRAM
28.             #pragma vertex vert
29.             #pragma fragment frag
30.             #define UNITY_PASS_DEFERRED
31.             #define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )
32.             #define _GLOSSYENV 1
33.             #include "UnityCG.cginc"
34.             #include "Lighting.cginc"
35.             #include "UnityPBSLighting.cginc"
36.             #include "UnityStandardBRDF.cginc"
37.             #pragma fragmentoption ARB_precision_hint_fastest
38.             #pragma multi_compile_shadowcaster
39.             #pragma multi_compile ___ UNITY_HDR_ON
40.             #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
41.             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
42.             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
43.             #pragma multi_compile_fog
44.             #pragma exclude_renderers gles3 metal d3d11_9x xbox360 xboxone ps3 ps4 psp2
45.             #pragma target 3.0
46.             uniform sampler2D _MainTex; uniform float4 _MainTex_ST;
47.             uniform sampler2D _BumpMap; uniform float4 _BumpMap_ST;
48.             uniform float4 _ColorWhite;
49.             uniform float4 _ColorBlack;
50.             uniform sampler2D _LerpTex; uniform float4 _LerpTex_ST;
51.             struct VertexInput {
52.                 float4 vertex : POSITION;
53.                 float3 normal : NORMAL;
54.                 float4 tangent : TANGENT;
55.                 float2 texcoord0 : TEXCOORD0;
56.                 float2 texcoord1 : TEXCOORD1;
57.                 float2 texcoord2 : TEXCOORD2;
58.             };
59.             struct VertexOutput {
60.                 float4 pos : SV_POSITION;
61.                 float2 uv0 : TEXCOORD0;
62.                 float2 uv1 : TEXCOORD1;
63.                 float2 uv2 : TEXCOORD2;
64.                 float4 posWorld : TEXCOORD3;
65.                 float3 normalDir : TEXCOORD4;
66.                 float3 tangentDir : TEXCOORD5;
67.                 float3 bitangentDir : TEXCOORD6;
68.                 #if defined(LIGHTMAP_ON) || defined(UNITY_SHOULD_SAMPLE_SH)
69.                     float4 ambientOrLightmapUV : TEXCOORD7;
70.                 #endif
71.             };
72.             VertexOutput vert (VertexInput v) {
73.                 VertexOutput o = (VertexOutput)0;
74.                 o.uv0 = v.texcoord0;
75.                 o.uv1 = v.texcoord1;
76.                 o.uv2 = v.texcoord2;
77.                 #ifdef LIGHTMAP_ON
78.                     o.ambientOrLightmapUV.xy = v.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
79.                     o.ambientOrLightmapUV.zw = 0;
80.                 #elif UNITY_SHOULD_SAMPLE_SH
81.                 #endif
82.                 #ifdef DYNAMICLIGHTMAP_ON
83.                     o.ambientOrLightmapUV.zw = v.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
84.                 #endif
85.                 o.normalDir = UnityObjectToWorldNormal(v.normal);
86.                 o.tangentDir = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );
87.                 o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);
88.                 o.posWorld = mul(unity_ObjectToWorld, v.vertex);
89.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex );
90.                 return o;
91.             }
92.             void frag(
93.                 VertexOutput i,
94.                 out half4 outDiffuse : SV_Target0,
95.                 out half4 outSpecSmoothness : SV_Target1,
96.                 out half4 outNormal : SV_Target2,
97.                 out half4 outEmission : SV_Target3 )
98.             {
99.                 i.normalDir = normalize(i.normalDir);
100.                 float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);
101.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
102.                 float3 _BumpMap_var = UnpackNormal(tex2D(_BumpMap,TRANSFORM_TEX(i.uv0, _BumpMap)));
103.                 float3 normalLocal = _BumpMap_var.rgb;
104.                 float3 normalDirection = normalize(mul( normalLocal, tangentTransform )); // Perturbed normals
105.                 float3 viewReflectDirection = reflect( -viewDirection, normalDirection );
106. ////// Lighting:
107.                 float Pi = 3.141592654;
108.                 float InvPi = 0.31830988618;
109. ///////// Gloss:
110.                 float node_383 = 0.0;
111.                 float gloss = node_383;
112. /////// GI Data:
113.                 UnityLight light; // Dummy light
114.                 light.color = 0;
115.                 light.dir = half3(0,1,0);
116.                 light.ndotl = max(0,dot(normalDirection,light.dir));
117.                 UnityGIInput d;
118.                 d.light = light;
119.                 d.worldPos = i.posWorld.xyz;
120.                 d.worldViewDir = viewDirection;
121.                 d.atten = 1;
122.                 #if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON)
123.                     d.ambient = 0;
124.                     d.lightmapUV = i.ambientOrLightmapUV;
125.                 #else
126.                     d.ambient = i.ambientOrLightmapUV;
127.                 #endif
128.                 d.boxMax[0] = unity_SpecCube0_BoxMax;
129.                 d.boxMin[0] = unity_SpecCube0_BoxMin;
130.                 d.probePosition[0] = unity_SpecCube0_ProbePosition;
131.                 d.probeHDR[0] = unity_SpecCube0_HDR;
132.                 d.boxMax[1] = unity_SpecCube1_BoxMax;
133.                 d.boxMin[1] = unity_SpecCube1_BoxMin;
134.                 d.probePosition[1] = unity_SpecCube1_ProbePosition;
135.                 d.probeHDR[1] = unity_SpecCube1_HDR;
136.                 Unity_GlossyEnvironmentData ugls_en_data;
137.                 ugls_en_data.roughness = 1.0 - gloss;
138.                 ugls_en_data.reflUVW = viewReflectDirection;
139.                 UnityGI gi = UnityGlobalIllumination(d, 1, normalDirection, ugls_en_data );
140. ////// Specular:
141.                 float3 specularColor = node_383;
142.                 float specularMonochrome;
143.                 float4 _LerpTex_var = tex2D(_LerpTex,TRANSFORM_TEX(i.uv0, _LerpTex));
144.                 float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));
145.                 float3 diffuseColor = (lerp(_ColorWhite.rgb,_ColorBlack.rgb,_LerpTex_var.r)*_MainTex_var.rgb); // Need this for specular when using metallic
146.                 diffuseColor = DiffuseAndSpecularFromMetallic( diffuseColor, specularColor, specularColor, specularMonochrome );
147.                 specularMonochrome = 1.0-specularMonochrome;
148.                 float NdotV = max(0.0,dot( normalDirection, viewDirection ));
149.                 half grazingTerm = saturate( gloss + specularMonochrome );
150.                 float3 indirectSpecular = (gi.indirect.specular);
151.                 indirectSpecular *= FresnelLerp (specularColor, grazingTerm, NdotV);
152. /////// Diffuse:
153.                 float3 indirectDiffuse = float3(0,0,0);
154.                 indirectDiffuse += gi.indirect.diffuse;
155. /// Final Color:
156.                 outDiffuse = half4( diffuseColor, 1 );
157.                 outSpecSmoothness = half4( specularColor, gloss );
158.                 outNormal = half4( normalDirection * 0.5 + 0.5, 1 );
159.                 outEmission = half4(0,0,0,1);
160.                 outEmission.rgb += indirectSpecular * 1;
161.                 outEmission.rgb += indirectDiffuse * diffuseColor;
162.                 #ifndef UNITY_HDR_ON
163.                     outEmission.rgb = exp2(-outEmission.rgb);
164.                 #endif
165.             }
166.             ENDCG
167.         }
168.         Pass {
169.             Name "FORWARD"
170.             Tags {
171.                 "LightMode"="ForwardBase"
172.             }
173.        
174.        
175.             CGPROGRAM
176.             #pragma vertex vert
177.             #pragma fragment frag
178.             #define UNITY_PASS_FORWARDBASE
179.             #define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )
180.             #define _GLOSSYENV 1
181.             #include "UnityCG.cginc"
182.             #include "AutoLight.cginc"
183.             #include "Lighting.cginc"
184.             #include "UnityPBSLighting.cginc"
185.             #include "UnityStandardBRDF.cginc"
186.             #pragma multi_compile_fwdbase_fullshadows
187.             #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
188.             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
189.             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
190.             #pragma multi_compile_fog
191.             #pragma exclude_renderers gles3 metal d3d11_9x xbox360 xboxone ps3 ps4 psp2
192.             #pragma target 3.0
193.             uniform sampler2D _MainTex; uniform float4 _MainTex_ST;
194.             uniform sampler2D _BumpMap; uniform float4 _BumpMap_ST;
195.             uniform float4 _ColorWhite;
196.             uniform float4 _ColorBlack;
197.             uniform sampler2D _LerpTex; uniform float4 _LerpTex_ST;
198.             struct VertexInput {
199.                 float4 vertex : POSITION;
200.                 float3 normal : NORMAL;
201.                 float4 tangent : TANGENT;
202.                 float2 texcoord0 : TEXCOORD0;
203.                 float2 texcoord1 : TEXCOORD1;
204.                 float2 texcoord2 : TEXCOORD2;
205.             };
206.             struct VertexOutput {
207.                 float4 pos : SV_POSITION;
208.                 float2 uv0 : TEXCOORD0;
209.                 float2 uv1 : TEXCOORD1;
210.                 float2 uv2 : TEXCOORD2;
211.                 float4 posWorld : TEXCOORD3;
212.                 float3 normalDir : TEXCOORD4;
213.                 float3 tangentDir : TEXCOORD5;
214.                 float3 bitangentDir : TEXCOORD6;
215.                 LIGHTING_COORDS(7,8)
216.                 UNITY_FOG_COORDS(9)
217.                 #if defined(LIGHTMAP_ON) || defined(UNITY_SHOULD_SAMPLE_SH)
218.                     float4 ambientOrLightmapUV : TEXCOORD10;
219.                 #endif
220.             };
221.             VertexOutput vert (VertexInput v) {
222.                 VertexOutput o = (VertexOutput)0;
223.                 o.uv0 = v.texcoord0;
224.                 o.uv1 = v.texcoord1;
225.                 o.uv2 = v.texcoord2;
226.                 #ifdef LIGHTMAP_ON
227.                     o.ambientOrLightmapUV.xy = v.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
228.                     o.ambientOrLightmapUV.zw = 0;
229.                 #elif UNITY_SHOULD_SAMPLE_SH
230.                 #endif
231.                 #ifdef DYNAMICLIGHTMAP_ON
232.                     o.ambientOrLightmapUV.zw = v.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
233.                 #endif
234.                 o.normalDir = UnityObjectToWorldNormal(v.normal);
235.                 o.tangentDir = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );
236.                 o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);
237.                 o.posWorld = mul(unity_ObjectToWorld, v.vertex);
238.                 float3 lightColor = _LightColor0.rgb;
239.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex );
240.                 UNITY_TRANSFER_FOG(o,o.pos);
241.                 TRANSFER_VERTEX_TO_FRAGMENT(o)
242.                 return o;
243.             }
244.             float4 frag(VertexOutput i) : COLOR {
245.                 i.normalDir = normalize(i.normalDir);
246.                 float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);
247.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
248.                 float3 _BumpMap_var = UnpackNormal(tex2D(_BumpMap,TRANSFORM_TEX(i.uv0, _BumpMap)));
249.                 float3 normalLocal = _BumpMap_var.rgb;
250.                 float3 normalDirection = normalize(mul( normalLocal, tangentTransform )); // Perturbed normals
251.                 float3 viewReflectDirection = reflect( -viewDirection, normalDirection );
252.                 float3 lightDirection = normalize(_WorldSpaceLightPos0.xyz);
253.                 float3 lightColor = _LightColor0.rgb;
254.                 float3 halfDirection = normalize(viewDirection+lightDirection);
255. ////// Lighting:
256.                 float attenuation = LIGHT_ATTENUATION(i);
257.                 float3 attenColor = attenuation * _LightColor0.xyz;
258.                 float Pi = 3.141592654;
259.                 float InvPi = 0.31830988618;
260. ///////// Gloss:
261.                 float node_383 = 0.0;
262.                 float gloss = node_383;
263.                 float specPow = exp2( gloss * 10.0+1.0);
264. /////// GI Data:
265.                 UnityLight light;
266.                 #ifdef LIGHTMAP_OFF
267.                     light.color = lightColor;
268.                     light.dir = lightDirection;
269.                     light.ndotl = LambertTerm (normalDirection, light.dir);
270.                 #else
271.                     light.color = half3(0.f, 0.f, 0.f);
272.                     light.ndotl = 0.0f;
273.                     light.dir = half3(0.f, 0.f, 0.f);
274.                 #endif
275.                 UnityGIInput d;
276.                 d.light = light;
277.                 d.worldPos = i.posWorld.xyz;
278.                 d.worldViewDir = viewDirection;
279.                 d.atten = attenuation;
280.                 #if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON)
281.                     d.ambient = 0;
282.                     d.lightmapUV = i.ambientOrLightmapUV;
283.                 #else
284.                     d.ambient = i.ambientOrLightmapUV;
285.                 #endif
286.                 d.boxMax[0] = unity_SpecCube0_BoxMax;
287.                 d.boxMin[0] = unity_SpecCube0_BoxMin;
288.                 d.probePosition[0] = unity_SpecCube0_ProbePosition;
289.                 d.probeHDR[0] = unity_SpecCube0_HDR;
290.                 d.boxMax[1] = unity_SpecCube1_BoxMax;
291.                 d.boxMin[1] = unity_SpecCube1_BoxMin;
292.                 d.probePosition[1] = unity_SpecCube1_ProbePosition;
293.                 d.probeHDR[1] = unity_SpecCube1_HDR;
294.                 Unity_GlossyEnvironmentData ugls_en_data;
295.                 ugls_en_data.roughness = 1.0 - gloss;
296.                 ugls_en_data.reflUVW = viewReflectDirection;
297.                 UnityGI gi = UnityGlobalIllumination(d, 1, normalDirection, ugls_en_data );
298.                 lightDirection = gi.light.dir;
299.                 lightColor = gi.light.color;
300. ////// Specular:
301.                 float NdotL = max(0, dot( normalDirection, lightDirection ));
302.                 float LdotH = max(0.0,dot(lightDirection, halfDirection));
303.                 float3 specularColor = node_383;
304.                 float specularMonochrome;
305.                 float4 _LerpTex_var = tex2D(_LerpTex,TRANSFORM_TEX(i.uv0, _LerpTex));
306.                 float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));
307.                 float3 diffuseColor = (lerp(_ColorWhite.rgb,_ColorBlack.rgb,_LerpTex_var.r)*_MainTex_var.rgb); // Need this for specular when using metallic
308.                 diffuseColor = DiffuseAndSpecularFromMetallic( diffuseColor, specularColor, specularColor, specularMonochrome );
309.                 specularMonochrome = 1.0-specularMonochrome;
310.                 float NdotV = max(0.0,dot( normalDirection, viewDirection ));
311.                 float NdotH = max(0.0,dot( normalDirection, halfDirection ));
312.                 float VdotH = max(0.0,dot( viewDirection, halfDirection ));
313.                 float visTerm = SmithJointGGXVisibilityTerm( NdotL, NdotV, 1.0-gloss );
314.                 float normTerm = max(0.0, GGXTerm(NdotH, 1.0-gloss));
315.                 float specularPBL = (NdotL*visTerm*normTerm) * (UNITY_PI / 4);
316.                 if (IsGammaSpace())
317.                     specularPBL = sqrt(max(1e-4h, specularPBL));
318.                 specularPBL = max(0, specularPBL * NdotL);
319.                 float3 directSpecular = (floor(attenuation) * _LightColor0.xyz)*specularPBL*FresnelTerm(specularColor, LdotH);
320.                 half grazingTerm = saturate( gloss + specularMonochrome );
321.                 float3 indirectSpecular = (gi.indirect.specular);
322.                 indirectSpecular *= FresnelLerp (specularColor, grazingTerm, NdotV);
323.                 float3 specular = (directSpecular + indirectSpecular);
324. /////// Diffuse:
325.                 NdotL = max(0.0,dot( normalDirection, lightDirection ));
326.                 half fd90 = 0.5 + 2 * LdotH * LdotH * (1-gloss);
327.                 float nlPow5 = Pow5(1-NdotL);
328.                 float nvPow5 = Pow5(1-NdotV);
329.                 float3 directDiffuse = ((1 +(fd90 - 1)*nlPow5) * (1 + (fd90 - 1)*nvPow5) * NdotL) * attenColor;
330.                 float3 indirectDiffuse = float3(0,0,0);
331.                 indirectDiffuse += gi.indirect.diffuse;
332.                 float3 diffuse = (directDiffuse + indirectDiffuse) * diffuseColor;
333. /// Final Color:
334.                 float3 finalColor = diffuse + specular;
335.                 fixed4 finalRGBA = fixed4(finalColor,1);
336.                 UNITY_APPLY_FOG(i.fogCoord, finalRGBA);
337.                 return finalRGBA;
338.             }
339.             ENDCG
340.         }
341.         Pass {
342.             Name "FORWARD_DELTA"
343.             Tags {
344.                 "LightMode"="ForwardAdd"
345.             }
346.             Blend One One
347.        
348.        
349.             CGPROGRAM
350.             #pragma vertex vert
351.             #pragma fragment frag
352.             #define UNITY_PASS_FORWARDADD
353.             #define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )
354.             #define _GLOSSYENV 1
355.             #include "UnityCG.cginc"
356.             #include "AutoLight.cginc"
357.             #include "Lighting.cginc"
358.             #include "UnityPBSLighting.cginc"
359.             #include "UnityStandardBRDF.cginc"
360.             #pragma multi_compile_fwdadd_fullshadows
361.             #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
362.             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
363.             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
364.             #pragma multi_compile_fog
365.             #pragma exclude_renderers gles3 metal d3d11_9x xbox360 xboxone ps3 ps4 psp2
366.             #pragma target 3.0
367.             uniform sampler2D _MainTex; uniform float4 _MainTex_ST;
368.             uniform sampler2D _BumpMap; uniform float4 _BumpMap_ST;
369.             uniform float4 _ColorWhite;
370.             uniform float4 _ColorBlack;
371.             uniform sampler2D _LerpTex; uniform float4 _LerpTex_ST;
372.             struct VertexInput {
373.                 float4 vertex : POSITION;
374.                 float3 normal : NORMAL;
375.                 float4 tangent : TANGENT;
376.                 float2 texcoord0 : TEXCOORD0;
377.                 float2 texcoord1 : TEXCOORD1;
378.                 float2 texcoord2 : TEXCOORD2;
379.             };
380.             struct VertexOutput {
381.                 float4 pos : SV_POSITION;
382.                 float2 uv0 : TEXCOORD0;
383.                 float2 uv1 : TEXCOORD1;
384.                 float2 uv2 : TEXCOORD2;
385.                 float4 posWorld : TEXCOORD3;
386.                 float3 normalDir : TEXCOORD4;
387.                 float3 tangentDir : TEXCOORD5;
388.                 float3 bitangentDir : TEXCOORD6;
389.                 LIGHTING_COORDS(7,8)
390.                 UNITY_FOG_COORDS(9)
391.             };
392.             VertexOutput vert (VertexInput v) {
393.                 VertexOutput o = (VertexOutput)0;
394.                 o.uv0 = v.texcoord0;
395.                 o.uv1 = v.texcoord1;
396.                 o.uv2 = v.texcoord2;
397.                 o.normalDir = UnityObjectToWorldNormal(v.normal);
398.                 o.tangentDir = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );
399.                 o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);
400.                 o.posWorld = mul(unity_ObjectToWorld, v.vertex);
401.                 float3 lightColor = _LightColor0.rgb;
402.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex );
403.                 UNITY_TRANSFER_FOG(o,o.pos);
404.                 TRANSFER_VERTEX_TO_FRAGMENT(o)
405.                 return o;
406.             }
407.             float4 frag(VertexOutput i) : COLOR {
408.                 i.normalDir = normalize(i.normalDir);
409.                 float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);
410.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
411.                 float3 _BumpMap_var = UnpackNormal(tex2D(_BumpMap,TRANSFORM_TEX(i.uv0, _BumpMap)));
412.                 float3 normalLocal = _BumpMap_var.rgb;
413.                 float3 normalDirection = normalize(mul( normalLocal, tangentTransform )); // Perturbed normals
414.                 float3 lightDirection = normalize(lerp(_WorldSpaceLightPos0.xyz, _WorldSpaceLightPos0.xyz - i.posWorld.xyz,_WorldSpaceLightPos0.w));
415.                 float3 lightColor = _LightColor0.rgb;
416.                 float3 halfDirection = normalize(viewDirection+lightDirection);
417. ////// Lighting:
418.                 float attenuation = LIGHT_ATTENUATION(i);
419.                 float3 attenColor = attenuation * _LightColor0.xyz;
420.                 float Pi = 3.141592654;
421.                 float InvPi = 0.31830988618;
422. ///////// Gloss:
423.                 float node_383 = 0.0;
424.                 float gloss = node_383;
425.                 float specPow = exp2( gloss * 10.0+1.0);
426. ////// Specular:
427.                 float NdotL = max(0, dot( normalDirection, lightDirection ));
428.                 float LdotH = max(0.0,dot(lightDirection, halfDirection));
429.                 float3 specularColor = node_383;
430.                 float specularMonochrome;
431.                 float4 _LerpTex_var = tex2D(_LerpTex,TRANSFORM_TEX(i.uv0, _LerpTex));
432.                 float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));
433.                 float3 diffuseColor = (lerp(_ColorWhite.rgb,_ColorBlack.rgb,_LerpTex_var.r)*_MainTex_var.rgb); // Need this for specular when using metallic
434.                 diffuseColor = DiffuseAndSpecularFromMetallic( diffuseColor, specularColor, specularColor, specularMonochrome );
435.                 specularMonochrome = 1.0-specularMonochrome;
436.                 float NdotV = max(0.0,dot( normalDirection, viewDirection ));
437.                 float NdotH = max(0.0,dot( normalDirection, halfDirection ));
438.                 float VdotH = max(0.0,dot( viewDirection, halfDirection ));
439.                 float visTerm = SmithJointGGXVisibilityTerm( NdotL, NdotV, 1.0-gloss );
440.                 float normTerm = max(0.0, GGXTerm(NdotH, 1.0-gloss));
441.                 float specularPBL = (NdotL*visTerm*normTerm) * (UNITY_PI / 4);
442.                 if (IsGammaSpace())
443.                     specularPBL = sqrt(max(1e-4h, specularPBL));
444.                 specularPBL = max(0, specularPBL * NdotL);
445.                 float3 directSpecular = attenColor*specularPBL*FresnelTerm(specularColor, LdotH);
446.                 float3 specular = directSpecular;
447. /////// Diffuse:
448.                 NdotL = max(0.0,dot( normalDirection, lightDirection ));
449.                 half fd90 = 0.5 + 2 * LdotH * LdotH * (1-gloss);
450.                 float nlPow5 = Pow5(1-NdotL);
451.                 float nvPow5 = Pow5(1-NdotV);
452.                 float3 directDiffuse = ((1 +(fd90 - 1)*nlPow5) * (1 + (fd90 - 1)*nvPow5) * NdotL) * attenColor;
453.                 float3 diffuse = directDiffuse * diffuseColor;
454. /// Final Color:
455.                 float3 finalColor = diffuse + specular;
456.                 fixed4 finalRGBA = fixed4(finalColor * 1,0);
457.                 UNITY_APPLY_FOG(i.fogCoord, finalRGBA);
458.                 return finalRGBA;
459.             }
460.             ENDCG
461.         }
462.         Pass {
463.             Name "Meta"
464.             Tags {
465.                 "LightMode"="Meta"
466.             }
467.             Cull Off
468.        
469.             CGPROGRAM
470.             #pragma vertex vert
471.             #pragma fragment frag
472.             #define UNITY_PASS_META 1
473.             #define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )
474.             #define _GLOSSYENV 1
475.             #include "UnityCG.cginc"
476.             #include "Lighting.cginc"
477.             #include "UnityPBSLighting.cginc"
478.             #include "UnityStandardBRDF.cginc"
479.             #include "UnityMetaPass.cginc"
480.             #pragma fragmentoption ARB_precision_hint_fastest
481.             #pragma multi_compile_shadowcaster
482.             #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
483.             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
484.             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
485.             #pragma multi_compile_fog
486.             #pragma exclude_renderers gles3 metal d3d11_9x xbox360 xboxone ps3 ps4 psp2
487.             #pragma target 3.0
488.             uniform sampler2D _MainTex; uniform float4 _MainTex_ST;
489.             uniform float4 _ColorWhite;
490.             uniform float4 _ColorBlack;
491.             uniform sampler2D _LerpTex; uniform float4 _LerpTex_ST;
492.             struct VertexInput {
493.                 float4 vertex : POSITION;
494.                 float2 texcoord0 : TEXCOORD0;
495.                 float2 texcoord1 : TEXCOORD1;
496.                 float2 texcoord2 : TEXCOORD2;
497.             };
498.             struct VertexOutput {
499.                 float4 pos : SV_POSITION;
500.                 float2 uv0 : TEXCOORD0;
501.                 float2 uv1 : TEXCOORD1;
502.                 float2 uv2 : TEXCOORD2;
503.                 float4 posWorld : TEXCOORD3;
504.             };
505.             VertexOutput vert (VertexInput v) {
506.                 VertexOutput o = (VertexOutput)0;
507.                 o.uv0 = v.texcoord0;
508.                 o.uv1 = v.texcoord1;
509.                 o.uv2 = v.texcoord2;
510.                 o.posWorld = mul(unity_ObjectToWorld, v.vertex);
511.                 o.pos = UnityMetaVertexPosition(v.vertex, v.texcoord1.xy, v.texcoord2.xy, unity_LightmapST, unity_DynamicLightmapST );
512.                 return o;
513.             }
514.             float4 frag(VertexOutput i) : SV_Target {
515.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
516.                 UnityMetaInput o;
517.                 UNITY_INITIALIZE_OUTPUT( UnityMetaInput, o );
518.            
519.                 o.Emission = 0;
520.            
521.                 float4 _LerpTex_var = tex2D(_LerpTex,TRANSFORM_TEX(i.uv0, _LerpTex));
522.                 float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));
523.                 float3 diffColor = (lerp(_ColorWhite.rgb,_ColorBlack.rgb,_LerpTex_var.r)*_MainTex_var.rgb);
524.                 float specularMonochrome;
525.                 float3 specColor;
526.                 float node_383 = 0.0;
527.                 diffColor = DiffuseAndSpecularFromMetallic( diffColor, node_383, specColor, specularMonochrome );
528.                 float roughness = 1.0 - node_383;
529.                 o.Albedo = diffColor + specColor * roughness * roughness * 0.5;
530.            
531.                 return UnityMetaFragment( o );
532.             }
533.             ENDCG
534.         }
535.     }
536.     FallBack "Diffuse"
537.     CustomEditor "ShaderForgeMaterialInspector"
538. }

 

Because it might not exist. If generic, off-the-shelf solutions could do everything that was ever needed then there'd be no further use for programmers.

Modding tools isn't necessarily about achieving something that's otherwise unachievable. It's about building workflows that suit your project and scale in ways that you need to scale. If you're getting a programmer to spend time automating something that you could have done manually and only needed to do once then you're probably not making the best use of your resources. Similarly, if you repeatedly do something manually that a programmer could make your computer do for you then you're also probably not making the best use of your resources.

 

You do realize this is my point, right? Just how inadequate does the shader tool have to be before it becomes a value add to have the source? This is assuming at least that it's fit for purchase and can cover most use cases. Just how out there and wacky are people getting for a handful of fairly typical datatypes and fairly typical operations not to cover it? And they are doing this frequently enough that making one-offs by hand isn't cost effective?

 

Guess what.



I bought it.

 

Why would it need to be a matter of inadequacy? All it would take is for the author to cease development of it and for Unity to reach the point where the editor needs modifications to function properly. It has happened before by the way with one of the earliest visual shader editors. Strumpy's Shader Editor became broken starting with Unity 4.

https://forum.unity3d.com/threads/strumpy-shader-editor-now-open-source.56180/

 

Nowhere near soon.

IMHO the amplify one's output is actually modifiable and clean, and worth using (from the glance at it above).

 

I would tend to think of something broken and not supported as being pretty inadequate and not very fit for purchase. Just how much time is actually being saved if you've become the primary support for it. I'm sorry, but having source code in this case seems far more like a non-issue at best and a trap at worst.

 

Naturally I wouldn't recommend purchasing a dead asset but unless you're able to predict the future you have no way of knowing if an asset will continue to receive support after purchasing it.

 

"Adequate" and "inadequate" are pretty binary terms for something like this. For me something may well be "adequate" if it's a good starting point for me to do my own stuff on top of. Like, say, the Unity Editor.

It all comes down to how much time something saves. If I can save more time by using someone else's tool and modding it compared to either building my own or doing things manually then that's a win. It's off the table if you don't have the source, though.

Even if I deem that something is "inadequate" for my specific needs, if it will take relatively little work to make it "adequate" then why start from scratch?

 

@Ryiah and everyone under the impression that Amplify makes cleaner/shorter shader code: Consider that Amplify currently creates surface shaders, while SF creates its own shader. A surface shader is kind of like Unity's shader shorthand, which will be used to generate the actual shader. A basic surface shader can be 50 lines but its generated code is around 700, while an SF shader is around 400. I'm not recommending one over the other, I'm just saying comparing SF output to Amplify output is apples to oranges. I have found a basic PBR shader from SF to be a little faster than a basic Unity PBR surface shader.

 

In all honesty, if you can write your own shaders, there's no point in buying any of them. IF you can write your own shaders.

 

As I said before on similar topics:
Anybody who have the skills to create a shader visually for sure has the skill to write it, the sintax couldn't be more simple since you should avoid most conditional code. The hard stuff is the math which you must know anyway even if you do it visually.
Just take a simple basic shader and start tweaking it, you'll be amazed how simple it is.
If you'll be relying on somebody else shader network, then there are plenty of free shaders around, so again I don't see the point.

 

I've been using SF for years. Learned surface shaders a month or two ago and, agreed, I will never go back to node editor. Surface shaders already are Unity's "shader editor" solution and its pretty fast and easy. I can't tell you how many times I've hooked up the same crap over and over when I could have been writing my own shaders and using a cginclude. Wish I'd learned shaders years ago.

 

I can write my own, but that's like saying, "If you know how to program, what's the point of syntax aids like auto indent?", it's a toy. Fun things are fun.

 

I dunno. I think its more like saying "if you can program, what's the point of visual scripting?", and to that I say, none. Visual scripting is for people who don't know code scripting.

 

Once again, I find myself disagreeing. I've been programming since I was 9, and during my time with Unreal I found myself banging out quick code with their Blueprint editor. If y'all don't want to use it, that's great, but I asked which one, not if I needed one at all. I bought Amplify and I'm pretty happy with it.

 

Yep gotta agree with @The-Britain, irrelevant of the language you still have to understand logical concepts to achieve said goal (if it's a proper VS system). For coders it's a great way to avoid boiler plate code for many game specific systems, it can streamline prototype's / development many times over. No matter how fast a coder you are, no matter how good you are, you couldn't physically type fast enough to create something like a camera / character controller in the time you could do it in BP's, never mind debugging etc.

As for the rest it's an easy way to do simple tasks without having to understanding the finer points of languages like C++ (also stops people bothering coders every two minutes). With C# it does become slightly less relevant, but I'm going off topic now.

The same applies to a decent material editor, it should exist to save you time / fit nicely into existing art pipelines. In UE I managed to whip up some very advanced terrain / particle / water / vertex paint materials with little effort. The dream would be to have a system in Unity on par (whether third party or not).

From my experience the guys / gals at Amplify are great, awesome support and never let products get stale etc. It's early days, but I purchased the early version (even if I don't use it).. As I'm sure it will mature and be worth every $.

 

Not saying a shader editor wouldn't necessarily be a good idea, but imo it really isn't as spooky as it looks to deal with shader code. You just have to understand that the graphics card is sort of a limited access device and the code interface has certain peculiarities.

The examples on the Unity site are a good starting point. Pretty much once you're inside the vert method you can just do whatever you like with the incoming data.

 

If you know exactly what you want, then the main benefit to an editor is it keeps an artist's eyes from melting. The real benefit I see is you can easily play with it. You see the results immediately, so you can go crazy trying anything and everything.

 

It would be cooler if amplify reached out to other shader developers like RTP/Uber etc and got some integration going. It would increase the appeal of the product since mostly, it's not really that useful to me if I have something like Uber. Because Uber offers a lot more than I'd get making my own from scratch. As Uber is also based on standard shader, it's a possibility.

I see the megasplat guy already jumped on board.

 

YES YES YES, I tried to do a few shader tutorials and i just couldn't seem to grasp it that well. That and i was always thinking that that there was always so much prep to do even for a basic custom shader, like declaring a variable in 2 different places just to use it, or just how specific some built in variables need to be used/placed to not get a magenta blob on screen.

Amplify & Shader Forge just let me dick around without worrying too much about it. And i get to make some interesting effects, intentionally or not. even if i cant do all of them yet.

 

It is worth remembering that you can actually write custom inspectors for materials that use your shaders. Meaning if you need some parameter to have a visual representation, chances are you can make this happen.

The api for writing custom editors for materials is a bit verbose, but it is there and can be used.

 

Is it possible to make a multipass shader use 2 passes from Shaders you make (and continue to tweak!) in Shaderforge by using usepass?
https://docs.unity3d.com/Manual/SL-UsePass.html

Maybe that would be a good way around some of the multipass limitations of shader editors in general?

 

Well you'd want all the stuff from Uber etc. provided in the mat editor, like UE4's "cheat" nodes / options. You can just drop in a POM node or check a tickbox for SSS, then it's just a matter of setting stuff like scatter amounts and translucency constant's..

Without all that extra cool stuff they don't really add that much to the table. In reality you could just buy Uber and it'll cover most user case scenario's for most of the game. As for the rest, well again the asset store does seem to cover most of it..

The only thing that's not easily accessible is a decent terrain shader for Unity's system, which is mainly down to the terrain system itself. Looking forward to that upgrade.!

 

Yeah it's just I need to tweak Uber, and I can't stand it's source frankly. I'm too stupid for all that.

 

Lol, AFAIK the guys at amplify were looking into adding all that Jazz.. It's early days for them. Something to keep an eye on maybe?

 

They have added it, several 3rd parties have added support, like that megasplat guy. I'm just saying the responsibility at this point to encourage 3rd party support lies with Amplify. It's a gentle nudge.

 

There's a lot of negativity going on regarding shader forge so I wanted to chime in a little bit (I own both).

Right now I would say that Shader Forge is the better product. There's a lot of subtle things that contribute to this, but I'd say its the best graph based shader editor I've ever used. The usability is what makes it for me; it feels like there has been a lot of care put into the UX and as such as a user I can focus on my goals rather than interacting with the thing. Small things like having a preview attached to every node and having float values be displayed under mathematical operations helps a lot. Also, being around for longer does give it some advantages. There are more nodes and you can do a lot more with Shader Forge right now than with Amplify.

That being said, I did purchase Amplify because it has the potential to de-throne Shader Forge, but it's definitely not there yet. One advantage to Amplify that was already pointed out is more editable shader code. However, this is only relevant if you need to edit shader code, which has been a rare desire for me with Shader Forge (currently, lack of texture arrays and GPU instancing being my only motivation to edit shader code). The main way Amplify is going to contend, I believe, is going to be through intergrations with 3rd party tools. Due to the open source I've already seen some 3rd party tools have integrations, and Amplify' Shader Editor's eventual integration with Amplify Texture will be a very juicy combo indeed.

Especially since it's super cheap in beta, I think its a good investment to get Amplify's Shader Editor since it's for sure going to go up in value. However,t if you need a robust shader editing solution to solve problems you have right now, Shader Forge is the better product as it stands.

 

Thanks for the clarification, interesting points. In my case I need to get at the code. I need to take a pass later in dev on the slower shaders and clean those up. Especially some of the more exotic particle shaders I have in mind. These have to be fast for obvious reasons.

 

Can you talk more about those? That sounds interesting.

 

Well it's just lit particles. Particle System in unity is upgraded so you get good tangents/normals so lighting is possible on them now. I was doing volume blood effects and nicer flow mapped smoke but I want them lit too.

Other things are: I want my transparent stuff to cast decent shadows. I want them to use cutout for shadows, but dither mask based on alpha value of particle.

Currently to do that, I just make a new standard shader and get coding. But it's slow going (as it's trial and error what works in Unity as trial and error is faster than finding non-existent documentation on what works) and something like amplify might speed things up. Problem is, I don't know if it supports passes for shadows and all that.

Other things are vector flipbook stuff. I'd like to get into that so I can do decent explosions. I'd like to also experiment with particles being all drawn to a buffer that's say, 75% the size and then composite with depth my way for soft particles but also particles that feel more volumetric than they actually are, so instead of this binary in front of, or behind, I can test/blend against a sphere or other primitive shape.

...and for obvious reasons this stuff isn't too quick. So I need to make them quick

 

Someone might've mentioned this already, but Shader Forge generates a fragment shader whereas Amplify generates a surface shader (which is then generated into a fragment shader by Unity). If you'd actually open the generated code of the amplify shader, it would probably be far longer than the Shader Forge generated one.

As for the assets themselves - I have both and I prefer Shader Forge because each node gives a nice preview. Overall I prefer the Shader Forge workflow with Key + Mouse click for quick access to nodes. I don't do anything but prototype shaders in these tools though and I would recommend you actually learn how to write your own shaders. You'll have a lot more freedom that way and the shaders will perform better.

I feel there's an undeserved fear of shaders that really doesn't make any sense. If you just give it some hours they will start making sense real quick if you're used to development. The Unity docs and surface shader system makes it really easy to get into.

 

Not for non programmers and I'd rather be coding the game than coding shaders which I feel is probably best left to the artists.

 

His new addon and usage of amplify with integrating some extra nodes is what got me interested in checking it out.

I agree the problem with third party solutions, unlike people making enhancements for a native engine feature like I dunno the poor state of Unity terrain and its default terrain shader is at least it progresses the state and features for that native feature a lot more. While the addons that come in to completely fill missing gaps, are less likely to get other developers making addons extending that third partly solution, or tutorials for etc.. it becomes even rarer, or fractured with multiple addons doing similar things splitting the user/knowledge base up more.

Its not very 'unifying' really

"I have both and I prefer Shader Forge because each node gives a nice preview."

yup one area I am hoping amplify implements support for in a later build soon.

 

This may be a bit conspiracy based, but I really believe Unity leaves out essential features so people need to buy them on the asset store. Thus offsetting development cost and padding their pockets with asset store royalty. At the cost of a complete product I'm afraid. Just look at ProGrids. There is no reason in the world that shouldn't be implemented directly.

Don't get me wrong, I'm not complaining. I mean they give us Unity for free, so I have no right. Just a thought.

 

I'm an artist and I love to code, mainly in C#. Game code makes perfect sense to me. Shaders are really hard for me to grasp. Maybe it's the fact that my code editor doesn't use intellisense on shaders, or the documentation is not easily searchable. To me, shader code logic just escapes me.

I have looked at the Unity examples, and while it seems like they are good, I just can't wrap my head around the concepts. Does anyone have a recommendation for a really good set of tutorials to learn to write shaders?

TBH, there seems to be a lot of assumptions about prior knowledge when I start reading about shaders. For example surface vs. fragment shaders vs. vertex. CG or compute, what? I don't really understand the difference and have not found a good resource to explain the differences and why as an artist I should use one over the other. It seems related to video cards and such, but as an artist I am really most interested in the visual reproduction on my current computer. Once I understand that, I could see starting to make the shaders cross-platform and/or performant.

Right now, I feel like my skills just aren't there and thus the need for tools like these.

 

Utter nonsense. I've spoken with staff for years, it's nonsense. No business would be able to survive doing that unless they want to earn pocket change and suffer a product that falls behind the competition. Currently, Unity's features by large beat the competition*. And it takes a long time to make that stuff.

*where competition is other engines and asset store

Regarding your comment about progrids...You can't assume your project needs are the same, therefore Unity doesn't assume either, so the idea of the editor is it's a blank slate that should be extended to exactly match the game you're working on.

Having said that, it could use a great built in grid system someday. I'm sure they will, they just haven't got around to it.

The reason your conspiracy theory falls apart big time is that Unity's cut from progrids probably would not be enough to pay for staff coffee for a single day.

 

I suppose you're right, but to me shaders have always been something quite technical, and you need to know what you're doing regardless if you're programming visually or in code. Because that's the thing - even though you're using a visual node system, you're still programming.

This whole node based visual authoring trend is fascinating, because it's as people think you don't need to know anything in order to use them. I don't know, is that the case? Can an artist really pick something like this up without any prior knowledge? To me it seems like the step from a system like Shader Froge to actually coding a shader is minimal, but then again I'm a developer so maybe I simply can't see the difficulty.

I think you're over-analyzing it. Game engine development is hard and takes a really long time, and right now their focus is on more important things.

In a way I suppose you're right though. Since the market has an ability to adjust itself to accommodate demand, Unity might focus mainly on features where demand is rather than where demand has been satisfied thanks to the asset store, but not in the way you suggest. I don't know if I'm making any sense.

Can't remember what I used to get into it. But here's a short overview:

A shader usually consists of two parts:

Vertex part

This takes some vertex data as input (vertex location in 3D space, vertex color, UVs etc). Here you can, if you want to, alter the location, if, for example, you want to extrude the vertices. Usually, you'll just transform the 3D point into the camera's 2D projection space.

A vertex function is also responsible for feeding the fragment shader with data.

Fragment part

This function takes the vertex output as input, and is doing its operations per-pixel. I.e., for each pixel on a face on an object, this function will run. Here you'll usually look up values in textures, using the vertex input (UVs), and do lighting calculations.

Then we have surface shaders...

Luckily, you don't need to think about all this, because Unity has made it easy with surface shaders. A surface shader is a more simple form of shader that is compiled into a fragment shader. All you need to do in a surface shader is feed it's different outputs (albedo, normal, emission, occlusion etc) with data (just like you would in a visual node based system). Then Unity will do all the lighting calculations and vertex stuff for you (unless you want to do it yourself, which they also make possible with certain macros).

CG is just a shader language I think, just like GLSL and HLSL are languages.

Compute shaders are something completely different. Like a normal shader, they're also programs that you run on the GPU, but more general purpose. Usually you'll feed a compute shader with some data, which it then can compute very fast using the GPU's parallell computing capabilities. It doesn't work with algorithms where each iteration depends on the previous one, but it's excellent for tasks where you just need to do a lot of something.