Bayer 4x4 dithering shader for use with Unity's FullscreenRenderPassFeature. This is meant to be plugged into a simple Shader Graph Custom Function node which takes in raw screen position and the URP sample buffer. Also includes 2x2 and 8x8 Bayer matrices in case you want to try those out.

Bayer4x4.hlsl

inline half3 GammaToLinearSpace (half3 sRGB)
{
  // Approximate version from http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html?m=1
  return sRGB * (sRGB * (sRGB * 0.305306011h + 0.682171111h) + 0.012522878h);
}

inline half3 LinearToGammaSpace (half3 linRGB)
{
  linRGB = max(linRGB, half3(0.h, 0.h, 0.h));
  // An almost-perfect approximation from http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html?m=1
  return max(1.055h * pow(linRGB, 0.416666667h) - 0.055h, 0.h);
}

float4 Posterize(float4 value, float steps, float bayerValue)
{
  value.rgb = LinearToGammaSpace(value.rgb);
  value = floor(value * steps + bayerValue) / steps;
  value.rgb = GammaToLinearSpace(value.rgb);
  return value;
}

float GetBayer2x2(float2 pixelPosition)
{
  const float bayer_matrix_2x2[2][2] = {
    {  0.00,  1.00 },
    {  0.25,  0.75 },
  };
  return bayer_matrix_2x2[pixelPosition.x % 2][pixelPosition.y % 2];
}

float GetBayer4x4(float2 pixelPosition)
{
  const float bayer_matrix_4x4[4][4] = {
    { 0.0,    0.5,    0.125,  0.625 },
    { 0.75,   0.25,   0.875,  0.375 },
    { 0.1875, 0.6875, 0.0625, 0.5625 },
    { 0.9375, 0.4375, 0.8125, 0.3125 },
  };
  return bayer_matrix_4x4[pixelPosition.x % 4][pixelPosition.y % 4];
}

float GetBayer8x8(float2 pixelPosition)
{
  const float bayer_matrix_8x8[8][8] = {
    { 0.000, 0.500, 0.125, 0.625, 0.03125, 0.53125, 0.15625, 0.65625 },
    { 0.750, 0.250, 0.875, 0.375, 0.78125, 0.28125, 0.90625, 0.40625 },
    { 0.1875, 0.6875, 0.0625, 0.5625, 0.21875, 0.71875, 0.09375, 0.59375 },
    { 0.9375, 0.4375, 0.8125, 0.3125, 0.96875, 0.46875, 0.84375, 0.34375 },
    { 0.015625, 0.515625, 0.140625, 0.640625, 0.046875, 0.546875, 0.171875, 0.671875 },
    { 0.765625, 0.265625, 0.890625, 0.390625, 0.796875, 0.296875, 0.921875, 0.421875 },
    { 0.203125, 0.703125, 0.078125, 0.578125, 0.234375, 0.734375, 0.109375, 0.609375 },
    { 0.953125, 0.453125, 0.828125, 0.328125, 0.984375, 0.484375, 0.859375, 0.359375 },
  };
  return bayer_matrix_8x8[pixelPosition.x % 8][pixelPosition.y % 8];
}

void Bayer4x4_float(float4 PixelPosition, float4 Color, float Steps, float RenderScale, out float4 Result)
{
  PixelPosition.xy *= _ScreenParams.xy * RenderScale;

  float bayerValue = GetBayer4x4(PixelPosition.xy);
  float4 outputBayer = step(bayerValue, Color);

  Color = Posterize(Color, Steps, bayerValue);
  Result = Color;
}

This is probably the wrong way to learn unity, but I was recently inspired by Who's Lila and Return of the Obra Dinn. Could you provide more specific directions for implementing this? Specifically, I am just playing with the Terminal scene in the "universal 3d sample" if that gives you enough info to point me in the right direction.

This is probably the wrong way to learn unity, but I was recently inspired by Who's Lila and Return of the Obra Dinn. Could you provide more specific directions for implementing this? Specifically, I am just playing with the Terminal scene in the "universal 3d sample" if that gives you enough info to point me in the right direction.

This is a bit complicated to explain in text. I'll try but you'll definitely want to cross reference the documentation for this. This requires a newer version of Unity since Full Screen Shader Graph and adding those graphs to the renderer is pretty recent. I'm not sure what version it was added, but I made this using Unity 6.

1. Download this file and put it somewhere in your Unity project
2. Create a new full screen shader graph with right click in your project (Create -> Shader Graph -> URP -> Fullscreen Shader Graph)
3. Open the Shader Graph and create a Custom Function node
4. For inputs, add the following:

• ScreenCoord Vector4
• Color Vector4
• Steps Float
• RenderScale Float

5. For outputs, add the following:

• Result Vector4

6. It's very important that the above names are exactly correct. (And probably in the correct order too.) They need to match the function parameters that you see in the shader's Bayer4x4_float function definition.
7. Set the Type on the node to use File, and then point it to the shader file you downloaded.
8. Set the Name to Bayer4x4. This is to match the name you see in Bayer4x4_float. The _float in the name is there to show that it outputs at the float precision as opposed to the half precision. For most shaders, this is going to be the case.
9. Now you need to set up the inputs and outputs for the Custom Function node you created.
10. Create a Screen Position node, and set its mode to Raw. Connect that to the ScreenCoord input. This tells the shader which pixel it's working on.
11. Create a URP Sample Buffer node and set its Source Buffer to Blit Source. This effectively the shader the texture of the full screen as you see it so it can apply a shader to it.
12. For Steps and RenderScale you'll probably want to create inputs to the Shader Graph so you can edit these on a material rather than editing the graph itself. It's not necessary, but it's very useful to have so you can edit them in real time and see what they do. For good default values I recommend 16 for Steps, and 1.0 for RenderScale. You can always mess with these values later.
13. Steps is kind of, but not really, like setting the bit depth available for color accuracy. Higher values mean more accurate color. Lower values give you stronger dithering.
14. It's important that RenderScale be set to match whatever your game's Render Scale is at. You can find it on your project's Universal Render Pipeline Asset, by default called something like PC_RPAsset. This will be 1.0 unless you touch it, but it's an easy way to get low resolution memes with big dithering.
15. Finally, take the Result output and link it to the Fragment's Base Color. For extra credit, separate out the values and send the w (alpha) value to the Alpha input of the Fragment, but you probably won't need this unless you're doing camera stacking.

You're almost done! The only thing left is to create a Material and then add it to your rendering stack.

1. Create a new Material, and set its shader to the shader graph you just created
2. Go your Universal Render Data asset, usually named somethign like PC_Renderer
3. Add a new Renderer Feature called Full Screen Pass Renderer Feature
4. Set the Pass Material to the new material you created
5. You should see the dithering effect now, as long as this pass is enabled
6. If you exposed the Steps and RenderScale options, you can play with it on this material to see what they do

I hope this helps! I know text isn't the best way to explain this, but it's the best I can do right now. It's kinda too bad setting this up is such a process, because you need to know your way around Shader Graph and most importantly the quirks and features of the Custom Function node, which isn't the most intuitive thing to set up.