Unity URP forward rendering process and obtaining screen space UVs and depth

Forward rendering process

cpu Cull and sort on , Reject as , The visual centrum of the camera is removed , Remove the model outside the camera view , Don't render anymore . Occlusion culling , Eliminate the invisible model in the visual vertebra , Don't render anymore . Sorting to ensure performance , Opacity is from near to far , Reduce unnecessary rendering , Translucent objects to ensure correctness , From far to near .

cpu Get the required relevant model data on ： Vertex data Map data There are also material properties , Submit the data to gpu, And call gpu Rendering , Render every time , As a drawcall.

stay gpu On , In two parts , Part is vertex shader , The other part is the slice shader .
In vertex shaders , Mainly position change , Position the vertex , In turn, is Model space World space Look space Cutting space The process is MVP Matrix transformation .

There is also a process from vertex shader to fragment shader , In the process , Crop and cull , Clip the elements that are not in the screen to those that are only in the clipping display space , The display range is [-w, w], The four-dimensional variables obtained here xy It is under the cutting space xy coordinate ,z Is depth ,w Namely w, Note that there , Because get the screen uv You also need to operate in this step , And the compatibility of different platforms also needs to appear from this step , Because depth is z From this step, it varies according to the platform . Then proceed NDC（ Normalized equipment coordinate system ）, Normalization operation , stay unity Inside ,xy Restriction on 0 To w Between , And depth z, Depending on the platform , Then for -w To w perhaps 0-w.NDC After the operation , Remove the back , Some invisible elements （ Mainly triangular surface , Points and lines don't need ） Get rid of . If the three points of the primitive triangle are rendered clockwise, it is the back , Will be eliminated , The face rendered counterclockwise is the front , Will be rendered .

After the back culling , About to switch to screen space （ Or buffer space ）, Here, it will be converted according to the rendered width and height , After the conversion , Element assembly , And then rasterize , Rasterization can be understood as obtaining the pixels of the screen occupied by the elements （ Usually called pianyuan ）, How many pixels does it occupy , How many times will the slice shader be called to calculate the color . This step is to calculate the results of all slices of the primitive synchronously .

Slice shader operation completed , The final output merging stage is reached . After your calculation , It may not be able to fill pixels with color , We also need to conduct multiple tests , After passing these tests , Then the color can be written to the frame buffer . These steps are ：

1. Translucency test According to transparency , How many colors below transparency are directly discarded for writing .unity The function inside is clip, Internal if the value passed in is less than 0, No color will be written .
2. Template testing According to the template set before , contrast , If you pass, you will continue to the next step .
3. Depth testing Compare the depth of the frame buffer , By continuing to the next step .
4. Mixed testing This step is mainly for translucent objects , The current color is mixed proportionally with the pixel color of the frame buffer , Get the final color .
   Last , After completion , You can write the color to the buffer smoothly . Be careful , The buffer does not just store the colors of pixels , There is also in-depth information , And template information .

Get screen space UV

The previous rendering process has said so much , Then you should know how to get the screen uv Is that right . Must be NDC Spatial xy Just the coordinates , So how to get , stay urp Inside , There are two ways , First, let's talk about the simplest ：

as follows , Use it directly urp Built in GetVertexPositionInputs function , Enter the vertex coordinates in model space , You can get the world space , Look space , Cutting space ,NDC All information in space . We can look at the structure ：

The second way , That is, we calculate by ourselves through the coordinates in the clipping space ,unity Relevant methods are also built in ,

You can see , In fact, it's just a revision xy Coordinates of ,zw It didn't move at all . take xy from -w To w, Changed to 0 To w The range of .

_ProjectionParams Of x Item is for platform compatibility ,dx Of y coordinate 0 It's the top , and opengl Platform 0 To 1 It's from bottom to top .
I also found the width and height constant of the screen ：

There is also time related

List others

These are all in UnityInput.hlsl In file , You can go and have a look for yourself .

Return to the right topic , Now that we have NDC Spatial xy, Their current range is [0, w], Then it's easy , As long as we divide by w, Then you get the screen space UV Coordinates .

Get depth

above , We get the screen UV, It's through NDC Coordinates in space xy Acquired , Actually z The value of is depth , We get the depth , First, limit it to 0-1 Or depending on the platform , stay -1 To 1 Between , In fact, it is in w Just fine .

such , You can get , Objects closer to the camera , The amount of color , The farther away , The darker it gets .

Why do you write this , because unity The values of the near clipping plane and the far clipping plane of each platform have been built in , We just need to judge



Here are a few of them , The normalized value of the far clipping plane and the near clipping plane of the platform , We can use this to calculate a unified depth rendering effect , You can do the rest by yourself unity Search in the Library , The names are listed below .

Get the depth in the depth map

The mood is here , Then write about how to get the depth in the depth map .
First , You have to urp Pipeline Asset Inside , Turn on depth texture rendering .

When it's turned on , You can shader It declares the texture _CameraDepthTexture, You can get the depth map .
Then take the screen obtained above uv, You can get the depth on the depth map .

It's that simple , You get the depth , renders , That's it

Last , There's another problem , Now the depth in the depth map and the depth you get , It's not linear , We need to be linear ,unity There are also built-in methods

Use according to your own needs , One is calculated from the near cutting surface , One is calculated from the camera position .1 Is the far cutting surface .
The first value is passed into the depth you calculated , Or the depth obtained from the depth map .
Second value _ZBufferParams, I also took a screenshot above , You can find it from above .

end .