Rendering into custom texture in Unity

[StructLayout(LayoutKind.Sequential)]  
public struct HeatmapObjectRendererData  
{  
   public Matrix4x4 localToWorldMatrix;  
   public float alpha;  
   public int blendMode;  
}

public unsafe class HeatmapObjectRenderer : MonoBehaviour  
{  
   // Collections that track all the renderers  
   private static List<HeatmapObjectRenderer> allInstances = new();  
   private static UnsafePtrList<HeatmapObjectRendererData>* AllInstanceData = null;
   public static int InstanceCount => allInstances.Count;
   // Internal data of this renderer  
   private HeatmapObjectRendererData* dataPtr;
   // Inspector properties  
   [Range(0.0f, 1.0f)]  
   public float alpha;  
   public HeatmapObjectBlendMode blendMode;  
}

public enum HeatmapObjectBlendMode  
{  
   FogCut = 0, // Will be used to render red channel  
   FogRestore = 1, // Will be used to restore red channel  
   DrawSteps = 2 // Will be used to render green channel  
}

 
public unsafe class HeatmapObjectRenderer : MonoBehaviour  
{  
  private static List<HeatmapObjectRenderer> allInstances = new();  
  private static UnsafePtrList<HeatmapObjectRendererData>* AllInstanceData = null;
  ...
  private HeatmapObjectRendererData* dataPtr;
  ...
  private void OnEnable()  
  {  
    // Allocate renderer data  
    dataPtr = AllocatorManager.Allocate<HeatmapObjectRendererData>(Allocator.Persistent);  
    UpdateData(); // not implemented yet - this will update the low-level data of the renderer  
    
    // Lazy-initialize collections  
    if (AllInstanceData == null)  
    AllInstanceData = UnsafePtrList<HeatmapObjectRendererData>.Create(1024, Allocator.Persistent);  
    
    // Start tracking the instance  
    allInstances.Add(this);  
    AllInstanceData->Add(dataPtr);  
  }  
  
  private void OnDisable()  
  {  
    // Stop tracking the instance  
    allInstances.RemoveSwapBack(this);  
    AllInstanceData->RemoveSwapBack(dataPtr);  
    
    // Release the renderer data  
    AllocatorManager.Free(Allocator.Persistent, dataPtr);  
    dataPtr = null;  
    
    // Dealloc a collection if this was the last renderer  
    if (AllInstanceData->Length <= 0)  
    {  
      UnsafePtrList<HeatmapObjectRendererData>.Destroy(AllInstanceData);  
      AllInstanceData = null;  
    }  
  }  
}

public unsafe class HeatmapObjectRenderer : MonoBehaviour  
{  
  private static List<HeatmapObjectRenderer> allInstances = new();  
  private static UnsafePtrList<HeatmapObjectRendererData>* AllInstanceData = null;
  
  public static int InstanceCount => allInstances.Count;
  
  private HeatmapObjectRendererData* dataPtr;
  
  [Range(0.0f, 1.0f)] public float alpha;  
  public HeatmapObjectBlendMode blendMode;  
   
  ...  
  
  // Updates the low-level data of the renderer.  
  private void UpdateData()  
  {  
    // If the data exists  
    if (dataPtr == null)  
      return;  
    
    // Fill the low-level renderer data  
    dataPtr->alpha = alpha;  
    dataPtr->blendMode = (int)blendMode;  
    dataPtr->localToWorldMatrix = transform.localToWorldMatrix;  
  }  
  
  // Updates low-level data of each renderer.  
  public static void UpdateInstances()  
  {  
    // Iterate through each instance  
    for (int i = 0; i < allInstances.Count; i++)  
      allInstances[i].UpdateData();  
  }  
  
  // Returns the low-level collection that can be used for rendering.  
  // It converts a list of pointers into a list of structs, which I will use in the rendering.  
  public static void FetchInstanceData(UnsafeList<HeatmapObjectRendererData>* targetListPtr)  
  {  
    // Return the data that will be used in rendering  
    for (int i = 0; i < AllInstanceData->Length; i++)  
      targetListPtr->Add(*(AllInstanceData->ElementAt(i)));  
  }  
}

public unsafe class HeatmapObjectRenderer : MonoBehaviour  
{  
  // Used to display the drawn quad in the editor.  
  private void OnDrawGizmosSelected()  
  {  
    // Visualise heatmap object in some nice way  
    Gizmos.color = new Color(1.0f, 0.2f, 0.2f, 1.0f * math.lerp(alpha, 1.0f, 0.5f));  
    Gizmos.matrix = transform.localToWorldMatrix * Matrix4x4.Scale(new Vector3(1.0f, 0.000001f, 1.0f));
    
    // Borders  
    Gizmos.DrawWireCube(Vector3.zero, new Vector3(1.0f, 0.0000001f, 1.0f));
    
    // Circle inside  
    Gizmos.color = new(1.0f, 0.2f, 0.2f, 0.5f * alpha);  
    Gizmos.DrawSphere(Vector3.zero + Vector3.up * 0.00001f, 0.5f);  
  }  
}

public class HeatmapCamera : MonoBehaviour  
{  
   // Singleton(ish) pattern  
   private static List<HeatmapCamera> allInstances = new();  
   public static HeatmapCamera MainInstance => allInstances.LastOrDefault();
  
   // Struct that stores all camera parameters required for rendering.  
   public HeatmapCameraParameters Parameters { get; private set; } = default;
  
   // Inspector field that allows me to select the rendered resolution  
   [SerializeField]  
   public HeatmapTextureResolution resolution = HeatmapTextureResolution._4096;
  
   // Target texture for the camera  
   private RenderTexture heatmapTexture;  
}

// Camera parameters  
public struct HeatmapCameraParameters  
{  
   public Matrix4x4 worldToCameraMatrix; // View matrix  
   public Matrix4x4 projectionMatrix; // Projection matrix  
   public RenderTexture heatmapTexture; // Target texture  
}

// Possible texture resolutions to select in the inspector  
public enum HeatmapTextureResolution  
{  
   _512 = 512,  
   _1024 = 1024,  
   _2048 = 2048,  
   _4096 = 4096  
}

 
public class HeatmapCamera : MonoBehaviour  
{  
  private static List<HeatmapCamera> allInstances = new();
  
  [SerializeField] public HeatmapTextureResolution resolution = HeatmapTextureResolution._4096;
  
  private RenderTexture heatmapTexture;  
  
  // Initialize a whole component  
  private void OnEnable()  
  {  
    // Register the instance  
    allInstances.Add(this);
    
    // Create a render texture  
    heatmapTexture = new RenderTexture(  
      (int)resolution, (int)resolution,  
      UnityEngine.Experimental.Rendering.GraphicsFormat.R16G16B16A16_SFloat,  
      UnityEngine.Experimental.Rendering.GraphicsFormat.None, 0  
    );  
    heatmapTexture.name = gameObject.name + "_RenderTexture"; // Always name resources  
    heatmapTexture.enableRandomWrite = true;  
    heatmapTexture.Create();
      
    // TODO: create matrices and parameters  
  }
  
  // Deinitialize the component  
  private void OnDisable()  
  {  
    // Unregister the instance  
    allInstances.Remove(this);  
    
    // Release the texture  
    heatmapTexture.Release();  
  }  
}

private void OnEnable()  
{  
  ...  
  
  // Create the orthogonal projection matrix for the camera.  
  // It renders object-space between (-1.0, -1.0, 0.0) to (1.0, 1.0, 2.0)  
  Matrix4x4 projectionMatrix = Matrix4x4.Ortho(-1.0f, 1.0f, -1.0f, 1.0f, 0.00001f, 2.0f);  
  
  // Move the projection back.  
  // It makes it render object-space between (-1.0, -1.0, -1.0) to (1.0, 1.0, 1.0)  
  projectionMatrix = projectionMatrix * Matrix4x4.Translate(new Vector3(0.0f, 0.0f, -1.0f));  
}

private void OnEnable()  
{  
  ...  
    
  Matrix4x4 projectionMatrix = Matrix4x4.Ortho(-1.0f, 1.0f, -1.0f, 1.0f, 0.00001f, 2.0f);  
  projectionMatrix = projectionMatrix * Matrix4x4.Translate(new Vector3(0.0f, 0.0f, -1.0f));  
    
  // Update public parameters  
  HeatmapCameraParameters parameters = new HeatmapCameraParameters();  
  parameters.projectionMatrix = projectionMatrix;  
  parameters.worldToCameraMatrix = transform.worldToLocalMatrix; // View matrix is just transform.worldToLocalMatrix.  
  parameters.heatmapTexture = heatmapTexture;  
  Parameters = parameters;
  
  // Set global view and projection matrices for the heatmap.
  // Projection matrix is converted from unified projection to the correct graphics API format. 
  Shader.SetGlobalMatrix(HeatmapRenderPass.Uniforms._HeatmapMatrixP, GL.GetGPUProjectionMatrix(parameters.projectionMatrix, false));
  Shader.SetGlobalMatrix(HeatmapRenderPass.Uniforms._HeatmapMatrixV, parameters.worldToCameraMatrix);  
}

public class HeatmapCamera : MonoBehaviour  
{  
  ...  
  // Drawing a gizmo to see where the camera is  
  private void OnDrawGizmosSelected()  
  {  
    // Draw a yellow box in object space  
    Gizmos.color = Color.yellow;  
    Gizmos.matrix = transform.localToWorldMatrix;  
    Gizmos.DrawWireCube(Vector3.zero, Vector3.one * float3(2.0f, 2.0f, 2.0f));  
    
    // Draw a line from near the plane to the center  
    Gizmos.color = Color.yellow * new Color(1, 1, 1, 0.5f);  
    Gizmos.DrawLine(new Vector3(0.0f, 0.0f, -1.0f), Vector3.zero);  
  }  
}

public class HeatmapRendererFeature : ScriptableRendererFeature  
{  
  // Material with a shader that I want to use to render all the objects.  
  public Material heatmapObjectRenderMaterial;  
  
  // Pass that implements the rendering  
  private HeatmapRenderPass heatmapRenderPass;
  public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)  
  {  
    // Only render for a game camera  
    bool shouldRenderHeatmap = renderingData.cameraData.cameraType == CameraType.Game;  
    if (!shouldRenderHeatmap)  
      return;
    
    // Batch-update all instances before rendering  
    HeatmapObjectRenderer.UpdateInstances();
    
    // Enqueue heatmap texture render pass  
    renderer.EnqueuePass(heatmapRenderPass);  
  }
  
  public override void Create()  
  {  
    // Create a render pass.  
    heatmapRenderPass = new HeatmapRenderPass(heatmapObjectRenderMaterial);  
  }
  
  protected override void Dispose(bool disposing)  
  {  
    // Release the render pass.  
    if (heatmapRenderPass != null)  
    {  
      heatmapRenderPass.Release();  
      heatmapRenderPass = null;  
    }  
  }  
}

// This class will implement the rendering logic  
public unsafe class HeatmapRenderPass : ScriptableRenderPass  
{  
  // Material that will be used to render the objects into a texture  
  internal Material heatmapRenderMaterial;  
  
  // Constructor used to allocate the resources  
  public HeatmapRenderPass(Material heatmapRenderMaterial)  
  {  
    this.heatmapRenderMaterial = heatmapRenderMaterial;  
  }  
  
  // Method used to release the resources.  
  public void Release()  
  {  
    heatmapRenderMaterial = null;  
  }  
  
  // I will implement the rendering here.  
}

// This class will implement the rendering logic  
public unsafe class HeatmapRenderPass : ScriptableRenderPass  
{  
  ...  
  
  // This method will implement the whole rendering  
  public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)  
  {  
    // Don't render when the camera is not present.  
    var heatmapCamera = HeatmapCamera.MainInstance;  
    if (heatmapCamera == null)  
      return;  
    
    // Don't render anything when there are no instances to render  
    if (HeatmapObjectRenderer.InstanceCount <= 0)  
      return;  
    
    // Don't render when the material is not set  
    if (heatmapRenderMaterial == null)  
      return;  
  }  
}

HeatmapObjectRenderer.FetchInstanceData(UnsafeList<HeatmapObjectRendererData>* targetListPtr)

public unsafe class HeatmapRenderPass : ScriptableRenderPass  
{  
  // Added unsafe list  
  private UnsafeList<HeatmapObjectRendererData>* heatmapObjectRendererInstances = null;  
  ...  
  
  public HeatmapRenderPass(Material heatmapRenderMaterial)  
  {  
    // Allocating the list in the constructor  
    heatmapObjectRendererInstances = UnsafeList<HeatmapObjectRendererData>.Create(1024, Allocator.Persistent);  
  }  
  ...  
  
  public void Release()  
  {  
    // Deallocating the list.  
    UnsafeList<HeatmapObjectRendererData>.Destroy(heatmapObjectRendererInstances);  
    heatmapObjectRendererInstances = null;  
  }  
  ...  
}

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)  
{  
  ...
  
  // Prepare buffer descriptor  
  BufferDesc heatmapObjectInstanceBufferDesc = new BufferDesc(HeatmapObjectRenderer.InstanceCount, sizeof(HeatmapObjectRendererData), GraphicsBuffer.Target.Structured);  
  heatmapObjectInstanceBufferDesc.name = nameof(Uniforms._HeatmapObjectInstanceBuffer);  
    
  // Allocate the graphics buffer using the render graph API  
  BufferHandle heatmapObjectInstanceBuffer = renderGraph.CreateBuffer(heatmapObjectInstanceBufferDesc);

// Using compute pass to set the buffer data  
using (var computeBuilder = renderGraph.AddComputePass<PassData>($"{nameof(HeatmapRenderPass)}_Compute", out PassData passData))  
{  
  // Ensure it is always executed  
  computeBuilder.AllowPassCulling(false);  
  
  // Notify that the pass will use the created instance buffer.  
  computeBuilder.UseBuffer(heatmapObjectInstanceBuffer, AccessFlags.ReadWrite);
  
  // Set render function  
  computeBuilder.SetRenderFunc((PassData passData, ComputeGraphContext context) =>  
  {  
    // Clear all instances  
    heatmapObjectRendererInstances->Clear();  
    
    // Fetch instance data into a low-level list  
    HeatmapObjectRenderer.FetchInstanceData(heatmapObjectRendererInstances);  
    
    // Set the buffer data.  
    context.cmd.SetBufferData(heatmapObjectInstanceBuffer, heatmapObjectRendererInstances);  
  });  
}

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)  
{
  ...  
  
  // Access heatmap camera parameters  
  HeatmapCameraParameters heatmapParameters = heatmapCamera.Parameters;  
  
  // Convert its texture into RTHandle  
  var heatmapTextureRT = RTHandles.Alloc(heatmapParameters.heatmapTexture);  
  
  // Import RTHandle into render graph to be able to use it as a render attachment  
  var heatmapTextureHandle = renderGraph.ImportTexture(heatmapTextureRT);  
}

public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)  
{
  ...  
  var heatmapTextureHandle = renderGraph.ImportTexture(heatmapTextureRT);
  
  // Render the instances into a texture  
  using (var rasterBuilder = renderGraph.AddRasterRenderPass<PassData>($"{nameof(HeatmapRenderPass)}_Raster", out PassData passData))  
  {  
    // Set target texture.  
    rasterBuilder.SetRenderAttachment(heatmapTextureHandle, 0, AccessFlags.ReadWrite, 0, 0);  
    
    // Declare that I will use the instance buffer created before  
    rasterBuilder.UseBuffer(heatmapObjectInstanceBuffer, AccessFlags.Read);  
    
    // Ensure that the rendered texture is available for all shaders after rendering this pass  
    rasterBuilder.SetGlobalTextureAfterPass(heatmapTextureHandle, Uniforms._HeatmapTexture);  
  }  
}

// Defines the resources used by the render function  
private class PassData  
{  
	public HeatmapCameraParameters cameraParameters;  
	public BufferHandle heatmapObjectInstanceBuffer;  
	public Material renderMaterial;  
	public int instanceCount;  
}
public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)  
{
	
	...  
	var heatmapTextureHandle = renderGraph.ImportTexture(heatmapTextureRT);
	
	using (var rasterBuilder = renderGraph.AddRasterRenderPass<PassData>($"{nameof(HeatmapRenderPass)}_Raster", out PassData passData))  
	{  
		rasterBuilder.SetRenderAttachment(heatmapTextureHandle, 0, AccessFlags.ReadWrite, 0, 0);  
		rasterBuilder.UseBuffer(heatmapObjectInstanceBuffer, AccessFlags.Read);  
		
		rasterBuilder.SetGlobalTextureAfterPass(heatmapTextureHandle, Uniforms._HeatmapTexture);  
		
		// Set the resources used by the render function  
		passData.cameraParameters = HeatmapCamera.MainInstance.Parameters;  
		passData.heatmapObjectInstanceBuffer = heatmapObjectInstanceBuffer;  
		passData.renderMaterial = heatmapRenderMaterial;  
		passData.instanceCount = HeatmapObjectRenderer.InstanceCount;  
		
		// Create the render function  
		rasterBuilder.SetRenderFunc((PassData passData, RasterGraphContext context) =>  
		{  
		// I will execute draw calls here using the resources in the passData.  
		});  
	}  
}

rasterBuilder.SetRenderFunc((PassData passData, RasterGraphContext context) =>  
{  
	// Get the property block using the render graph API.  
	var propertyBlock = context.renderGraphPool.GetTempMaterialPropertyBlock();  
	  
	// Set instance buffer shader property  
	propertyBlock.SetBuffer(Uniforms._HeatmapObjectInstanceBuffer, passData.heatmapObjectInstanceBuffer);  
	  
	// Set view and projection matrices.  
	propertyBlock.SetMatrix(Uniforms._HeatmapMatrixV, passData.cameraParameters.worldToCameraMatrix);  
	propertyBlock.SetMatrix(Uniforms._HeatmapMatrixP, GL.GetGPUProjectionMatrix(passData.cameraParameters.projectionMatrix, true));  
});

public static class Uniforms  
{  
	public static readonly int _HeatmapObjectInstanceBuffer = Shader.PropertyToID(nameof(_HeatmapObjectInstanceBuffer));  
	public static readonly int _HeatmapMatrixV = Shader.PropertyToID(nameof(_HeatmapMatrixV));  
	public static readonly int _HeatmapMatrixP = Shader.PropertyToID(nameof(_HeatmapMatrixP));  
	public static readonly int _HeatmapTexture = Shader.PropertyToID(nameof(_HeatmapTexture));  
}

rasterBuilder.SetRenderFunc((PassData passData, RasterGraphContext context) =>  
{  
  var propertyBlock = context.renderGraphPool.GetTempMaterialPropertyBlock();  
   
  propertyBlock.SetBuffer(Uniforms._HeatmapObjectInstanceBuffer, passData.heatmapObjectInstanceBuffer);  
   
  propertyBlock.SetMatrix(Uniforms._HeatmapMatrixV, passData.cameraParameters.worldToCameraMatrix);  
  propertyBlock.SetMatrix(Uniforms._HeatmapMatrixP, passData.cameraParameters.projectionMatrix);  
   
  // Draw additive passes.  
  context.cmd.DrawProcedural(Matrix4x4.identity, passData.renderMaterial, 0, MeshTopology.Triangles, 6, passData.instanceCount, propertyBlock);
  // Draw multiply passes  
  context.cmd.DrawProcedural(Matrix4x4.identity, passData.renderMaterial, 1, MeshTopology.Triangles, 6, passData.instanceCount, propertyBlock);
  // Draw green color max passes  
  context.cmd.DrawProcedural(Matrix4x4.identity, passData.renderMaterial, 2, MeshTopology.Triangles, 6, passData.instanceCount, propertyBlock);  
});

Shader "Heatmap/Object"  
{  
   SubShader  
   {  
       Tags { "RenderType"="Transparent" "RenderQueue"="3000" }  
       LOD 100
       // Pass 0  
       Pass  
       {  
           // Additive blending  
           Blend One Zero  
           ZTest Off  
           Cull Off  
           ZWrite Off
           HLSLPROGRAM
           #pragma vertex vert  
           #pragma fragment frag  
                     
           #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
           // Quad vertices in object space. 2 triangles.  
           static const float4 quadVerticesOS[] =  
           {  
               float4(-0.5, 0.0,-0.5, 1.0),  
               float4(-0.5, 0.0, 0.5, 1.0),  
               float4( 0.5, 0.0, 0.5, 1.0),  
               float4(-0.5, 0.0,-0.5, 1.0),  
               float4( 0.5, 0.0, 0.5, 1.0),  
               float4( 0.5, 0.0,-0.5, 1.0)  
           };
           // Vertex shader input - contains only vertex ID and instance ID  
           struct VertexData  
           {  
               uint instanceID : SV_InstanceID;  
               uint vertexID : SV_VertexID;  
           };  
             
           // No interpolators for fragment shader, just position on the screen  
           struct FragmentData  
           {  
               float4 positionCS_SV : SV_Position;  
           };
           // Vertex shader  
           FragmentData vert(VertexData input)  
           {  
               FragmentData output;
               // Read vertex position  
               float4 positionOS = quadVerticesOS[input.vertexID];
               // Display it as a quad on the screen  
               float4 positionCS = positionOS.xzyw;  
               output.positionCS_SV = positionCS;
               return output;  
           }
           // Fragment shader  
           float4 frag(FragmentData input) : SV_Target0  
           {  
               // Output yellow color  
               return float4(1.0, 1.0, 0.0, 1.0);  
           }
           ENDHLSL  
       }  
   }  
}

...
rasterBuilder.SetRenderFunc((PassData passData, RasterGraphContext context) =>  
{  
// Clear the texture between each draw - this change is temporary  
context.cmd.ClearRenderTarget(false, true, Color.clear);
...

// Vertex shader  
FragmentData vert(VertexData input)  
{  
   FragmentData output;
   float4 positionOS = quadVerticesOS[input.vertexID];
   float4 positionCS = positionOS.xzyw;
   positionCS.xy *= 0.05; // Render small quad  
   positionCS.xy += input.instanceID * 0.05; // Apply offset using instance ID
   output.positionCS_SV = positionCS;
   return output;  
}

// Data defined for each renderer  
struct HeatmapObjectRendererData  
{  
  float4x4 localToWorldMatrix;  
  float alpha;  
  int blendMode;  
};

// Buffer that stores the data of all instances  
StructuredBuffer<HeatmapObjectRendererData> _HeatmapObjectInstanceBuffer;

// View-projection matrices  
float4x4 _HeatmapMatrixV;  
float4x4 _HeatmapMatrixP;

// Vertex shader  
FragmentData vert(VertexData input)  
{  
	FragmentData output;
	
	// Access renderer data using the instance ID.  
	HeatmapObjectRendererData instanceData = _HeatmapObjectInstanceBuffer[input.instanceID];
	
	// Get vertex position in object space  
	float4 positionOS = quadVerticesOS[input.vertexID];
	
	// Convert vertex position from object space into world space using the matrix in the renderer data,  
	float4 positionWS = mul(instanceData.localToWorldMatrix, positionOS);
	
	// Convert world-space into view space using the view matrix.  
	float4 positionVS = mul(_HeatmapMatrixV, positionWS);
	
	// Convert view-space into clip space.  
	float4 positionCS = mul(_HeatmapMatrixP, positionVS);
	
	output.positionCS_SV = positionCS;
	
	return output;  
}

private void OnGUI()  
{  
	if (heatmapTexture != null)  
		GUI.DrawTexture(new Rect(0, 0, 512, 512), heatmapTexture, ScaleMode.ScaleToFit, false);  
}

 
Pass  
{  
  // Changed blending to additive  
  Blend One One

struct FragmentData  
{  
	float4 positionCS_SV : SV_Position;
	
	// Added interpolator for UV  
	float2 uv : TEXCOORD0;  
};

FragmentData vert(VertexData input)  
{  
	FragmentData output;
	
	HeatmapObjectRendererData instanceData = _HeatmapObjectInstanceBuffer[input.instanceID];
	
	float4 positionOS = quadVerticesOS[input.vertexID];  
	float4 positionWS = mul(instanceData.localToWorldMatrix, positionOS);  
	float4 positionVS = mul(_HeatmapMatrixV, positionWS);  
	float4 positionCS = mul(_HeatmapMatrixP, positionVS);  
	output.positionCS_SV = positionCS;
	
	// Calculate UV using object space  
	// Object space is from (-0.5 to 0.5) in the XZ axis, so I just need to add 0.5 to make it 0-1 range.  
	float2 uv = positionOS.xz + 0.5f;  
	output.uv = uv;
	
	return output;  
}
float4 frag(FragmentData input) : SV_Target0  
{    
	// Calculate the blob intensity  
	float distanceToCenter = distance(input.uv, float2(0.5f, 0.5f));  
	float blob = smoothstep(0.5, 0.0, distanceToCenter);
	
	// Draw blob into red channel  
	return float4(blob, 0.0, 0.0, 0.0);  
}