Merge remote-tracking branch 'refs/remotes/origin/master' into specular-occlusion

# Conflicts:
#	ScriptableRenderPipeline/Core/ShaderLibrary/CommonLighting.hlsl

ScriptableRenderPipeline/Core/Camera/FreeCamera.cs

+using System.Collections;
+using System.Collections.Generic;
+    [ExecuteInEditMode]
     public class FreeCamera : MonoBehaviour
     {
         public float m_LookSpeedController = 120f;
         private static string kRightStickY = "Controller Right Stick Y";
         private static string kVertical = "Vertical";
         private static string kHorizontal = "Horizontal";
-        private string[] m_RequiredInputAxes = { kMouseX, kMouseY, kRightStickX, kRightStickY, kVertical, kHorizontal };
-        private bool m_Valid = true;
-            m_Valid = Debugging.CheckRequiredInputAxisMapping(m_RequiredInputAxes);
+            RegisterInputs();
+        }
+
+        void RegisterInputs()
+        {
+#if UNITY_EDITOR
+            List <InputManagerEntry> inputEntries = new List<InputManagerEntry>();
+
+            // Add new bindings
+            inputEntries.Add(new InputManagerEntry { name = kRightStickX, kind = InputManagerEntry.Kind.Axis, axis = InputManagerEntry.Axis.Fourth, sensitivity = 1.0f, gravity = 1.0f, deadZone = 0.2f });
+            inputEntries.Add(new InputManagerEntry { name = kRightStickY, kind = InputManagerEntry.Kind.Axis, axis = InputManagerEntry.Axis.Fifth, sensitivity = 1.0f, gravity = 1.0f, deadZone = 0.2f, invert = true });
+
+            InputRegistering.RegisterInputs(inputEntries);
+#endif
-            if (m_Valid)
+            float inputRotateAxisX = 0.0f;
+            float inputRotateAxisY = 0.0f;
+            if (Input.GetMouseButton(1))
-                float inputRotateAxisX = 0.0f;
-                float inputRotateAxisY = 0.0f;
-                if (Input.GetMouseButton(1))
-                {
-                    inputRotateAxisX = Input.GetAxis(kMouseX) * m_LookSpeedMouse;
-                    inputRotateAxisY = Input.GetAxis(kMouseY) * m_LookSpeedMouse;
-                }
-                inputRotateAxisX += (Input.GetAxis(kRightStickX) * m_LookSpeedController * Time.deltaTime);
-                inputRotateAxisY += (Input.GetAxis(kRightStickY) * m_LookSpeedController * Time.deltaTime);
+                inputRotateAxisX = Input.GetAxis(kMouseX) * m_LookSpeedMouse;
+                inputRotateAxisY = Input.GetAxis(kMouseY) * m_LookSpeedMouse;
+            }
+            inputRotateAxisX += (Input.GetAxis(kRightStickX) * m_LookSpeedController * Time.deltaTime);
+            inputRotateAxisY += (Input.GetAxis(kRightStickY) * m_LookSpeedController * Time.deltaTime);
-                float inputVertical = Input.GetAxis(kVertical);
-                float inputHorizontal = Input.GetAxis(kHorizontal);
+            float inputVertical = Input.GetAxis(kVertical);
+            float inputHorizontal = Input.GetAxis(kHorizontal);
-                bool moved = inputRotateAxisX != 0.0f || inputRotateAxisY != 0.0f || inputVertical != 0.0f || inputHorizontal != 0.0f;
-                if (moved)
-                {
-                    float rotationX = transform.localEulerAngles.x;
-                    float newRotationY = transform.localEulerAngles.y + inputRotateAxisX;
+            bool moved = inputRotateAxisX != 0.0f || inputRotateAxisY != 0.0f || inputVertical != 0.0f || inputHorizontal != 0.0f;
+            if (moved)
+            {
+                float rotationX = transform.localEulerAngles.x;
+                float newRotationY = transform.localEulerAngles.y + inputRotateAxisX;
-                    // Weird clamping code due to weird Euler angle mapping...
-                    float newRotationX = (rotationX - inputRotateAxisY);
-                    if (rotationX <= 90.0f && newRotationX >= 0.0f)
-                        newRotationX = Mathf.Clamp(newRotationX, 0.0f, 90.0f);
-                    if (rotationX >= 270.0f)
-                        newRotationX = Mathf.Clamp(newRotationX, 270.0f, 360.0f);
+                // Weird clamping code due to weird Euler angle mapping...
+                float newRotationX = (rotationX - inputRotateAxisY);
+                if (rotationX <= 90.0f && newRotationX >= 0.0f)
+                    newRotationX = Mathf.Clamp(newRotationX, 0.0f, 90.0f);
+                if (rotationX >= 270.0f)
+                    newRotationX = Mathf.Clamp(newRotationX, 270.0f, 360.0f);
-                    transform.localRotation = Quaternion.Euler(newRotationX, newRotationY, transform.localEulerAngles.z);
+                transform.localRotation = Quaternion.Euler(newRotationX, newRotationY, transform.localEulerAngles.z);
-                    float moveSpeed = Time.deltaTime * m_MoveSpeed;
-                    if (Input.GetMouseButton(1))
-                        moveSpeed *= Input.GetKey(KeyCode.LeftShift) ? m_Turbo : 1.0f;
-                    else
-                        moveSpeed *= Input.GetAxis("Fire1") > 0.0f ? m_Turbo : 1.0f;
-                    transform.position += transform.forward * moveSpeed * inputVertical;
-                    transform.position += transform.right * moveSpeed * inputHorizontal;
-                }
+                float moveSpeed = Time.deltaTime * m_MoveSpeed;
+                if (Input.GetMouseButton(1))
+                    moveSpeed *= Input.GetKey(KeyCode.LeftShift) ? m_Turbo : 1.0f;
+                else
+                    moveSpeed *= Input.GetAxis("Fire1") > 0.0f ? m_Turbo : 1.0f;
+                transform.position += transform.forward * moveSpeed * inputVertical;
+                transform.position += transform.right * moveSpeed * inputHorizontal;
             }
         }
     }

ScriptableRenderPipeline/Core/Debugging/DebugActionManager.cs

         void RegisterInputs()
         {
 #if UNITY_EDITOR
-            // Grab reference to input manager
-            var currentSelection = UnityEditor.Selection.activeObject;
-            UnityEditor.EditorApplication.ExecuteMenuItem("Edit/Project Settings/Input");
-            var inputManager = UnityEditor.Selection.activeObject;
-
-            // Wrap in serialized object
-            var soInputManager = new UnityEditor.SerializedObject(inputManager);
-            var spAxes = soInputManager.FindProperty("m_Axes");
+            List <InputManagerEntry > inputEntries = new List<InputManagerEntry>();
-            new InputManagerEntry { name = kEnableDebugBtn1, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "left ctrl", altBtnPositive = "joystick button 8" }.WriteEntry(spAxes);
-            new InputManagerEntry { name = kEnableDebugBtn2, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "backspace", altBtnPositive = "joystick button 9" }.WriteEntry(spAxes);
-
-            new InputManagerEntry { name = kDebugNextBtn, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "page down", altBtnPositive = "joystick button 5" }.WriteEntry(spAxes);
-            new InputManagerEntry { name = kDebugPreviousBtn, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "page up", altBtnPositive = "joystick button 4" }.WriteEntry(spAxes);
-
-            new InputManagerEntry { name = kDPadHorizontal, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "right", btnNegative = "left", gravity = 1000.0f, deadZone = 0.001f, sensitivity = 1000.0f }.WriteEntry(spAxes);
-            new InputManagerEntry { name = kDPadHorizontal, kind = InputManagerEntry.Kind.Axis, axis = InputManagerEntry.Axis.Sixth, btnPositive = "right", btnNegative = "left", gravity = 1000.0f, deadZone = 0.001f, sensitivity = 1000.0f }.WriteEntry(spAxes);
-            new InputManagerEntry { name = kDPadVertical, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "up", btnNegative = "down", gravity = 1000.0f, deadZone = 0.001f, sensitivity = 1000.0f }.WriteEntry(spAxes);
-            new InputManagerEntry { name = kDPadVertical, kind = InputManagerEntry.Kind.Axis, axis = InputManagerEntry.Axis.Seventh, btnPositive = "up", btnNegative = "down", gravity = 1000.0f, deadZone = 0.001f, sensitivity = 1000.0f }.WriteEntry(spAxes);
-
-            new InputManagerEntry { name = kValidateBtn, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "return", altBtnPositive = "joystick button 0" }.WriteEntry(spAxes);
-            new InputManagerEntry { name = kPersistentBtn, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "right shift", altBtnPositive = "joystick button 2" }.WriteEntry(spAxes);
+            inputEntries.Add(new InputManagerEntry { name = kEnableDebugBtn1, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "left ctrl", altBtnPositive = "joystick button 8" });
+            inputEntries.Add(new InputManagerEntry { name = kEnableDebugBtn2, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "backspace", altBtnPositive = "joystick button 9" });
+            
+            inputEntries.Add(new InputManagerEntry { name = kDebugNextBtn, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "page down", altBtnPositive = "joystick button 5" });
+            inputEntries.Add(new InputManagerEntry { name = kDebugPreviousBtn, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "page up", altBtnPositive = "joystick button 4" });
-            // Commit
-            soInputManager.ApplyModifiedProperties();
+            inputEntries.Add(new InputManagerEntry { name = kDPadHorizontal, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "right", btnNegative = "left", gravity = 1000.0f, deadZone = 0.001f, sensitivity = 1000.0f });
+            inputEntries.Add(new InputManagerEntry { name = kDPadHorizontal, kind = InputManagerEntry.Kind.Axis, axis = InputManagerEntry.Axis.Sixth, btnPositive = "right", btnNegative = "left", gravity = 1000.0f, deadZone = 0.001f, sensitivity = 1000.0f });
+            inputEntries.Add(new InputManagerEntry { name = kDPadVertical, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "up", btnNegative = "down", gravity = 1000.0f, deadZone = 0.001f, sensitivity = 1000.0f });
+            inputEntries.Add(new InputManagerEntry { name = kDPadVertical, kind = InputManagerEntry.Kind.Axis, axis = InputManagerEntry.Axis.Seventh, btnPositive = "up", btnNegative = "down", gravity = 1000.0f, deadZone = 0.001f, sensitivity = 1000.0f });
+            
+            inputEntries.Add(new InputManagerEntry { name = kValidateBtn, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "return", altBtnPositive = "joystick button 0" });
+            inputEntries.Add(new InputManagerEntry { name = kPersistentBtn, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "right shift", altBtnPositive = "joystick button 2" });
-            UnityEditor.Selection.activeObject = currentSelection;
+            InputRegistering.RegisterInputs(inputEntries);
-
-
-#if UNITY_EDITOR
-        class InputManagerEntry
-        {
-            public enum Kind { KeyOrButton, Mouse, Axis }
-            public enum Axis { X, Y, Third, Fourth, Fifth, Sixth, Seventh, Eigth }
-            public enum Joy { All, First, Second }
-
-            public string	name = "";
-            public string	desc = "";
-            public string	btnNegative = "";
-            public string	btnPositive = "";
-            public string	altBtnNegative = "";
-            public string	altBtnPositive = "";
-            public float	gravity = 0.0f;
-            public float	deadZone = 0.0f;
-            public float	sensitivity = 0.0f;
-            public bool		snap = false;
-            public bool		invert = false;
-            public Kind		kind = Kind.Axis;
-            public Axis		axis = Axis.X;
-            public Joy		joystick = Joy.All;
-
-            bool InputAlreadyRegistered(string name, Kind kind, UnityEditor.SerializedProperty spAxes)
-            {
-                for (var i = 0; i < spAxes.arraySize; ++i )
-                {
-                    var spAxis = spAxes.GetArrayElementAtIndex(i);
-                    var axisName = spAxis.FindPropertyRelative("m_Name").stringValue;
-                    var kindValue = spAxis.FindPropertyRelative("type").intValue;
-                    if (axisName == name && (int)kind == kindValue)
-                        return true;
-                }
-
-                return false;
-            }
-
-            public void WriteEntry(UnityEditor.SerializedProperty spAxes)
-            {
-                if(InputAlreadyRegistered(name, kind, spAxes))
-                    return;
-
-                spAxes.InsertArrayElementAtIndex(spAxes.arraySize);
-                var spAxis = spAxes.GetArrayElementAtIndex(spAxes.arraySize - 1);
-                spAxis.FindPropertyRelative("m_Name").stringValue = name;
-                spAxis.FindPropertyRelative("descriptiveName").stringValue = desc;
-                spAxis.FindPropertyRelative("negativeButton").stringValue = btnNegative;
-                spAxis.FindPropertyRelative("altNegativeButton").stringValue = altBtnNegative;
-                spAxis.FindPropertyRelative("positiveButton").stringValue = btnPositive;
-                spAxis.FindPropertyRelative("altPositiveButton").stringValue = altBtnPositive;
-                spAxis.FindPropertyRelative("gravity").floatValue = gravity;
-                spAxis.FindPropertyRelative("dead").floatValue = deadZone;
-                spAxis.FindPropertyRelative("sensitivity").floatValue = sensitivity;
-                spAxis.FindPropertyRelative("snap").boolValue = snap;
-                spAxis.FindPropertyRelative("invert").boolValue = invert;
-                spAxis.FindPropertyRelative("type").intValue = (int)kind;
-                spAxis.FindPropertyRelative("axis").intValue = (int)axis;
-                spAxis.FindPropertyRelative("joyNum").intValue = (int)joystick;
-            }
-        }
-#endif
     }
 }

ScriptableRenderPipeline/Core/ShaderLibrary/CommonLighting.hlsl

 }
 
 // Ref: Moving Frostbite to PBR - Gotanda siggraph 2011
-float GetSpecularOcclusion(float NdotV, float ambientOcclusion, float roughness)
+// Return specular occlusion based on ambient occlusion (usually get from SSAO) and view/roughness info
+float SpecularOcclusionFromAmbientOcclusion(float NdotV, float ambientOcclusion, float roughness)
+}
+
+// ref: Practical Realtime Strategies for Accurate Indirect Occlusion
+// Update ambient occlusion to colored ambient occlusion based on statitics of how light is bouncing in an object and with the albedo of the object
+float3 GTAOMultiBounce(float visibility, float3 albedo)
+{
+    float3 a =  2.0404 * albedo - 0.3324;
+    float3 b = -4.7951 * albedo + 0.6417;
+    float3 c =  2.7552 * albedo + 0.6903;
+
+    float x = visibility;
+    return max(x, ((x * a + b) * x + c) * x);
 }
 
 // Based on Oat and Sander's 2008 technique

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.hlsl

 
 struct LightLoopContext
 {
-    // Visible from Material
-    float ambientOcclusion;
+    // Visible from Material - these values are expected in any LightLoopContext
+    float indirectAmbientOcclusion; // Ambient occlusion use for indirect lighting (reflection probe, baked diffuse lighting)
+    float directAmbientOcclusion;   // Ambient occlusion use for direct lighting (directional, punctual, area)
-    // Not visible from Material (user should not use these properties in Material)
+    // Not visible from Material (user should not use these properties in Material file)
+};
+
+// Store all the accumulated lighting produce by the light loop
+struct LightLoopAccumulatedLighting
+{
+    float3 dirDiffuseLighting;
+    float3 dirSpecularLighting;
+
+    float3 punctualDiffuseLighting;
+    float3 punctualSpecularLighting;
+
+    float3 areaDiffuseLighting;
+    float3 areaSpecularLighting;
+
+    float3 envDiffuseLighting;
+    float3 envSpecularLighting;
 };
 
 //-----------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

     totalIblWeight = saturate(accumulatedWeight);
     weight.y -= saturate(accumulatedWeight - totalIblWeight);
 
-    // TODO: We do'nt use ibl diffuse lighting currently, let here in case users want to use it.
-    // iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x);
+    iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x);
-void LightLoop( float3 V, PositionInputs posInput, PreLightData prelightData, BSDFData bsdfData, float3 bakeDiffuseLighting, uint featureFlags,
+void LightLoop( float3 V, PositionInputs posInput, PreLightData preLightData, BSDFData bsdfData, float3 bakeDiffuseLighting, uint featureFlags,
                 out float3 diffuseLighting,
                 out float3 specularLighting)
 {
     // We store inverse AO so neutral is black. So either we sample inside or outside the texture it return 0 in case of neutral
-    context.ambientOcclusion = 1.0 - LOAD_TEXTURE2D(_AmbientOcclusionTexture, posInput.unPositionSS).x;
+    context.indirectAmbientOcclusion = 1.0 - LOAD_TEXTURE2D(_AmbientOcclusionTexture, posInput.unPositionSS).x;
+    context.directAmbientOcclusion = lerp(1.0, context.indirectAmbientOcclusion, _AmbientOcclusionDirectLightStrenght);
-    diffuseLighting = float3(0.0, 0.0, 0.0);
-    specularLighting = float3(0.0, 0.0, 0.0);
+    // This struct is use to store accumulated lighting, summation is done in PostEvaluateBSDF
+    LightLoopAccumulatedLighting accLighting;
+    ZERO_INITIALIZE(LightLoopAccumulatedLighting, accLighting);
 
     uint i = 0; // Declare once to avoid the D3D11 compiler warning.
 
         {
             float3 localDiffuseLighting, localSpecularLighting;
 
-            EvaluateBSDF_Directional(context, V, posInput, prelightData, _DirectionalLightDatas[i], bsdfData,
+            EvaluateBSDF_Directional(context, V, posInput, preLightData, _DirectionalLightDatas[i], bsdfData,
-            diffuseLighting += localDiffuseLighting;
-            specularLighting += localSpecularLighting;
+            accLighting.dirDiffuseLighting += localDiffuseLighting;
+            accLighting.dirSpecularLighting += localSpecularLighting;
         }
     }
 
         {
             float3 localDiffuseLighting, localSpecularLighting;
 
-            EvaluateBSDF_Punctual(  context, V, posInput, prelightData, _LightDatas[FetchIndex(punctualLightStart, i)], bsdfData,
+            EvaluateBSDF_Punctual(  context, V, posInput, preLightData, _LightDatas[FetchIndex(punctualLightStart, i)], bsdfData,
-            diffuseLighting += localDiffuseLighting;
-            specularLighting += localSpecularLighting;
+            accLighting.punctualDiffuseLighting += localDiffuseLighting;
+            accLighting.punctualSpecularLighting += localSpecularLighting;
         }
 
         #else
             float3 localDiffuseLighting, localSpecularLighting;
 
-            EvaluateBSDF_Punctual(  context, V, posInput, prelightData, _LightDatas[i], bsdfData,
+            EvaluateBSDF_Punctual(  context, V, posInput, preLightData, _LightDatas[i], bsdfData,
-            diffuseLighting += localDiffuseLighting;
-            specularLighting += localSpecularLighting;
+            accLighting.punctualDiffuseLighting += localDiffuseLighting;
+            accLighting.punctualSpecularLighting += localSpecularLighting;
         }
 
         #endif
     {
-        float3 localDiffuseLighting, localSpecularLighting;
-
         #ifdef LIGHTLOOP_TILE_PASS
 
         uint areaLightStart;
 
             while (i < areaLightCount && lightType == GPULIGHTTYPE_LINE)
             {
-                EvaluateBSDF_Area(  context, V, posInput, prelightData, _LightDatas[areaIndex], bsdfData, GPULIGHTTYPE_LINE,
+                float3 localDiffuseLighting, localSpecularLighting;
+
+                EvaluateBSDF_Area(  context, V, posInput, preLightData, _LightDatas[areaIndex], bsdfData, GPULIGHTTYPE_LINE,
-                diffuseLighting += localDiffuseLighting;
-                specularLighting += localSpecularLighting;
+                accLighting.areaDiffuseLighting += localDiffuseLighting;
+                accLighting.areaSpecularLighting += localSpecularLighting;
 
                 i++;
                 areaIndex = i < areaLightCount ? FetchIndex(areaLightStart, i) : 0;
             while (i < areaLightCount && lightType == GPULIGHTTYPE_RECTANGLE)
             {
-                EvaluateBSDF_Area(  context, V, posInput, prelightData, _LightDatas[areaIndex], bsdfData, GPULIGHTTYPE_RECTANGLE,
+                float3 localDiffuseLighting, localSpecularLighting;
+
+                EvaluateBSDF_Area(  context, V, posInput, preLightData, _LightDatas[areaIndex], bsdfData, GPULIGHTTYPE_RECTANGLE,
-                diffuseLighting += localDiffuseLighting;
-                specularLighting += localSpecularLighting;
+                accLighting.areaDiffuseLighting += localDiffuseLighting;
+                accLighting.areaSpecularLighting += localSpecularLighting;
 
                 i++;
                 areaIndex = i < areaLightCount ? FetchIndex(areaLightStart, i) : 0;
 
         #else
-
-            EvaluateBSDF_Area(  context, V, posInput, prelightData, _LightDatas[i], bsdfData, _LightDatas[i].lightType,
+            float3 localDiffuseLighting, localSpecularLighting;
+
+            EvaluateBSDF_Area(  context, V, posInput, preLightData, _LightDatas[i], bsdfData, _LightDatas[i].lightType,
-            diffuseLighting += localDiffuseLighting;
-            specularLighting += localSpecularLighting;
+            accLighting.areaDiffuseLighting += localDiffuseLighting;
+            accLighting.areaSpecularLighting += localSpecularLighting;
-    float3 iblDiffuseLighting  = float3(0.0, 0.0, 0.0);
-    float3 iblSpecularLighting = float3(0.0, 0.0, 0.0);
-    float  totalIblWeight      = 0.0; // Max: 1
-
-    // Reflection probes are sorted by volume (in the increasing order).
-    if (featureFlags & LIGHTFEATUREFLAGS_ENV)
+    if (featureFlags & LIGHTFEATUREFLAGS_ENV || featureFlags & LIGHTFEATUREFLAGS_SKY)
-        float3 localDiffuseLighting, localSpecularLighting;
-        float2 weight;
-        context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
-
-    #ifdef LIGHTLOOP_TILE_PASS
-        uint envLightStart;
-        uint envLightCount;
-        GetCountAndStart(posInput, LIGHTCATEGORY_ENV, envLightStart, envLightCount);
-    #else
-        uint envLightCount = _EnvLightCount;
-    #endif
+        float  totalIblWeight      = 0.0; // Max: 1
-        // Note: In case of IBL we are sorted from smaller to bigger projected solid angle bounds. We are not sorted by type so we can't do a 'while' approach like for area light.
-        for (i = 0; i < envLightCount && totalIblWeight < 1.0; ++i)
+        // Reflection probes are sorted by volume (in the increasing order).
+        if (featureFlags & LIGHTFEATUREFLAGS_ENV)
+            float3 localDiffuseLighting, localSpecularLighting;
+            float2 weight;
+            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
+
-            uint envLightIndex = FetchIndex(envLightStart, i);
+            uint envLightStart;
+            uint envLightCount;
+            GetCountAndStart(posInput, LIGHTCATEGORY_ENV, envLightStart, envLightCount);
-            uint envLightIndex = i;
+            uint envLightCount = _EnvLightCount;
-            EvaluateBSDF_Env(context, V, posInput, prelightData, _EnvLightDatas[envLightIndex], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
-            applyWeigthedIblLighting(localDiffuseLighting, localSpecularLighting, weight, iblDiffuseLighting, iblSpecularLighting, totalIblWeight);
+
+            // Note: In case of IBL we are sorted from smaller to bigger projected solid angle bounds. We are not sorted by type so we can't do a 'while' approach like for area light.
+            for (i = 0; i < envLightCount && totalIblWeight < 1.0; ++i)
+            {
+            #ifdef LIGHTLOOP_TILE_PASS
+                uint envLightIndex = FetchIndex(envLightStart, i);
+            #else
+                uint envLightIndex = i;
+            #endif
+                EvaluateBSDF_Env(context, V, posInput, preLightData, _EnvLightDatas[envLightIndex], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+                applyWeigthedIblLighting(localDiffuseLighting, localSpecularLighting, weight, accLighting.envDiffuseLighting, accLighting.envSpecularLighting, totalIblWeight);
+            }
-    }
-    if (featureFlags & LIGHTFEATUREFLAGS_SKY)
-    {
-        // Only apply the sky IBL if the sky texture is available, and if we haven't yet accumulated enough IBL lighting.
-        if (_EnvLightSkyEnabled && totalIblWeight < 1.0)
+        if (featureFlags & LIGHTFEATUREFLAGS_SKY)
-            float3 localDiffuseLighting, localSpecularLighting;
-            float2 weight;
+            // Only apply the sky IBL if the sky texture is available, and if we haven't yet accumulated enough IBL lighting.
+            if (_EnvLightSkyEnabled && totalIblWeight < 1.0)
+            {
+                float3 localDiffuseLighting, localSpecularLighting;
+                float2 weight;
-            // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
-            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
-            EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
-            EvaluateBSDF_Env(context, V, posInput, prelightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
-            applyWeigthedIblLighting(localDiffuseLighting, localSpecularLighting, weight, iblDiffuseLighting, iblSpecularLighting, totalIblWeight);
+                // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
+                context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
+                EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
+                EvaluateBSDF_Env(context, V, posInput, preLightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+                applyWeigthedIblLighting(localDiffuseLighting, localSpecularLighting, weight, accLighting.envDiffuseLighting, accLighting.envSpecularLighting, totalIblWeight);
+            }
-    // Apply ambient occlusion on direct lighting based on strenght factor
-    diffuseLighting *= lerp(1.0, context.ambientOcclusion, _AmbientOcclusionDirectLightStrenght);
-
-    diffuseLighting += iblDiffuseLighting;
-    specularLighting += iblSpecularLighting;
-
-    // Apply GI at the same time as reflection
-    // Add indirect diffuse + emissive (if any) - Ambient occlusion is multiply by emissive which is wrong but not a big deal
-    diffuseLighting += bakeDiffuseLighting * context.ambientOcclusion;
+    // Also Apply indiret diffuse (GI)
+    // PostEvaluateBSDF will perform any operation wanted by the material and sum everything into diffuseLighting and specularLighting
+    PostEvaluateBSDF(   context, preLightData, bsdfData, accLighting, bakeDiffuseLighting,
+                        diffuseLighting, specularLighting);
 
     ApplyDebug(context, posInput.positionWS, diffuseLighting, specularLighting);
 }

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 // EvaluateBSDF_Directional (supports directional and box projector lights)
 //-----------------------------------------------------------------------------
 
-float4 EvaluateCookie_Directional(LightLoopContext context, DirectionalLightData lightData,
+float4 EvaluateCookie_Directional(LightLoopContext lightLoopContext, DirectionalLightData lightData,
                                   float3 lighToSample)
 {
     // Compute the NDC position (in [-1, 1]^2) by projecting 'positionWS' onto the near plane.
 
     // We let the sampler handle tiling or clamping to border.
     // Note: tiling (the repeat mode) is not currently supported.
-    float4 cookie = SampleCookie2D(context, coord, lightData.cookieIndex);
+    float4 cookie = SampleCookie2D(lightLoopContext, coord, lightData.cookieIndex);
 
     cookie.a = isInBounds ? cookie.a : 0;
 
 // EvaluateBSDF_Punctual (supports spot, point and projector lights)
 //-----------------------------------------------------------------------------
 
-float4 EvaluateCookie_Punctual(LightLoopContext context, LightData lightData,
+float4 EvaluateCookie_Punctual(LightLoopContext lightLoopContext, LightData lightData,
                                float3 lighToSample)
 {
     int lightType = lightData.lightType;
 
     [branch] if (lightType == GPULIGHTTYPE_POINT)
     {
-        cookie = SampleCookieCube(context, positionLS, lightData.cookieIndex);
+        cookie = SampleCookieCube(lightLoopContext, positionLS, lightData.cookieIndex);
     }
     else
     {
         float2 coord = positionNDC * 0.5 + 0.5;
 
         // We let the sampler handle clamping to border.
-        cookie   = SampleCookie2D(context, coord, lightData.cookieIndex);
+        cookie = SampleCookie2D(lightLoopContext, coord, lightData.cookieIndex);
         cookie.a = isInBounds ? cookie.a : 0;
     }
 
         F = Sqr(-F * bsdfData.coatCoverage + 1.0);
     }
 
-    // TODO: we must always perform a weight calculation as due to tiled rendering we need to smooth out cubemap at boundaries.
-    // So goal is to split into two category and have an option to say if we parallax correct or not.
-
-    // Apply specular occlusion on it
-    specularLighting *= bsdfData.specularOcclusion * GetSpecularOcclusion(preLightData.NdotV, lightLoopContext.ambientOcclusion, bsdfData.roughness);
+
+//-----------------------------------------------------------------------------
+// PostEvaluateBSDF
+// ----------------------------------------------------------------------------
+
+void PostEvaluateBSDF(  LightLoopContext lightLoopContext, PreLightData preLightData, BSDFData bsdfData, LightLoopAccumulatedLighting accLighting, float3 bakeDiffuseLighting,
+                        out float3 diffuseLighting, out float3 specularLighting)
+{
+    // Add indirect diffuse + emissive (if any) - Ambient occlusion is multiply by emissive which is wrong but not a big deal
+    bakeDiffuseLighting *= GTAOMultiBounce(lightLoopContext.indirectAmbientOcclusion, bsdfData.diffuseColor);
+
+    float specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(preLightData.NdotV, lightLoopContext.indirectAmbientOcclusion, bsdfData.roughness);
+    // Try to mimic multibounce with specular color. Not the point of the original formula but ok result.
+    accLighting.envSpecularLighting *= bsdfData.specularOcclusion * GTAOMultiBounce(specularOcclusion, bsdfData.fresnel0);
+
+    // TODO: we could call a function like PostBSDF that will apply albedo and divide by PI once for the loop
+
+    // envDiffuseLighting is not used in our case
+    diffuseLighting = (accLighting.dirDiffuseLighting + accLighting.punctualDiffuseLighting + accLighting.areaDiffuseLighting) * GTAOMultiBounce(lightLoopContext.directAmbientOcclusion, bsdfData.diffuseColor) + bakeDiffuseLighting;
+    specularLighting = accLighting.dirSpecularLighting + accLighting.punctualSpecularLighting + accLighting.areaSpecularLighting + accLighting.envSpecularLighting;
+}
+
 
 #endif // #ifdef HAS_LIGHTLOOP

ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/Resources/AtmosphericScattering.hlsl

 uniform float       _MiePhaseAnisotropy;
 uniform float       _MieExtinctionFactor;
 
-SAMPLER2D(sampler_MainDepthTexture);
-TEXTURE2D_FLOAT(_MainDepthTexture);
 TEXTURE2D(_OcclusionTexture);
 
 float HenyeyGreensteinPhase(float g, float cosTheta) {
 
 void VolundTransferScatter(float3 worldPos, out float4 coords1, out float4 coords2, out float4 coords3) {
     const float3 scaledWorldPos = WorldScale(worldPos);
-    const float3 worldCamPos = WorldScale(_CameraPosWS.xyz);
+    const float3 worldCamPos = WorldScale(_WorldSpaceCameraPos.xyz);
 
     const float c_MieScaleHeight = 1200.f;
     const float worldRayleighDensity = 1.f;
     const float worldVecLen = length(worldVec);
     const float3 worldDir = worldVec / worldVecLen;
 
-    const float3 worldDirUnscaled = normalize(worldPos - _CameraPosWS.xyz);
+    const float3 worldDirUnscaled = normalize(worldPos - _WorldSpaceCameraPos.xyz);
 
     const float viewSunCos = dot(worldDirUnscaled, _SunDirection);
     const float rayleighPh = min(1.f, RayleighPhase(viewSunCos) * 12.f);

ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/Resources/SkyProcedural.shader

             #pragma multi_compile _ ATMOSPHERICS_DEBUG
             #pragma multi_compile _ PERFORM_SKY_OCCLUSION_TEST
 
-            #include "../../../ShaderConfig.cs.hlsl"
+            #include "../../../ShaderVariables.hlsl"
-            // x exposure, y multiplier, z rotation
-            float4 _SkyParam;
-
-            // x = width, y = height, z = 1.0/width, w = 1.0/height
-            float4 _ScreenSize;
-
-            float4 _CameraPosWS;
-
-            float4x4 _InvViewProjMatrix;
-
-            float _SkyDepth;
-
-            float _DisableSkyOcclusionTest;
+            // x exposure, y multiplier, z rotation
+            float4   _SkyParam;
+            float    _SkyDepth;
+            float    _DisableSkyOcclusionTest;
-
 
             struct Attributes
             {
                 Varyings output;
                 output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID, UNITY_RAW_FAR_CLIP_VALUE);
                 return output;
-            }
-
-            float3 GetAbsolutePositionWS(float3 cameraRelativePositionWS)
-            {
-                float3 pos = cameraRelativePositionWS;
-            #if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
-                pos += _CameraPosWS;
-            #endif
-                return pos;
             }
 
             float4 Frag(Varyings input) : SV_Target

ScriptableRenderPipeline/Core/Inputs.meta

+fileFormatVersion: 2
+guid: edb108228f2caa44ca8154fd4985e101
+folderAsset: yes
+timeCreated: 1504859102
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/Core/Inputs/InputRegistering.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEngine.Experimental
+{
+#if UNITY_EDITOR
+    public class InputManagerEntry
+    {
+        public enum Kind { KeyOrButton, Mouse, Axis }
+        public enum Axis { X, Y, Third, Fourth, Fifth, Sixth, Seventh, Eigth }
+        public enum Joy { All, First, Second }
+
+        public string	name = "";
+        public string	desc = "";
+        public string	btnNegative = "";
+        public string	btnPositive = "";
+        public string	altBtnNegative = "";
+        public string	altBtnPositive = "";
+        public float	gravity = 0.0f;
+        public float	deadZone = 0.0f;
+        public float	sensitivity = 0.0f;
+        public bool		snap = false;
+        public bool		invert = false;
+        public Kind		kind = Kind.Axis;
+        public Axis		axis = Axis.X;
+        public Joy		joystick = Joy.All;
+    }
+
+    public class InputRegistering
+    {
+
+        static bool InputAlreadyRegistered(string name, InputManagerEntry.Kind kind, UnityEditor.SerializedProperty spAxes)
+        {
+            for (var i = 0; i < spAxes.arraySize; ++i)
+            {
+                var spAxis = spAxes.GetArrayElementAtIndex(i);
+                var axisName = spAxis.FindPropertyRelative("m_Name").stringValue;
+                var kindValue = spAxis.FindPropertyRelative("type").intValue;
+                if (axisName == name && (int)kind == kindValue)
+                    return true;
+            }
+
+            return false;
+        }
+
+        static void WriteEntry(UnityEditor.SerializedProperty spAxes, InputManagerEntry entry)
+        {
+            if (InputAlreadyRegistered(entry.name, entry.kind, spAxes))
+                return;
+
+            spAxes.InsertArrayElementAtIndex(spAxes.arraySize);
+            var spAxis = spAxes.GetArrayElementAtIndex(spAxes.arraySize - 1);
+            spAxis.FindPropertyRelative("m_Name").stringValue = entry.name;
+            spAxis.FindPropertyRelative("descriptiveName").stringValue = entry.desc;
+            spAxis.FindPropertyRelative("negativeButton").stringValue = entry.btnNegative;
+            spAxis.FindPropertyRelative("altNegativeButton").stringValue = entry.altBtnNegative;
+            spAxis.FindPropertyRelative("positiveButton").stringValue = entry.btnPositive;
+            spAxis.FindPropertyRelative("altPositiveButton").stringValue = entry.altBtnPositive;
+            spAxis.FindPropertyRelative("gravity").floatValue = entry.gravity;
+            spAxis.FindPropertyRelative("dead").floatValue = entry.deadZone;
+            spAxis.FindPropertyRelative("sensitivity").floatValue = entry.sensitivity;
+            spAxis.FindPropertyRelative("snap").boolValue = entry.snap;
+            spAxis.FindPropertyRelative("invert").boolValue = entry.invert;
+            spAxis.FindPropertyRelative("type").intValue = (int)entry.kind;
+            spAxis.FindPropertyRelative("axis").intValue = (int)entry.axis;
+            spAxis.FindPropertyRelative("joyNum").intValue = (int)entry.joystick;
+        }
+
+        static public void RegisterInputs(List<InputManagerEntry> entries)
+        {
+            // Grab reference to input manager
+            var currentSelection = UnityEditor.Selection.activeObject;
+            UnityEditor.EditorApplication.ExecuteMenuItem("Edit/Project Settings/Input");
+            var inputManager = UnityEditor.Selection.activeObject;
+
+            // Wrap in serialized object
+            var soInputManager = new UnityEditor.SerializedObject(inputManager);
+            var spAxes = soInputManager.FindProperty("m_Axes");
+
+            foreach(InputManagerEntry entry in entries)
+            {
+                WriteEntry(spAxes, entry);
+            }
+
+            // Commit
+            soInputManager.ApplyModifiedProperties();
+
+            UnityEditor.Selection.activeObject = currentSelection;
+        }
+    }
+#endif
+}

ScriptableRenderPipeline/Core/Inputs/InputRegistering.cs.meta

+fileFormatVersion: 2
+guid: 130ea682941bc7e48a1cd0af4ce3844c
+timeCreated: 1504859117
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: