Convert to SRP HD

Sorry if this has been asked before (can't find anything) but how do I convert my existing project to the SRP HD pipeline?

 

So in a shorter way, Is it possible to convert our projects to HDRP (completely) or do we need to create new projects with HDRP built-in (Template) and redo everything?

 

Thanks for the writeup. I have Unity 2018.1.04b and there is no Edit -> Render Pipeline menu. It could have something to do with a convoluted method of downloading a GIT repo, fixing dependencies, etc. Never got that part to work. Could that be the cause? Why not make it easier to test?

 

Edit->Project Settings->Graphics., First field.

 

Is there a recommended time/date/HDRP version when we will be able start working on our new projects (HDRP) that won't break after a SRP/HDRP update?

 

When its actually released?

 

I mean, I know that. But probably no one wants to wait 5-9 months just to start working on their new project/convert the current one.
For sure there is going to be an experimental build that's going to be one of the final releases before the final one that's just going to work and won't break, That's why I was asking.

I'm just excited about this feature and I want to get my project on it as fast as I can.

 

Why pack AO with metal/rough and not height? I feel like baking AO into textures is kind of outdated and now it's either dynamic or handled by the lightmapper. Is it just to bring it in line with UE?

 

But it is still required to download the appropriate version from GIT, then download a custom post processing folder, right?

By the way, it would be nice to see some side by side comparisons of the regular Unity look and the HD look.

 

One other question. Is it possible to have an end user config option to choose between the different render pipelines or does it require maintaining two completely separate projects and executables?

 

And eventually, pick from many of the (soon to be) community authored SRPs that will undoubtedly come out!

Probably the most exciting part for me is that the rendering pipeline will be less in the hands of the developers and more in the hands of community, which means that if we dont like X Y or Z, we can finally just add it ourselves!

 

Yes, it's the only sane way. Have to resist casual users demanding it be everything, because - duh - we already have that and don't want the same mistakes.

 

So how to convert my project to the low end pipeline? What things to take into account?

 

Given what we have seen in the blog posts about writing SRP and the new pipelines, I really don't think its too outside the realms of possiblity of creating a (either official or community authored) program that will "translate" shaders from Standard Pipeline to one of the new pipelines. There will be definite detail loss, and lots of cases difficult to cover but I am sure getting something that effectively converts from one to the other possible as long as 1:1 is not what your trying to achieve (and shouldn't be if your changing the pipeline).

I'm going to be playing around with this idea, is anyone else going to have a shot at something like this or interested in something like this?

 

Ok, here it is: https://forum.unity.com/threads/convert-to-srp-low-end.515291/

 

Hi,
it's great to have new customizable rendering pipelines. But I have few questions about the Buildin one:

Will those mistakes be fixed someday?
Does the Builtin pipeline expected to disappear or being converted to scriptable?

 

How do I convert a custom shader to be compatible with the HD pipeline?

 

How is specific order of rendering done? I have a sword and shield that sometimes needs to be rendered on top of some but not all the other objects, and sometimes they don't... due to clipping issues.

I cannot render it without depth or the models render incorrectly. They also need shadows, so it's not an easy solution with builtin.

I wonder if HD offers a simpler way to control these situations, thanks.

 

Thanks for the example. Will try to make it work. My shader heavily abuses the standard mesh data (colors, normals, etc.) so I hope that won't pose any problems.

 

Ok, I got the shader to compile but it doesn't draw anything. Can you see anything wrong with it right of the bat?

By the way, how is fog handled now?

Code (CSharp):

1.  
2. Shader "Lights/Omnidirectional"{
3.  
4.     Properties{
5.  
6.         _MainTex ("Light Texture", 2D) = "white" {}
7.         [KeywordEnum(Doughnut, Equal)] _Lobe ("Radiation pattern", Float) = 0  
8.         _MinPixelSize ("Minimum screen size", FLOAT) = 5.0
9.         _Attenuation ("Attenuation", Range(0.01, 1)) = 0.37
10.         _BrightnessOffset ("Brightness offset", Range(-1, 1)) = 0
11.     }  
12.  
13.     SubShader{
14.  
15.         Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent"}
16.         Blend SrcAlpha One
17.         AlphaTest Greater .01
18.         ColorMask RGB
19.         Lighting Off ZWrite Off
20.  
21.         Pass{
22.  
23.             //SRP conversion:
24.             //Added:
25.             HLSLINCLUDE
26.             #pragma target 4.5
27.             #include "CoreRP/ShaderLibrary/common.hlsl"
28.             #include "HDRP/ShaderVariables.hlsl"
29.  
30.             //SRP conversion:
31.             //Removed:
32.            // #include "UnityCG.cginc"
33.  
34.             #include "lightFunctions.cginc"
35.  
36.             #pragma vertex vert
37.             #pragma fragment frag        
38.             #pragma multi_compile _LOBE_DOUGHNUT _LOBE_EQUAL
39.             #pragma multi_compile_fog //Enable fog
40.             #pragma glsl_no_auto_normalization
41.  
42.             uniform sampler2D _MainTex;      
43.             float _MinPixelSize;
44.             float angle;
45.             float _BrightnessOffset;
46.             float _Attenuation;
47.  
48.             //These global variables are set from a Unity script.
49.             float _ScaleFactor;
50.             float _GlobalBrightnessOffset;
51.  
52.             struct vertexInput {
53.  
54.                 float4 center : POSITION; //Mesh center position is stored in the position channel (vertices in Unity).
55.                 float4 corner : TANGENT; //Mesh corner is stored in the tangent channel (tangent in Unity). The scale is stored in the w component.
56.                 float4 normal : NORMAL; //Rotation forward vector is stored in the Normal channel (normals in Unity).
57.                 float2 uvs : TEXCOORD0; //Texture coordinates (uv in Unity).
58.                 float2 RGback : TEXCOORD1; //RG(B) back color is stored in a UV channel (uv2 in Unity).
59.                 float2 up : TEXCOORD2; //Rotation up vector is stored in a UV channel (uv3 in Unity).
60.                 float2 z : TEXCOORD3; //Rotation up vector (3rd component) is stored in a UV channel (uv4 in Unity). The x component is used for the blue component of the back color.
61.                 half4 RGBAfront : COLOR; //The front color is stored in the Color channel (colors32 in Unity). This channel is used as an ID for strobe lights.  
62.             };
63.  
64.  
65.             struct vertexOutput{
66.  
67.                 float4 pos : SV_POSITION;
68.                 float2 uvs : TEXCOORD0;
69.                 half4 color : COLOR;
70.  
71.                 //This is not a UV coordinate but it is just used to pass some variables
72.                 //from the vertex shader to the fragment shader. x = gain.
73.                 float2 container : TEXCOORD1;
74.  
75.                 //Enable fog.
76.                 UNITY_FOG_COORDS(2)
77.             };  
78.  
79.  
80.             vertexOutput vert(vertexInput input){
81.  
82.                 vertexOutput output;
83.                 float gain;
84.                 float distanceGain;
85.                 float angleGain;
86.                 float dotProduct;
87.                 float scale;
88.  
89.                 //Get a vector from the vertex to the camera and cache the result.
90.                 float3 objSpaceViewDir = ObjSpaceViewDir(input.center);
91.  
92.                 //Get the distance between the camera and the light.
93.                 float distance = length(objSpaceViewDir);  
94.              
95.                 //Use a fixed alpha because we use the alpha value to modulate the gain instead.
96.                 half4 RGBAfont = half4(input.RGBAfront.r, input.RGBAfront.g, input.RGBAfront.b, 0.2h);
97.  
98.                 #if _LOBE_EQUAL
99.                     angleGain = GetEqualLobe();
100.                     output.color = RGBAfont;
101.                 #else
102.                     //Compose the back color. There is no float4 slot left, so we use UV channels to store the colors.
103.                     float4 RGBAback = float4(input.RGback.x, input.RGback.y, input.z.x, 0.2f);
104.  
105.                     float3 viewDir = normalize(objSpaceViewDir);
106.  
107.                     //Compose the up vector. A UV channel only holds two floats,
108.                     //so we need to fetch the z coordinate from a third UV channel.
109.                     float3 upVector = float3(input.up.x, input.up.y, input.z.y);
110.  
111.                     //TODO: figure out a way to get the rotated normal from elsewhere instead.
112.                     float3 rotatedNormal = ProjectVectorOnPlane(upVector, viewDir);
113.                     dotProduct = dot(viewDir, rotatedNormal);
114.  
115.                     //Use a Phase Function to simulate the light lens shape and its effect it has on the light brightness.          
116.                     angleGain = GetRoundLobe(dotProduct);
117.                     //angleGain = GetEggLobe(dotProduct);
118.                     //angleGain = GetEqualLobe();        
119.                     //angleGain = GetTearDropLobe(dotProduct);
120.  
121.                     float forwardDotProduct = dot(viewDir, input.normal);
122.  
123.                     //Create a smooth transition between the two colors.
124.                     //output.color = Get015DegreeTransition(forwardDotProduct, RGBAfont, RGBAback);
125.                     //output.color = Get03DegreeTransition(forwardDotProduct, RGBAfont, RGBAback);
126.                     //output.color = Get06DegreeTransition(forwardDotProduct, RGBAfont, RGBAback);
127.                     output.color = Get10DegreeTransition(forwardDotProduct, RGBAfont, RGBAback);
128.                 #endif
129.  
130.                 //Calculate the scale. If the light size is smaller than one pixel, scale it up
131.                 //so it remains at least one pixel in size.
132.                 scale = ScaleUp(distance, _ScaleFactor, input.corner.w, angleGain, _MinPixelSize);
133.  
134.                 //Get the vertex offset to shift and scale the light.
135.                 float4 offset = GetOffset(scale, input.corner);
136.  
137.                 //Place the vertex by moving it away from the center.
138.                 //Rotate the billboard towards the camera.
139.                 output.pos = mul(UNITY_MATRIX_P, float4(UnityObjectToViewPos(input.center), 1.0f) + offset);
140.  
141.                 //Far away lights should be less bright. Attenuate with the inverse square law.
142.                 distanceGain = Attenuate(distance, _Attenuation);
143.  
144.                 //Merge the distance gain (attenuation), angle gain (lens simulation), and light brightness into a single gain value.
145.                 //Note that the individual light brightness is stored in the front color alpha channel.
146.                 gain = MergeGain(distanceGain, angleGain, _GlobalBrightnessOffset, input.RGBAfront.a + _BrightnessOffset);
147.  
148.                 //Send the gain to the fragment shader.
149.                 output.container = float2(gain, 0.0f);
150.  
151.                 //UV mapping.
152.                 output.uvs = input.uvs;
153.  
154.                 //Enable fog.
155.                 UNITY_TRANSFER_FOG(output, output.pos);
156.  
157.                 return output;
158.             }
159.  
160.             //SRP conversion:
161.             //Note: not sure whether to use COLOR or SV_Target
162.             half4 frag(vertexOutput input) : COLOR{
163.  
164.                 //Compute the final color.
165.                 //Note: input.container.x fetches the gain from the vertex shader. No need to calculate this for each fragment.
166.                 half4 col = 2.0h * input.color * tex2D(_MainTex, input.uvs) * (exp(input.container.x * 5.0h));      
167.              
168.                 //Enable fog. Use black due to the blend mode used.      
169.                 UNITY_APPLY_FOG_COLOR(input.fogCoord, col, half4(0,0,0,0));
170.                  
171.                 return col;
172.             }
173.             ENDHLSL
174.         }
175.     }
176. }
177.  

 

Thanks for clearing that up. Here are some more issues I found.

I assume that UnityCG.cginc is depreciated with the release of the SRP (it causes compile errors), but this helper function is missing (maybe more):

Code (CSharp):

1. ObjSpaceViewDir()

My new conversion attempt compiles, but still doesn't work correctly. There seems to be a problem with the billboard world/screen space conversion as I can see the billboards incorrectly on screen of in the distance. Before I was using this function:

Code (CSharp):

1. output.pos = mul(UNITY_MATRIX_P, float4(UnityObjectToViewPos(input.center), 1.0f) + offset);

I converted this like so (incorrect, I am sure):

Code (CSharp):

1. output.pos.xyz = TransformObjectToWorld(input.center.xyz);
2. output.pos = mul(UNITY_MATRIX_P, float4(output.pos.xyz, 1.0f) + offset); //Rotate billboard towards camera. Not sure how to convert this to SRP.
3. output.pos.xyz = GetCameraRelativePositionWS(output.pos.xyz);
4. output.pos = TransformWorldToHClip(output.pos.xyz);

Another question. I see that the SRP shader version uses two passes. My original only uses one pass. Isn't this bad for performance?

New shader attempt:

Code (CSharp):

1.  
2. Shader "Lights/Omnidirectional"{
3.  
4.     Properties{
5.  
6.         _MainTex ("Light Texture", 2D) = "white" {}
7.         [KeywordEnum(Doughnut, Equal)] _Lobe ("Radiation pattern", Float) = 0  
8.         _MinPixelSize ("Minimum screen size", FLOAT) = 5.0
9.         _Attenuation ("Attenuation", Range(0.01, 1)) = 0.37
10.         _BrightnessOffset ("Brightness offset", Range(-1, 1)) = 0
11.     }  
12.  
13.     //SRP conversion:
14.     //Added:
15.     HLSLINCLUDE
16.     #pragma target 4.5
17.     #define SHADER_CUSTOM_VERTEX customVert
18.     #include "CoreRP/ShaderLibrary/common.hlsl"
19.     #include "HDRP/ShaderVariables.hlsl"
20.  
21.     //SRP conversion:
22.     //Removed:
23.     //#include "UnityCG.cginc"
24.  
25.     #include "lightFunctions.cginc"
26.  
27.     //SRP conversion:
28.     //Removed:
29.     //#pragma vertex vert
30.     //#pragma fragment frag    
31.  
32.     #pragma multi_compile _LOBE_DOUGHNUT _LOBE_EQUAL  
33.     #pragma glsl_no_auto_normalization
34.  
35.     //SRP conversion:
36.     //Removed:
37.     //#pragma multi_compile_fog
38.  
39.     uniform sampler2D _MainTex;      
40.     float _MinPixelSize;
41.     float angle;
42.     float _BrightnessOffset;
43.     float _Attenuation;
44.  
45.     //These global variables are set from a Unity script.
46.     float _ScaleFactor;
47.     float _GlobalBrightnessOffset;
48.  
49.     struct vertexInput {
50.  
51.         float4 center : POSITION; //Mesh center position is stored in the position channel (vertices in Unity).
52.         float4 corner : TANGENT; //Mesh corner is stored in the tangent channel (tangent in Unity). The scale is stored in the w component.
53.         float4 normal : NORMAL; //Rotation forward vector is stored in the Normal channel (normals in Unity).
54.         float2 uvs : TEXCOORD0; //Texture coordinates (uv in Unity).
55.         float2 RGback : TEXCOORD1; //RG(B) back color is stored in a UV channel (uv2 in Unity).
56.         float2 up : TEXCOORD2; //Rotation up vector is stored in a UV channel (uv3 in Unity).
57.         float2 z : TEXCOORD3; //Rotation up vector (3rd component) is stored in a UV channel (uv4 in Unity). The x component is used for the blue component of the back color.
58.         half4 RGBAfront : COLOR; //The front color is stored in the Color channel (colors32 in Unity). This channel is used as an ID for strobe lights.  
59.     };
60.  
61.     struct vertexOutput{
62.  
63.         float4 pos : SV_POSITION;
64.         float2 uvs : TEXCOORD0;
65.         half4 color : COLOR;
66.  
67.         //This is not a UV coordinate but it is just used to pass some variables
68.         //from the vertex shader to the fragment shader. x = gain.
69.         float2 container : TEXCOORD1;
70.     };  
71.  
72.     vertexOutput vert(vertexInput input){
73.  
74.         vertexOutput output;
75.         float gain;
76.         float distanceGain;
77.         float angleGain;
78.         float dotProduct;
79.         float scale;
80.  
81.         //SRP conversion:
82.         //Missing function ObjSpaceViewDir2(), so copied from UnityCG.cginc
83.         float3 objSpaceViewDir = ObjSpaceViewDir2(input.center); //Get a vector from the vertex to the camera and cache the result.
84.  
85.         //Get the distance between the camera and the light.
86.         float distance = length(objSpaceViewDir);  
87.              
88.         //Use a fixed alpha because we use the alpha value to modulate the gain instead.
89.         half4 RGBAfont = half4(input.RGBAfront.r, input.RGBAfront.g, input.RGBAfront.b, 0.2h);
90.  
91.         #if _LOBE_EQUAL
92.             angleGain = GetEqualLobe();
93.             output.color = RGBAfont;
94.         #else
95.             //Compose the back color. There is no float4 slot left, so we use UV channels to store the colors.
96.             float4 RGBAback = float4(input.RGback.x, input.RGback.y, input.z.x, 0.2f);
97.  
98.             float3 viewDir = normalize(objSpaceViewDir);
99.  
100.             //Compose the up vector. A UV channel only holds two floats,
101.             //so we need to fetch the z coordinate from a third UV channel.
102.             float3 upVector = float3(input.up.x, input.up.y, input.z.y);
103.  
104.             //TODO: figure out a way to get the rotated normal from elsewhere instead.
105.             float3 rotatedNormal = ProjectVectorOnPlane(upVector, viewDir);
106.             dotProduct = dot(viewDir, rotatedNormal);
107.  
108.             //Use a Phase Function to simulate the light lens shape and its effect it has on the light brightness.          
109.             angleGain = GetRoundLobe(dotProduct);
110.             //angleGain = GetEggLobe(dotProduct);
111.             //angleGain = GetEqualLobe();        
112.             //angleGain = GetTearDropLobe(dotProduct);
113.  
114.             float forwardDotProduct = dot(viewDir, input.normal.xyz);
115.  
116.             //Create a smooth transition between the two colors.
117.             //output.color = Get015DegreeTransition(forwardDotProduct, RGBAfont, RGBAback);
118.             //output.color = Get03DegreeTransition(forwardDotProduct, RGBAfont, RGBAback);
119.             //output.color = Get06DegreeTransition(forwardDotProduct, RGBAfont, RGBAback);
120.             output.color = Get10DegreeTransition(forwardDotProduct, RGBAfont, RGBAback);
121.         #endif
122.  
123.  
124.         //Calculate the scale. If the light size is smaller than one pixel, scale it up
125.         //so it remains at least one pixel in size.
126.         scale = ScaleUp(distance, _ScaleFactor, input.corner.w, angleGain, _MinPixelSize);
127.  
128.         //Get the vertex offset to shift and scale the light.
129.         float4 offset = GetOffset(scale, input.corner);
130.  
131.         //SRP conversion:
132.         //Instead of this:
133.         //output.pos = mul(UNITY_MATRIX_P, float4(UnityObjectToViewPos(input.center), 1.0f) + offset); //Place the vertex by moving it away from the center, rotate the billboard towards the camera.
134.         //Use this instead, but not sure if it is correct...
135.         output.pos.xyz = TransformObjectToWorld(input.center.xyz);
136.         output.pos = mul(UNITY_MATRIX_P, float4(output.pos.xyz, 1.0f) + offset); //Rotate billboard towards camera. Not sure how to convert this to SRP.
137.         output.pos.xyz = GetCameraRelativePositionWS(output.pos.xyz);
138.         output.pos = TransformWorldToHClip(output.pos.xyz);      
139.  
140.         //Far away lights should be less bright. Attenuate with the inverse square law.
141.         distanceGain = Attenuate(distance, _Attenuation);
142.  
143.         //Merge the distance gain (attenuation), angle gain (lens simulation), and light brightness into a single gain value.
144.         //Note that the individual light brightness is stored in the front color alpha channel.
145.         gain = MergeGain(distanceGain, angleGain, _GlobalBrightnessOffset, input.RGBAfront.a + _BrightnessOffset);
146.  
147.         //Send the gain to the fragment shader.
148.         output.container = float2(gain, 0.0f);
149.  
150.         //UV mapping.
151.         output.uvs = input.uvs;
152.  
153.         //SRP conversion:
154.         //Removed:
155.         //UNITY_TRANSFER_FOG(output, output.pos);
156.  
157.         return output;
158.     }
159.  
160.     //SRP conversion:
161.     //Note: not sure whether to use COLOR or SV_Target
162.     half4 frag(vertexOutput input) : COLOR{
163.  
164.         //Compute the final color.
165.         //Note: input.container.x fetches the gain from the vertex shader. No need to calculate this for each fragment.
166.         half4 col = 2.0h * input.color * tex2D(_MainTex, input.uvs) * (exp(input.container.x * 5.0h));      
167.              
168.         //SRP conversion:
169.         //Removed:
170.         //UNITY_APPLY_FOG_COLOR(input.fogCoord, col, half4(0,0,0,0)); //Use black due to the blend mode used.  
171.                  
172.         return col;
173.     }
174.     ENDHLSL
175.  
176.     SubShader{
177.  
178.         Tags {"RenderType"="Transparent"}
179.  
180.         Pass
181.         {
182.             Name ""
183.             Tags{ "LightMode" = "ForwardOnly" }
184.             Blend SrcAlpha One
185.             AlphaTest Greater .01
186.             ColorMask RGB
187.             Lighting Off
188.             ZWrite Off
189.             HLSLPROGRAM
190.                 #pragma vertex vert
191.                 #pragma fragment frag
192.             ENDHLSL
193.         }
194.  
195.         Pass
196.         {
197.             Name ""
198.             Tags{ "LightMode" = "DepthForwardOnly" }
199.             HLSLPROGRAM
200.                 #pragma vertex vert
201.                 #pragma fragment frag
202.             ENDHLSL
203.         }
204.     }
205. }

 

Is there anyone who can shed some light on the camera transform issue?

 

@Elecman,
The DepthForwardOnly pass will be used only when there's a depth pre-pass.

 

Yeah, I figured that, but since I was slapped on the hand, I figured I'd better do what SebLagarde said:

 

How about using custom projection matrix?

 

Since RC1 is available, I wondered if there is any manual available how to write shaders for the HD SRP. So far I can't find anything, which is rather odd.

 

I think that later HD SRP will also get shadergraph.

 

Thanks for the example. The main point my shader breaks on is the camera relative rendering. I have an unlit emissive billboard shader which does some non-standard vertex manipulations so it is causing problems.

In my case, I won't be using shaderGraph because that means I will have to re-write my shaders from scratch using a system I am not familiar with. It is likely faster just to do the code conversion.