Screen Space Reflections for Unity

In my demo(previous page) I am using forward rendering. On the Mac it shows the reflections correctly. Livenda mentioned they were upside down... He did not say that he was using Windows(assuming he was) that they were upside down.

That doesn't give you a solution but wanted to point it out.

Gary

 

Hi, yes the reflection flip is a Direct X only issue (Which has now been fixed on the new upcoming update) so it would be fine on the Mac as it will be using OpenGL

If you have MSAA Enabled with the current version in forward mode the reflections will be flipped when using DirectX. It's fixed in the upcoming update which should be available in a few days (could be sooner as it depends on Unity Asset store)

Cheers!

 

Hi, I tried the supplied Demos, but I think something weird is going on here.

Is it a problem of the project, of the implementation, or of the hardware? Sometimes the reflections look... inverted or slanted.
I'm pretty sure this isn't what the asset is going to deliver:

 

I think you're seeing the issue mentioned in the post right above yours. Direct X inverts reflections, so if you're on windows, that may be the problem. As Livenda has said, it should be fixed in the next version (which Unity will hopefully approve soon).

 

I'm sorry, you're right, I didn't read, I had to post while in a hurry

Anyway, well, that's not the kind of "minor" issue I would expect to find at page 21 of the thread of an asset of this caliber - just trying it once would have been sufficient to spot the glitch.
That's not really a bug, that felt like pushing un untested version to the store, I want to believe that was just a series of unfortunate of coincidences.

I hope Windows is going to get as much support and testing as iOs, if it's truly a multiplatform asset. I'm glad there's going to be a patch, but wasn't expecting this kind of issues from a 1 year old product, I'm a bit worried and hope this isn't the trend but a single version isolated issue.

 

This is not a "minor" Glitch, and is actually a Unity Direct X issue and it is for us not a simple matter of just flipping the image. Candela SSRR is a complex plugin supporting multiple platform and render targets including multiple option configurations, hence the core raytrace engine has to do multiple checks for this to work without loosing performance using conditional statements.

Anyways, in the new update there is an option to flip the reflections when using MSAA on the PC and Mac OS is not affected as it is using OpenGL.

Cheers!
Livenda

 

Man, I wish this was still on sale... I'd buy it in a heartbeat. especially for my game with the cocktail of post fx

 

It is: https://www.assetstore.unity3d.com/#/content/15851

 

YES!!! After seeing Gary's render with Alloy, I am looking to see how far I can push the quality of Unity with this

 

Doctor Mackinnon update with Candela tweaks. Open image in new tab for full size!

Fictional alternate 80's universe sci-fi game(working on in spare time) A supercomputer and optical processor industry giant with his new home computer models.

 

Livenda,

Any word on the update? Its been quite awhile.

 

Been thinking about the same thing.

@Candela : Is it possible to send us the update without having to wait for it to be available on the asset store ?

 

Hi Everyone,

Candela SSRR V1.02 has been submitted and should be available by the weekend, we will provide the full list of changes/ updates Tomorrow.

One notable feature is the ability to have multiple ways to control which objects are included in reflections. There are many permutations,e.g. you can now specify an object to be completely taken out of reflections so it will not reflect and be reflected more importantly, not occlude other reflections even if it is in front of another object (This is an important feature and was not straight forward to implement as Candela is a Screen Space effect and only reflects what is on the screen and does not know what is behind objects, known as Depth Shadowing). This also works with Transparent shaders and Particles! So you are able to have Windows using cubemap reflections in front of Candela SSRR local reflections.

We are already working on the next update and will be releasing them in rapid successions, last but not least just a reminder Candela SSRR is 50% Off on the Unity Asset Store Madness Sale which ends in 2 days.

Unfortunately we are unable to do that, updates will be available through the Asset Store.

Cheers!

 

this asset worth every penny !!!


Livenda, please, any news about the GI solution ?


many thanks

 

I bought this product with the 'Buying Group'. How should I update?

 

Hi Livenda,

I just purchased Candela SSRR and looked over the sample content. I checked out the source files and have some requests.
I see many areas for optimization, some of them very easy, some of them would require slight architecture changes.
I broke them down into 3 sections:

- memory -
Generally, good job!
But the camera script currently allocates unnecessary memory each frame. Specifically "bool d3d" allocates memory and is only necessary on Start() since its not possible to change gpu during the app running and couldnt be updated on onRenderImage.


- CPU -
- replacing the strings being used to set values on shaders each frame will gain a noticable optimization by changing them to use the nameID method instead.

- many or most of the variables being set to materials have a cost to being set regardless if they are changing. its usually cheaper to check if the value has changed before setting a value "in case" its changed.

-The part of the cpu code that sets the sensitivity could be reworked to have 1/3 of the vector creation overhead since the data doesnt change between each setting.

-In general the code is organized in a way to read it easy enough and there are comments for most parts, but the naming convention is inconsistent. I would recommend using the c# camel case naming convention describe on MSDN. Similar goes for file names, it would be beneficial if the files were consistently named with Candela in the name for when a bug, error, or log shows up. Most files look fine, but some are inconsistent.

-In the blur iterations section with the Blits, it would be much faster if it was reengineered to include both X and Y blur in a single blit then flip flop between textures being used each frame. regardless of the complexity of a blit, the root act of blit-ing has a heavy cost.


- GPU -
-There appears to be an excessive use of if() statements in the shaders. It appears sometimes they are used for logical checks that are better done on the CPU where it could branch between multiple shaders or passes. It even appears some of the values that are being checked in some shaders for if() are being directly set by the cpu and are not modified. Sometimes they check data that may be possible to be replaced with a clamp. Sometimes they appear to be valid if() checks looking at dynamic and changing data.
Although if() statements "can" optimize shaders, they typical stall shaders and cause poor performance. dx11 handles if() better than dx9, but its still fairly standard to try to never use if(). sometimes the compiler will fix it up, but most of the time it cant.
Often when a if() is encountered in a shader, it processes both sides of the outcome, in the end saving nothing and always costing the combined possible total.

-tex2dlod is used often in your shaders, but the feature of accessing an lod doesnt appear to be used. it may be better to use tex2d instead, if nothing else it would make the code more consistent while reading it.

-it would be more useful if the actual source shader for CandelaSSRRv1.shader was included. It may be by design that the compiled and obfuscated version was included, but it severely limits modifications and optimizations. Its not difficult to spend a day de-obfuscating a shader, but its fairly unnecessary since the organized version is available on your end.

-the blur shaders are returning half4 which is limiting the data range but floats are used elsewhere. I would recommend returning float4 in the shader. If you are interested in lowering data processing in the shaders, I would recommend const, lowp, and half values where applicable inside the fragment shader.

-in a few spots its possible to reorganize the math without impacting the result but allowing the compiled shader to create a MAD and use fewer instructions. Not a large gain, but often every instruction matters.

-in the multiply parts using "0.1428571428571429" there isnt any point carrying out the data beyond 7 decimals. floating point precision doesnt go beyond that in shaders... halfs even less so.

//====

I am not sure if you are already doing this or maybe you already tried it and decided it wasnt worth it, but you might be able to save a lot of performance by running a stencil pass to only allow reflection processing on possible reflection object screen pixels instead of all screen pixels. I looked around and didnt see anything jump out, but maybe I overlooked it.

All requests and comments aside, its great to see more higher end visual features available on the asset store. I cant wait to see how I can use this in my current project and what you decide to do with your upcoming projects.

Thanks,
- Pheck

 

Waiting for the GI solution too.....

 

Yes, we need the GI Solution Please

 

Hi,

I'm getting a "NullReferenceException: Object reference not set to an instance of an object
moviePlayer.Start () (at Assets/CandelaSSRR/Examples/Scripts/moviePlayer.cs:18 )"
On Windows when pressing Play in the Music Studio scene.

I believe the problem is in the embedding of the video. Do you have any idea on how to solve it?
EDIT: I had to convert the videos to MPG and reassign them.

Also, for some reason the Music Studio Scene materials haven't got the proper bump textures assigned.

In the meantime, here's a little video I made of the Pinball scene, a little pimped up and a little more alive

Do you know how to remove the artifacts (the "line banding" at 0:17 in the upper reflection plane)?

 

This is a very simple shader created with Shader Forge to try and solve compatibility issues with CandelaSSR.

Code (csharp):

1. // Shader created with Shader Forge Beta 0.33
2. // Shader Forge (c) Joachim Holmer - http://www.acegikmo.com/shaderforge/
3. // Note: Manually altering this data may prevent you from opening it in Shader Forge
4. /*SF_DATA;ver:0.33;sub:START;pass:START;ps:flbk:,lico:1,lgpr:1,nrmq:1,limd:1,uamb:True,mssp:True,lmpd:False,lprd:False,enco:False,frtr:True,vitr:True,dbil:False,rmgx:True,rpth:1,hqsc:True,hqlp:False,blpr:0,bsrc:0,bdst:0,culm:0,dpts:2,wrdp:True,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,ofsf:0,ofsu:0,f2p0:False;n:type:ShaderForge.SFN_Final,id:1,x:32719,y:32712|diff-5-OUT,spec-3-OUT,gloss-4-OUT;n:type:ShaderForge.SFN_Color,id:2,x:33167,y:32585,ptlb:Color,ptin:_Color,glob:False,c1:0.5,c2:0.5,c3:0.5,c4:1;n:type:ShaderForge.SFN_Vector1,id:3,x:33167,y:32732,v1:0;n:type:ShaderForge.SFN_Slider,id:4,x:33167,y:32825,ptlb:Gloss,ptin:_Gloss,min:0,cur:0,max:1;n:type:ShaderForge.SFN_Append,id:5,x:32964,y:32558|A-2-RGB,B-2-A;proporder:2-4;pass:END;sub:END;*/
5.  
6. Shader "Shader Forge/CandelaSSR_SF_simple" {
7.     Properties {
8.         _Color ("Color", Color) = (0.5,0.5,0.5,1)
9.         _Gloss ("Gloss", Range(0, 1)) = 0
10.     }
11.     SubShader {
12.         Tags {
13.             "RenderType"="Opaque"
14.         }
15.         Pass {
16.             Name "PrePassBase"
17.             Tags {
18.                 "LightMode"="PrePassBase"
19.             }
20.            
21.            
22.             Fog {Mode Off}
23.             CGPROGRAM
24.             #pragma vertex vert
25.             #pragma fragment frag
26.             #define UNITY_PASS_PREPASSBASE
27.             #include "UnityCG.cginc"
28.             #pragma exclude_renderers xbox360 ps3 flash d3d11_9x
29.             #pragma target 3.0
30.             uniform fixed4 unity_Ambient;
31.             uniform float _Gloss;
32.             struct VertexInput {
33.                 float4 vertex : POSITION;
34.                 float3 normal : NORMAL;
35.             };
36.             struct VertexOutput {
37.                 float4 pos : SV_POSITION;
38.                 float4 posWorld : TEXCOORD0;
39.                 float3 normalDir : TEXCOORD1;
40.             };
41.             VertexOutput vert (VertexInput v) {
42.                 VertexOutput o;
43.                 o.normalDir = mul(float4(v.normal,0), _World2Object).xyz;
44.                 o.posWorld = mul(_Object2World, v.vertex);
45.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
46.                 return o;
47.             }
48.             fixed4 frag(VertexOutput i) : COLOR {
49.                 i.normalDir = normalize(i.normalDir);
50.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
51. /////// Normals:
52.                 float3 normalDirection =  i.normalDir;
53.                 return fixed4( normalDirection * 0.5 + 0.5, _Gloss );
54.             }
55.             ENDCG
56.         }
57.         Pass {
58.             Name "PrePassFinal"
59.             Tags {
60.                 "LightMode"="PrePassFinal"
61.             }
62.             ZWrite Off
63.            
64.             Fog {Mode Off}
65.             CGPROGRAM
66.             #pragma vertex vert
67.             #pragma fragment frag
68.             #define UNITY_PASS_PREPASSFINAL
69.             #include "UnityCG.cginc"
70.             #pragma multi_compile_prepassfinal
71.             #pragma exclude_renderers xbox360 ps3 flash d3d11_9x
72.             #pragma target 3.0
73.             uniform sampler2D _LightBuffer;
74.             #if defined (SHADER_API_XBOX360)  defined (HDR_LIGHT_PREPASS_ON)
75.                 sampler2D _LightSpecBuffer;
76.             #endif
77.             uniform fixed4 unity_Ambient;
78.             uniform float4 _Color;
79.             uniform float _Gloss;
80.             struct VertexInput {
81.                 float4 vertex : POSITION;
82.                 float3 normal : NORMAL;
83.             };
84.             struct VertexOutput {
85.                 float4 pos : SV_POSITION;
86.                 float4 posWorld : TEXCOORD0;
87.                 float3 normalDir : TEXCOORD1;
88.                 float4 projPos : TEXCOORD2;
89.             };
90.             VertexOutput vert (VertexInput v) {
91.                 VertexOutput o;
92.                 o.normalDir = mul(float4(v.normal,0), _World2Object).xyz;
93.                 o.posWorld = mul(_Object2World, v.vertex);
94.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
95.                 o.projPos = ComputeScreenPos (o.pos);
96.                 COMPUTE_EYEDEPTH(o.projPos.z);
97.                 return o;
98.             }
99.             fixed4 frag(VertexOutput i) : COLOR {
100.                 i.normalDir = normalize(i.normalDir);
101.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
102. /////// Normals:
103.                 float3 normalDirection =  i.normalDir;
104. ////// Lighting:
105.                 half4 lightAccumulation = tex2Dproj(_LightBuffer, UNITY_PROJ_COORD(i.projPos));
106.                 #if defined (SHADER_API_GLES) || defined (SHADER_API_GLES3)
107.                     lightAccumulation = max(lightAccumulation, half4(0.001));
108.                 #endif
109.                 #ifndef HDR_LIGHT_PREPASS_ON
110.                     lightAccumulation = -log2(lightAccumulation);
111.                 #endif
112.                 #if defined (SHADER_API_XBOX360)  defined (HDR_LIGHT_PREPASS_ON)
113.                     lightAccumulation.w = tex2Dproj (_LightSpecBuffer, UNITY_PROJ_COORD(i.projPos)).r;
114.                 #endif
115. /////// Diffuse:
116.                 float3 diffuse = lightAccumulation.rgb * 0.5 + unity_Ambient.rgb*0.5;
117. ////// Specular:
118.                 float node_3 = 0.0;
119.                 float3 specularColor = float3(node_3,node_3,node_3);
120.                 float3 specular = (lightAccumulation.rgb * 2)*lightAccumulation.a * specularColor;
121.                 float3 finalColor = 0;
122.                 float3 diffuseLight = diffuse;
123.                 finalColor += diffuseLight * float4(_Color.rgb,_Color.a).rgb;
124.                 finalColor += specular;
125. /// Final Color:
126.                 return fixed4(finalColor,1);
127.             }
128.             ENDCG
129.         }
130.         Pass {
131.             Name "ForwardBase"
132.             Tags {
133.                 "LightMode"="ForwardBase"
134.             }
135.            
136.            
137.             CGPROGRAM
138.             #pragma vertex vert
139.             #pragma fragment frag
140.             #define UNITY_PASS_FORWARDBASE
141.             #include "UnityCG.cginc"
142.             #include "AutoLight.cginc"
143.             #pragma multi_compile_fwdbase_fullshadows
144.             #pragma exclude_renderers xbox360 ps3 flash d3d11_9x
145.             #pragma target 3.0
146.             uniform float4 _LightColor0;
147.             uniform float4 _Color;
148.             uniform float _Gloss;
149.             struct VertexInput {
150.                 float4 vertex : POSITION;
151.                 float3 normal : NORMAL;
152.             };
153.             struct VertexOutput {
154.                 float4 pos : SV_POSITION;
155.                 float4 posWorld : TEXCOORD0;
156.                 float3 normalDir : TEXCOORD1;
157.                 LIGHTING_COORDS(2,3)
158.             };
159.             VertexOutput vert (VertexInput v) {
160.                 VertexOutput o;
161.                 o.normalDir = mul(float4(v.normal,0), _World2Object).xyz;
162.                 o.posWorld = mul(_Object2World, v.vertex);
163.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
164.                 TRANSFER_VERTEX_TO_FRAGMENT(o)
165.                 return o;
166.             }
167.             fixed4 frag(VertexOutput i) : COLOR {
168.                 i.normalDir = normalize(i.normalDir);
169.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
170. /////// Normals:
171.                 float3 normalDirection =  i.normalDir;
172.                 float3 lightDirection = normalize(_WorldSpaceLightPos0.xyz);
173.                 float3 halfDirection = normalize(viewDirection+lightDirection);
174. ////// Lighting:
175.                 float attenuation = LIGHT_ATTENUATION(i);
176.                 float3 attenColor = attenuation * _LightColor0.xyz;
177. /////// Diffuse:
178.                 float NdotL = dot( normalDirection, lightDirection );
179.                 float3 diffuse = max( 0.0, NdotL) * attenColor + UNITY_LIGHTMODEL_AMBIENT.rgb;
180. ///////// Gloss:
181.                 float gloss = _Gloss;
182.                 float specPow = exp2( gloss * 10.0+1.0);
183. ////// Specular:
184.                 NdotL = max(0.0, NdotL);
185.                 float node_3 = 0.0;
186.                 float3 specularColor = float3(node_3,node_3,node_3);
187.                 float3 specular = (floor(attenuation) * _LightColor0.xyz) * pow(max(0,dot(halfDirection,normalDirection)),specPow) * specularColor;
188.                 float3 finalColor = 0;
189.                 float3 diffuseLight = diffuse;
190.                 finalColor += diffuseLight * float4(_Color.rgb,_Color.a).rgb;
191.                 finalColor += specular;
192. /// Final Color:
193.                 return fixed4(finalColor,1);
194.             }
195.             ENDCG
196.         }
197.         Pass {
198.             Name "ForwardAdd"
199.             Tags {
200.                 "LightMode"="ForwardAdd"
201.             }
202.             Blend One One
203.            
204.            
205.             Fog { Color (0,0,0,0) }
206.             CGPROGRAM
207.             #pragma vertex vert
208.             #pragma fragment frag
209.             #define UNITY_PASS_FORWARDADD
210.             #include "UnityCG.cginc"
211.             #include "AutoLight.cginc"
212.             #pragma multi_compile_fwdadd_fullshadows
213.             #pragma exclude_renderers xbox360 ps3 flash d3d11_9x
214.             #pragma target 3.0
215.             uniform float4 _LightColor0;
216.             uniform float4 _Color;
217.             uniform float _Gloss;
218.             struct VertexInput {
219.                 float4 vertex : POSITION;
220.                 float3 normal : NORMAL;
221.             };
222.             struct VertexOutput {
223.                 float4 pos : SV_POSITION;
224.                 float4 posWorld : TEXCOORD0;
225.                 float3 normalDir : TEXCOORD1;
226.                 LIGHTING_COORDS(2,3)
227.             };
228.             VertexOutput vert (VertexInput v) {
229.                 VertexOutput o;
230.                 o.normalDir = mul(float4(v.normal,0), _World2Object).xyz;
231.                 o.posWorld = mul(_Object2World, v.vertex);
232.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
233.                 TRANSFER_VERTEX_TO_FRAGMENT(o)
234.                 return o;
235.             }
236.             fixed4 frag(VertexOutput i) : COLOR {
237.                 i.normalDir = normalize(i.normalDir);
238.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
239. /////// Normals:
240.                 float3 normalDirection =  i.normalDir;
241.                 float3 lightDirection = normalize(lerp(_WorldSpaceLightPos0.xyz, _WorldSpaceLightPos0.xyz - i.posWorld.xyz,_WorldSpaceLightPos0.w));
242.                 float3 halfDirection = normalize(viewDirection+lightDirection);
243. ////// Lighting:
244.                 float attenuation = LIGHT_ATTENUATION(i);
245.                 float3 attenColor = attenuation * _LightColor0.xyz;
246. /////// Diffuse:
247.                 float NdotL = dot( normalDirection, lightDirection );
248.                 float3 diffuse = max( 0.0, NdotL) * attenColor;
249. ///////// Gloss:
250.                 float gloss = _Gloss;
251.                 float specPow = exp2( gloss * 10.0+1.0);
252. ////// Specular:
253.                 NdotL = max(0.0, NdotL);
254.                 float node_3 = 0.0;
255.                 float3 specularColor = float3(node_3,node_3,node_3);
256.                 float3 specular = attenColor * pow(max(0,dot(halfDirection,normalDirection)),specPow) * specularColor;
257.                 float3 finalColor = 0;
258.                 float3 diffuseLight = diffuse;
259.                 finalColor += diffuseLight * float4(_Color.rgb,_Color.a).rgb;
260.                 finalColor += specular;
261. /// Final Color:
262.                 return fixed4(finalColor * 1,0);
263.             }
264.             ENDCG
265.         }
266.     }
267.     FallBack "Diffuse"
268.     CustomEditor "ShaderForgeMaterialInspector"
269. }
270.  

Is there anything wrong with this basic shader that might explain why the alpha in the diffuse doesn't affect the reflectivity of the screen space reflections? Otherwise the glossiness is affecting the sharpness of the reflection, which I've been able to create a slider to adjust. I'm still stumped on getting the overall reflectivity tweaked.

Thanks!

 

I dont know about Livenda but I found that extremely helpful and a nice education in how i can optimise my own stuff so thanks! (And i actually think fluidsim may well show up somewhere in what i'm doing eventualy, funtimes)

 

You should receive an e-mail in the next day or so with the download information for the new update, thanks.

First let me say the new Pimped out Pinball Table looks AWESOME! Can we include this video in our Candela SSRR web page? would it be at all possible to do a higher quality video? that would be great. In regards to the "line banding" This is now fixed in V1.02 which has been already submitted and should be available any time now. Please take a look at the next post outlining the release notes for V1.02, thanks again!

Thanks for your very kind words! We will be making an announcement Tomorrow in regards to our upcoming GI Engine, very exciting stuff!

Cheers.

 

Hello Pheck,

Thank you for your in-depth insight regarding some of the Candela SSRR Coding aspects. We will certainly take some of what you have outlined into consideration in the next coming updates. I will send you a PM to discuss them further in a little more detail why we have done few things the way we have, you have been very helpful. Some of the points you have mentioned are not possible with Candela SSRR as we have to target all the platfroms. With the naming convention, we will update to be more inline with the standards. tex2dlod is required for branching and is faster then tex2D when an lod level is specified. Thanks again.

Cheers,
Livenda

 

Below is the fixed shader code. The shader was not passing the _Color.a in the finalColor and was writing either a 1 or a 0 . I just added _Color.a in the w component of the finalColor and it works. This is a core change in shaderforge code generation if you like it to be automatic. But for all other users, this is a simple fix for now. Thanks again.

Code (csharp):

1. // Shader created with Shader Forge Beta 0.33
2. // Shader Forge (c) Joachim Holmer - http://www.acegikmo.com/shaderforge/
3. // Note: Manually altering this data may prevent you from opening it in Shader Forge
4. /*SF_DATA;ver:0.33;sub:START;pass:START;ps:flbk:,lico:1,lgpr:1,nrmq:1,limd:1,uamb:True,mssp:True,lmpd:False,lprd:False,enco:False,frtr:True,vitr:True,dbil:False,rmgx:True,rpth:1,hqsc:True,hqlp:False,blpr:0,bsrc:0,bdst:0,culm:0,dpts:2,wrdp:True,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,ofsf:0,ofsu:0,f2p0:False;n:type:ShaderForge.SFN_Final,id:1,x:32719,y:32712|diff-5-OUT,spec-3-OUT,gloss-4-OUT;n:type:ShaderForge.SFN_Color,id:2,x:33167,y:32585,ptlb:Color,ptin:_Color,glob:False,c1:0.5,c2:0.5,c3:0.5,c4:1;n:type:ShaderForge.SFN_Vector1,id:3,x:33167,y:32732,v1:0;n:type:ShaderForge.SFN_Slider,id:4,x:33167,y:32825,ptlb:Gloss,ptin:_Gloss,min:0,cur:0,max:1;n:type:ShaderForge.SFN_Append,id:5,x:32964,y:32558|A-2-RGB,B-2-A;proporder:2-4;pass:END;sub:END;*/
5.  
6. Shader "Shader Forge/CandelaSSR_SF_simple" {
7.     Properties {
8.         _Color ("Color", Color) = (0.5,0.5,0.5,1)
9.         _Gloss ("Gloss", Range(0, 1)) = 0
10.     }
11.     SubShader {
12.         Tags {
13.             "RenderType"="Opaque"
14.         }
15.         Pass {
16.             Name "PrePassBase"
17.             Tags {
18.                 "LightMode"="PrePassBase"
19.             }
20.            
21.            
22.             Fog {Mode Off}
23.             CGPROGRAM
24.             #pragma vertex vert
25.             #pragma fragment frag
26.             #define UNITY_PASS_PREPASSBASE
27.             #include "UnityCG.cginc"
28.             #pragma exclude_renderers xbox360 ps3 flash d3d11_9x
29.             #pragma target 3.0
30.             uniform fixed4 unity_Ambient;
31.             uniform float _Gloss;
32.             struct VertexInput {
33.                 float4 vertex : POSITION;
34.                 float3 normal : NORMAL;
35.             };
36.             struct VertexOutput {
37.                 float4 pos : SV_POSITION;
38.                 float4 posWorld : TEXCOORD0;
39.                 float3 normalDir : TEXCOORD1;
40.             };
41.             VertexOutput vert (VertexInput v) {
42.                 VertexOutput o;
43.                 o.normalDir = mul(float4(v.normal,0), _World2Object).xyz;
44.                 o.posWorld = mul(_Object2World, v.vertex);
45.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
46.                 return o;
47.             }
48.             fixed4 frag(VertexOutput i) : COLOR {
49.                 i.normalDir = normalize(i.normalDir);
50.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
51. /////// Normals:
52.                 float3 normalDirection =  i.normalDir;
53.                 return fixed4( normalDirection * 0.5 + 0.5, _Gloss );
54.             }
55.             ENDCG
56.         }
57.         Pass {
58.             Name "PrePassFinal"
59.             Tags {
60.                 "LightMode"="PrePassFinal"
61.             }
62.             ZWrite Off
63.            
64.             Fog {Mode Off}
65.             CGPROGRAM
66.             #pragma vertex vert
67.             #pragma fragment frag
68.             #define UNITY_PASS_PREPASSFINAL
69.             #include "UnityCG.cginc"
70.             #pragma multi_compile_prepassfinal
71.             #pragma exclude_renderers xbox360 ps3 flash d3d11_9x
72.             #pragma target 3.0
73.             uniform sampler2D _LightBuffer;
74.             #if defined (SHADER_API_XBOX360)  defined (HDR_LIGHT_PREPASS_ON)
75.                 sampler2D _LightSpecBuffer;
76.             #endif
77.             uniform fixed4 unity_Ambient;
78.             uniform float4 _Color;
79.             uniform float _Gloss;
80.             struct VertexInput {
81.                 float4 vertex : POSITION;
82.                 float3 normal : NORMAL;
83.             };
84.             struct VertexOutput {
85.                 float4 pos : SV_POSITION;
86.                 float4 posWorld : TEXCOORD0;
87.                 float3 normalDir : TEXCOORD1;
88.                 float4 projPos : TEXCOORD2;
89.             };
90.             VertexOutput vert (VertexInput v) {
91.                 VertexOutput o;
92.                 o.normalDir = mul(float4(v.normal,0), _World2Object).xyz;
93.                 o.posWorld = mul(_Object2World, v.vertex);
94.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
95.                 o.projPos = ComputeScreenPos (o.pos);
96.                 COMPUTE_EYEDEPTH(o.projPos.z);
97.                 return o;
98.             }
99.             fixed4 frag(VertexOutput i) : COLOR {
100.                 i.normalDir = normalize(i.normalDir);
101.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
102. /////// Normals:
103.                 float3 normalDirection =  i.normalDir;
104. ////// Lighting:
105.                 half4 lightAccumulation = tex2Dproj(_LightBuffer, UNITY_PROJ_COORD(i.projPos));
106.                 #if defined (SHADER_API_GLES) || defined (SHADER_API_GLES3)
107.                     lightAccumulation = max(lightAccumulation, half4(0.001));
108.                 #endif
109.                 #ifndef HDR_LIGHT_PREPASS_ON
110.                     lightAccumulation = -log2(lightAccumulation);
111.                 #endif
112.                 #if defined (SHADER_API_XBOX360)  defined (HDR_LIGHT_PREPASS_ON)
113.                     lightAccumulation.w = tex2Dproj (_LightSpecBuffer, UNITY_PROJ_COORD(i.projPos)).r;
114.                 #endif
115. /////// Diffuse:
116.                 float3 diffuse = lightAccumulation.rgb * 0.5 + unity_Ambient.rgb*0.5;
117. ////// Specular:
118.                 float node_3 = 0.0;
119.                 float3 specularColor = float3(node_3,node_3,node_3);
120.                 float3 specular = (lightAccumulation.rgb * 2)*lightAccumulation.a * specularColor;
121.                 float3 finalColor = 0;
122.                 float3 diffuseLight = diffuse;
123.                 finalColor += diffuseLight * float4(_Color.rgb,_Color.a).rgb;
124.                 finalColor += specular;
125. /// Final Color:
126.                 return fixed4(finalColor,_Color.a);
127.             }
128.             ENDCG
129.         }
130.         Pass {
131.             Name "ForwardBase"
132.             Tags {
133.                 "LightMode"="ForwardBase"
134.             }
135.            
136.            
137.             CGPROGRAM
138.             #pragma vertex vert
139.             #pragma fragment frag
140.             #define UNITY_PASS_FORWARDBASE
141.             #include "UnityCG.cginc"
142.             #include "AutoLight.cginc"
143.             #pragma multi_compile_fwdbase_fullshadows
144.             #pragma exclude_renderers xbox360 ps3 flash d3d11_9x
145.             #pragma target 3.0
146.             uniform float4 _LightColor0;
147.             uniform float4 _Color;
148.             uniform float _Gloss;
149.             struct VertexInput {
150.                 float4 vertex : POSITION;
151.                 float3 normal : NORMAL;
152.             };
153.             struct VertexOutput {
154.                 float4 pos : SV_POSITION;
155.                 float4 posWorld : TEXCOORD0;
156.                 float3 normalDir : TEXCOORD1;
157.                 LIGHTING_COORDS(2,3)
158.             };
159.             VertexOutput vert (VertexInput v) {
160.                 VertexOutput o;
161.                 o.normalDir = mul(float4(v.normal,0), _World2Object).xyz;
162.                 o.posWorld = mul(_Object2World, v.vertex);
163.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
164.                 TRANSFER_VERTEX_TO_FRAGMENT(o)
165.                 return o;
166.             }
167.             fixed4 frag(VertexOutput i) : COLOR {
168.                 i.normalDir = normalize(i.normalDir);
169.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
170. /////// Normals:
171.                 float3 normalDirection =  i.normalDir;
172.                 float3 lightDirection = normalize(_WorldSpaceLightPos0.xyz);
173.                 float3 halfDirection = normalize(viewDirection+lightDirection);
174. ////// Lighting:
175.                 float attenuation = LIGHT_ATTENUATION(i);
176.                 float3 attenColor = attenuation * _LightColor0.xyz;
177. /////// Diffuse:
178.                 float NdotL = dot( normalDirection, lightDirection );
179.                 float3 diffuse = max( 0.0, NdotL) * attenColor + UNITY_LIGHTMODEL_AMBIENT.rgb;
180. ///////// Gloss:
181.                 float gloss = _Gloss;
182.                 float specPow = exp2( gloss * 10.0+1.0);
183. ////// Specular:
184.                 NdotL = max(0.0, NdotL);
185.                 float node_3 = 0.0;
186.                 float3 specularColor = float3(node_3,node_3,node_3);
187.                 float3 specular = (floor(attenuation) * _LightColor0.xyz) * pow(max(0,dot(halfDirection,normalDirection)),specPow) * specularColor;
188.                 float3 finalColor = 0;
189.                 float3 diffuseLight = diffuse;
190.                 finalColor += diffuseLight * float4(_Color.rgb,_Color.a).rgb;
191.                 finalColor += specular;
192. /// Final Color:
193.                 return fixed4(finalColor,_Color.a);
194.             }
195.             ENDCG
196.         }
197.         Pass {
198.             Name "ForwardAdd"
199.             Tags {
200.                 "LightMode"="ForwardAdd"
201.             }
202.             Blend One One
203.            
204.            
205.             Fog { Color (0,0,0,0) }
206.             CGPROGRAM
207.             #pragma vertex vert
208.             #pragma fragment frag
209.             #define UNITY_PASS_FORWARDADD
210.             #include "UnityCG.cginc"
211.             #include "AutoLight.cginc"
212.             #pragma multi_compile_fwdadd_fullshadows
213.             #pragma exclude_renderers xbox360 ps3 flash d3d11_9x
214.             #pragma target 3.0
215.             uniform float4 _LightColor0;
216.             uniform float4 _Color;
217.             uniform float _Gloss;
218.             struct VertexInput {
219.                 float4 vertex : POSITION;
220.                 float3 normal : NORMAL;
221.             };
222.             struct VertexOutput {
223.                 float4 pos : SV_POSITION;
224.                 float4 posWorld : TEXCOORD0;
225.                 float3 normalDir : TEXCOORD1;
226.                 LIGHTING_COORDS(2,3)
227.             };
228.             VertexOutput vert (VertexInput v) {
229.                 VertexOutput o;
230.                 o.normalDir = mul(float4(v.normal,0), _World2Object).xyz;
231.                 o.posWorld = mul(_Object2World, v.vertex);
232.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
233.                 TRANSFER_VERTEX_TO_FRAGMENT(o)
234.                 return o;
235.             }
236.             fixed4 frag(VertexOutput i) : COLOR {
237.                 i.normalDir = normalize(i.normalDir);
238.                 float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
239. /////// Normals:
240.                 float3 normalDirection =  i.normalDir;
241.                 float3 lightDirection = normalize(lerp(_WorldSpaceLightPos0.xyz, _WorldSpaceLightPos0.xyz - i.posWorld.xyz,_WorldSpaceLightPos0.w));
242.                 float3 halfDirection = normalize(viewDirection+lightDirection);
243. ////// Lighting:
244.                 float attenuation = LIGHT_ATTENUATION(i);
245.                 float3 attenColor = attenuation * _LightColor0.xyz;
246. /////// Diffuse:
247.                 float NdotL = dot( normalDirection, lightDirection );
248.                 float3 diffuse = max( 0.0, NdotL) * attenColor;
249. ///////// Gloss:
250.                 float gloss = _Gloss;
251.                 float specPow = exp2( gloss * 10.0+1.0);
252. ////// Specular:
253.                 NdotL = max(0.0, NdotL);
254.                 float node_3 = 0.0;
255.                 float3 specularColor = float3(node_3,node_3,node_3);
256.                 float3 specular = attenColor * pow(max(0,dot(halfDirection,normalDirection)),specPow) * specularColor;
257.                 float3 finalColor = 0;
258.                 float3 diffuseLight = diffuse;
259.                 finalColor += diffuseLight * float4(_Color.rgb,_Color.a).rgb;
260.                 finalColor += specular;
261. /// Final Color:
262.                 return fixed4(finalColor * 1,_Color.a);
263.             }
264.             ENDCG
265.         }
266.     }
267.     FallBack "Diffuse"
268.     CustomEditor "ShaderForgeMaterialInspector"
269. }
270.  

 

When was the last update submitted to the asset store ?
It's taking ages to show up..

 

Thanks for looking into what needed to be tweaked! I'll reach out to Shader Forge to see if they can make this work by default.

cheers

 

Hi Everyone,

Here are the V1.02 Release Notes, we already have new updates and will be submitted next week.

NEW : Flip Reflections - For MSAA Compatibility in DX11/DX9 Rendering paths
NEW : Use Layer Mask - Exclude Objects via Layers for Transparent objects and Particles
NEW : Tools - Exclude Objects via a Script (method 2)
NEW : Complete Exclude Mode - Exclude objects completely (no casting or receiving reflections and not occluding reflections cast by other objects) not using transparent shaders
NEW : AlphaBias Option for better compatibility with other third party products such as Skyshop in Forward render mode
NEW : FishTank Demo Scene showing Glass other object exclusion from reflections and occlusion via layer masks
NEW : ExcludeandReflect Demo Scene Showing Planar reflected Glass with SSRR reflections behind and Object exclusion via scripting.

Other Fixes Changes

- Documentation updated
- Fixed bug with horizontal line at some camera clip distances
- Overall stability and performance improvements
- Fixed Circular Artifact bug in close distance reflections
- Particles and Transparent objects no longer messing reflections as they can now be excluded

Cheers.

 

Sure, no problem, the video is already in HD (1280x720p) when enabled, YouTube recompression really had a hard time because the dirt on the lenses blurred the image a bit, I may work to produce a (1920x1080p) video but I may need some extra time to re-capure, recomposite the video itself and to reupload it.

The update is great news!

If you're taking feature requests, I'd ask for more included shaders. Extending the existing ones to create hdr emissive shaders didn't take much time, but having it ready and tested out-of-the-box is another thing.
I'd like to see in particular Emissive (that as you see work great in HDR) and Transparent/Cutout-Diffuse/Specular/Bumped SSRR shaders for details like carpets or flags.

[as a side note, you may have already answered to this: is particle reflection non feasible at all? Stop-motion reflected motion-generated particle clouds would have been nice to see!]

 

I don't get it, you have been saying for over 1 week that the update has been submitted, I'm not understanding.
So now you are going to submit it next week ?

 

Hi BigB,

I think you miss understood, V1.02 has already been submitted to the Unity Asset Store. We already have another update to V1.03 coming soon and will be submitted next week.

Cheers!

 

I did miss understood.
I apology !

 

Can you please automate this for everyone who is in the buying group? I didnt get the mail.

Greetings

 

oh my ! this asset store is really slow ! i really need for my project !

dear livenda, whats the news about the GI solution ?

 

It's been over 1 week already, they are taking their sweet time..., I guess we will touch v1.03 in 1 month or more lol

 

Does it have to be _Color.a or can it be any alpha? For example: diff_albedo.a or any .a attribute

also: any ideas as to why Candela wouldn't work in Forward rendering mode? I seem to only be able to get it to function correctly in Deferred.

thanks

 

Yes, it has been a little slow. We have contacted Unity to see if they can push V1.02 to the Asset Store asap, fingers crossed.

This should work as well of course, however you need to provide a texture in the .a Channel. You can also multiply the _Color.a with the diff .a to modulate this as well. We are looking at the forward mode now with shaderforge however it could be out of our hands to do anything at this stage...

Yes, certainly. The next update will be completely automated for GB purchasers, please contact our support and we can send you the download link directly if you still have not received it, thanks again.

Cheers!

 

Hi...
EQUATION
A Shader Developer wants to make more customers...
A Customer buys good shaders to save time and get realistic quality...

Since Candela SSRR is dealing with Reflections
so to achieve this equation

I suggest Candela SSRR team should post step by step tutorials, showing how to use Candela SSRR with:
01- Marmoset Skyshop Shaders.
02- ALLOY PHYSICAL SHADER FRAMEWORK.
03- Shader Forge

Best Regards

 

I concur, when this is in place I'll also purchase Candela SSRR.
Thanks in advance

 

Well if this helps, when i first got Candela I just replaced all of Candela's shaders with Skyshop shaders and it just worked, that was it, in the demo scenes I tested anyway

 

Hi everything worked smooth but at some point when I have global blur enabled I see yellow and blue lines around every edge. How can I get rid of it? I've tried reimporting the whole thing again but didn't help. Anyway your product is truly awesome!

Thx

 

This is from the game I'm currently developing and this visual is achieved with Alloy Physical Shader pack and Candela SSRR
Thanks a lot.

 

Damn dude! That's awesome! XD

Is that just Alloy and Candela, or are you also using Skyshop?

 

The update is finally online

 

The new way to exclude what we want from the reflection works beautifully
Good work.
I'm posting two shots with extensive use of alpha-blended particles and surfaces.

 

Are there any instructions on how to set up an object for the exclude?

 

It's pretty simple, just add the objects you want excluded to a specific layer, and add the layer in the candela exclusions.

 

Thanks. It turns out I had done it right at one point, but it was a corrupted J-peg that was preventing it from working on the object in question. Another dude figured it out and turned it to a Tga and it worked fine.

 

Thanks!
And nope, just Alloy Candela. Alloy was an instant bought when it came out, and Candela was on 50% sale. Being an indie, that's the most I can afford. Rest is Unity's magic

I had a very hard time adjusting cubemaps, but with Candela I don't have any need of those anymore

 

I'm having issues getting Alloy's skin shader, Skyshop, Candela SSRR and Shadow Softener to play nicely together with Deferred lighting. It seems that the reflections behind the character are showing through on the character and unless I turn down the Global Bias and Reflection Multiply (which eliminates reflections effectively) so that the issue doesn't show the character looks bad. If I switch to Forward rendering it looks better but the seams of the mesh are visible in certain areas from a distance, moving closer the seams diminish but are still visible. Any advice would be greatly appreciated. Thanks.


Deferred


Forward

 

I don't have Candela, but this is good to know. I am using Alloy as well... maybe you could just exclude the character model from reflections (but that would defeat the purpose of SSRR)