Alan Zucconi writes tutorials on shaders, procedural animation, color, and math for game and graphics programming.
Commenters recommend his tutorials as clear first steps for shaders and graphics, including his diffraction grating and atmospheric scattering articles that produce working images.
For procedural animation: I have yet to find the path to learning this skill. It is very opaque, and I think you just need to attack it with your brain and learn it.
For shader and graphics programming: I liked this tutorial series as a "first steps" by Freya Holmér: https://www.youtube.com/watch?v=kfM-yu0iQBk
Here is another list: https://www.alanzucconi.com/2018/01/03/learning-shaders/
The Book of Shaders is a popular suggestion, but it appears to be abandoned: https://thebookofshaders.com/
For general Unreal? Tom Looman's $300 Unreal C++ class, available on his website. It is pricey but really excellent.
I also discovered this AWESOME list of learning paths for all gamedev concepts: https://github.com/miloyip/game-programmer
UE5 Nanite -> https://dev.epicgames.com/documentation/en-us/unreal-engine/nanite-virtualized-geometry-in-unreal-engine
WebGPU -> https://developer.mozilla.org/en-US/docs/Web/API/WebGPU_API
Meshlet -> https://developer.nvidia.com/blog/introduction-turing-mesh-shaders/
LOD -> https://en.wikipedia.org/wiki/Level_of_detail_(computer_graphics)
Software rasterizer -> https://en.wikipedia.org/wiki/Rasterisation ("software" means it runs on the CPU instead of GPU)
Billboard imposters -> https://www.alanzucconi.com/2018/08/25/shader-showcase-saturday-7/
Culling -> https://en.wikipedia.org/wiki/Hidden-surface_determination
A neat real-world example of ancient Quake code surviving to this day is visible in Valves games - the hardcoded patterns for flickering lights in Quake 1 survived into GoldSrc and then into Source and then into Source 2, most recently showing up in Half Life Alyx, 24 years on from their original appearance in Quake 1.
https://www.alanzucconi.com/2021/06/15/valve-flickering-lights/
Basically all of the bigger systems will have been Ship-of-Theseus'd several times over by now, but little things like that can slip through the cracks.
Yes, it's possible to do physically based diffraction grating effects in the traditional pipeline. Here's a tutorial on it: https://www.alanzucconi.com/2017/07/15/the-nature-of-light/ (I actually implemented this effect recently: the article is great overall, but you can get rid of the loop by using some simple algebra.)
However, as pointed out in sibling comments, this makes assumptions about the coherence of the light coming in.
I mostly just think they look cool :)
In the post there's a demo on how to use the same algorithm that generates Voronoi diagrams to render 2D drop shadows with a spread radius.
You may also be interested in Alan Zucconi's article on Voronoi diagrams where he outlines a few use-cases in games: http://www.alanzucconi.com/2015/02/24/to-voronoi-and-beyond/2/#acp_wrapper
By interpolating, you mean like given two colors, you want to generate the intermediate gradient colors, like on this article[1]? If that's the case, I don't see why interpolating two saturated colors would provide a shade of gray. Can you clarify?
[1]: https://www.alanzucconi.com/2016/01/06/colour-interpolation/