Merge pull request #36 from EvgeniiG/master

Fix bugs and refactor

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.cs

                                 if (areaLightCount >= k_MaxAreaLightsOnSCreen)
                                     continue;
                                 lightCategory = LightCategory.Area;
-                                gpuLightType = GPULightType.Rectangle;
+                                gpuLightType = GPULightType.Line;
                                 lightVolumeType = LightVolumeType.Box;
                                 ++areaLightCount;
                                 break;

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/Resources/SkyHDRI.shader

             #pragma vertex Vert
             #pragma fragment Frag
 
-            #pragma multi_compile _ ATMOSPHERICS_DEBUG
-            #pragma multi_compile _ ATMOSPHERICS_OCCLUSION_FULLSKY
-            #pragma multi_compile _ PERFORM_SKY_OCCLUSION_TEST
-
-            #ifndef PERFORM_SKY_OCCLUSION_TEST
-                #define IS_RENDERING_SKY
-            #endif
-
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
-            #include "AtmosphericScattering.hlsl"
 
             TEXTURECUBE(_Cubemap);
             SAMPLERCUBE(sampler_Cubemap);
                 float3 rotDirY = float3(sinPhi, 0, cosPhi);
                 dir = float3(dot(rotDirX, dir), dir.y, dot(rotDirY, dir));
 
-                /*
-                Coordinate coord = GetCoordinate(input.positionCS.xy, _ScreenSize.zw);
-
-                // If the sky box is too far away (depth set to 0), the resulting look is too foggy.
-                const float skyDepth = 0.01;
-
-                #ifdef PERFORM_SKY_OCCLUSION_TEST
-                    // Determine whether the sky is occluded by the scene geometry.
-                    // Do not perform blending with the environment map if the sky is occluded.
-                    float rawDepth     = max(skyDepth, LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).r);
-                    float skyTexWeight = (rawDepth > skyDepth) ? 0.0 : 1.0;
-                #else
-                    float rawDepth     = skyDepth;
-                    float skyTexWeight = 1.0;
-                #endif
-
-                float3 positionWS = UnprojectToWorld(rawDepth, coord.positionSS, _InvViewProjMatrix);
-
-                float4 c1, c2, c3;
-                VolundTransferScatter(positionWS, c1, c2, c3);
-
-                float4 coord1 = float4(c1.rgb + c3.rgb, max(0.f, 1.f - c1.a - c3.a));
-                float3 coord2 = c2.rgb;
-
-                float sunCos = dot(normalize(dir), _SunDirection);
-                float miePh  = MiePhase(sunCos, _MiePhaseAnisotropy);
-
-                float2 occlusion  = float2(1.0, 1.0); // TODO.
-                float  extinction = coord1.a;
-                float3 scatter    = coord1.rgb * occlusion.x + coord2 * miePh * occlusion.y;
-
-                #ifdef ATMOSPHERICS_DEBUG
-                    switch (_AtmosphericsDebugMode)
-                    {
-                        case ATMOSPHERICS_DBG_RAYLEIGH:           return c1;
-                        case ATMOSPHERICS_DBG_MIE:                return c2 * miePh;
-                        case ATMOSPHERICS_DBG_HEIGHT:             return c3;
-                        case ATMOSPHERICS_DBG_SCATTERING:         return float4(scatter, 0.0);
-                        case ATMOSPHERICS_DBG_OCCLUSION:          return float4(occlusion.xy, 0.0, 0.0);
-                        case ATMOSPHERICS_DBG_OCCLUDEDSCATTERING: return float4(scatter, 0.0);
-                    }
-                #endif
-
-                */
-
-
-                // Apply extinction to the scene color when performing alpha-blending.
-                //return float4(skyColor * (skyTexWeight * extinction) + scatter, extinction);
             }
 
             ENDHLSL

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/SkyRenderer.cs

 
         private void RenderSky(Matrix4x4 invViewProjectionMatrix, SkyParameters skyParameters, Mesh skyMesh, RenderLoop renderLoop)
         {
-            Shader.EnableKeyword("PERFORM_SKY_OCCLUSION_TEST");
-
             m_RenderSkyPropertyBlock.SetTexture("_Cubemap", skyParameters.skyHDRI);
             m_RenderSkyPropertyBlock.SetVector("_SkyParam", new Vector4(skyParameters.exposure, skyParameters.multiplier, skyParameters.rotation, 0.0f));
             m_RenderSkyPropertyBlock.SetMatrix("_InvViewProjMatrix", invViewProjectionMatrix);
 
         private void RenderSkyToCubemap(SkyParameters skyParameters, RenderTexture target, RenderLoop renderLoop)
         {
-            Shader.DisableKeyword("PERFORM_SKY_OCCLUSION_TEST");
-
             for (int i = 0; i < 6; ++i)
             {
                 Utilities.SetRenderTarget(renderLoop, target, 0, (CubemapFace)i);
                 RenderSkyToCubemap(skyParams, target, renderLoop);
                 // End temp
 
-                // 
-
 
                 // Do the convolution on remaining mipmaps
                 float invOmegaP = (6.0f * input.width * input.width) / (4.0f * Mathf.PI); // Solid angle associated to a pixel of the cubemap;
                     for (int face = 0; face < 6; ++face)
                     {
                         Utilities.SetRenderTarget(renderLoop, target, mip, (CubemapFace)face);
- 
+
                         var cmd = new CommandBuffer { name = "" };
                         cmd.DrawMesh(m_CubemapFaceMesh[face], Matrix4x4.identity, m_GGXConvolveMaterial, 0, 0, propertyBlock);
                         renderLoop.ExecuteCommandBuffer(cmd);
                 {
                     // Trigger a rebuild of cubemap / convolution
                     // TODO: can we have some kind of hash value here ? +> use or override GetHashCode() + include a refresh rate value in parameters
-                    // TODO: we could apply multiplier/exposure and rotation on the final result (i.e on the sky ibl and on lightprobe / lightmap, but can be tricky as Unity seems to merge sky information with 
+                    // TODO: we could apply multiplier/exposure and rotation on the final result (i.e on the sky ibl and on lightprobe / lightmap, but can be tricky as Unity seems to merge sky information with
-                        skyParameters.multiplier != m_bakedSkyParameters.multiplier)
+                        skyParameters.multiplier != m_bakedSkyParameters.multiplier ||
+                        skyParameters.skyHDRI != m_bakedSkyParameters.skyHDRI)
                     {
                         using (new Utilities.ProfilingSample("Sky Pass: Render Cubemap", renderLoop))
                         {
                         }
 
                         // Cleanup all this...
+                        m_bakedSkyParameters.skyHDRI = skyParameters.skyHDRI;
                         m_bakedSkyParameters.skyResolution = skyParameters.skyResolution;
                         m_bakedSkyParameters.exposure = skyParameters.exposure;
                         m_bakedSkyParameters.rotation = skyParameters.rotation;

Assets/ScriptableRenderLoop/ShaderLibrary/AreaLighting.hlsl

 
     sum *= INV_TWO_PI; // Normalization
 
-    return twoSided ? abs(sum) : max(sum, 0.0);
+    sum = twoSided ? abs(sum) : max(sum, 0.0);
+
+    return isfinite(sum) ? sum : 0.0;
 }
 
 // For polygonal lights.

Assets/TestScenes/HDTest/HDRenderLoopTest.unity

   - component: {fileID: 605581071}
   - component: {fileID: 605581070}
   - component: {fileID: 605581072}
-  - component: {fileID: 605581073}
   m_Layer: 0
   m_Name: Sun (directional light)
   m_TagString: Untagged
   isDoubleSided: 0
   areaLightLength: 0
   areaLightWidth: 0
---- !u!114 &605581073
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 605581069}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 97f65a78ace4fbf4187144e9fe724009, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  worldRayleighColorRamp:
-    serializedVersion: 2
-    key0: {r: 0.3019608, g: 0.4, b: 0.6, a: 1}
-    key1: {r: 0.5019608, g: 0.6, b: 0.8, a: 1}
-    key2: {r: 0, g: 0, b: 0, a: 0}
-    key3: {r: 0, g: 0, b: 0, a: 0}
-    key4: {r: 0, g: 0, b: 0, a: 0}
-    key5: {r: 0, g: 0, b: 0, a: 0}
-    key6: {r: 0, g: 0, b: 0, a: 0}
-    key7: {r: 0, g: 0, b: 0, a: 0}
-    ctime0: 0
-    ctime1: 65535
-    ctime2: 0
-    ctime3: 0
-    ctime4: 0
-    ctime5: 0
-    ctime6: 0
-    ctime7: 0
-    atime0: 0
-    atime1: 65535
-    atime2: 0
-    atime3: 0
-    atime4: 0
-    atime5: 0
-    atime6: 0
-    atime7: 0
-    m_Mode: 0
-    m_NumColorKeys: 2
-    m_NumAlphaKeys: 2
-  worldRayleighColorIntensity: 1
-  worldRayleighDensity: 10
-  worldRayleighExtinctionFactor: 1.1
-  worldRayleighIndirectScatter: 0.33
-  worldMieColorRamp:
-    serializedVersion: 2
-    key0: {r: 0.9490196, g: 0.7490196, b: 0.5019608, a: 1}
-    key1: {r: 1, g: 0.9019608, b: 1, a: 1}
-    key2: {r: 0, g: 0, b: 0, a: 0}
-    key3: {r: 0, g: 0, b: 0, a: 0}
-    key4: {r: 0, g: 0, b: 0, a: 0}
-    key5: {r: 0, g: 0, b: 0, a: 0}
-    key6: {r: 0, g: 0, b: 0, a: 0}
-    key7: {r: 0, g: 0, b: 0, a: 0}
-    ctime0: 0
-    ctime1: 65535
-    ctime2: 0
-    ctime3: 0
-    ctime4: 0
-    ctime5: 0
-    ctime6: 0
-    ctime7: 0
-    atime0: 0
-    atime1: 65535
-    atime2: 0
-    atime3: 0
-    atime4: 0
-    atime5: 0
-    atime6: 0
-    atime7: 0
-    m_Mode: 0
-    m_NumColorKeys: 2
-    m_NumAlphaKeys: 2
-  worldMieColorIntensity: 1
-  worldMieDensity: 15
-  worldMieExtinctionFactor: 0
-  worldMiePhaseAnisotropy: 0.9
-  worldNearScatterPush: 0
-  worldNormalDistance: 1000
-  heightRayleighColor: {r: 1, g: 1, b: 1, a: 1}
-  heightRayleighIntensity: 1
-  heightRayleighDensity: 10
-  heightMieDensity: 0
-  heightExtinctionFactor: 1.1
-  heightSeaLevel: 0
-  heightDistance: 50
-  heightPlaneShift: {x: 0, y: 0, z: 0}
-  heightNearScatterPush: 0
-  heightNormalDistance: 1000
-  atmosphericShaderOverride: {fileID: 0}
-  worldScaleExponent: 1
-  depthTexture: 0
-  debugMode: 0
 --- !u!1 &609148480
 GameObject:
   m_ObjectHideFlags: 0

ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 5.6.0a6
+m_EditorVersion: 5.6.0b1

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/Resources/SkyProcedural.shader

+Shader "Hidden/HDRenderLoop/SkyProcedural"
+{
+    SubShader
+    {
+        Pass
+        {
+            ZWrite Off
+            ZTest LEqual
+            Blend One Zero
+
+            HLSLPROGRAM
+            #pragma target 5.0
+            #pragma only_renderers d3d11 // TEMP: unitl we go futher in dev
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #pragma multi_compile _ ATMOSPHERICS_DEBUG
+            #pragma multi_compile _ ATMOSPHERICS_OCCLUSION_FULLSKY
+            #pragma multi_compile _ PERFORM_SKY_OCCLUSION_TEST
+
+            #ifndef PERFORM_SKY_OCCLUSION_TEST
+                #define IS_RENDERING_SKY
+            #endif
+
+            #include "Color.hlsl"
+            #include "Common.hlsl"
+            #include "CommonLighting.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
+            #include "AtmosphericScattering.hlsl"
+
+            TEXTURECUBE(_Cubemap);
+            SAMPLERCUBE(sampler_Cubemap);
+
+            float4x4 _InvViewProjMatrix;
+            float4   _SkyParam; // x exposure, y multiplier, z rotation
+
+            struct Attributes
+            {
+                float3 positionCS : POSITION;
+                float3 eyeVector : NORMAL;
+            };
+
+            struct Varyings
+            {
+                float4 positionCS : SV_POSITION;
+                float3 eyeVector : TEXCOORD0;
+            };
+
+            Varyings Vert(Attributes input)
+            {
+                // TODO: implement SV_vertexID full screen quad
+                Varyings output;
+                output.positionCS = float4(input.positionCS.xy, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
+                output.eyeVector  = input.eyeVector;
+
+                return output;
+            }
+
+            float4 Frag(Varyings input) : SV_Target
+            {
+                float3 dir = normalize(input.eyeVector);
+
+                // Rotate direction
+                float phi = DegToRad(_SkyParam.z);
+                float cosPhi, sinPhi;
+                sincos(phi, sinPhi, cosPhi);
+                float3 rotDirX = float3(cosPhi, 0, -sinPhi);
+                float3 rotDirY = float3(sinPhi, 0, cosPhi);
+                dir = float3(dot(rotDirX, dir), dir.y, dot(rotDirY, dir));
+
+                Coordinate coord = GetCoordinate(input.positionCS.xy, _ScreenSize.zw);
+
+                // If the sky box is too far away (depth set to 0), the resulting look is too foggy.
+                const float skyDepth = 0.01;
+
+                #ifdef PERFORM_SKY_OCCLUSION_TEST
+                    // Determine whether the sky is occluded by the scene geometry.
+                    // Do not perform blending with the environment map if the sky is occluded.
+                    float rawDepth     = max(skyDepth, LOAD_TEXTURE2D(_CameraDepthTexture, coord.unPositionSS).r);
+                    float skyTexWeight = (rawDepth > skyDepth) ? 0.0 : 1.0;
+                #else
+                    float rawDepth     = skyDepth;
+                    float skyTexWeight = 1.0;
+                #endif
+
+                float3 positionWS = UnprojectToWorld(rawDepth, coord.positionSS, _InvViewProjMatrix);
+
+                float4 c1, c2, c3;
+                VolundTransferScatter(positionWS, c1, c2, c3);
+
+                float4 coord1 = float4(c1.rgb + c3.rgb, max(0.f, 1.f - c1.a - c3.a));
+                float3 coord2 = c2.rgb;
+
+                float sunCos = dot(normalize(dir), _SunDirection);
+                float miePh  = MiePhase(sunCos, _MiePhaseAnisotropy);
+
+                float2 occlusion  = float2(1.0, 1.0); // TODO.
+                float  extinction = coord1.a;
+                float3 scatter    = coord1.rgb * occlusion.x + coord2 * miePh * occlusion.y;
+
+                #ifdef ATMOSPHERICS_DEBUG
+                    switch (_AtmosphericsDebugMode)
+                    {
+                        case ATMOSPHERICS_DBG_RAYLEIGH:           return c1;
+                        case ATMOSPHERICS_DBG_MIE:                return c2 * miePh;
+                        case ATMOSPHERICS_DBG_HEIGHT:             return c3;
+                        case ATMOSPHERICS_DBG_SCATTERING:         return float4(scatter, 0.0);
+                        case ATMOSPHERICS_DBG_OCCLUSION:          return float4(occlusion.xy, 0.0, 0.0);
+                        case ATMOSPHERICS_DBG_OCCLUDEDSCATTERING: return float4(scatter, 0.0);
+                    }
+                #endif
+
+                float3 skyColor = ClampToFloat16Max(SAMPLE_TEXTURECUBE_LOD(_Cubemap, sampler_Cubemap, dir, 0).rgb * exp2(_SkyParam.x) * _SkyParam.y);
+
+                // Apply extinction to the scene color when performing alpha-blending.
+                return float4(skyColor * (skyTexWeight * extinction) + scatter, extinction);
+            }
+
+            ENDHLSL
+        }
+
+    }
+    Fallback Off
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/Resources/SkyProcedural.shader.meta

+fileFormatVersion: 2
+guid: f96d105ca709d5c499b4886b48313d60
+timeCreated: 1481041226
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: