koobas.hobune.stream
Shaders problems after moving to URP
Hi friends,
I just moved to URP and I got some problems with a few shader :( I'm noob in this aspect can I convert my previos shader to URP? Thanks in advance!
Shader "CarPaint/Metallic Detail" {
Properties {
_Color ("Main Color", Color) = (1,1,1,1)
_Detail ("Detail Texture", 2D) = "black" {}
_SpecularMap("Specular Map", 2D) = "white" {}
_Cube ("Cubemap", CUBE) = "" {}
_BumpMap ("Bumpmap (RGB Trans)", 2D) = "bump" {}
_Reflection ("Reflection", Range(0, 1)) = 0.5
_SpecColor ("Specular Color", Color) = (0.5,0.5,0.5,1)
_Shininess ("Shininess", Range (0.01, 1)) = 0.078125
_RimPower ("Rim Power", Range(0.5,8.0)) = 3.0
}
SubShader {
Tags { "RenderType"="Opaque" }
LOD 200
CGPROGRAM
#pragma surface surf BlinnPhong
#pragma target 3.0
sampler2D _SpecularMap;
samplerCUBE _Cube;
half4 _Color;
half4 _DecalColor;
half _Reflection;
half _RimPower;
float _Shininess;
sampler2D _BumpMap;
sampler2D _Detail;
struct Input {
float2 uv_BumpMap;
float2 uv_Detail;
float3 worldRefl;
float3 viewDir;
float2 uv_SpecularMap;
INTERNAL_DATA
};
void surf (Input IN, inout SurfaceOutput o) {
half4 bump = tex2D(_BumpMap, IN.uv_BumpMap);
half4 detail = tex2D(_Detail, IN.uv_Detail);
half3 norm = UnpackNormal (bump);
half4 grain = tex2D (_SpecularMap, IN.uv_SpecularMap);
half4 refl = texCUBE (_Cube, WorldReflectionVector (IN, norm));
half rim1 = saturate(dot(normalize(IN.viewDir), norm));
half rim2 = 1 - rim1;
half3 color = lerp(_Color.rgb, detail.rgb, detail.a);
o.Normal = norm;
o.Gloss = _SpecColor.rgb * (1 - detail.a);
o.Albedo = lerp(color, color + refl.rgb * pow(rim1, _RimPower), _Reflection * (1 - detail.a / 2));
o.Alpha = 1;
o.Specular = (1 - grain.a * _SpecColor.a) * _Shininess * (1 - detail.a);
o.Emission = refl * _Reflection * pow(rim2, _RimPower) * (1 - detail.a);
}
ENDCG
}
FallBack "Specular"
}
Shader 2:
//Simple Physical Shader was written by Ryan Gatts 2014
//Based on concepts pioneered by Double Fine, Disney, Unreal Engine, Jim Blinn, Sean Murphy, Josh Ols, and Nicholas Francis.
Shader "ShaderSuperb/Session22/SimplePhysicalShaderCoat"
{
Properties
{
_MainColor("Main Color", Color) = (0.5, 0.5, 0.5, 0.5)
_MainTex("Main Color Texture", 2D) = "white" {}
_Smoothness("Smoothness", Range(1, 12)) = 2.0
_SmoothMap("Smoothness Map", 2D) = "white" {}
_Metallicity("Metallicity", Range(0, 1)) = 0
_MetalMap("Metallicity Map", 2D) = "white" {}
_Wrap("Light Wrap", float) = 0.25
_NormalMap("Normal Map", 2D) = "bump" {}
_BumpDepth("Bump Depth", Range(0.1, 4.0)) = 1
_Coat("Clear Coat", Range(0, 1)) = 0
_CoatMap("Clear Coat Map", 2D) = "white" {}
_CoatSmooth("Coat Smoothness", Range(1, 12)) = 12
_RSRM("RSRM", 2D) = "gray" {}
}
SubShader
{
Pass
{
Tags{ "LightMode" = "ForwardBase" }
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma target 3.0
#pragma multi_compile_fwdadd_fullshadows
#include "UnityCG.cginc"
#include "AutoLight.cginc"
//user defined
uniform sampler2D _MainTex;
uniform sampler2D _NormalMap;
uniform sampler2D _SmoothMap;
uniform sampler2D _MetalMap;
uniform sampler2D _CoatMap;
uniform sampler2D _RSRM;
uniform float4 _MainTex_ST;
uniform float4 _NormalMap_ST;
uniform float4 _SmoothMap_ST;
uniform float4 _MetalMap_ST;
uniform float4 _CoatMap_ST;
uniform float4 _MainColor;
uniform float _Smoothness;
uniform float _Metallicity;
uniform float _Wrap;
uniform float _Coat;
uniform float _CoatSmooth;
uniform float _BumpDepth;
//unity defined
uniform float4 _LightColor0;
//base input struct
struct vertexInput
{
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 texcoord : TEXCOORD0;
float4 tangent : TANGENT;
};
struct vertexOutput
{
float4 pos : SV_POSITION;
float4 tex : TEXCOORD0;
float4 posWorld : TEXCOORD1;
float3 normalWorld : TEXCOORD2;
float3 tangentWorld : TEXCOORD3;
float3 binormalWorld : TEXCOORD4;
LIGHTING_COORDS(5,6)
};
//vertex function
vertexOutput vert (vertexInput v)
{
vertexOutput o;
float4x4 modelMatrix = unity_ObjectToWorld;
float4x4 modelMatrixInverse = unity_WorldToObject;
o.normalWorld = normalize(mul(float4(v.normal, 0.0), unity_WorldToObject).xyz);
o.tangentWorld = normalize(mul(unity_ObjectToWorld, half4(half3(v.tangent.xyz), 0)));
o.binormalWorld = normalize(cross (o.normalWorld, o.tangentWorld) * v.tangent.w);
o.posWorld = mul(unity_ObjectToWorld, v.vertex);
o.pos = UnityObjectToClipPos(v.vertex);
o.tex = v.texcoord;
TRANSFER_VERTEX_TO_FRAGMENT(o); // for shadows
return o;
}
//take a -1 to 1 range and fit it 0 to 1
float clamp01 (float toBeNormalized)
{
return toBeNormalized * 0.5 + 0.5;
}
float3 calculateAmbientReflection( float3 rsrm , float texM )
{
float3 amb = UNITY_LIGHTMODEL_AMBIENT.xyz;
return float3 (1.5 * rsrm * amb + amb * 0.5 * texM);
}
//fragment function
float4 frag(vertexOutput i) : COLOR
{
float shadAtten = LIGHT_ATTENUATION(i);
float4 tex = tex2D(_MainTex, i.tex.xy * _MainTex_ST.xy + _MainTex_ST.zw);
tex = tex * _MainColor;
float texS = tex2D(_SmoothMap, i.tex.xy * _SmoothMap_ST.xy + _SmoothMap_ST.zw);
texS = texS * _Smoothness;
float texM = tex2D(_MetalMap, i.tex.xy * _MetalMap_ST.xy + _MetalMap_ST.zw);
texM = texM * _Metallicity;
float4 texN = tex2D(_NormalMap, i.tex.xy * _NormalMap_ST.xy + _NormalMap_ST.zw);
float nDepth = 8 / (_BumpDepth * 8);
float4 texC1= tex2D(_CoatMap, i.tex.xy * _CoatMap_ST.xy + _CoatMap_ST.zw);
float texC = Luminance(texC1.rgb) * _Coat * texC1.a;
//Unpack Normal
half3 localCoords = half3(2.0 * texN.ag - float2(1.0, 1.0), 0.0);
localCoords.z = nDepth;
//normal transpose matrix
float3x3 local2WorldTranspose = float3x3
(
i.tangentWorld,
i.binormalWorld,
i.normalWorld
);
//Calculate normal direction
float3 normalDir = normalize( mul( localCoords, local2WorldTranspose));
float3 N = normalize( normalDir);
float3 V = normalize( _WorldSpaceCameraPos.xyz - i.posWorld.xyz);
float3 fragmentToLight = _WorldSpaceLightPos0.xyz - i.posWorld.xyz;
float distanceToLight = length(fragmentToLight);
float atten = pow(2, -0.1 * distanceToLight * distanceToLight) * _WorldSpaceLightPos0.w + 1 - _WorldSpaceLightPos0.w; // (-0.1x^2)^2 for pointlights 1 for dirlights
float3 L = (normalize(fragmentToLight)) * _WorldSpaceLightPos0.w + normalize(_WorldSpaceLightPos0.xyz) * (1 - _WorldSpaceLightPos0.w);
float3 H = normalize( V + L );
float3 worldReflect = reflect(V,N);
//lighting
float NdotL = dot(N,L);
float NdotV = 1 - max(0.0, dot(N,V));
float NdotH = clamp(dot(N,H), 0, 1);
float VdotL = clamp01(dot(V,L));
float wrap = clamp(_Wrap, -0.25, 1.0);
float4 texdesat = dot(tex.rgb, float3(0.3, 0.59, 0.11));
float3 difftex = lerp(tex, float4(0,0,0,0), pow(texM, 1)).xyz;
float3 spectex = lerp(texdesat, tex, texM).xyz;
VdotL = pow(VdotL, 0.85);
float smooth = 4 * pow(1.8, texS - 2) + 1.5;
float smoothCoat= 4 * pow(1.8, _CoatSmooth - 2) + 1.5;
float rim = texM + (pow(NdotV, 1 + texS / 6)) * (1 - texM);
float coatrim = pow(NdotV, 1 + _CoatSmooth / 6);
float bellclamp = (1 / (1 + pow(0.65 * acos(dot(N,L)), 16)));
float3 rsrm = tex2D(_RSRM, float2((1 - (texS - 1) * 0.09), 1 - clamp01(worldReflect.y)));
float3 rsrmDiff = tex2D(_RSRM, float2(1, N.y));
float3 rsrmCoat = tex2D(_RSRM, float2((1 - (_CoatSmooth - 1) * 0.09), 1 - clamp01(worldReflect.y)));
float3 ambReflect = calculateAmbientReflection(rsrm, texM);
float3 ambReflectDiff = calculateAmbientReflection(rsrmDiff, texM);
float3 ambReflectCoat = calculateAmbientReflection(rsrmCoat, 0);
float3 spec = NdotH;
spec = pow (spec, smooth * VdotL) * log(smooth*(VdotL+1)) * bellclamp * texS * (1 / texS) * 0.5;
spec *= shadAtten * atten * spectex.xyz * _LightColor0.rgb * (2+texM) * spectex.xyz;
spec += ambReflect * spectex.rgb * rim * 2 - texC * 0.05;
float3 coat = NdotH;
coat = pow (coat, 4 * smoothCoat * VdotL) * log(smoothCoat*(VdotL+1)) * bellclamp * smoothCoat * (1 / smoothCoat) * 0.5;
coat *= shadAtten * atten * texC * _LightColor0.rgb;
coat += ambReflectCoat * texC * coatrim * 2;
float3 diff = max(0, (pow(max(0, (NdotL * (1 - wrap) + wrap)), (2 * wrap + 1))));
diff *= lerp(shadAtten, 1, wrap) * atten * difftex.xyz * _LightColor0.rgb * 2 * _LightColor0.rgb * difftex.xyz;
diff += ambReflect * difftex.xyz * rim + ambReflectDiff * 2 * difftex.xyz;
return float4 (atan(clamp(spec + diff + coat, 0, 2)), 1); //this is used to round off values above one and give better color reproduction in bright scenes
}
ENDCG
}
Pass
{
Tags{ "LightMode" = "ForwardAdd"}
Fog {Mode Off}
Blend One One
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma target 3.0
#include "UnityCG.cginc"
//user defined
uniform sampler2D _MainTex;
uniform sampler2D _NormalMap;
uniform sampler2D _SmoothMap;
uniform sampler2D _MetalMap;
uniform sampler2D _CoatMap;
uniform float4 _MainTex_ST;
uniform float4 _NormalMap_ST;
uniform float4 _SmoothMap_ST;
uniform float4 _MetalMap_ST;
uniform float4 _CoatMap_ST;
uniform float4 _MainColor;
uniform float _Smoothness;
uniform float _Wrap;
uniform float _Coat;
uniform float _CoatSmooth;
uniform float _BumpDepth;
uniform float _Metallicity;
//unity defined
uniform float4 _LightColor0;
//base input struct
struct vertexInput
{
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 texcoord : TEXCOORD0;
float4 tangent : TANGENT;
};
struct vertexOutput
{
float4 pos : SV_POSITION;
float4 tex : TEXCOORD0;
float4 posWorld : TEXCOORD1;
float3 normalWorld : TEXCOORD2;
float3 tangentWorld : TEXCOORD3;
float3 binormalWorld : TEXCOORD4;
};
//vertex function
vertexOutput vert (vertexInput v)
{
vertexOutput o;
float4x4 modelMatrix = unity_ObjectToWorld;
float4x4 modelMatrixInverse = unity_WorldToObject;
o.normalWorld = normalize( mul(float4(v.normal, 0.0), unity_WorldToObject).xyz);
o.tangentWorld = normalize(mul(unity_ObjectToWorld, half4(half3(v.tangent.xyz), 0)));
o.binormalWorld = normalize(cross (o.normalWorld, o.tangentWorld) * v.tangent.w);
o.posWorld = mul(unity_ObjectToWorld, v.vertex);
o.pos = UnityObjectToClipPos(v.vertex);
o.tex = v.texcoord;
return o;
}
//fragment function
float4 frag(vertexOutput i) : COLOR
{
float4 tex = tex2D(_MainTex, i.tex.xy * _MainTex_ST.xy + _MainTex_ST.zw);
tex = tex * _MainColor;
float4 texS = tex2D(_SmoothMap, i.tex.xy * _SmoothMap_ST.xy + _SmoothMap_ST.zw);
texS = texS * _Smoothness;
float4 texM = tex2D(_MetalMap, i.tex.xy * _MetalMap_ST.xy + _MetalMap_ST.zw);
texM = texM * _Metallicity;
float4 texN = tex2D(_NormalMap, i.tex.xy * _NormalMap_ST.xy + _NormalMap_ST.zw);
float nDepth = 8 / (_BumpDepth * 8);
float4 texC1= tex2D(_CoatMap, i.tex.xy * _CoatMap_ST.xy + _CoatMap_ST.zw);
float texC = Luminance(texC1.rgb) * _Coat * texC1.a;
//Unpack Normal
half3 localCoords = half3(2.0 * texN.ag - float2(1.0, 1.0), 0.0);
localCoords.z = nDepth;
//normal transpose matrix
float3x3 local2WorldTranspose = float3x3
(
i.tangentWorld,
i.binormalWorld,
i.normalWorld
);
//Calculate normal direction
float3 normalDir = normalize( mul( localCoords, local2WorldTranspose));
float3 N = normalize(normalDir);
float3 V = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
float3 fragmentToLight = _WorldSpaceLightPos0.xyz - i.posWorld.xyz;
float distanceToLight = length(fragmentToLight);
float atten = pow(2, -0.1 * distanceToLight * distanceToLight) * _WorldSpaceLightPos0.w + 1 - _WorldSpaceLightPos0.w;
float3 L = normalize(fragmentToLight) * _WorldSpaceLightPos0.w + normalize(_WorldSpaceLightPos0.xyz) * (1 - _WorldSpaceLightPos0.w);
float3 H = normalize(V + L);
//lighting
float NdotL = dot(N,L);
float NdotH = clamp(dot(N,H), 0, 1);
float VdotL = dot(V,L) * 0.5 + 0.5;
float wrap = clamp(_Wrap, -0.25, 1.0);
float4 texdesat = dot(tex.rgb, float3(0.3, 0.59, 0.11));
float3 difftex = lerp(tex, float4(0,0,0,0), pow(texM, 1)).xyz;
float3 spectex = lerp(texdesat, tex, texM).xyz;
VdotL = pow(VdotL, 0.85);
float smooth = 4 * pow(1.8, texS - 2) + 1.5;
float smoothCoat= 4 * pow(1.8, _CoatSmooth - 2) + 1.5;
float bellclamp = (1 / (1 + pow(0.65 * acos(dot(N,L)), 16)));
float3 spec = NdotH;
spec = pow(spec, smooth * VdotL) * log(smooth * (VdotL + 1)) * bellclamp;
spec *= atten * spectex.xyz * _LightColor0.rgb * (2 + _Metallicity) * spectex.xyz;
spec -= texC * 0.05;
float3 coat = NdotH;
coat = pow (coat, smoothCoat * VdotL) * log(smoothCoat*(VdotL+1)) * bellclamp * smoothCoat * (1 / smoothCoat) * 0.5;
coat *= atten * texC * _LightColor0.rgb;
float3 diff = max(0, (pow(max(0, (NdotL * (1 - wrap) + wrap)), (2 * wrap + 1))));
diff *= atten * difftex.xyz * _LightColor0.rgb * 2 * difftex.xyz;
return float4 (atan(clamp(spec + diff + coat, 0, 2)), 1); //this is used to round off values above one and give better color reproduction in bright scenes
}
ENDCG
}
}
Fallback "Diffuse"
}
Thanks in advance!
