Hey there!
Thought I'd give a quick breakdown of one of our cooler VFX in Loop Lock Malfunction in case anyone finds it interesting/cool/helpful. The glitch effect happens when you take damage and looks like this:
Glitchy!
This effect looks really complicated, but is actually quite simple! Let's break it down.
Start with a sphere
Technically we could draw this effect with a single plane that covers the player, but then we need to ensure it always renders on top of the player and faces the camera which is just extra work for slightly better performance. Considering this was a jam game, dev time was way more valuable to us so we just used a sphere. This also allows us to take some other shortcuts in the shader (more on that in a bit).
_Yup, that's a sphere.
Now we need a shader
I used Amplify Shader Editor to speed up the creation of the shader, but this can be done with some pretty straightforward HLSL code too. If you need help with one of the nodes, it's pretty likely you can just google it and find someone who has implemented it manually. Oh, and I should mention this is being done in the Unity Built-in Pipeline, not one of the SRPs. This relies on GrabPass which is not supported in HDRP (and possibly not in URP either, but don't quote me on that one), though there are ways to code in equivalent functionality with more effort.
_Oh... that's pretty simple.
Let's modulate the UVs
As the above picture shows, the magic really all comes down to what UVs we use to sample the screen colors. Here's the node setup (don't worry, I'll go over what's happening after the picture):

Starting on the left, we need to take the default screen UVs and multiply them by the ratio of the screen width to the screen height. This ensures our texture doesn't look stretched on wider screens. We then multiply that by a GlitchScale parameter and pass that into a Panner node which animates the UVs vertically over time (controlled by the Speed parameter). This goes into a texture sampler that has a displacement map. The one I used looks like this:

As you can see, it's mostly gray. This is because we subtract 0.5 from the value so black will be -0.5 and white will be +0.5. Therefore the gray will have no visible displacement. We then multiply this by the GlitchAmount parameter to control the overall strength of the effect. That gives us something like this:
_Ah, much glitchier!
But wait! Look at those awful hard edges where the sphere just ends (the ones with red arrows pointing at them). We have to do something about that.
Fresnel time!
So you remember that shortcut I mentioned earlier? N-no? (Wow you have a short memory...) WELL ANYWAYS, this is where it comes in handy. Since the sphere has smooth normals, we can use a Fresnel effect to control the intensity of the effect and fade it out towards the edges.
_VERY exaggerated Fresnel effect for illustration
We then multiply the strength by the Fresnel value (which we saturate first to clamp the range from 0-1) which gives us a nice soft falloff.

Meanwhile in CPU land...
At this point, the only thing left to do is set the GlitchAmount value over time whenever you take damage. We use an AnimationCurve that we evaluate in an IEnumerator to gradually decrease the intensity. When you get hit, the glitch sphere is enabled and we start the coroutine (making sure to stop the previous one if one was already playing). When the coroutine finishes, we disable the sphere so that it's not rendering while you aren't taking damage.
And that's it!
That's all there is to it! If you wanna see the effect in action, you can check out Loop Lock Malfunction and get hit by some lasers. Shouldn't be too hard. :stuckouttongue: Hopefully you found this interesting/cool/helpful and I look forward to seeing more VFX like this from your future Ludum Dare projects. :sunglasses:
Oh and here's the full ASE graph for reference. Knock yourself out.
