Catlike Coding

I finally cover the topic of triplanar mapping! Not only that, we're going to modify our existing include files to work both with and without regular vertex UV coordinates. We end up with an approach that's somewhat like Unity's surface shaders, in that we rely on a surface function to setup the dat

My latest advanced rendering tutorial goes through how FXAA works. It isn't just a bad filter that tuns images into a blurry mess. At least, not if you configure it well. You'll find that there are more options than just on-off. FXAA, a Unity Tutorial (Catlikecoding)

Here is a new advanced rendering tutorial, and it's about bloom! The bloom post-processing effect can be used to make things glow, or for other artistic effects. It's been overused a lot, giving it a negative reputation, but that's not stopping you from creating something good with it. Covering an i

After figuring out how tessellation works, the next step is to actually do something useful with it. In this tutorial, we'll combine tessellation with vertex displacement, turning an otherwise boring flat plane into an interesting surface. The idea is similar to parallax mapping, except now we're us

Now that we can conveniently show the wireframe of rendered triangles, we move on to subdividing them on the GPU. While conceptually straightforward, tessellation is a complicated process for the GPU to pull off, requiring multiple stages that we have to program. Tessellatino, a Unity Tutorial (Catl

This is the first tutorial in the Advanced Rendering category. It's about how to apply flat shading and a wireframe effect to any mesh. The main point is to introduce screen-space derivatives and geometry shaders. Besides that, it's a stepping stone to tessellation, which will be the next topic. Fla

The last effect that we add to our custom shader is parallax mapping. First, we duplicate the same parallax approach that the standard shader supports. Then we'll move beyond that and use raymarching to create a more convincing effect. This tutorial is the last part of the rendering series, covering

After covering static global illumination, it's time to tackle realtime GI. Then we move on to offer better light probe support for large objects, via proxy volumes. We finish by investigating LOD groups and supporting cross-fading between LOD levels. Rendering 18, Realtime GI, Probe Volumes, LOD Gr

Now that we know how to bake lights, lets combine both baked and realtime lighting. This can be done in various ways, either to enhance performance or realism. However, because mixed lighting is quite new, we are bound to encounter some bugs that we have to work around. Rendering 17, Mixed Lighting,

We've finally arrived at lightmapping! I've been postponing it until Unity offered a reasonably stable solution after introducing Enlighten. Version 5.6 is good enough. In this tutorial, we'll focus exclusively on baked static lighting. This is the most basic and also the most limited form of lightm

You already know how to fill the G-buffers. Now you'll also render your own deferred lights, instead of leaving that to Unity. From now on, the Rendering series is also created with Unity 5.6. This has introduced a few changes, but you should be able to handle that. Also, Nvidia's Cg documentation h

Fog is a common effect, used to add a sense of depth to a scene. It can be added to a forward shader, but requires a separate pass for deferred shading. We'll use an image effect for that. Rendering 14, Fog, a Unity Tutorial (Catlikecoding)

So far, we've only used the forward rendering path. But Unity also supports deferred shading. This tutorial investigates how that works. Rendering 13, Deferred Shading, a Unity Tutorial (Catlikecoding)

After supporting semitransparent surfaces, now it's time to support their shadows! Cutout shadows are not that hard. It's the semitransparent ones that are problematic. We have to use a trick to approximate them. Rendering 12, Semitransparent Shadows, a Unity C# Tutorial (Catlikecoding)

In the last tutorial of 2016, we'll cover semitransparent rendering. Unity's standard shaders support four rendering modes. They are opaque, cutout, fade, and transparency. Until now, we've always rendered in opaque mode. Now we'll add support for the other three modes. And just like the standard sh

Our materials weren't complex enough, really. So this time we'll add support for occlusion maps and detail masks. Now we can create some messy materials! And that's more reastic, because reality is messy. Besides that, we'll also take care of multi-material editing. While that's already somewhat pos

http://catlikecoding.com/unity/tutorials/rendering/part-9/ We're going to power up our shader's GUI. After that, we add support for metallic, smoothness, and emission maps. This adds a lot of flexibility to our shader. You can create complex materials, like glowing lava or a circuit board with light

http://catlikecoding.com/unity/tutorials/rendering/part-8/ Shading is all about reflections. Ironically, mirrors are one of the hardest things to get right. In real life, light bounces all over the place. Mirrors just work. Seemingly infinite bounces aren't a problem at all. Two mirrors facing each

http://catlikecoding.com/unity/tutorials/rendering/part-7/ It has been very sunny weather lately. I had to look for the shade, so I could write this tutorial. Shadows complicate the rendering process a lot. In this tutorial, we'll first investigate the work needed to render shadows for directional l

http://catlikecoding.com/unity/tutorials/rendering/part-6/ Part 6 of the Rendering series will be a bumpy ride. Because we're going to mess with normal vectors!