Blending pointlight shadows in Unity

I still have not seen analogs of similar shadows for a point source of light (Pointlight with a blur effect at a distance, imitating arealight) in computer games. Everywhere - either fully baked shadows, or “light bulbs” without any shadows at all, the maximum is ordinary PCF filtering. Although PCSS-shadows have been used for directional sunlight for a long time (GTA5, for example). In Unreal, there is an interesting algorithm similar to raytracing, which draws beautiful arealight-shadows, but only for static geometry (additional volumes are required). In Unity, everything is very bad - only sunlight is gently filtered, and “spotlights” and “light bulbs” are in the span.



If at some “spotlight bilinear filtering” hangs on Unity, then on point “light bulbs” there is such a horror:

')





Is it really that adding ordinary PCF filtering is such a performance hit? Even if the blow, then why not make the option of including this filtering optional?



As it turned out, there is no impact on performance. In Unity 5, the technology deffered lighting (deferred lighting), and the more in the frame of light sources with dynamic shadow, the worse the performance. And what kind of filtering of these shadows is not so important. The same number of passes is performed, the same number of pixels are processed, this moment just requires scene optimization. And the number of samples from the cubic texture of the depth of the “light bulb” may affect the performance, but very little (in the area of ​​the FPS pair).



It should also be said that blurring the resulting shadow with the image effect will not work. There is no interlayer between sampling from the texture of depth and the imposition of light, such is the system in Unity. A pity, it would be possible to win something.



So, we change the algorithm



Creating special materials for the sake of soft shadows is painstaking, and making changes to existing shaders with a script (as was done in ShadowSoftener) is also somehow not very convenient. It is much faster and more practical to apply shadows at once to all shaders in the project (built-in, handwritten, downloaded) by changing just one file “UnityShadowLibrary.cginc”, which is located in the editor's directory: "... \ Unity5 \ Editor \ Data \ CGIncludes".



We find this piece, which is responsible for the shadow of a point source of light:

#if defined (SHADOWS_SOFT) float z = 1.0/128.0; float4 shadowVals; shadowVals.x = SampleCubeDistance (vec+float3( z, z, z)); shadowVals.y = SampleCubeDistance (vec+float3(-z,-z, z)); shadowVals.z = SampleCubeDistance (vec+float3(-z, z,-z)); shadowVals.w = SampleCubeDistance (vec+float3( z,-z,-z)); half4 shadows = (shadowVals < mydist.xxxx) ? _LightShadowData.rrrr : 1.0f; return dot(shadows,0.25); #else 

In place of it, you can put any algorithm you like, but first we analyze the input parameters:



vec is a four-dimensional vector. x, y and z is the direction from the “light bulb” to the pixel. By sampling this value using SampleCubeDistance, we get the distance of the shadowed object. If the distance is greater than the length of vec, the shadow per pixel does not fall. (mydist is the same distance, but this is not an input parameter, it is calculated higher in the same file) In each sample, the coordinate is shifted by a fixed amount, creating the effect of a non-uniform border. Do not laugh. Professional programmers who develop Unity call it soft shadow.



_LightShadowData.r - this value of the slider adjusts the brightness of the shadow. You can use it, for example, to change the degree of blur of the shadow or to change some other parameter to debug the shader directly in the editor. Unfortunately, I have not figured out what other _LightShadowData components are affecting. Apparently, for a point source of light there are no more parameters.



We return the brightness from the function (0 to 1.0), i.e. a multiplier that acts as atten (attenuation) in all shaders, so the modified shadow will also work in all shaders that support shading.



To see the changes , find the folder of your project, in it - the folder «Library». Remove the “ShaderCache” directory from this folder and restart Unity. I also restarted Unity after each shader editing, it was unnerving and complicated debugging.



That's all.



I tried this option here, smearing the edges with an unsightly dithering:

  #if defined (SHADOWS_SOFT) //  ,    float downscale = 32.0f; //   const float3 rndseed = float3(12.9898,78.233,45.5432); float3 randomvec = float3( dot(vec,rndseed) , dot(vec.yzx,rndseed) , dot(vec.zxy,rndseed) ); randomvec = frac(sin(randomvec) * 43758.5453); //      float3 xvec = normalize(cross(vec,randomvec)); float3 yvec = normalize(cross(vec,xvec)); float3 vec1 = xvec / downscale; float3 vec2 = yvec / downscale; float4 shadowVals; //    shadowVals.x = SampleCubeDistance (vec+vec1); shadowVals.y = SampleCubeDistance (vec+vec2); shadowVals.z = SampleCubeDistance (vec-vec1); shadowVals.w = SampleCubeDistance (vec-vec2); //  half4 shadows = (shadowVals < mydist.xxxx) ? _LightShadowData.rrrr : 1.0f; return dot(shadows,0.25); #else 

There are as many samples as in the eerie canonical implementation, but at least the pixels do not make my eyes callous:







Without hesitation (but for a long time debugging), I made the following PCF4x4 implementation with “manual” bilinear filtering (of course, DirectX11 commands can be inserted into Unity shaders, among which there is bilinear filtering of the cubic shadows, but I went selections for “manual” smoothing, it turned out not 16 samples, but 25).







Or even like this:







This is not an honest PCSS, but a faster and simpler implementation. The maximum blur is the same PCF4x4. A clear shadow near the shader is achieved by increasing the sharpness. By the way, the shapen effect is also a lot of where it applies. Here we have a symbiosis, with which you can achieve a beautiful effect.



The above-mentioned slider adjusts the transition angle of a soft shadow to a sharp one. This parameter can be selected in different ways for different "light bulbs", based on the size of the premises in which they are located.



I put the code of the last implementation under cat. It is a bit cumbersome and untidy, because I did not use a two-dimensional cycle of samples, but I wrote them down manually to reduce the number of commands and the number of variables used, and at the same time apply operations with vectors where you can calculate several variables at once. Plus, I basically did not use conditional transitions, replacing them with mathematics. Therefore, look at your own risk.







If you are not exactly satisfied with this approach, implement more suitable algorithms within Unity. I would only be glad of such activity, because I really am depressed by the stagnation in Unity in terms of realtime shadows, which has been dragging on for many years.



PS: Most of all I would like to hear the opinions of those who work directly with Unity and know what is possible and what is not, although there will most likely be extensive reflections on algorithms that cannot be inserted into the engine because of its closed architecture. But I also will join the lengthy reflections with joy and explain some points.