Download "The Graphics Pipeline and You | Writing Unity URP Code Shaders Tutorial [1/9] ✔️ 2021.3"
!["videoThumbnail The Graphics Pipeline and You | Writing Unity URP Code Shaders Tutorial [1/9] ✔️ 2021.3](/_next/image?url=https%3A%2F%2Funidownloader.com%2FcontentImages%2F2Hrv_QHe-oPeoAJ5VmmV-NrKLUw%3D%2Ffilters%3Aquality(80)%3Aformat(webp)%2Fi.ytimg.com%252Fvi_webp%252FKVWsAL37NGw%252Fmaxresdefault.webp&w=1139&q=75)
Table of contents
Similar videos from our catalog
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252F7UuFRs2TBI0%252Fsddefault.jpg&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi_webp%252FCoch-PkHY54%252Fmaxresdefault.webp&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FJLFkv3ieV18%252Fmaxresdefault.jpg&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FOVb2lfCw5eM%252Fmaxresdefault.jpg&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FQe53ATaodRk%252Fmaxresdefault.jpg&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FQw2fkZK79M8%252Fmaxresdefault.jpg&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FaQuc5dwxh2I%252Fmaxresdefault.jpg&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FnVg8dyKniL4%252Fmaxresdefault.jpg&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi_webp%252FwhmPkDp3dqo%252Fmaxresdefault.webp&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252Fxo9JRPhGi68%252Fmaxresdefault.jpg&w=1139&q=75)
Video tags
Subtitles
Russian
00:00:00
hi i'm ned and i make games00:00:02
would you like to start writing shaders00:00:04
but don't know where to begin00:00:06
or are you having issues with urp's00:00:08
shader graph and would like an00:00:09
alternative in this tutorial series i'll00:00:11
walk you through writing a fully00:00:13
featured general purpose shader for00:00:14
unity's universal render pipeline00:00:16
exclusively in code00:00:18
this topic is pretty big so i'll break00:00:20
it into several videos check the video00:00:23
description for links to each tutorial00:00:25
and a playlist too00:00:26
we'll start with understanding the00:00:28
structure of shaders and then move on to00:00:30
lighting and shadows before finishing00:00:32
with more advanced topics like00:00:33
physically based materials and custom00:00:35
lighting models00:00:37
also if you prefer reading tutorials00:00:39
i've created a written version of the00:00:40
entire series also linked in the video00:00:42
description before i move on i want to00:00:45
thank all my patrons for helping make00:00:46
this series possible and give a big00:00:48
shout out to my next gen patron00:00:50
cubeydoobydoo thank you all so much00:00:53
i'd like to quickly show off a wonderful00:00:55
game from some long time viewers kitty00:00:57
cat squash it's an adorable casual00:01:00
puzzle game where you match cute kitties00:01:02
and try to beat your high scores00:01:04
it starts simple but can quickly become00:01:05
a brain teaser try out a bunch of00:01:07
different game modes gravity was my00:01:09
favorite and unlock 16 different cats i00:01:12
love seeing juliet on my board so00:01:14
precious kitty cat squash is available00:01:16
on steam the google play store and the00:01:19
amazon app store00:01:20
go get your cute kitty fix00:01:23
thank you inspired by madness games for00:01:25
sponsoring this video00:01:26
let's lay out some goals of this00:01:28
tutorial series my aim is to teach how00:01:30
to write shaders i will show several00:01:33
examples writing each step by step and00:01:35
explaining as we go00:01:37
do not view these examples as ready for00:01:39
production shaders but rather as a00:01:41
blueprint that you can customize to your00:01:43
game's needs00:01:44
after completing this series you'll know00:01:46
how to write your own version of urp's00:01:48
standard lit shader00:01:50
as well as customize it with your own00:01:51
lighting algorithm and more you'll also00:01:54
know several optimization techniques and00:01:56
how to leverage unity's debugging tools00:01:58
to diagnose and fix rendering bugs00:02:01
the examples in this tutorial were00:02:02
tested in unity 2020.3 and 2021.300:02:06
as you follow the tutorial you will come00:02:08
across many features that are only00:02:10
possible in 2021 however i have written00:02:13
the shaders so that the same code runs00:02:15
in each version00:02:17
there's quite a lot to set up and00:02:18
understand before anything will display00:02:20
on screen which can make learning00:02:22
shaders pretty difficult00:02:24
to speed up the process i'll explain00:02:26
information as needed and i might gloss00:02:28
over some edge cases or technicalities00:02:31
don't worry i'll address them if they00:02:32
become important later on00:02:34
to keep this series from becoming even00:02:36
longer i will assume that you have some00:02:38
general game development knowledge00:02:40
you should be comfortable using unity00:02:42
and its 3d game tools such as models00:02:45
textures materials and mesh renderers00:02:48
and although you need no prior00:02:49
experience writing shaders you should00:02:51
know how to program c-sharp experience00:02:53
will definitely be useful with all that00:02:56
out of the way let's get started00:03:00
in this series we'll use unity's00:03:01
universal render pipeline is one of00:03:03
several rendering frameworks that unity00:03:05
provides but i chose urp for this00:03:08
project due to its recency and ability00:03:10
to support a wide variety of platforms00:03:12
all while remaining pretty lightweight00:03:15
i would highly suggest creating a fresh00:03:17
project for this tutorial you can either00:03:19
select the urp project template00:03:22
or use a blank template add urp manually00:03:25
through the package manager and activate00:03:27
it in graphics settings00:03:46
either way create a new standard scene00:03:48
to work with00:03:51
large shaders like the one will write00:03:53
are made of several files to help keep00:03:55
things organized create a new folder00:03:57
called mylit to contain them all00:04:00
create a shader file by selecting unlit00:04:02
shader from the create dialog and name00:04:05
it mylit.shader00:04:07
if you create a material you'll already00:04:09
see your shader in the shader selection00:04:11
menu of the material inspector00:04:14
it will be under the unlit submenu00:04:19
open your shader file in your code00:04:20
editor of choice00:04:22
if you're using visual studio sometimes00:04:24
unity doesn't generate a visual studio00:04:26
project correctly when there are no00:04:27
c-sharp scripts present00:04:30
first create an empty c-sharp script00:04:36
so your shader will appear in the00:04:37
solution explorer00:04:42
regardless inside mylit.shader is a lot00:04:45
of automatically generated code00:04:47
delete it all for now00:04:50
this part of a shader is written in a00:04:52
language called shader lab and it00:04:54
defines meta information about the00:04:55
actual drawing code00:04:57
the first line opens a shader block and00:04:59
defines the shader's name in the00:05:01
material inspector any slashes will00:05:03
create subsections in the selection menu00:05:06
useful for organization00:05:08
the block is bound by curly braces00:05:10
like classes in c sharp00:05:13
a shader is more than just code that00:05:14
draws a single shader is actually made00:05:17
of many sometimes thousands of smaller00:05:19
functions00:05:20
unity can choose to run any of them00:05:22
depending on the situation they're00:05:24
organized into several subdivisions the00:05:26
top most of which are known as00:05:28
subshaders00:05:30
subshaders allow you to write different00:05:31
code for different render pipelines and00:05:33
unity will automatically pick the00:05:35
correct sub shader to use at any time00:05:38
define a sub shader with a sub shader00:05:40
block and then add a tags block to set00:05:42
the render pipeline tags blocks hold00:05:44
user defined metadata in a format sort00:05:46
of like a c sharp dictionary tell unity00:05:49
to use this sub shader when the00:05:50
universal rendering pipeline is active00:05:52
by setting the render pipeline tag to00:05:54
universal pipeline00:05:57
that's the only sub shader that we'll00:05:58
ever need in this tutorial00:06:00
subshaders are just the first00:06:01
subdivision of a shader below them are00:06:03
passes passa's purpose is a bit more00:06:06
abstract each pass has a specific job to00:06:09
help draw the entire scene like00:06:11
calculating lighting casting shadows or00:06:14
creating special data for00:06:15
post-processing effects00:06:17
unity expects all shaders to have00:06:20
specific passes to enable all of urp's00:06:22
features but for now let's only focus on00:06:25
the most important pass the one that00:06:27
draws a material's color00:06:29
to signal that this pass will draw color00:06:31
add a tags block inside the path type00:06:34
key is light mode00:06:36
and the value for a lit color pass is00:06:38
universal forward00:06:40
you can also name passes which will help00:06:42
a lot in debugging00:06:44
okay we're almost ready to write some00:06:46
code erp shader code is written in a00:06:48
language called hlsl which is similar to00:06:51
a streamlined c plus to mark a section00:06:54
of a shader file as containing hlsl00:06:57
surround it with the hlsl program and00:07:00
end hlsl code words00:07:03
to keep things organized i like to keep00:07:05
hlsl code in a separate file from the00:07:07
dot shader metadata thankfully this is00:07:09
easy to do00:07:11
you can't create an hlsl file directly00:07:13
in unity but you can in visual studio00:07:17
or inside your file system00:07:23
either way name this new file00:07:25
myletforwardlitpass.hlsl00:07:32
and open it in your code editor00:07:35
i just want to mention that many code00:07:37
editors don't work well with urp shaders00:07:40
so while working through this tutorial00:07:42
ignore any errors that you see in your00:07:44
code editor and just rely on unity's00:07:46
console00:07:48
when writing shaders you need to have a00:07:49
different mindset than you would when00:07:51
working with c sharp00:07:52
for one there's no heap meaning most00:07:55
variables work like numeric primitives00:07:57
or structs00:07:58
you can't define classes or methods or00:08:00
use inheritance structs and functions00:08:03
are still available to help you organize00:08:05
your code00:08:06
if you've ever worked with data-driven00:08:08
design you'll also feel at home writing00:08:10
shaders00:08:11
the focus is gathering data and then00:08:12
transforming it from one form to another00:08:15
in the broadest sense shaders transform00:08:17
meshes materials and orientation data00:08:20
into colors on the screen00:08:22
there are two standard functions which00:08:24
the system calls kind of like the start00:08:26
and update functions in mono behaviors00:08:29
these functions are called the vertex00:08:31
and fragment functions and every pass00:08:34
must have one of each00:08:35
these both focus on transforming data00:08:38
from one form to another the vertex00:08:40
function takes mesh and world position00:08:42
data and transforms it into positions on00:08:45
the screen00:08:46
the fragment function takes those00:08:47
positions as well as material settings00:08:50
and produces pixel colors00:08:52
unity's rendering system employs00:08:54
something called the graphics pipeline00:08:56
to link together these functions and00:08:58
handle low-level logic00:09:00
the pipeline gathers and prepares your00:09:01
data calls the vertex and fragment00:09:03
functions and displays the final colors00:09:06
on the screen it's made of several00:09:08
stages running one after another kind of00:09:10
like an assembly line00:09:11
each stage has a specific job00:09:13
transforming data for later down in the00:09:15
assembly line00:09:17
there are two special stages the vertex00:09:19
and fragment stages which are00:09:21
programmable00:09:22
they run the vertex and fragment00:09:24
functions that you write00:09:25
the other stages are not programmable00:09:28
and run the same code for all shaders00:09:30
although you can influence them with00:09:32
various settings00:09:34
let's take a look at each stage starting00:09:37
at the beginning the input assembler00:09:39
it prepares data for the vertex stage00:09:42
gathering data from meshes and packaging00:09:44
it in a neat struct00:09:45
structs in hlsl are very similar to c00:09:48
sharp a pass by value variable00:09:50
containing various data fields00:09:52
this tract is customizable and you can00:09:55
choose what data the input assembler00:09:56
gathers by adding fields to the struct00:09:59
but just what kind of data can the input00:10:01
assembler access00:10:03
the input assembler works with meshes00:10:05
specifically mesh vertices00:10:07
each vertex has a bunch of data assigned00:10:09
to it such as position normal vector00:10:12
texture uvs etc each data type is known00:10:15
as a vertex data stream00:10:17
to access any stream in your input00:10:19
structure you simply need to tag it and00:10:21
the assembler will automatically set it00:10:23
for you00:10:24
for example here's an input struct for00:10:26
our forward passes vertex function00:10:28
it defines a struct called attributes00:10:31
which has a field called position with a00:10:34
type called float3 float3 is the hlsl00:10:37
term for c-sharp vector3 or a vector00:10:40
containing three float numbers00:10:43
we can use semantics to tag variables00:10:45
and the input assembler will00:10:46
automatically set them to a particular00:10:48
data stream00:10:50
for example the position semantic00:10:52
corresponds to vertex position00:10:54
keep in mind that only the semantic00:10:56
determines what data the input assembler00:10:58
will choose to place in variables feel00:11:01
free to name variables however you wish00:11:03
we'll see more semantics later on hlsl00:11:05
uses them pretty often to help the00:11:07
graphics pipeline along00:11:10
with that let's move on to the vertex00:11:12
stage as a programmable stage you get to00:11:14
define the code that runs here defining00:11:17
a function in hlsl is very similar to c00:11:19
sharp with a return type void at the00:11:22
moment00:11:23
a function name and a list of arguments00:11:26
an argument's type precedes the variable00:11:29
name this function only needs a single00:11:31
argument of attributes type00:11:33
the vertex stage's primary objective is00:11:36
to compute where mesh vertices appear on00:11:37
the screen00:11:39
however notice that the attribute struct00:11:40
only contains a single position00:11:43
only data for a single vertex00:11:45
the render pipeline actually calls the00:11:47
vertex function multiple times passing00:11:50
it data for each vertex until all are00:11:52
placed on the screen00:11:53
in fact many calls will run in parallel00:11:56
if you've ever programmed multi-threaded00:11:58
systems you know that parallel00:12:00
processing can introduce a lot of00:12:02
complexity shaders bypass a lot of this00:12:05
by forbidding storage of state00:12:06
information00:12:07
each vertex function call is effectively00:12:10
isolated from all the others00:12:12
you cannot pass the result of one vertex00:12:14
function or any data computed inside to00:12:16
another00:12:18
each call can only depend on the data in00:12:20
the input struct as well as other global00:12:22
data but more on that later00:12:25
in addition each vertex function call00:12:27
only knows about data of a single vertex00:12:30
this is mostly for efficiency the gpu00:12:33
doesn't want to load the entire mesh at00:12:35
once00:12:36
we need to compute the screen position00:12:37
for a vertex described in the attribute00:12:39
struct when talking about positions it's00:12:42
important to determine the coordinate00:12:43
system that it's defined in its space00:12:47
the position vertex data streams gives00:12:49
values in object space00:12:51
which is another name for the local00:12:53
space that you're accustomed to in00:12:54
unity's scene editor00:12:56
if you view a mesh in a 3d modeling00:12:58
program these positions are also00:13:00
displayed there00:13:04
another space you'll often use is world00:13:06
space00:13:08
it's a common space that all objects00:13:10
exist in relative to one another00:13:12
to get world space from object space00:13:14
just apply an object's transform00:13:16
component00:13:17
unity provides this data to shaders as00:13:19
we'll see soon00:13:21
however a vertex's position on screen is00:13:23
described using a space called clip00:13:26
space00:13:27
an explanation of clip space would fill00:13:29
an entire tutorial but luckily we don't00:13:31
have to work with it directly00:13:33
urp provides a nice function to convert00:13:36
an object space position to clip space00:13:38
to access it we first need to access the00:13:40
urp shaders library in hlsl we can00:13:43
reference any other hlsl file with the00:13:46
hash include directive00:13:48
these commands tell the shader processor00:13:50
to read the file located at a given00:13:52
location and copy its contents into this00:13:54
line00:13:56
if you're curious what's inside the00:13:57
lighting.hlsl file or any other urp00:14:00
source file you can read them yourself00:14:03
in your packages folder00:14:05
included files can themselves include00:14:07
many other files leading to a kind of00:14:09
tree structure00:14:11
for instance lighting hlsl will pull in00:14:13
many helpful functions from across the00:14:15
entire urp library00:14:17
one such function git vertex position00:14:20
inputs is located in the shader variable00:14:23
functions.hlsl file00:14:25
its source code isn't really important00:14:27
but it returns a structure containing00:14:29
the past object space position converted00:14:32
into various other spaces clip space is00:14:34
one of them just what we need00:14:37
note that clip space is a float 4 type00:14:40
if you tried to store it in a float 300:14:42
unity would give you a warning that data00:14:44
will be truncated or lost this is a00:14:46
common source of bugs so always heed00:14:48
these warnings and use the correct00:14:50
vector size00:14:51
keeping track of which space a position00:14:53
is in can get tricky pretty fast00:14:56
standard erp code adds a suffix to all00:14:58
position variables indicating the space00:15:01
os denotes object space cs clip space00:15:05
etc00:15:06
we should follow this pattern as well00:15:10
next we must fulfill the vertex stage's00:15:12
job and output the clip space position00:15:14
for the input vertex to do that let's00:15:17
define another struct called00:15:18
interpolators to serve as the vertex00:15:20
stages return type write a float400:15:23
position cs field inside of it with the00:15:26
sv underscore position semantic the00:15:28
semantic signals that this field00:15:30
contains clip space vertex positions00:15:33
have the vertex function return an00:15:35
interpolator struct declare a variable00:15:37
of interpolator's type set the position00:15:40
cs field and return the structure00:15:43
with that the vertex stage is complete00:15:46
the next stage in the rendering pipeline00:15:47
is called the rasterizer00:15:49
the rasterizer takes all vertex screen00:15:51
positions and calculates which of the00:15:53
mesh's triangles appear over which00:15:55
pixels on the screen if a triangle is00:15:58
entirely off screen the render is smart00:16:00
enough to ignore it the rasterizer then00:16:02
gathers all data for the next stage in00:16:04
the pipeline the fragment stage00:16:07
the fragment stage is also programmable00:16:10
and the fragment function runs once for00:16:12
every pixel the rasterizer determines00:16:14
contains a triangle00:16:15
the fragment function calculates and00:16:17
outputs the final color each pixel00:16:19
should display00:16:21
but of course each call only handles one00:16:23
pixel00:16:25
the fragment function has a form like00:16:27
this00:16:28
it takes a struct as an argument which00:16:30
contains data output from the vertex00:16:32
function00:16:33
naturally the type should match so both00:16:35
should be an interpolator00:16:37
the values inside input have been00:16:39
modified by the rasterizer00:16:41
for instance position cs no longer00:16:44
contains slip space position but rather00:16:46
this fragment's pixel position00:16:49
you can also pass other data from the00:16:51
vertex function into the fragment00:16:53
function through the interpolator struct00:16:55
a technique that we'll use later on00:16:57
the fragment function outputs a float400:17:00
the color of the pixel it might be00:17:02
strange to think about but colors are00:17:04
just vectors they contain a red green00:17:07
blue and alpha value each ranging from 000:17:09
to 1. to let the pipeline know that00:17:11
we're returning the final pixel color00:17:14
tag the entire fragment function with00:17:16
the sv underscore target semantic when00:17:19
tagging a function with a semantic the00:17:21
compiler interprets the return value as00:17:23
having that semantic00:17:25
so we can finally display something on00:17:27
screen now let's just color all pixels00:17:29
white return a float4 with all00:17:32
components set to 1.00:17:34
see here that you don't need to write00:17:35
new in hlsl when constructing vectors00:17:39
just the type name is fine00:17:41
the last stage in the graphics pipeline00:17:43
is the presentation stage it takes the00:17:46
output of the fragment function and00:17:48
together with information from the00:17:49
rasterizer colors all pixels accordingly00:17:53
there's one last thing to do we need to00:17:55
register our vertex and fragment00:17:57
functions to a shader pass00:17:59
return to the mylet.shader file tell the00:18:02
compiler to read the code inside your00:18:04
myletforwardlitpass.hlsl00:18:06
file using a hash include command00:18:09
next register the vertex and fragment00:18:11
functions using a hash pragma command00:18:14
hashpragma has a variety of uses00:18:16
relating to shader metadata but the00:18:19
vertex and fragment sub-commands00:18:21
register the corresponding functions to00:18:23
the containing pass00:18:24
make sure that the function names match00:18:26
those in your hlsl file00:18:30
and we're now finally ready to view your00:18:32
shader make sure the material has mylet00:18:35
selected and create a sphere in your00:18:37
scene give it your material it should00:18:40
now appear as a flat white circle00:18:45
if it's colored magenta or there's some00:18:47
other issue check unity's console and00:18:49
the shader asset to see if there are any00:18:51
errors00:18:56
okay so we have a flat white circle now00:18:58
that's a good starting place let's make00:19:00
the color adjustable from the material00:19:03
inspector this is possible through a00:19:05
system unity calls material properties00:19:08
material properties are essentially hlsl00:19:11
variables that can be set and edited00:19:13
through the material inspector in unity00:19:15
they are specified per material and00:19:18
allow objects using the same shader to00:19:20
look different00:19:21
if you are wondering what's the00:19:22
difference between a shader and a00:19:24
material this is basically it a material00:19:27
is a shader with specific property00:19:29
settings00:19:31
we can define properties inside the dot00:19:33
shader file with a properties block00:19:36
the syntax for these is inconsistent but00:19:39
i'll explain it00:19:41
to define a color property first decide00:19:43
on a reference name00:19:45
this is how you'll access a property in00:19:47
hlsl00:19:49
by convention property names start with00:19:51
an underscore00:19:52
follow that with a parentheses pair like00:19:54
you're writing a function00:19:56
the first argument is a string00:19:58
this is a label how it will display in00:20:00
the material inspector00:20:02
the next argument is the property type00:20:05
there are various but color defines a00:20:08
color property00:20:09
close the parentheses and then set a00:20:11
default value the syntax is different00:20:14
for each property type00:20:15
but for colors start with an equal sign00:20:18
and then the red green blue alpha values00:20:21
inside of parentheses00:20:24
as mentioned before00:20:25
colors are just four float values each00:20:28
corresponding to a color channel00:20:30
red green blue and alpha00:20:33
these combine to create any color that a00:20:36
computer can display00:20:38
each number ranges from zero to one00:20:40
where white is all ones and black is all00:20:42
zeros00:20:43
for alpha one is opaque and zero is00:20:46
invisible if you'd like more info on how00:20:48
these numbers combine to create a color00:20:51
i have a link in the video description00:20:54
now you should be able to see your00:20:55
property in the material inspector00:20:58
later this shader will have many00:21:00
properties so we should organize them00:21:02
add a header label denoting surface00:21:04
options to do that use this header00:21:07
command strangely the label is not00:21:09
enclosed in quotation marks here00:21:12
there's one last thing that we should do00:21:14
properties can be tagged with attributes00:21:16
like classes in c sharp these give00:21:18
properties special features00:21:20
tag color tint with the main color00:21:22
attribute00:21:24
now it's possible to easily set this00:21:25
property from c sharp using00:21:27
material.color00:21:30
the property is all set up but the value00:21:32
is not reflected on screen00:21:35
open myletforwardlitpass.hlsl00:21:38
although we defined a property in00:21:39
shaderlab we must also define it here in00:21:42
hlsl00:21:43
make sure the reference name matches00:21:45
exactly00:21:47
unity will automatically synchronize00:21:49
this variable with the material00:21:50
inspector00:21:52
earlier i did say that vertex and00:21:54
fragment functions could only access00:21:56
data from a single vertex or fragment00:21:58
and while this is true they can also00:22:01
access any material properties00:22:03
these variables are uniform meaning they00:22:06
don't change while the pipeline is00:22:07
running00:22:09
unity sets them before the pipeline00:22:10
begins and you cannot modify them from a00:22:13
vertex or fragment function00:22:15
with this in mind have the fragment00:22:17
function return color tint as the final00:22:19
color00:22:21
return to the scene editor select your00:22:23
material and change the color tint00:22:25
property00:22:26
the shader should immediately reflect00:22:28
your choice00:22:33
flat colors are great but it'd be really00:22:36
cool to vary the color across the sphere00:22:38
we can do this with textures00:22:41
shaders love working with textures00:22:43
they're just image files but shaders00:22:45
think of them as 2d arrays of color data00:22:48
when you zoom into a texture this does00:22:50
become pretty obvious00:22:52
to add a texture to a shader first add a00:22:54
texture material property00:22:57
defining a texture property is much the00:22:59
same as a color property00:23:01
instead of listing a typos color set it00:23:03
to 2d00:23:04
the syntax for default textures is kind00:23:07
of strange following the equal sign type00:23:10
white with quotes followed by a pair of00:23:12
curly braces00:23:14
if no texture is set in the material00:23:15
inspector unity will fill this property00:23:18
with a small white texture by default00:23:20
you can also set the default color to00:23:22
black gray or red00:23:25
similarly to the main color attribute00:23:27
there is also a main texture attribute00:23:30
tagging this property makes it easily00:23:31
assignable from c sharp using00:23:33
material.main texture your property00:23:36
should now show up in the material00:23:37
inspector00:23:39
notice the four numbers beside it they00:23:41
allow you to set an offset and scale for00:23:43
this texture which is useful for tiling00:23:47
now let's take a look at the hlsl side00:23:49
of things00:23:50
defining a texture variable is a bit00:23:52
more complicated than a color variable00:23:55
you first must use this special syntax00:23:57
to define a 2d texture once again the00:24:00
name must match the property reference00:24:02
exactly texture 2d here is not a type00:24:06
but something called a macro00:24:08
you can think of macros similarly to00:24:10
functions except they run on the text00:24:13
making up code00:24:14
you can create macros yourself using the00:24:16
hash define command00:24:18
before compiling the system will search00:24:21
for any text matching a defined macro00:24:23
and replace the macro name with the text00:24:26
that you specify00:24:27
macros can also have arguments00:24:30
the system will replace any occurrences00:24:32
of argument names in the macro00:24:33
definition with whatever text that you00:24:35
pass in00:24:36
this is a really simple overview of00:24:38
macros but they can be pretty useful in00:24:40
shader code hlsl doesn't have00:24:43
inheritance or polymorphism so if you00:24:45
want to work with any structure that has00:24:47
a position os field but you don't00:24:49
necessarily know the structure type a00:24:51
macro can do the trick00:24:53
here's an example00:24:55
they're also great at handling platform00:24:57
differences which is what unity has done00:24:59
with texture2d see different graphics00:25:01
apis like directx opengl etc use00:25:05
different type names for textures to00:25:07
make shader code platform independent00:25:10
unity provides a variety of macros to00:25:12
deal with textures00:25:13
that's just one less thing that we have00:25:15
to worry about00:25:16
moving on there are a couple more00:25:18
variables that unity automatically sets00:25:20
when you define a texture property00:25:22
textures have a companion structure00:25:24
called a sampler which defines how to00:25:26
read a texture options include the00:25:29
sampling and clamping mode that you're00:25:30
familiar with from the texture importer00:25:32
point by linear etc unity stores00:25:35
samplers in a second variable which you00:25:37
define with the sampler macro00:25:39
the name here is important it must00:25:42
always have the pattern sampler followed00:25:44
by the texture reference name00:25:46
finally remember the tiling and offset00:25:48
values from the material inspector00:25:51
unity stores those inside of a float400:25:53
variable00:25:54
the name must follow the pattern of the00:25:56
texture name followed by st00:25:59
inside the x and y components hold the x00:26:02
and y scales while the z and w00:26:04
components hold the x and y offsets00:26:07
and yes the fourth component of a float400:26:09
vector is referred to as w in hlsl00:26:14
now we'd like to sample the texture or00:26:16
read color data from it00:26:18
we should do that in the fragment stage00:26:20
to apply texture colors to each pixel00:26:23
use the sample texture 2d macro to get00:26:26
the color out of a texture at a specific00:26:28
location00:26:29
it takes three arguments the texture the00:26:32
sampler and the uv coordinate to sample00:26:36
well what are uvs00:26:38
uvs are texture coordinates assigned to00:26:40
all vertices of a mesh00:26:43
which define how a texture wraps around00:26:45
a model00:26:47
think of how cartographers try to unwrap00:26:49
a globe to fit on a flat map they're00:26:52
basically assigning uvs to positions on00:26:54
the globe00:26:55
uvs are float 2 variables where the x00:26:58
and y coordinates define a 2d position00:27:00
on a texture uvs are normalized or00:27:02
independent of the texture's dimensions00:27:05
they always range from 0 to 1 and by00:27:07
convention 0 0 is the bottom left corner00:27:10
of a texture00:27:12
unfortunately we can't grab uvs out of00:27:14
thin air in the fragment stage they're00:27:17
another vertex data stream that the00:27:18
input assembler needs to gather00:27:21
add a float2 uv field to the attribute00:27:23
structure with a text chord 0 semantic00:27:26
text chord 0 is short for texture00:27:29
coordinate set number 0.00:27:31
models can have many sets of uvs or00:27:33
texture coordinates for instance unity00:27:35
uses tech scored 1 for light map uvs but00:27:38
we'll get to that later00:27:40
the attribute struct is not available in00:27:42
the vertex stage either however we can00:27:44
store data in the interpolator struct00:27:46
which will eventually make its way to00:27:48
the fragment stage00:27:49
add another float 2 uv field there00:27:52
have it also used the text chord 000:27:54
semantic00:27:56
in the vertex function past the uv from00:27:58
the attribute struct to the00:27:59
interpolator's tract we can also apply00:28:02
uv scaling and offset there which we00:28:04
might as well00:28:06
this way we'll only have to compute it00:28:07
once per vertex instead of once per00:28:09
pixel00:28:10
it's a good idea to do as much as00:28:11
possible in the vertex function since it00:28:14
generally runs fewer times than the00:28:15
fragment function00:28:17
unity provides the transform text macro00:28:19
to apply tiling00:28:21
there are two interesting things about00:28:22
it00:28:23
first the double hash tells the00:28:25
pre-compiler to append text to whatever00:28:28
is passed in as the macro argument00:28:30
when the macro runs you can see how it00:28:32
replaces name with underscore color map00:28:34
correctly referencing color map st00:28:38
second the x y and zw suffixes give easy00:28:42
access to a pair of components as a00:28:43
float 2. this mechanism is called00:28:45
swizzling you can ask for any00:28:48
combination of the x y z and w00:28:50
components in any order the compiler00:28:53
will construct an appropriately sized00:28:54
float vector variable for you00:28:56
you can also use rgb and a the same way00:29:00
which is more intuitive for colors00:29:02
it's even possible to assign values with00:29:04
a swizzle operator00:29:05
anyway00:29:06
now we have the uv data in the fragment00:29:08
stage but let's take a moment to really00:29:11
think about what's happening here00:29:13
the vertex function outputs data for00:29:15
each vertex the rasterizer takes those00:29:17
values places the vertices on the screen00:29:20
and figures out what pixels cover the00:29:22
formed triangle00:29:24
it finally generates an input structure00:29:26
for each fragment function call but what00:29:28
value will input uv have for each00:29:31
fragment00:29:32
the rasterizer will interpolate any00:29:34
field tagged with a text chord semantic00:29:36
using an algorithm called barycentric00:29:38
interpolation00:29:40
you're probably familiar with linear00:29:42
interpolation where a value on a number00:29:44
line is expressed as the weighted00:29:46
average of the values at each endpoint00:29:49
barycentric interpolation uses the same00:29:51
idea except extends it to a triangle00:29:54
the value at any point inside the00:29:55
triangle is a weighted average of the00:29:57
values at each corner00:29:59
luckily the rasterizer handles all of00:30:01
this for us so the algorithm is not00:30:03
really important00:30:06
to recap the values and interpolators00:30:08
are a combination of values returned by00:30:10
the vertex function00:30:12
specifically for any fragment they are a00:30:14
combination of values from the three00:30:16
vertices forming the triangle that00:30:18
covers this fragment's pixel00:30:22
well all that for some uvs but we00:30:25
finally have all that we need to call00:30:27
sample texture 2d00:30:29
it returns a float for the color of the00:30:31
texture at the specified uv position00:30:34
depending on the sampler sample mode00:30:36
point by linear etc this color may be a00:30:39
combination of adjacent pixels to help00:30:42
smooth things out00:30:43
regardless multiply the sample with the00:30:45
color tint property and then return it00:30:48
in hlsl multiplying two vectors is a00:30:51
component-wise operation meaning the00:30:53
x-components of each vector are00:30:54
multiplied together then the00:30:56
y-components etc all arithmetic00:30:58
operators work like this00:31:01
in the scene editor set a texture on00:31:03
your material and marvel at what you've00:31:05
accomplished00:31:08
note how the texture and color tint00:31:09
properties interact00:31:12
also notice that if your texture has an00:31:14
alpha component the shader doesn't00:31:17
really handle transparency yet so the00:31:19
sphere will always be opaque00:31:22
we'll fix that in a future tutorial so00:31:24
stay tuned00:31:27
i hope that this wet your appetite for00:31:29
shader programming because we're really00:31:31
just getting started00:31:33
in the next part of this tutorial series00:31:35
we'll add simple lighting to finally00:31:36
give objects dimensionality and then00:31:38
we'll delve into shadows learning how to00:31:40
add additional passes to a shader00:31:44
you've gotten past a lot of the theory00:31:46
and can now focus on the fun stuff00:31:48
please stay tuned and subscribe and00:31:50
press the bell to be notified when my00:31:51
next tutorial video goes live00:31:54
if you enjoyed this consider liking the00:31:56
video as well it really helps out with00:31:58
the youtube algorithm00:32:00
if you have any issues or questions00:32:02
please feel free to leave a comment or00:32:04
contact me on any of my social media00:32:05
accounts00:32:07
i want to take another moment to thank00:32:09
all of my patrons for helping make this00:32:11
video possible and give a big shout out00:32:13
to my next gen patron croobiedoobydoo00:32:16
again thank you all for your support it00:32:18
really does mean a lot and if you want00:32:20
to download an example trader from this00:32:22
tutorial or any of my others you can00:32:25
join my patreon as well00:32:27
and finally don't forget to check out00:32:28
kitty cat squash00:32:30
thanks again inspired by madness games00:32:32
for sponsoring this video00:32:35
everyone thanks so much again for00:32:36
watching and make games00:32:40
[Music]00:32:53
youDescription:
Play Kitty Cat Squash ► https://store.steampowered.com/app/1814110/Kitty_Cat_Squash/ ✔️ Tutorial tested in 2020.3 and 2021.3 🚨 Edits: If you create your project from a template, ensure "Depth Priming Mode" is set to "Disabled" in your URP settings asset. To find this asset, open Project Settings, navigate to Graphics, and select the renderer asset at the top of the window. Would you like to start writing shaders but don’t know where to start? Or, have you encountered a limitation of URP’s Shader Graph you need to overcome? In this tutorial series, I’ll walk you through writing a fully featured, general purpose shader for Unity’s Universal Render Pipeline — exclusively in code. Don't know HLSL or ShaderLab? No problem. Tutorial series: 📰 Article version ►https://nedmakesgames.medium.com/writing-unity-urp-shaders-with-code-part-1-the-graphics-pipeline-and-you-798cbc941cea 🔀 Playlist ► https://www.youtube.com/playlist?list=PLAUha41PUKAYdsStTcjJbNV-GM3F2xm9s 1️⃣ The Graphics Pipeline ► You're watching it! 2️⃣ Lighting and Shadows ► https://www.youtube.com/watch?v=1bm0McKAh9E 3️⃣ Transparency ► https://www.youtube.com/watch?v=4zw6Vq5CzLY 4️⃣ PBR Materials ► https://www.youtube.com/watch?v=5GGISvt4KEA 5️⃣ Advanced Lighting ► Coming soon 6️⃣ Advanced URP Features ► Coming soon 7️⃣ Custom Lighting Models ► Coming soon 8️⃣ Vertex Animation ► Coming soon 9️⃣ Interacting with C# ► Coming soon 👑 Join my Patreon to access tutorials early, download project files, vote on future topics, and more! Thank you so much! ► https://www.patreon.com/nedmakesgames 🔗 Check out my website for a searchable list of tutorials! ► https://nedmakesgames.github.io/ 2️⃣ 2nd Channel ► https://www.youtube.com/nedmakesgames2 🔴 Twitch ► https://www.twitch.tv/nedmakesgames 🐦 Twitter ► https://twitter.com/nedmakesgames 🎮 Discord ► https://discord.com/invite/ubxSVBK 📸 Instagram ► https://www.facebook.com/unsupportedbrowser 👽 Reddit ► https://reddit.com/u/nedmakesgames 🎶 TikTok ► https://www.tiktok.com/@nedmakesgames ☕ Ko-fi ► https://ko-fi.com/nedmakesgames 📚 Reference scripts ► Flat white: https://gist.github.com/NedMakesGames/e102eaf3b0918a75d538053ab1853914 ► Flat color: https://gist.github.com/NedMakesGames/863ecfbe1c77dc9aefb4d5ebc72d19c9 ► Textures: https://gist.github.com/NedMakesGames/a10b965c8b453e07e9cedb29f155ee3b ⏲️ Timestamps: 0:00 Intro 0:53 Ad 1:26 Tutorial scope 2:58 Project set up 4:50 ShaderLab 7:02 Intro to HLSL 8:52 The Graphics Pipeline 9:34 The Input Assembler 11:09 The Vertex Stage 12:40 Spaces 15:45 The Rasterizer 16:04 The Fragment Stage 15:52 Hello World 18:54 Properties in ShaderLab 21:34 Properties in HLSL 22:31 Texture Properties 23:46 Macros 25:16 Sampling a Texture 26:35 What Are UVs 27:12 UVs in the Vertex Function 29:06 Interpolation 30:22 Hello Textures 31:26 Wrap up and credits 🎖️ Credits, references and further reading: • Unity Technologies: Shader Calibration Scene - https://assetstore.unity.com/packages/templates/tutorials/shader-calibration-scene-25422 • shedmon: Wooden Slingshot - https://sketchfab.com/3d-models/wooden-slingshot-a909ff4b85a64acebe23795967aa9fe3 • Martijn Vaes: DAE — Bilora Bella 46 Camera — Game Ready Asset - https://sketchfab.com/3d-models/dae-bilora-bella-46-camera-game-ready-asset-eeb9d9f0627f4783b5d16a8732f0d1a4 • tonyflanagan: Thailand Girl — Animated - https://sketchfab.com/3d-models/thailand-girl-animated-a41f779fe45b4a04bdbf212e49b7f6b5 • Kelvin Valerio: Brown Cat with Green Eyes - https://www.pexels.com/photo/brown-cat-with-green-eyes-617278/ • owowowsam: Mini Earth - https://www.cgtrader.com/free-3d-models/space/planet/mini-earth • Tom Patterson: Natural Earth III - http://www.shadedrelief.com/natural3/pages/textures.html • W3schools: CSS RGB Colors - https://www.w3schools.com/css/css_colors_rgb.asp Music: https://www.purple-planet.com/
Preparing download options
* — If the video is playing in a new tab, go to it, then right-click on the video and select "Save video as..."
** — Link intended for online playback in specialized players
Questions about downloading video
How can I download "The Graphics Pipeline and You | Writing Unity URP Code Shaders Tutorial [1/9] ✔️ 2021.3" video?
http://unidownloader.com/ website is the best way to download a video or a separate audio track if you want to do without installing programs and extensions.
The UDL Helper extension is a convenient button that is seamlessly integrated into YouTube, Instagram and OK.ru sites for fast content download.
UDL Client program (for Windows) is the most powerful solution that supports more than 900 websites, social networks and video hosting sites, as well as any video quality that is available in the source.
UDL Lite is a really convenient way to access a website from your mobile device. With its help, you can easily download videos directly to your smartphone.
Which format of "The Graphics Pipeline and You | Writing Unity URP Code Shaders Tutorial [1/9] ✔️ 2021.3" video should I choose?
The best quality formats are FullHD (1080p), 2K (1440p), 4K (2160p) and 8K (4320p). The higher the resolution of your screen, the higher the video quality should be. However, there are other factors to consider: download speed, amount of free space, and device performance during playback.
Why does my computer freeze when loading a "The Graphics Pipeline and You | Writing Unity URP Code Shaders Tutorial [1/9] ✔️ 2021.3" video?
The browser/computer should not freeze completely! If this happens, please report it with a link to the video. Sometimes videos cannot be downloaded directly in a suitable format, so we have added the ability to convert the file to the desired format. In some cases, this process may actively use computer resources.
How can I download "The Graphics Pipeline and You | Writing Unity URP Code Shaders Tutorial [1/9] ✔️ 2021.3" video to my phone?
You can download a video to your smartphone using the website or the PWA application UDL Lite. It is also possible to send a download link via QR code using the UDL Helper extension.
How can I download an audio track (music) to MP3 "The Graphics Pipeline and You | Writing Unity URP Code Shaders Tutorial [1/9] ✔️ 2021.3"?
The most convenient way is to use the UDL Client program, which supports converting video to MP3 format. In some cases, MP3 can also be downloaded through the UDL Helper extension.
How can I save a frame from a video "The Graphics Pipeline and You | Writing Unity URP Code Shaders Tutorial [1/9] ✔️ 2021.3"?
This feature is available in the UDL Helper extension. Make sure that "Show the video snapshot button" is checked in the settings. A camera icon should appear in the lower right corner of the player to the left of the "Settings" icon. When you click on it, the current frame from the video will be saved to your computer in JPEG format.
What's the price of all this stuff?
It costs nothing. Our services are absolutely free for all users. There are no PRO subscriptions, no restrictions on the number or maximum length of downloaded videos.