Changed texelSizeRcp passed into shaders from a float2 to a float4. The first xy coordinates are the actual texel size of the texture, whereas zw are the texelsizes relative to the viewport.

Added a factor of 100 to the normal bias passed into the shader.
Updated shaders to use the new zw component for the normal bias offset.
Added bias offset code to point, spot and punctual routines as well.

Assets/ScriptableRenderPipeline/HDRenderPipeline/Shadow/Shadow.cs

 
                     sd.worldToShadow = vp.transpose; // apparently we need to transpose matrices that are sent to HLSL
                     sd.scaleOffset   = new Vector4( ce.current.viewport.width * m_WidthRcp, ce.current.viewport.height * m_HeightRcp, ce.current.viewport.x, ce.current.viewport.y );
-                    sd.texelSizeRcp  = new Vector2( m_WidthRcp, m_HeightRcp );
+                    sd.texelSizeRcp  = new Vector4( m_WidthRcp, m_HeightRcp, 1.0f / ce.current.viewport.width, 1.0f / ce.current.viewport.height );
                     sd.PackShadowmapId( m_TexSlot, m_SampSlot, ce.current.slice );
                     sd.PackShadowType( sr.shadowType, sanitizedAlgo );
                     sd.payloadOffset = originalPayloadCount;
                     case LightType.Point        : add = --m_MaxShadows[(int)GPUShadowType.Point        , 0] >= 0; shadowType = GPUShadowType.Point      ; facecount = 6; break;
                     case LightType.Spot         : add = --m_MaxShadows[(int)GPUShadowType.Spot         , 0] >= 0; shadowType = GPUShadowType.Spot       ; facecount = 1; break;
                 }
+                
+                if( add )
+                {
+                    // TODO: do the shadow distance logic here
+                }
 
                 if( add )
                 {
                 ShadowUtils.MapLightType( ald.archetype, vl.lightType, out sd.lightType, out shadowtype );
                 // current bias value range is way too large, so scale by 0.01 for now until we've decided  whether to actually keep this value or not.
                 sd.bias = 0.01f * (SystemInfo.usesReversedZBuffer ? l.shadowBias : -l.shadowBias);
-                sd.normalBias = l.shadowNormalBias;
+                sd.normalBias = 100.0f * l.shadowNormalBias;
                 
                 shadowIndices.AddUnchecked( (int) shadowDatas.Count() );
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Shadow/ShadowAlgorithms.hlsl

 // If the light hits the surface perpendicularly there will be no offset.
 float3 EvalShadow_NormalBias( float3 normalWS, float NoL, float2 texelSize, float normalBias )
 {
-	return 2.0 * max( texelSize.x, texelSize.y ) * normalBias * (1.0 - NoL) * normalWS;
+	return max( texelSize.x, texelSize.y ) * normalBias * (1.0 - NoL) * normalWS;
 }
 
 // function called by spot, point and directional eval routines to calculate shadow coordinates
 	GetCubeFaceID( L, faceIndex );
 	ShadowData sd = shadowContext.shadowDatas[index + 1 + faceIndex];
 	uint payloadOffset = GetPayloadOffset( sd );
+	// normal based bias
+	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
 	// get shadowmap texcoords
 	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );
 	// get the algorithm
 		GetCubeFaceID( L, faceIndex );																																					\
 		ShadowData sd = shadowContext.shadowDatas[index + 1 + faceIndex];																												\
 		uint payloadOffset = GetPayloadOffset( sd );																																	\
+		/* normal based bias */																																							\
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );																\
 		/* get shadowmap texcoords */																																					\
 		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );																														\
 		/* sample the texture */																																						\
 	// load the right shadow data for the current face
 	ShadowData sd = shadowContext.shadowDatas[index];
 	uint payloadOffset = GetPayloadOffset( sd );
+	// normal based bias
+	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
 	// get shadowmap texcoords
 	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );
 	// get the algorithm
 		/* load the right shadow data for the current face */																														\
 		ShadowData sd = shadowContext.shadowDatas[index];																															\
 		uint payloadOffset = GetPayloadOffset( sd );																																\
+		/* normal based bias */																																						\
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );															\
 		/* get shadowmap texcoords */																																				\
 		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );																													\
 		/* sample the texture */																																					\
 
 	ShadowData sd = shadowContext.shadowDatas[index + faceIndex];
 	uint payloadOffset = GetPayloadOffset( sd );
+	// normal based bias
+	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
 	// get shadowmap texcoords
 	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );
 	// sample the texture according to the given algorithm
 																																														\
 		ShadowData sd = shadowContext.shadowDatas[index + faceIndex];																													\
 		uint payloadOffset = GetPayloadOffset( sd );																																	\
+		/* normal based bias */																																							\
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );																\
 		/* get shadowmap texcoords */																																					\
 		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );																														\
 		/* sample the texture */																																						\
 
 	ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];
 	// normal based bias
-	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp, sd.normalBias );
+	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
 	// get shadowmap texcoords
 	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );
 
 		uint shadowSplitIndex = EvalShadow_GetSplitSphereIndexForDirshadows( positionWS, dirShadowSplitSpheres );																		\
 		ShadowData sd = shadowContext.shadowDatas[index + 1 + shadowSplitIndex];																										\
 		/* normal based bias */																																							\
-		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp, sd.normalBias );																\
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );																\
 		/* get shadowmap texcoords */																																					\
 		float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );																														\
 		/* sample the texture */																																						\

Assets/ScriptableRenderPipeline/HDRenderPipeline/Shadow/ShadowAlgorithmsCustom.hlsl

 
 	ShadowData sd = shadowContext.shadowDatas[shadowDataIndex + 1 + shadowSplitIndex];
 	// normal based bias
-	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp, sd.normalBias );
+	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
 	// get shadowmap texcoords
 	float3 posTC = EvalShadow_GetTexcoords( sd, positionWS );
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Shadow/ShadowBase.cs

         // shadow texture related params (need to be set by ShadowmapBase and derivatives)
         public Matrix4x4     worldToShadow;  // to light space matrix
         public Vector4       scaleOffset;    // scale and offset of shadowmap in atlas
-        public Vector2       texelSizeRcp;   // reciprocal of the shadowmap's texel size in x and y
+        public Vector4       texelSizeRcp;   // reciprocal of the shadowmap's texel size in x and y. xy is texture relative, zw is viewport relative.
         public uint          id;             // packed texture id, sampler id and slice idx
         public uint          shadowType;     // determines the shadow algorithm, i.e. which map to sample and how to interpret the data
         public uint          payloadOffset;  // if this shadow type requires additional data it can be fetched from a global Buffer<uint> at payloadOffset.

Assets/ScriptableRenderPipeline/HDRenderPipeline/Shadow/ShadowBase.cs.hlsl

-//
+//
 // This file was automatically generated from Assets/ScriptableRenderPipeline/HDRenderPipeline/Shadow/ShadowBase.cs.  Please don't edit by hand.
 //
 
 {
 	float4x4 worldToShadow;
 	float4 scaleOffset;
-	float2 texelSizeRcp;
+	float4 texelSizeRcp;
 	uint id;
 	uint shadowType;
 	uint payloadOffset;
 {
 	return value.scaleOffset;
 }
-float2 GetTexelSizeRcp(ShadowData value)
+float4 GetTexelSizeRcp(ShadowData value)
 {
 	return value.texelSizeRcp;
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Shadow/ShadowSampling.hlsl

 //
 //					9 tap adaptive PCF sampling
 //
-float SampleShadow_PCF_9tap_Adaptive( ShadowContext shadowContext, inout uint payloadOffset, float2 texelSizeRcp, float3 tcs, float bias, uint slice, uint texIdx, uint sampIdx )
+float SampleShadow_PCF_9tap_Adaptive( ShadowContext shadowContext, inout uint payloadOffset, float4 texelSizeRcp, float3 tcs, float bias, uint slice, uint texIdx, uint sampIdx )
 {
 	float2 params     = asfloat( shadowContext.payloads[payloadOffset].xy );
 	float  depthBias  = params.x;
 	return flSum;
 }
 
-float SampleShadow_PCF_9tap_Adaptive(ShadowContext shadowContext, inout uint payloadOffset, float2 texelSizeRcp, float3 tcs, float bias, uint slice, Texture2DArray tex, SamplerComparisonState compSamp )
+float SampleShadow_PCF_9tap_Adaptive(ShadowContext shadowContext, inout uint payloadOffset, float4 texelSizeRcp, float3 tcs, float bias, uint slice, Texture2DArray tex, SamplerComparisonState compSamp )
 {
 	float2 params     = asfloat( shadowContext.payloads[payloadOffset].xy );
 	float  depthBias  = params.x;