copying sample texture into 4kx4k atlas

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

     return float4(uv * 2.0 - 1.0, z, 1.0);
 }
 
+
+// draw procedural with 2 triangles has index order (0,1,2)  (0,2,3)
+
+// 0 - 0,0
+// 1 - 0,1
+// 2 - 1,1
+// 3 - 1,0
+
+float2 GetQuadTexCoord(uint vertexID)
+{
+	uint topBit = vertexID >> 1;
+	uint botBit = (vertexID & 1);
+	float u = topBit; 
+	float v = (topBit + botBit) & 1; // produces 0 for indices 0,3 and 1 for 1,2
+#if !UNITY_UV_STARTS_AT_TOP
+	v = 1.0 - v;
+#endif
+	return float2(u, v);
+}
+
+// 0 - 0,1
+// 1 - 0,0
+// 2 - 1,0
+// 3 - 1,1
+float4 GetQuadVertexPosition(uint vertexID, float z = UNITY_NEAR_CLIP_VALUE)
+{
+	uint topBit = vertexID >> 1;
+	uint botBit = (vertexID & 1);
+	float x = topBit;
+	float y = 1 - (topBit + botBit) & 1; // produces 1 for indices 0,3 and 0 for 1,2
+	return float4(x, y, z, 1.0); 
+}
+
 #if !defined(SHADER_API_GLES)
 
 // LOD dithering transition helper

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

 
         public static readonly int _DebugFullScreenTexture = Shader.PropertyToID("_DebugFullScreenTexture");
         public static readonly int _BlitTexture = Shader.PropertyToID("_BlitTexture");
-        public static readonly int _BlitScaleBiasSrc = Shader.PropertyToID("_BlitScaleBiasSrc");
-        public static readonly int _BlitScaleBiasDst = Shader.PropertyToID("_BlitScaleBiasDst");
+        public static readonly int _BlitScaleBias = Shader.PropertyToID("_BlitScaleBias");
+        public static readonly int _BlitScaleBiasRt = Shader.PropertyToID("_BlitScaleBiasRt");
 
         public static readonly int _WorldScales = Shader.PropertyToID("_WorldScales");
         public static readonly int _FilterKernels = Shader.PropertyToID("_FilterKernels");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDUtils.cs

             }
         }
 
-        public static void BlitTexture(CommandBuffer cmd, Texture source, RTHandle destination, Vector4 scaleBiasSrc, Vector4 scaleBiasDst, float srcMipLevel, int dstMipLevel, bool bilinear)
+        public static void BlitQuad(CommandBuffer cmd, Texture source, Vector4 scaleBiasTex, Vector4 scaleBiasRT, int mipLevelTex, bool bilinear)
-            s_PropertyBlock.SetVector(HDShaderIDs._BlitScaleBiasSrc, scaleBiasSrc);
-            s_PropertyBlock.SetVector(HDShaderIDs._BlitScaleBiasDst, scaleBiasDst);
-            s_PropertyBlock.SetFloat(HDShaderIDs._BlitMipLevel, srcMipLevel);
-            cmd.SetRenderTarget(destination, dstMipLevel);
-            cmd.DrawProcedural(Matrix4x4.identity, GetBlitMaterial(), bilinear ? 1 : 0, MeshTopology.Triangles, 3, 1, s_PropertyBlock);
+            s_PropertyBlock.SetVector(HDShaderIDs._BlitScaleBias, scaleBiasTex);
+            s_PropertyBlock.SetVector(HDShaderIDs._BlitScaleBiasRt, scaleBiasRT);
+            s_PropertyBlock.SetFloat(HDShaderIDs._BlitMipLevel, mipLevelTex);
+            cmd.DrawProcedural(Matrix4x4.identity, GetBlitMaterial(), bilinear ? 2 : 3, MeshTopology.Quads, 4, 1, s_PropertyBlock);
-        public static void BlitTexture(CommandBuffer cmd, RTHandle source, RTHandle destination, Vector4 scaleBiasSrc, Vector4 scaleBiasDst, float mipLevel, bool bilinear)
+        public static void BlitTexture(CommandBuffer cmd, RTHandle source, RTHandle destination, Vector4 scaleBias, float mipLevel, bool bilinear)
-            s_PropertyBlock.SetVector(HDShaderIDs._BlitScaleBiasSrc, scaleBiasSrc);
-            s_PropertyBlock.SetVector(HDShaderIDs._BlitScaleBiasDst, scaleBiasDst);
+            s_PropertyBlock.SetVector(HDShaderIDs._BlitScaleBias, scaleBias);
             s_PropertyBlock.SetFloat(HDShaderIDs._BlitMipLevel, mipLevel);
             cmd.DrawProcedural(Matrix4x4.identity, GetBlitMaterial(), bilinear ? 1 : 0, MeshTopology.Triangles, 3, 1, s_PropertyBlock);
         }
         {
             // Will set the correct camera viewport as well.
             SetRenderTarget(cmd, camera, destination);
-            BlitTexture(cmd, source, destination, camera.scaleBias, new Vector4(1.0f, 1.0f, 0.0f, 0.0f), mipLevel, bilinear);
+            BlitTexture(cmd, source, destination, camera.scaleBias, mipLevel, bilinear);
         }
 
         // This case, both source and destination are camera-scaled but we want to override the scale/bias parameter.
             SetRenderTarget(cmd, camera, destination);
-            BlitTexture(cmd, source, destination, scaleBias, new Vector4(1.0f, 1.0f, 0.0f, 0.0f),mipLevel, bilinear);
+            BlitTexture(cmd, source, destination, scaleBias, mipLevel, bilinear);
         }
 
         public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RTHandle source, RTHandle destination, Rect destViewport, float mipLevel = 0.0f, bool bilinear = false)
-            BlitTexture(cmd, source, destination, camera.scaleBias, new Vector4(1.0f, 1.0f, 0.0f, 0.0f), mipLevel, bilinear);
+            BlitTexture(cmd, source, destination, camera.scaleBias, mipLevel, bilinear);
         }
 
         // This particular case is for blitting a camera-scaled texture into a non scaling texture. So we setup the full viewport (implicit in cmd.Blit) but have to scale the input UVs.
             SetRenderTarget(cmd, camera, destination);
 
             cmd.SetGlobalTexture(HDShaderIDs._BlitTexture, source);
-            cmd.SetGlobalVector(HDShaderIDs._BlitScaleBiasSrc, new Vector4(1.0f, 1.0f, 0.0f, 0.0f));
-            cmd.SetGlobalVector(HDShaderIDs._BlitScaleBiasDst, new Vector4(1.0f, 1.0f, 0.0f, 0.0f));
+            cmd.SetGlobalVector(HDShaderIDs._BlitScaleBias, new Vector4(1.0f, 1.0f, 0.0f, 0.0f));
             cmd.SetGlobalFloat(HDShaderIDs._BlitMipLevel, 0.0f);
             // Wanted to make things clean and not use SetGlobalXXX APIs but can't use MaterialPropertyBlock with RenderTargetIdentifier so YEY
             //s_PropertyBlock.SetTexture(HDShaderIDs._BlitTexture, source);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalUtilities.hlsl

 			if(diffuseIndex != -1)
 			{
 				ApplyBlendDiffuse(DBuffer0, mask, positionDS.xz, diffuseIndex, DBUFFERHTILEBIT_DIFFUSE, decalBlend, lod);
-				alpha = alpha < decalBlend ? decalBlend : alpha;	// use decal alpha if it higher than transparent alpha
+				alpha = alpha < decalBlend ? decalBlend : alpha;	// use decal alpha if it is higher than transparent alpha
 			}
 
 			if(normalIndex != -1)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/Blit.shader

         TEXTURE2D(_BlitTexture);
         SamplerState sampler_PointClamp;
         SamplerState sampler_LinearClamp;
-        uniform float4 _BlitScaleBiasSrc;
-		uniform float4 _BlitScaleBiasDst;
+        uniform float4 _BlitScaleBias;
+		uniform float4 _BlitScaleBiasRt;
         uniform float _BlitMipLevel;
 
         struct Attributes
         Varyings Vert(Attributes input)
         {
             Varyings output;
-            output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID) * float4(_BlitScaleBiasDst.xy, 1, 1) + float4(_BlitScaleBiasDst.zw, 0, 0);
-            output.texcoord   = GetFullScreenTriangleTexCoord(input.vertexID) * _BlitScaleBiasSrc.xy + _BlitScaleBiasSrc.zw;
+            output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
+            output.texcoord   = GetFullScreenTriangleTexCoord(input.vertexID) * _BlitScaleBias.xy + _BlitScaleBias.zw;
+
+		Varyings VertQuad(Attributes input)
+		{
+			Varyings output;
+			output.positionCS = GetQuadVertexPosition(input.vertexID) * float4(_BlitScaleBiasRt.x, _BlitScaleBiasRt.y, 1, 1) + float4(_BlitScaleBiasRt.z, _BlitScaleBiasRt.w, 0, 0);
+			output.positionCS.xy = output.positionCS.xy * float2(2.0f, -2.0f) + float2(-1.0f, 1.0f); //convert to -1..1
+			output.texcoord = GetQuadTexCoord(input.vertexID) * _BlitScaleBias.xy + _BlitScaleBias.zw;
+			return output;
+		}
 
         float4 FragNearest(Varyings input) : SV_Target
         {
                 #pragma vertex Vert
                 #pragma fragment FragBilinear
             ENDHLSL
-        }		
+        }
+
+		// 2: Nearest quad
+		Pass
+		{
+			ZWrite Off ZTest Always Blend Off Cull Off
+
+			HLSLPROGRAM
+				#pragma vertex VertQuad
+				#pragma fragment FragNearest
+			ENDHLSL
+		}
+
+		// 3: Bilinear quad
+		Pass
+		{
+			ZWrite Off ZTest Always Blend Off Cull Off
+
+			HLSLPROGRAM
+				#pragma vertex VertQuad
+				#pragma fragment FragBilinear
+			ENDHLSL
+		}
+
     }
 
     Fallback Off

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Texture2DAtlas.cs

         {
             float scaleW = (float)texture.width / m_Width;
             float scaleH = (float) texture.height / m_Height;
-            HDUtils.BlitTexture(cmd, texture, m_AtlasTexture, new Vector4(1,1,0,0), new Vector4(scaleW, scaleH, 0, 0), 0, 0, false);
+            for (int mipLevel = 0; mipLevel < (texture as Texture2D).mipmapCount; mipLevel++)
+            {
+                cmd.SetRenderTarget(m_AtlasTexture, mipLevel);
+                HDUtils.BlitQuad(cmd, texture, new Vector4(1, 1, 0, 0), new Vector4(scaleW, scaleH, 0, 0), mipLevel, false);
+            }
         }
     }
 }