Shader Development from Scratch for (Unity 6 Compatible)

This lecture introduces the course and takes you through the content that will be covered showing demos of the effects that will be covered.

H3D has a bustling online student community.  Here's how to get involved.

How to contact us

More often than not when you are learning something new with software you will find it difficult to tell when you've done something wrong or the software is not working. Here are a couple of common issues you might come across when you start to develop shaders. Be sure to use these as a go to when debugging your own work.

This article explains how to get the shaders in this course to work with Unity 6.

In this lecture we will take a look at the graphics pipeline and the stages in taking a model from virtual to an image on the screen.

There's nothing like seeing your first shader program come to life. There's still much to discuss about the technical and programmatic specifications of shaders, but lets start with a simple example to get the ball rolling.

Shader code has a lot in common with regular C# but can sometimes look a little strange especially with respect to data types. In this lecture we will go over these types and discuss how they are used.

The structure of a model's mesh is crutial in determiing how a shader will affect its surface. Understanding all the 3D components of a mesh is a fundamental you should have under your belt before attempting to manipulate the look of its surface with shaders.

In this lecture we will examine in detail the properties block and investigate how external values and images can be used in shaders.

Before you can start writing more complex shaders an understanding of the way surface brightness is calculated based on the lighting model is necessary. In this lecture we will introduce the concept of lighting models and examine the simpliest: Lambert.

In this lecture normal mapping will be introduced. The method is a way to add detail and depth to a model when no geometric detail exists.

This lecture is a challenge on modifying the bumped and diffuse textures.

Sometimes it can be difficult to visualise mathematical concepts without models to support them.  In this article I will provide a tool for examining normals in Unity which will visualise them and how they change as their coordinates do.

In this section we will examine three illumination models from the history of computer graphics. Learning how each is applied across the surface of a polygon to give a resulting visual effect will give you a better appreciation for the role of the normal in developing shaders.

When you want to create an effect that involves multiple vectors, such as the world reflection and normals you need to mix these together in the shader so one affects the other before adding a texture. In this lecture you will learn how to effect a world reflection with a normal map.

At some point in the rendering pipeline a pixel ends up in a buffer or two. As you create more shaders and shaders containing multiple effects it becomes critical to understand exactly whats going on otherwise it becomes difficult to debug your code. In this lecture we will examing the roles of the frame buffer, z buffer and g buffer and touch on the processes of forward and deferred lighting.

Being able to tell where the part of a model is facing with respect to the viewer is critical for the production of numerous shader effects. The dot product function is "need to know" information for any shader writer.

Rim lighting demonstrates perfectly the use of the dot product, though it requires a little mathematical manipulation to get just the right results. In this lecture we will look at introducing other mathematical operations into the code to tweak the dot product.

When you want to vary the effect a shader has on different parts of a surface, logical statements are your friend. In this lecture we will explore the use of logical statements embedded in the code to turn parts of an effect on and off.

Thus far we've only used Lambert as the lighting model for our shader. To expand the possibilities of what you can do with shaders, we now examine the other lighting models available in Unity.

Lambert lighting cannot produce specular highlights. For that you need BlinnPhong. In this lecture we will employ the BlinnPhong lighting model to add glossy effects to our model.

In this lecture we take a look at the Unity Physically-Based Lighting Shaders and use the lighting models to investigate the metallic and specular features.

To the Standard PBR shader created in the last lecture add an emissive slider that makes the model glow in the same areas that are grey and white in the metallic gloss map. See the working example in this video. The solution is attached.

To the Standard Specular PBR shader created in the previous lecture reverse the glossiness effect so the black areas of the map are highly reflective and the grey and white much more diffuse. See the working example in this video. The solution is attached.

In this lecture we will explore the creation of custom lighting models through the development of our own Lambert, BlinnPhong and Toon Ramped lighting from scratch.

Many effects including particles and vegetation in games rely on textures which use the alpha channel. In this lecture we will explore the creation of shaders that manipulate this channel as well as discover how transparency works withing the rendering pipeline with respect to the Z buffer.

In this lecture we will use the alpha channel with rim lighting to create a holographic effect. Included in the lesson will be pointers on using mulitple passes to clear up z buffer issues arising from making models transparent.

Blending provides you with control over the way incoming colours are added to colours already in the frame buffer. Through a series of very simple blend statements you can create a plethora of effects. This lecture shows you how.

By default in computer graphics the reverse side of polygons are not shown to save on processing. However, in the case of billboards you might want to be able to draw on both sides. This lecture shows you how to turn on the drawing of the backfaces.

Sometimes you might want a shader that takes more than one image and then merges them together onto a single surface. In this lecture you will learn how to do this as well as dynamically turn one on and off at runtime.

In this lecture we will examine the use of another buffer called the Stencil Buffer. This is useful for masking certain pixels to create a variety of effects including XRay Vision and Drawing Holes in walls.

The best way to get to understand the stencil buffer is to try it out many different ways. In this lecture we will use the stencil buffer to create a fun optical illusion as well as a dynamic piece of stencil code to let you play with the stencil settings via the Inspector.

In this lecture we'll examine the structure of a vertex/fragment shader. I'll point out a few of the nuances in the code and then show you how to create your own.

Both the vertex shader and fragment shader both deal with vertices and they can both produce colours. In this lecture we will examine the differences.

V/F shaders, like surface shaders, are capable of processing materials to colour the surface of objects. In this lecture we will look at how UV values are processed in both the Vert and Frag functions. Towards the end I will show you how to take a screen grab of a scene and use that as a manipulatable material on a plane.

While lighting is best kept to surface shaders that handle them elegantly on your behalf, it is handy to know how they work in V/F shaders. This lecture examines how to add a lambert lighting model to create diffuse light.

There's no point in having light if you can't have shadows. So let's modify the lighting shader in this lecture to examine how shadows are cast and received.

In this lecture we will examine the use of a vertex shader with a surface shader. The vertex shader will be used to extrude the surface of a mesh for a ballooning effect.

Outline is a cool effect you can combine with toon shading to get a Borderlands rendered look. In this lecture we will examine two ways to achieve the look.

In this lecture we will create everyone's favourite glass. But this glass isn't simply a transparent pane. It includes bump mapping, a stained-glass pattern and light refraction.

Once you know how, modifying vertices with mathematical functions can create all sorts of interesting effects. In this lecture we will examine the sin function for producing waves on the surface of a plane.

In this lecture we will examine a simple way to change the UV values of a surface over time to create a texture that rolls over the surface.

In this lecture we will use more sine functions and lots of them, plus a cosine, pow and squareroot to create some old school plasma to warp across the surface of objects.

In this lecture we will learn about the basics of ray marching and use it to render a sphere inside a cube with shader code.

In this lecture we will explore further facets of the ray marching algorithm and also calculate per pixel lighting.

In this lecture we will begin looking at another way to mathematically represent a sphere and depth test in two places.

In this lecture we will create the function that calculates the fog density.

In this lecture we will use the fog calculating function in the vertex shader to render a ball of volumetric fog.

In this lecture we will look at the Value Noise algorithm that will be used to create clouds as well as begin setting up the cloud environment.

In this lecture we will start writing the value noise algorithm.

In this lecture we begin with an overview of programming predictable random values and write some random functions for the shader.

In this lecture we complete the writing of the 3d value noise and test out some of its basic functionality.

In this lecture we will put the final function together that will combine lighting and cloud density into the shader for your first view of simple clouds.

In this lecture we will look at mixing and matching map functions and multiple marches to create better clouds.

In this lecture we will begin modifying the clouds shader to work on the camera.

In this lecture we will complete writing the Clouds.cs script that bypasses the normal Unity drawing to render the clouds on the camera.

In this lecture we will finished adjusting the existing clouds shader to work when attached to a camera.

In this lecture the camera direction is corrected for the cloud movement and a challenge involving plasma is presented.

This article presents some extra reading and content on volumetric shaders.

This link provides further information on the courses you can look at taking based on your interests and skill level.