HDRP Renderer With Custom Shader Code ? [Unity]

Hello !

I was trying to figure if there is a way to write custom shader with HDRP mode in Unity ?

I don’t find for now if they have update the HDRP recently to fix the “pink” error with custom shaders.
With no specific renderer it’s ok, but HDRP seems bug.

If someone has an idea to fix this with code ?
ex : For Fluid Simulation (vertex animation texture)

Hmm, I might be wrong, but I believe the intention is to use the new node based system with the render pipelines right?

I’m not sure if custom shaders still work in that environment (Although they totaly should in my opinion).

HDRP have different lighning than legacy unity render. I have changed shaders in LWRP and in most cases It was wrong lightning type and tags.

Exactly what i want to do. I saw some people trying to code something to integrate the new render pipeline to custom shaders.

This is a problem when you already started something with the render and you can’t go back just for this kind of situation…

Like you said, my goal is to know what is the lightning type and tags to integrate to the custom shader

The shader is from Sidefx

Shader “sidefx/vertex_fluid_shader” {
Properties {
_Color (“Color”, Color) = (1,1,1,1)
_MainTex (“Albedo (RGB)”, 2D) = “white” {}
_Glossiness (“Smoothness”, Range(0,1)) = 0.5
_Metallic (“Metallic”, Range(0,1)) = 0.0
_boundingMax(“Bounding Max”, Float) = 1.0
_boundingMin(“Bounding Min”, Float) = 1.0
_numOfFrames(“Number Of Frames”, int) = 240
_speed(“Speed”, Float) = 0.33
[MaterialToggle] _pack_normal (“Pack Normal”, Float) = 0
_posTex (“Position Map (RGB)”, 2D) = “white” {}
_nTex (“Normal Map (RGB)”, 2D) = “grey” {}
_colorTex (“Colour Map (RGB)”, 2D) = “white” {}
SubShader {
Tags { “RenderType”=“Opaque” }
LOD 200

	// Physically based Standard lighting model, and enable shadows on all light types
	#pragma surface surf Standard addshadow vertex:vert

	// Use shader model 3.0 target, to get nicer looking lighting
	#pragma target 3.0

	sampler2D _MainTex;
	sampler2D _posTex;
	sampler2D _nTex;
	sampler2D _colorTex;
	uniform float _pack_normal;
	uniform float _boundingMax;
	uniform float _boundingMin;
	uniform float _speed;
	uniform int _numOfFrames;

	struct Input {
		float2 uv_MainTex;
		float4 vcolor : COLOR ;

	half _Glossiness;
	half _Metallic;
	fixed4 _Color;

// Add instancing support for this shader. You need to check ‘Enable Instancing’ on materials that use the shader.
// See Unity - Manual: GPU instancing for more information about instancing.
// #pragma instancing_options assumeuniformscaling
// put more per-instance properties here

	//vertex function
	void vert(inout appdata_full v){
		//calculate uv coordinates
		float timeInFrames = ((ceil(frac(-_Time.y * _speed) * _numOfFrames))/_numOfFrames) + (1.0/_numOfFrames);
		//get position, normal and colour from textures
		float4 texturePos = tex2Dlod(_posTex,float4(v.texcoord.x, (timeInFrames + v.texcoord.y), 0, 0));
		float3 textureN = tex2Dlod(_nTex,float4(v.texcoord.x, (timeInFrames + v.texcoord.y), 0, 0));
		float3 textureCd = tex2Dlod(_colorTex,float4(v.texcoord.x, (timeInFrames + v.texcoord.y), 0, 0));

		//expand normalised position texture values to world space
		float expand = _boundingMax - _boundingMin;
		texturePos.xyz *= expand;
		texturePos.xyz += _boundingMin;
		texturePos.x *= -1;  //flipped to account for right-handedness of unity
		v.vertex.xyz = texturePos.xzy;  //swizzle y and z because textures are exported with z-up

		//calculate normal
		if (_pack_normal){
			//decode float to float2
			float alpha = texturePos.w * 1023;
			float2 f2;
			f2.x = floor(alpha / 32.0) / 31.0;
			f2.y = (alpha - (floor(alpha / 32.0)*32.0)) / 31.0;

			//decode float2 to float3
			float3 f3;
			f2 *= 4;
			f2 -= 2;
			float f2dot = dot(f2,f2);
			f3.xy = sqrt(1 - (f2dot/4.0)) * f2;
			f3.z = 1 - (f2dot/2.0);
			f3 = clamp(f3, -1.0, 1.0);
			f3 = f3.xzy;
			f3.x *= -1;
			v.normal = f3;
		} else {
			textureN = textureN.xzy;
			textureN *= 2;
			textureN -= 1;
			textureN.x *= -1;
			v.normal = textureN;

		//set vertex colour
		v.color.rgb = textureCd;

	void surf (Input IN, inout SurfaceOutputStandard o) {
		// Albedo comes from a texture tinted by color
		fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
		o.Albedo = c.rgb * IN.vcolor.rgb;  //multiply existing albedo map by vertex colour
		// Metallic and smoothness come from slider variables
		o.Metallic = _Metallic;
		o.Smoothness = _Glossiness;
		o.Alpha = c.a;
FallBack "Diffuse"


You can check this repo from Keijiro Takahashi with great HDRP examples. He used some custom shaders for check possibilities of new render as i know, so it can help, i think.

1 Like

Thx man appreciate it ! i take a look !

Sorry about the delay. I’ve released a first pass of the VAT shaders for the scriptable rendering pipeline. You can find more info on our forums.