Merge branch 'master' of https://github.com/Unity-Technologies/ScriptableRenderPipeline

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 
                 // Broadcast SSS parameters to all shaders.
                 cmd.SetGlobalInt(HDShaderIDs._EnableSSSAndTransmission, m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission ? 1 : 0);
-                cmd.SetGlobalInt(HDShaderIDs._TexturingModeFlags, sssParameters.texturingModeFlags);
-                cmd.SetGlobalInt(HDShaderIDs._TransmissionFlags, sssParameters.transmissionFlags);
+                unsafe
+                {
+                    // Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
+                    // Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
+                    uint texturingModeFlags = sssParameters.texturingModeFlags;
+                    uint transmissionFlags  = sssParameters.transmissionFlags;
+                    cmd.SetGlobalFloat(HDShaderIDs._TexturingModeFlags, *(float*)&texturingModeFlags);
+                    cmd.SetGlobalFloat(HDShaderIDs._TransmissionFlags,  *(float*)&transmissionFlags);
+                }
                 cmd.SetGlobalVectorArray(HDShaderIDs._ThicknessRemaps,            sssParameters.thicknessRemaps);
                 cmd.SetGlobalVectorArray(HDShaderIDs._ShapeParams,                sssParameters.shapeParams);
                 cmd.SetGlobalVectorArray(HDShaderIDs._HalfRcpVariancesAndWeights, sssParameters.halfRcpVariancesAndWeights);
                     // TODO: Remove this once fix, see comment inside the function
                     hdCamera.SetupComputeShader(m_SubsurfaceScatteringCS, cmd);
 
-                    cmd.SetComputeIntParam(        m_SubsurfaceScatteringCS, HDShaderIDs._TexturingModeFlags, sssParameters.texturingModeFlags);
-                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._WorldScales,        sssParameters.worldScales);
-                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._FilterKernels,      sssParameters.filterKernels);
-                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._ShapeParams,        sssParameters.shapeParams);
+                    unsafe
+                    {
+                        // Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
+                        // Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
+                        uint texturingModeFlags = sssParameters.texturingModeFlags;
+                        cmd.SetComputeFloatParam(m_SubsurfaceScatteringCS, HDShaderIDs._TexturingModeFlags, *(float*)&texturingModeFlags);
+                    }
+
+                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._WorldScales,   sssParameters.worldScales);
+                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._FilterKernels, sssParameters.filterKernels);
+                    cmd.SetComputeVectorArrayParam(m_SubsurfaceScatteringCS, HDShaderIDs._ShapeParams,   sssParameters.shapeParams);
 
                     cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._GBufferTexture0,  m_GbufferManager.GetGBuffers()[0]);
                     cmd.SetComputeTextureParam(m_SubsurfaceScatteringCS, m_SubsurfaceScatteringKernel, HDShaderIDs._GBufferTexture1,  m_GbufferManager.GetGBuffers()[1]);

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Deferred.shader

                 LightLoop(V, posInput, preLightData, bsdfData, bakeLightingData, LIGHT_FEATURE_MASK_FLAGS_OPAQUE, diffuseLighting, specularLighting);
 
                 Outputs outputs;
+
-                outputs.specularLighting = float4(specularLighting, 1.0);
-                outputs.diffuseLighting  = TagLightingForSSS(diffuseLighting);
+                if (_EnableSSSAndTransmission != 0)
+                {
+                    outputs.specularLighting = float4(specularLighting, 1.0);
+                    outputs.diffuseLighting  = TagLightingForSSS(diffuseLighting);
+                }
+                else
+                {
+                    outputs.specularLighting = float4(diffuseLighting + specularLighting, 1.0);
+                    outputs.diffuseLighting  = 0;
+                }
             #else
                 outputs.combinedLighting = float4(diffuseLighting + specularLighting, 1.0);
             #endif

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 #define SSS_WRAP_LIGHT cos(PI/2 - SSS_WRAP_ANGLE)
 
 CBUFFER_START(UnitySSSParameters)
-uint   _EnableSSSAndTransmission;           // Globally toggles subsurface and transmission scattering on/off
-uint   _TexturingModeFlags;                 // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
-uint   _TransmissionFlags;                  // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
+// Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
+// Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
+uint   _EnableSSSAndTransmission; // Globally toggles subsurface and transmission scattering on/off
+float  _TexturingModeFlags;       // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
+float  _TransmissionFlags;        // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
 // Old SSS Model >>>
 uint   _UseDisneySSS;
 float4 _HalfRcpVariancesAndWeights[SSS_N_PROFILES][2]; // 2x Gaussians in RGB, A is interpolation weights
     bsdfData.subsurfaceRadius  = subsurfaceRadius;
     bsdfData.thickness = _ThicknessRemaps[subsurfaceProfile].x + _ThicknessRemaps[subsurfaceProfile].y * thickness;
 
-    uint transmissionMode = BitFieldExtract(_TransmissionFlags, 2u, 2u * subsurfaceProfile);
+    uint transmissionMode = BitFieldExtract(asuint(_TransmissionFlags), 2u, 2u * subsurfaceProfile);
-    bsdfData.enableTransmission = transmissionMode != SSS_TRSM_MODE_NONE && (_EnableSSSAndTransmission > 0);
+    bsdfData.enableTransmission = _EnableSSSAndTransmission != 0 && transmissionMode != SSS_TRSM_MODE_NONE;
-        if (_UseDisneySSS)
+        if (_UseDisneySSS != 0)
         {
             bsdfData.transmittance = ComputeTransmittanceDisney(_ShapeParams[subsurfaceProfile].rgb,
                                                                 _TransmissionTints[subsurfaceProfile].rgb,
 
         if (enableSssAndTransmission)
         {
-            bool performPostScatterTexturing = IsBitSet(_TexturingModeFlags, bsdfData.subsurfaceProfile);
+            bool performPostScatterTexturing = IsBitSet(asuint(_TexturingModeFlags), bsdfData.subsurfaceProfile);
 
             if (performPostScatterTexturing)
             {

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringSettings.cs

         public bool useDisneySSS = true;
         public SubsurfaceScatteringProfile[] profiles;
 
-        [NonSerialized] public int       texturingModeFlags;        // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
-        [NonSerialized] public int       transmissionFlags;         // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
+        [NonSerialized] public uint      texturingModeFlags;        // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
+        [NonSerialized] public uint      transmissionFlags;         // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
         [NonSerialized] public Vector4[] thicknessRemaps;           // Remap: 0 = start, 1 = end - start
         [NonSerialized] public Vector4[] worldScales;               // Size of the world unit in meters (only the X component is used)
         [NonSerialized] public Vector4[] shapeParams;               // RGB = S = 1 / D, A = filter radius
             int i = p + 1;
 
             // Erase previous value (This need to be done here individually as in the SSS editor we edit individual component)
-            int mask = 1 << i;
+            uint mask = 1u << i;
-            mask = 3 << i * 2;
+            mask = 3u << i * 2;
-            texturingModeFlags |= (int)profiles[p].texturingMode    << i;
-            transmissionFlags  |= (int)profiles[p].transmissionMode << i * 2;
+            texturingModeFlags |= (uint)profiles[p].texturingMode    << i;
+            transmissionFlags  |= (uint)profiles[p].transmissionMode << i * 2;
 
             thicknessRemaps[i]   = new Vector4(profiles[p].thicknessRemap.x, profiles[p].thicknessRemap.y - profiles[p].thicknessRemap.x, 0f, 0f);
             worldScales[i]       = new Vector4(profiles[p].worldScale, 0f, 0f, 0f);

ScriptableRenderPipeline/HDRenderPipeline/ShaderVariablesFunctions.hlsl

 #if defined(SHADERPASS) && (SHADERPASS != SHADERPASS_SHADOWS)
     return GetPrimaryCameraPosition();
 #else
-    // TEMP: this is rather expensive. Then again, we need '_WorldSpaceCameraPos'
-    // to represent the position of the primary (scene view) camera in order to
-    // have identical tessellation levels for both the scene view and shadow views.
-    // Otherwise, depth comparisons become meaningless!
-    float4x4 trViewMat = transpose(GetWorldToViewMatrix());
-    float3   rotCamPos = trViewMat[3].xyz;
-    return mul((float3x3)trViewMat, -rotCamPos);
+    // This is a generic solution.
+    // However, for the primary camera, using '_WorldSpaceCameraPos' is better for cache locality,
+    // and in case we enable camera-relative rendering, we can statically set the position is 0.
+    return UNITY_MATRIX_I_V._14_24_34;
 #endif
 }