Last active
May 14, 2020 00:33
-
-
Save leegoonz/f1d475df86c5a0216673692813b5936a to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Shader "URP_PBR_7.12" | |
{ | |
Properties | |
{ | |
[MainColor] _BaseColor("Albedo Color", Color) = (0.5,0.5,0.5,1) | |
[MainTexture] _BaseMap("Albedo", 2D) = "white" {} | |
_BumpMap("Normal Map", 2D) = "bump" {} | |
_BumpScale("Scale", Range(1,2)) = 1.0 | |
_Smoothness("Roughness", Range(0.0, 1.0)) = 0.5 | |
[Gamma] _Metallic("Metallic", Range(0.0, 1.0)) = 0.0 | |
_MetallicGlossMap("MetallicTexture", 2D) = "white" {} | |
_SpecColor("Specular", Color) = (0.2, 0.2, 0.2) | |
[ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0 | |
[ToggleOff] _EnvironmentReflections("Environment Reflections", Float) = 1.0 | |
_OcclusionMap("Occlusion", 2D) = "white" {} | |
_OcclusionStrength("Strength", Range(0.0, 1.0)) = 1.0 | |
_EmissionColor("Color", Color) = (0,0,0) | |
_EmissionMap("Emission", 2D) = "white" {} | |
} | |
SubShader | |
{ | |
Tags{"RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" "IgnoreProjector" = "True"} | |
LOD 300 | |
Cull Back | |
HLSLINCLUDE | |
#pragma target 3.0 | |
ENDHLSL | |
Pass | |
{ | |
Name "ForwardLit" | |
Tags{"LightMode" = "UniversalForward"} | |
Name "Base" | |
Blend One Zero | |
ZWrite On | |
ZTest LEqual | |
Offset 0,0 | |
ColorMask RGBA | |
HLSLPROGRAM | |
// Required to compile gles 2.0 with standard SRP library | |
// All shaders must be compiled with HLSLcc and currently only gles is not using HLSLcc by default | |
#pragma prefer_hlslcc gles | |
#pragma exclude_renderers d3d11_9x | |
// ------------------------------------- | |
// Material Keywords | |
#pragma shader_feature _ALPHATEST_ON | |
#pragma shader_feature _ALPHAPREMULTIPLY_ON | |
#pragma shader_feature _EMISSION | |
#pragma shader_feature _METALLICSPECGLOSSMAP | |
#pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A | |
#pragma shader_feature _SPECULARHIGHLIGHTS_OFF | |
#pragma shader_feature _ENVIRONMENTREFLECTIONS_OFF | |
#pragma shader_feature _SPECULAR_SETUP | |
#pragma shader_feature _RECEIVE_SHADOWS_OFF | |
// ------------------------------------- | |
// Universal Pipeline keywords | |
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS | |
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE | |
#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS | |
#pragma multi_compile _ _ADDITIONAL_LIGHT_SHADOWS | |
#pragma multi_compile _ _SHADOWS_SOFT | |
#pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE | |
// ------------------------------------- | |
// Unity defined keywords | |
#pragma multi_compile _ DIRLIGHTMAP_COMBINED | |
#pragma multi_compile _ LIGHTMAP_ON | |
#pragma multi_compile_fog | |
//-------------------------------------- | |
// GPU Instancing | |
#pragma multi_compile_instancing | |
#pragma vertex vert | |
#pragma fragment frag | |
#include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl" | |
#include "Packages/com.unity.render-pipelines.universal/Shaders/LitForwardPass.hlsl" | |
struct mySurfaceData | |
{ | |
half3 albedo; | |
half3 specular; | |
half metallic; | |
half roughness; | |
half3 normalTS; | |
half3 emission; | |
half occlusion; | |
half alpha; | |
}; | |
struct myInputData | |
{ | |
float3 positionWS; | |
half3 normalWS; | |
half3 viewDirectionWS; | |
float4 shadowCoord; | |
half fogCoord; | |
half3 vertexLighting; | |
half3 bakedGI; | |
}; | |
struct myAttributes | |
{ | |
float4 positionOS : POSITION; | |
float3 normalOS : NORMAL; | |
float4 tangentOS : TANGENT; | |
float2 texcoord : TEXCOORD0; | |
float2 lightmapUV : TEXCOORD1; | |
UNITY_VERTEX_INPUT_INSTANCE_ID | |
}; | |
struct myVaryings | |
{ | |
float2 uv : TEXCOORD0; | |
DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1); | |
#ifdef _ADDITIONAL_LIGHTS | |
float3 positionWS : TEXCOORD2; | |
#endif | |
float4 normalWS : TEXCOORD3; // xyz: normal, w: viewDir.x | |
float4 tangentWS : TEXCOORD4; // xyz: tangent, w: viewDir.y | |
float4 bitangentWS : TEXCOORD5; // xyz: bitangent, w: viewDir.z | |
half4 fogFactorAndVertexLight : TEXCOORD6; // x: fogFactor, yzw: vertex light | |
#ifdef _MAIN_LIGHT_SHADOWS | |
float4 shadowCoord : TEXCOORD7; | |
#endif | |
float3 viewDirWS : TEXCOORD8; | |
float4 positionCS : SV_POSITION; | |
UNITY_VERTEX_INPUT_INSTANCE_ID | |
UNITY_VERTEX_OUTPUT_STEREO | |
}; | |
myVaryings vert (myAttributes input ) | |
{ | |
myVaryings output = (myVaryings)0; | |
UNITY_SETUP_INSTANCE_ID(input); | |
UNITY_TRANSFER_INSTANCE_ID(input, output); | |
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output); | |
VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz); | |
VertexNormalInputs normalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS); | |
half3 viewDirWS = GetCameraPositionWS() - vertexInput.positionWS; | |
half3 vertexLight = VertexLighting(vertexInput.positionWS, normalInput.normalWS); | |
half fogFactor = ComputeFogFactor(vertexInput.positionCS.z); | |
output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap); | |
output.normalWS = half4(normalInput.normalWS, viewDirWS.x); | |
output.tangentWS = half4(normalInput.tangentWS, viewDirWS.y); | |
output.bitangentWS = half4(normalInput.bitangentWS, viewDirWS.z); | |
output.viewDirWS = viewDirWS; | |
OUTPUT_LIGHTMAP_UV(input.lightmapUV, unity_LightmapST, output.lightmapUV); | |
OUTPUT_SH(output.normalWS.xyz, output.vertexSH); | |
output.fogFactorAndVertexLight = half4(fogFactor, vertexLight); | |
#ifdef _ADDITIONAL_LIGHTS | |
output.positionWS = vertexInput.positionWS; | |
#endif | |
#ifdef _MAIN_LIGHT_SHADOWS | |
output.shadowCoord = GetShadowCoord(vertexInput); | |
#endif | |
output.positionCS = vertexInput.positionCS; | |
return output; | |
} | |
void myInitializeInputData(myVaryings input, half3 normalTS, out myInputData inputData) | |
{ | |
inputData = (myInputData)0; | |
#ifdef _ADDITIONAL_LIGHTS | |
inputData.positionWS = input.positionWS; | |
#endif | |
half3 viewDirWS = half3(input.normalWS.w, input.tangentWS.w, input.bitangentWS.w); | |
inputData.normalWS = TransformTangentToWorld(normalTS, | |
half3x3(input.tangentWS.xyz, input.bitangentWS.xyz, input.normalWS.xyz)); | |
inputData.normalWS = NormalizeNormalPerPixel(inputData.normalWS); | |
viewDirWS = SafeNormalize(viewDirWS); | |
inputData.viewDirectionWS = viewDirWS; | |
#if defined(_MAIN_LIGHT_SHADOWS) && !defined(_RECEIVE_SHADOWS_OFF) | |
inputData.shadowCoord = input.shadowCoord; | |
#else | |
inputData.shadowCoord = float4(0, 0, 0, 0); | |
#endif | |
inputData.fogCoord = input.fogFactorAndVertexLight.x; | |
inputData.vertexLighting = input.fogFactorAndVertexLight.yzw; | |
inputData.bakedGI = SAMPLE_GI(input.lightmapUV, input.vertexSH, inputData.normalWS); | |
} | |
half3 mySampleNormal(float2 uv, TEXTURE2D_PARAM(bumpMap, sampler_bumpMap), half scale = 1.0h) | |
{ | |
half4 n = SAMPLE_TEXTURE2D(bumpMap, sampler_bumpMap, uv); | |
return UnpackNormalScale(n, scale); | |
} | |
half mySampleOcclusion(float2 uv) | |
{ | |
#if defined(SHADER_API_GLES) | |
return SAMPLE_TEXTURE2D(_OcclusionMap, sampler_OcclusionMap, uv).g; | |
#else | |
half occ = SAMPLE_TEXTURE2D(_OcclusionMap, sampler_OcclusionMap, uv).g; | |
return LerpWhiteTo(occ, _OcclusionStrength); | |
#endif | |
return 1.0; | |
} | |
half3 mySampleEmission(float2 uv, half3 emissionColor, TEXTURE2D_PARAM(emissionMap, sampler_emissionMap)) | |
{ | |
return SAMPLE_TEXTURE2D(emissionMap, sampler_emissionMap, uv).rgb * emissionColor; | |
} | |
half4 mySampleMetallicSpecGloss(float2 uv , half metallicScale , half roughnessScale) | |
{ | |
half4 specGloss; | |
specGloss = SAMPLE_TEXTURE2D(_MetallicGlossMap, sampler_MetallicGlossMap, uv); | |
specGloss.x *=metallicScale; | |
specGloss.y *=roughnessScale; | |
return specGloss; | |
} | |
void myInitializeStandardLitSurfaceData(float2 uv, out mySurfaceData outSurfaceData) | |
{ | |
half4 albedoAlpha = SampleAlbedoAlpha(uv, TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap)); | |
outSurfaceData.alpha = Alpha(albedoAlpha.a, _BaseColor, _Cutoff); | |
half2 metallicRoughness = mySampleMetallicSpecGloss(uv , _Metallic , _Smoothness); | |
outSurfaceData.albedo = albedoAlpha.rgb * _BaseColor.rgb; | |
outSurfaceData.metallic = metallicRoughness.r; | |
outSurfaceData.specular = half3(0.0h, 0.0h, 0.0h); | |
outSurfaceData.roughness = metallicRoughness.y; | |
outSurfaceData.normalTS = mySampleNormal(uv, TEXTURE2D_ARGS(_BumpMap, sampler_BumpMap), _BumpScale); | |
outSurfaceData.occlusion = mySampleOcclusion(uv); | |
outSurfaceData.emission = mySampleEmission(uv, _EmissionColor.rgb, TEXTURE2D_ARGS(_EmissionMap, sampler_EmissionMap)); | |
} | |
half4 frag (myVaryings input ) : SV_Target | |
{ | |
UNITY_SETUP_INSTANCE_ID(input); | |
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input); | |
mySurfaceData surfaceData; | |
myInitializeStandardLitSurfaceData(input.uv, surfaceData); | |
float AlphaClipThreshold = 0; | |
myInputData InputData; | |
myInitializeInputData(input, surfaceData.normalTS, InputData); | |
half4 color = UniversalFragmentPBR(InputData, surfaceData.albedo, surfaceData.metallic, surfaceData.specular, | |
surfaceData.roughness, surfaceData.occlusion, surfaceData.emission, surfaceData.alpha); | |
color.rgb = MixFog(color.rgb, InputData.fogCoord); | |
#if _AlphaClip | |
clip(Alpha - AlphaClipThreshold); | |
#endif | |
#ifdef LOD_FADE_CROSSFADE | |
LODDitheringTransition (input.clipPos.xyz, unity_LODFade.x); | |
#endif | |
return color; | |
} | |
ENDHLSL | |
} | |
Pass | |
{ | |
Name "ShadowCaster" | |
Tags{"LightMode" = "ShadowCaster"} | |
ZWrite On | |
ZTest LEqual | |
HLSLPROGRAM | |
#pragma prefer_hlslcc gles | |
#pragma exclude_renderers d3d11_9x | |
//-------------------------------------- | |
// GPU Instancing | |
#pragma multi_compile_instancing | |
#pragma vertex ShadowPassVertex | |
#pragma fragment ShadowPassFragment | |
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" | |
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl" | |
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl" | |
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl" | |
struct GraphVertexInput | |
{ | |
float4 vertex : POSITION; | |
float3 normal : NORMAL; | |
UNITY_VERTEX_INPUT_INSTANCE_ID | |
}; | |
struct VertexOutput | |
{ | |
float4 clipPos : SV_POSITION; | |
UNITY_VERTEX_INPUT_INSTANCE_ID | |
UNITY_VERTEX_OUTPUT_STEREO | |
}; | |
float3 _LightDirection; | |
VertexOutput ShadowPassVertex(GraphVertexInput v) | |
{ | |
VertexOutput o; | |
UNITY_SETUP_INSTANCE_ID(v); | |
UNITY_TRANSFER_INSTANCE_ID(v, o); | |
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO (o); | |
float3 defaultVertexValue = v.vertex.xyz; | |
float3 vertexValue = defaultVertexValue; | |
v.vertex.xyz = vertexValue; | |
v.normal = /*ase_vert_out:Vertex Normal;Float3;3;-1;_Normal*/ v.normal /*end*/; | |
float3 positionWS = TransformObjectToWorld(v.vertex.xyz); | |
float3 normalWS = TransformObjectToWorldDir(v.normal); | |
float invNdotL = 1.0 - saturate(dot(_LightDirection, normalWS)); | |
float scale = invNdotL * _ShadowBias.y; | |
positionWS = _LightDirection * _ShadowBias.xxx + positionWS; | |
positionWS = normalWS * scale.xxx + positionWS; | |
float4 clipPos = TransformWorldToHClip(positionWS); | |
#if UNITY_REVERSED_Z | |
clipPos.z = min(clipPos.z, clipPos.w * UNITY_NEAR_CLIP_VALUE); | |
#else | |
clipPos.z = max(clipPos.z, clipPos.w * UNITY_NEAR_CLIP_VALUE); | |
#endif | |
o.clipPos = clipPos; | |
return o; | |
} | |
half4 ShadowPassFragment(VertexOutput IN /*ase_frag_input*/ ) : SV_TARGET | |
{ | |
UNITY_SETUP_INSTANCE_ID(IN); | |
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(IN); | |
float Alpha = 1; | |
float AlphaClipThreshold = AlphaClipThreshold; | |
#if _AlphaClip | |
clip(Alpha - AlphaClipThreshold); | |
#endif | |
#ifdef LOD_FADE_CROSSFADE | |
LODDitheringTransition (IN.clipPos.xyz, unity_LODFade.x); | |
#endif | |
return 0; | |
} | |
ENDHLSL | |
} | |
Pass | |
{ | |
Name "DepthOnly" | |
Tags{"LightMode" = "DepthOnly"} | |
ZWrite On | |
ColorMask 0 | |
HLSLPROGRAM | |
#pragma prefer_hlslcc gles | |
#pragma exclude_renderers d3d11_9x | |
//-------------------------------------- | |
// GPU Instancing | |
#pragma multi_compile_instancing | |
#pragma vertex vert | |
#pragma fragment frag | |
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" | |
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl" | |
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl" | |
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl" | |
struct GraphVertexInput | |
{ | |
float4 vertex : POSITION; | |
float3 normal : NORMAL; | |
UNITY_VERTEX_INPUT_INSTANCE_ID | |
}; | |
struct VertexOutput | |
{ | |
float4 clipPos : SV_POSITION; | |
UNITY_VERTEX_INPUT_INSTANCE_ID | |
UNITY_VERTEX_OUTPUT_STEREO | |
}; | |
VertexOutput vert(GraphVertexInput v ) | |
{ | |
VertexOutput o = (VertexOutput)0; | |
UNITY_SETUP_INSTANCE_ID(v); | |
UNITY_TRANSFER_INSTANCE_ID(v, o); | |
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); | |
float3 defaultVertexValue = v.vertex.xyz; | |
float3 vertexValue = defaultVertexValue; | |
v.vertex.xyz = vertexValue; | |
v.normal = v.normal; | |
o.clipPos = TransformObjectToHClip(v.vertex.xyz); | |
return o; | |
} | |
half4 frag(VertexOutput IN /*ase_frag_input*/ ) : SV_TARGET | |
{ | |
UNITY_SETUP_INSTANCE_ID(IN); | |
float Alpha =1; | |
float AlphaClipThreshold = AlphaClipThreshold; | |
#if _AlphaClip | |
clip(Alpha - AlphaClipThreshold); | |
#endif | |
#ifdef LOD_FADE_CROSSFADE | |
LODDitheringTransition (IN.clipPos.xyz, unity_LODFade.x); | |
#endif | |
return 0; | |
} | |
ENDHLSL | |
} | |
Pass | |
{ | |
Name "Meta" | |
Tags{"LightMode" = "Meta"} | |
Cull Off | |
HLSLPROGRAM | |
#pragma prefer_hlslcc gles | |
#pragma exclude_renderers d3d11_9x | |
#pragma vertex vert | |
#pragma fragment frag | |
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" | |
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/MetaInput.hlsl" | |
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl" | |
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl" | |
#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A | |
#pragma shader_feature EDITOR_VISUALIZATION | |
struct GraphVertexInput | |
{ | |
float4 vertex : POSITION; | |
float3 normal : NORMAL; | |
float4 texcoord1 : TEXCOORD1; | |
float4 texcoord2 : TEXCOORD2; | |
UNITY_VERTEX_INPUT_INSTANCE_ID | |
}; | |
struct VertexOutput | |
{ | |
float4 clipPos : SV_POSITION; | |
UNITY_VERTEX_INPUT_INSTANCE_ID | |
UNITY_VERTEX_OUTPUT_STEREO | |
}; | |
VertexOutput vert(GraphVertexInput v ) | |
{ | |
VertexOutput o = (VertexOutput)0; | |
UNITY_SETUP_INSTANCE_ID(v); | |
UNITY_TRANSFER_INSTANCE_ID(v, o); | |
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); | |
float3 defaultVertexValue = v.vertex.xyz; | |
float3 vertexValue = defaultVertexValue; | |
v.vertex.xyz = vertexValue; | |
v.normal = v.normal ; | |
o.clipPos = MetaVertexPosition(v.vertex, v.texcoord1.xy, v.texcoord1.xy, unity_LightmapST, unity_DynamicLightmapST); | |
return o; | |
} | |
half4 frag(VertexOutput IN) : SV_TARGET | |
{ | |
UNITY_SETUP_INSTANCE_ID(IN); | |
float3 Albedo = float3(0.5, 0.5, 0.5); | |
float3 Emission = 0; | |
float Alpha = 1; | |
float AlphaClipThreshold = 0; | |
#if _AlphaClip | |
clip(Alpha - AlphaClipThreshold); | |
#endif | |
MetaInput metaInput = (MetaInput)0; | |
metaInput.Albedo = Albedo; | |
metaInput.Emission = Emission; | |
return MetaFragment(metaInput); | |
} | |
ENDHLSL | |
} | |
} | |
FallBack "Hidden/InternalErrorShader" | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment