Catlike Coding

We continue the modernization of our shadows code, pulling it out of the lighting pass and splitting it into three passes. Custom SRP 7.2 - Separate Shadow Passes (Catlikecoding)

Our shadow handling code has always resided in a single class, which took care of both directional and other shadows. Because those two shadow types are handled separately we now give them their own classes. This is a rather dry refactor, but it paves the way for giving them dedicated render passes

Unity 6.5 has been released and of course it breaks our SRP again. But the fix is simple. We officially lost LPPV support with this update, but we'll add support for the superior Adaptive Probe Volume system in the future. Custom SRP 7.0.0 (Catlikecoding)

This time we change our color LUT into a true 3D texture, which we fill via a compute shader. Custom SRP 6.2.0 (Catlikecoding)

Want to see the color LUT used by a camera? Now you can! We add a debug visualization for it. This will come in handy when we modernize the LUT, which we'll do in the future. Besides that we also fix rendering when a camera is set to render to a texture. Custom SRP 6.1.0 (Catlikecoding)

We upgrade our Custom SRP project to Unity 6.3, and... it fails to render. So we fix that! Native render passes are now supported and we get the Render Graph Viewer working again. Custom SRP 6.0.0 (Catlikecoding)

This take we convert some of our unsafe passes to more restrictive raster render passes. This will allow more efficient pass management and rendering in the future. Custom SRP 5.1.0 (Catlikecoding)

This time we make the jump to Unity 6.1 and migrate to using more specific pass types. (This tutorial came out in May, but the Patreon post ended up missing, hence it is late.) Custom SRP 5.0.0 (Catlikecoding)

We open our RP in Unity 6, are greeted with a bunch of errors and a stream of warnings, then make everything work again. We can now finally use renderer lists for the skybox and shadow casters, no longer needing to fall back to old API calls. Shadow caster culling is done all at once, no longer inte

This time we simplify a few things. We consolidate some shadow setting and also remove the lights-per-object mode. This is in preparation for the migration to Unity 6, which will officially release next week. Custom SRP 3.2.0 (Catlikecoding)

This time we make our Forward+ render configurable, adding settings for tile size and max lights per tile. We also hide the deprecated settings and mark the lights-per-object mode as obsolete. As we move forward and get closer to Unity 6 the goal is to make things as simple as possible before switch

We bump the major version up to 3, because we added a simple implementation of Tiled Forward+ rendering. This can make rendering much more efficient when there are many visible point and spot lights. Custom SRP 3.0.0 (Catlikecoding)

We replace the old structured buffer arrays for light and shadow data with structured buffers. Custom SRP 2.5.0 (Catlikecoding)

We start 2024 with finalizing our RP's migration to the Render Graph API. In this case it's mostly moving code around so the tutorial paints with broader strokes than usual. With that out of the way we can move on to modernizing other parts of our RP as well. Custom SRP 2.4.0 (Catlikecoding)

Previously we let the render graph manage our camera render textures. This time we do the same for shadow textures. We also get rid of the separate Lighting class, merging it into LightingPass. What's left are Post FX, which will come later. Custom SRP 2.3.0 (Catlikecoding)

After introducing renderer lists we now introduce texture handles. We let the render graph manage the render textures for the color and depth attachments as well as their copies. While we adapt our passes to work with these we also decouple them from CameraRenderer. Shadow maps and post FX will also

This tutorial introduces renderer lists, which is an alternative way of drawing geometry that makes it possible for the render graph to cull passes. Yes, the screenshot is very old. It is the image of the first tutorial in the Custom SRP series. Custom SRP 2.1.0 (Catlikecoding)

Version 2.0.0 of our custom SRP makes the switch to exclusively using the Render Graph API. This is just the first step, with minimal refactoring to rely on the API. Proper usage of it and better code separation will follow in the next versions. Note that this, like all future releases, is both a pr

The Custom SRP tutorial series has seen some changes! First, I upgraded the entire series to Unity 2022. These are minimal changes that I point out throughout the series, so you'll see them if you work through the series now. Second, I have created a Custom SRP project that has the latest FXAA tutor

This time we're building support for FXAA into our RP. It is an implementation of the (configurable) FXAA 3.11 quality PC version, which can achieve the best results. FXAA (Catlikecoding)

In the last tutorial of 2020 we decouple the resolution at which we render from the camera target resolution, and make this configurable both for the entire RP and per camera. To make everything work as expected we also have to perform color correction and tone mapping at the adjusted resolution, in

This times we're covering billboard particles. Unlit only, but with support for flipbooks, near fading, soft particles, and distortion. We have to do quite a bit to make that work. Particles (Catlikecoding)

We're going to crank our graph's resolution up to 1,000, rendering a million moving cubes at once! To pull that off we'll move our function library to the GPU. This takes advantage of the parallel processing power of the GPU and eliminates data transfer from CPU to GPU. Compute Shaders (Catlikecodin

We revisit rendering multiple cameras at the same time, this time in combination with post FX. Besides that we also add support for rendering layer masks, which enables flexible masking. Multiple Cameras (Catlikecoding)

This time we add various color grading tools to our RP, mimicking some of the URP/HDRP ones. Then we bake both color grading and tone mapping in a LUT. Color Grading (Catlikecoding)

This month the custom SRP tutorial comes first, and it's about HDR rendering! We fight fireflies, create scatter-based bloom, and apply tone mapping. HDR (Catlikecoding)

This time we lay the groundwork for our own post-FX stack. The first effect that we create is artistic bloom, because it's so obvious. Post Processing (Catlikecoding)

Point and spot lights should get realtime shadows too! Now they do. Unfortunately I haven't yet figured out how to stop Unity from switching the cull mode for point light shadows. It becomes a non-issue when universally rendering two-sided shadows, but it's not ideal. Point and Spot Shadows (Catlike

We finally move beyond only supporting directional lights, including point and spot lights as well! This tutorial covers realtime, baked, and shadow mask for those other light types. Realtime shadows will come later. Point and Spot Lights (Catlikecoding)

It's time to add support for some more complex materials to our RP's shader! Complex Maps (Catlikecoding)

This time we extend our custom RP with support for LOD groups and reflections. We keep the reflections simple, specifically one probe per object, no box projections. LOD and Reflections (Catlikecoding)

This time we deal with the truly mixed lighting modes: those that mix realtime lighting and shadows with baked shadows! Shadow Masks (Catlikecoding)

This time we cover baking light in the Custom SRP series. Light maps, light probes, and light probe proxy volumes. We also consolidate the shader input in a single file so we don't have to redefine it for each pass, as we now also need a meta pass. Baked Light (Catlikecoding)

We wrap up 2019 with part 4 of the SRP series, and it is massive! All of our directional lights get cascaded shadow maps in one large atlas, with filtering up to PCF 7x7, cascade blending, semitransparent shadow casters, and more. Enjoy! Directional Shadows (Catlikecoding)

The third Custom SRP tutorial dives into lighting. We limit ourselves to directional lights only, but that's already a lot of ground to cover. It works through topics that got covered by multiple tutorials of the old SRP series, besides using a new approach. Directional Lights (Catlikecoding)

We continue building our custom SRP, this time creating an unlit shader and figuring out how to draw things efficiently. It's covering old ground from the previous SRP series, including a crash-course of writing shaders because some people today have only used the shader graph. But it goes fast and

Here is the first part of Custom SRP, my new series covering the scriptable render pipeline in Unity 2019 and later. This first installment is mostly an upgrade from the old experimental API to the current one. But it also introduces a dedicated camera-renderer, segregates code more, uses partial cl

The final installment of the SRP series deals with render scale, MSAA, and HDR to make our images as pretty as possible. The last installment? Yes. I end the current SRP series here. I will follow it up with a new modern SRP series that will both upgrade everything to Unity 2019 and also introduce n

Unity has multiple post-processing solutions. There's the old OnRenderImage approach, there's the PPV2 stack, and there's the upcoming new stacks specific to the LW/Universal and HD render pipelines. And now we're going to make our own. Post-processing solutions can be quite complex, but for this se

In this part of the SRP series we're taking a look at LOD groups. We add support for cross-fading LOD levels by clipping with a screen-space blue noise bias. Once that's done we implement shader variant stripping to limit how many shader variants get included in builds, because each feature we add t

During the process of upgrading the SRP series to Unity 2019 I have encountered a Unity bug that I consider a showstopper. In short, all light indices beyond the fourth per object are broken. The issue has been reproduced and is in the issue tracker. It currently has a low priority. I'd like to get

We move on from global illumination to mixed lighting, which means combining realtime lighting with baked shadows. Or the other way around, in case of subtractive lighting. This tutorial is still for Unity 2018. The upgrade of the SRP series to 2019 is progressing, but not finished yet. It's a lot o

This installment of the Scriptable Render Pipeline series covers the big subject of indirect lighting in one go, both static and dynamic, with light maps, probe groups, LPPVs, and emission. Shadow masks aren't part of this, because they are for direct lighting. I'll cover them later. Global Illumina

We're going to enhance our scriptable render pipeline with reflections! Specular highlights, fresnel, and environment maps. All those were already covered by the Rendering series, but now we're doing it ourselves in our own pipeline. Reflections (Catlikecoding)

This time we'll add support for transparency to our pipeline, first alpha clipping and then fading. This tutorial is all about editing shaders, including adding a shader GUI for some convenient functionality. Transparency (Catlikecoding)

After spotlight shadows, we add support for directional shadows. Mixing directional and spotlight shadows requires a little work. Once that's finished, we move on to cascaded shadow maps. We'll define a main light that uses a separate cascaded shadow map to better use our shadow texels. Directional

I have upgraded the Scriptable Render Pipeline series so it works with Unity 2018.3. There are a few changes. MyShaderIncludePaths is gone, as that approach is no longer supported. Instead, core library files are included via Packages/com.unity.render-pipelines.core and our own files via a relative

We're adding support for shadows to our pipeline now! We start with spotlight shadows, which are simplest. That's still plenty for one tutorial, because we have to figure out how to deal with up to sixteen shadowed spotlights, while sticking to single-pass forward rendering for the regular camera. W