CommonParrot/Space-Smash-Out
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
a38acd711f
Space-Smash-Out/Assets/Shaders/URP_PBRLitRipples.shader
Jakob Feldmann 94863a7eb5 feat: free fly arena, 4-player support, 4-player arena, test-scene option etc. 
There is also overhauled camera zoom behavior, an update to the match logic,
tweaks to the main menu scene.
2024-05-05 17:53:56 +02:00

692 lines
24 KiB
Plaintext
Raw Blame History

// Example Shader for Universal RP
// Written by @Cyanilux
// https://www.cyanilux.com/tutorials/urp-shader-code
/*
Roughly equivalent to the URP/Lit.shader (but Forward path only)
https://github.com/Unity-Technologies/Graphics/blob/master/Packages/com.unity.render-pipelines.universal/Shaders/Lit.shader
*/
// This template from Cyanilux is under CC0 license.
// I modified it to work with my URP Version: 14.0.8.
// You can spawn and edit a ripple on the surface manually over the inspector
// or use the properties accessible via script, to spawn and animate up to 5 waves simultaneously.
Shader "CustomShaders/GlossyPBRRipples" {
Properties {
// In the regular URP shaders provided by unity, a custom shader GUI manages
// these properties. This is hard to extend.
// This here is a bit messier in the inspector, but easier to extend/modify.
[MainTexture] _BaseMap("Base Map (RGB) Smoothness / Alpha (A)", 2D) = "white" {}
[MainColor] _BaseColor("Base Color", Color) = (1, 1, 1, 1)
[Space(20)]
[Toggle(_ALPHATEST_ON)] _AlphaTestToggle ("Alpha Clipping", Float) = 0
_Cutoff ("Alpha Cutoff", Float) = 0.5
[Space(20)]
[Toggle(_SPECULAR_SETUP)] _MetallicSpecToggle ("Workflow, Specular (if on), Metallic (if off)", Float) = 0
[Toggle(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)] _SmoothnessSource ("Smoothness Source, Albedo Alpha (if on) vs Metallic (if off)", Float) = 0
_Metallic("Metallic", Range(0.0, 1.0)) = 0
_Smoothness("Smoothness", Range(0.0, 1.0)) = 0.5
[Toggle(_ENVIRONMENTREFLECTIONS_OFF)] _EnvironmentalReflections("Turn Environmental Reflections Off", Float) = 0
[Toggle(_SPECULARHIGHLIGHTS_OFF)] _SpecularHighlights("Turn Specular Highlights Off", Float) = 0
_SpecColor("Specular Color (only affects specular workflow)", Color) = (0.5, 0.5, 0.5, 0.5)
[Space(20)]
// This acts as the Metallic- or Specular Gloss Map, depending on the toggle
[Toggle(_METALLICSPECGLOSSMAP)] _MetallicSpecGlossMapToggle ("Use Metallic/Specular Gloss Map", Float) = 0
_MetallicSpecGlossMap("Specular or Metallic Map", 2D) = "white" {}
[Space(20)]
[Toggle(_CLEARCOAT)] _ClearCoat("Use Clear Coat", Float) = 0
_ClearCoatMap("Clear Coat Map", 2D) = "white" {}
_ClearCoatMask("Clear Coat Mask", Range(0.0, 1.0)) = 0.0
_ClearCoatSmoothness("Clear Coat Smoothness", Range(0.0, 1.0)) = 1.0
[Space(20)]
[Toggle(_NORMALMAP)] _NormalMapToggle ("Use Normal Map", Float) = 0
[NoScaleOffset] _BumpMap("Normal Map", 2D) = "bump" {}
_BumpScale("Bump Scale", Float) = 1
// Not including Height (parallax) map in this example/template
[Space(20)]
[Toggle(_OCCLUSIONMAP)] _OcclusionToggle ("Use Occlusion Map", Float) = 0
[NoScaleOffset] _OcclusionMap("Occlusion Map", 2D) = "bump" {}
_OcclusionStrength("Occlusion Strength", Range(0.0, 1.0)) = 1.0
[Space(20)]
[Toggle(_EMISSION)] _Emission ("Emission", Float) = 0
[HDR] _EmissionColor("Emission Color", Color) = (0,0,0)
[NoScaleOffset]_EmissionMap("Emission Map", 2D) = "white" {}
[Space(20)]
[Toggle(_MANUAL_RIPPLE)] _ManualRipple("Use Manual/Test Ripple", Float) = 0
_ManualRippleOrigin("Ripple Origin", Vector) = (0,0,0)
_ManualRippleFrequency("Ripple Frequency", Float) = 0
_ManualRippleDensity("Ripple Density", Float) = 0
_ManualRippleAmplitude("Ripple Amplitude", Float) = 0
_ManualRippleRadius("Ripple Effect Radius", Float) = 0
_ManualRippleAnim("Ripple Animation Progress", Range(0.0, 1.0)) = 0
// These are inverted fom what the URP/Lit shader does which is a bit annoying.
// They would usually be handled by the Lit ShaderGUI but I'm using Toggle instead,
// which assumes the keyword is more of an "on" state.
// Not including Detail maps in this template
}
SubShader {
Tags {
"RenderPipeline"="UniversalPipeline"
"RenderType"="Transparent"
"Queue"="Transparent"
}
HLSLINCLUDE
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
CBUFFER_START(UnityPerMaterial)
float4 _BaseMap_ST;
float4 _BaseColor;
float4 _EmissionColor;
float4 _SpecColor;
half _Metallic;
half _Smoothness;
half _OcclusionStrength;
half _Cutoff;
half _BumpScale;
half _SurfaceTransparent;
half _ClearCoatMask;
half _ClearCoatSmoothness;
CBUFFER_END
half _ShaderTime;
half _SpikeEase(half x){
return 1.0 - pow(abs(sin(3.14159265359* (x + 0.5)/2.0)), 0.5);
}
half _TriangleEase(half x){
return min(cos(3.14159265359 * x/2.0), 1 - abs(x));
}
half _TrapezoidEase(half x){
return 1.0 - pow(max(0.0, abs(x) * 2.0 - 1.0), 1.0);
}
// Computes the displacement of the vertice for a 3D sine wave ripple
half _ComputeRipple(half3 vert, half3 orig, half radius, half freq, half dens, half ampl, half start_time, half duration) {
half dist = distance(vert, orig);
half anim = smoothstep(start_time, start_time + duration, _ShaderTime);
half i = sin((freq * anim - dist * dens)) * ampl * _TrapezoidEase(anim * 2 - 1);
// Displacement gets lower as it approaches the set max distance
return i * smoothstep(radius, 0, dist);
}
half _ComputeManualRipple(half3 vert, half3 orig, half radius, half freq, half dens, half ampl, half anim) {
half dist = distance(vert, orig);
half i = sin((freq * anim - dist * dens)) * ampl * _TrapezoidEase(anim * 2 - 1);
// Displacement gets lower as it approaches the set max distance
return i * smoothstep(radius, 0, dist);
}
ENDHLSL
Pass {
Name "ForwardLit"
Tags { "LightMode"="UniversalForward"
"RenderType" = "Transparent"
"Queue"="Transparent"
}
ZTest LEqual
ZWrite Off
Blend One OneMinusSrcAlpha
HLSLPROGRAM
// Ripple Properties
// These can't be set in Editor but are read/writeable from script
half3 _RippleOrigins[5];
half _RippleFrequencies[5];
half _RippleDensities[5];
half _RippleAmplitudes[5];
half _RippleRadii[5];
half _RippleStartTimes[5];
half _RippleDurations[5];
// These are the properties for the singular ripple which can be adjusted in the
// inspector.
half3 _ManualRippleOrigin = {0,0,0};
half _ManualRippleRadius = 0;
half _ManualRippleFrequency = 0;
half _ManualRippleDensity = 0;
half _ManualRippleAmplitude = 0;
half _ManualRippleAnim = 0;
#pragma vertex LitPassVertex
#pragma fragment LitPassFragment
// ---------------------------------------------------------------------------
// Keywords
// ---------------------------------------------------------------------------
// Material Keywords
#pragma shader_feature_local _NORMALMAP
#pragma shader_feature_local_fragment _ALPHATEST_ON
#pragma shader_feature_local_fragment _ALPHAPREMULTIPLY_ON
#pragma shader_feature_local_fragment _EMISSION
#pragma shader_feature_local_fragment _METALLICSPECGLOSSMAP
#pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
#pragma shader_feature_local_fragment _OCCLUSIONMAP
#pragma shader_feature_local_vertex _MANUAL_RIPPLE
//#pragma shader_feature_local _PARALLAXMAP // v10+ only
//#pragma shader_feature_local _ _DETAIL_MULX2 _DETAIL_SCALED // v10+ only
// Note, for this template not supporting parallax/height mapping or detail maps
// v10+ only, URP/ComplexLit shader
#pragma shader_feature_local_fragment _ _CLEARCOAT _CLEARCOATMAP
#pragma shader_feature_local_fragment _SPECULARHIGHLIGHTS_OFF
#pragma shader_feature_local_fragment _ENVIRONMENTREFLECTIONS_OFF
#pragma shader_feature_local_fragment _SPECULAR_SETUP
#pragma shader_feature_local_fragment _SURFACE_TYPE_TRANSPARENT
#pragma shader_feature_local _RECEIVE_SHADOWS_OFF
// URP Keywords
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
#pragma multi_compile_fragment _ _REFLECTION_PROBE_BLENDING
#pragma multi_compile_fragment _ _REFLECTION_PROBE_BOX_PROJECTION
#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
#pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS
#pragma multi_compile_fragment _ _SHADOWS_SOFT
#pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION // v10+ only (for SSAO support)
#pragma multi_compile _ LIGHTMAP_SHADOW_MIXING // v10+ only, renamed from "_MIXED_LIGHTING_SUBTRACTIVE"
#pragma multi_compile _ SHADOWS_SHADOWMASK // v10+ only
// Unity Keywords
#pragma multi_compile _ LIGHTMAP_ON
#pragma multi_compile _ DIRLIGHTMAP_COMBINED
#pragma multi_compile_fog
// GPU Instancing (not supported)
//#pragma multi_compile_instancing
// ---------------------------------------------------------------------------
// Structs
// ---------------------------------------------------------------------------
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
struct Attributes {
float4 positionOS : POSITION;
#ifdef _NORMALMAP
float4 tangentOS : TANGENT;
#endif
float4 normalOS : NORMAL;
float2 uv : TEXCOORD0;
float2 lightmapUV : TEXCOORD1;
float4 color : COLOR;
//UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct Varyings {
float4 positionCS : SV_POSITION;
float2 uv : TEXCOORD0;
DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1);
float3 positionWS : TEXCOORD2;
#ifdef _NORMALMAP
half4 normalWS : TEXCOORD3; // xyz: normal, w: viewDir.x
half4 tangentWS : TEXCOORD4; // xyz: tangent, w: viewDir.y
half4 bitangentWS : TEXCOORD5; // xyz: bitangent, w: viewDir.z
#else
half3 normalWS : TEXCOORD3;
#endif
#ifdef _ADDITIONAL_LIGHTS_VERTEX
half4 fogFactorAndVertexLight : TEXCOORD6; // x: fogFactor, yzw: vertex light
#else
half fogFactor : TEXCOORD6;
#endif
#if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
float4 shadowCoord : TEXCOORD7;
#endif
float4 color : COLOR;
//UNITY_VERTEX_INPUT_INSTANCE_ID
//UNITY_VERTEX_OUTPUT_STEREO
};
#include "PBRSurface.hlsl"
#include "PBRInput.hlsl"
// ---------------------------------------------------------------------------
// Vertex Shader
// ---------------------------------------------------------------------------
Varyings LitPassVertex(Attributes IN) {
Varyings OUT;
//UNITY_SETUP_INSTANCE_ID(IN);
//UNITY_TRANSFER_INSTANCE_ID(IN, OUT);
//UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
half ripple_displacement = 0.0;
[unroll(5)]
for(int i = 0; i < 5; i++)
ripple_displacement += _ComputeRipple(IN.positionOS.xyz,
_RippleOrigins[i],
_RippleRadii[i],
_RippleFrequencies[i],
_RippleDensities[i],
_RippleAmplitudes[i],
_RippleStartTimes[i],
_RippleDurations[i]);
IN.positionOS += IN.normalOS * ripple_displacement;
#if _MANUAL_RIPPLE
ripple_displacement += _ComputeManualRipple(IN.positionOS.xyz,
_ManualRippleOrigin,
_ManualRippleRadius,
_ManualRippleFrequency,
_ManualRippleDensity,
_ManualRippleAmplitude,
_ManualRippleAnim);
IN.positionOS += IN.normalOS * ripple_displacement;
#endif
// if _TestRipple
VertexPositionInputs positionInputs = GetVertexPositionInputs(IN.positionOS.xyz);
#ifdef _NORMALMAP
VertexNormalInputs normalInputs = GetVertexNormalInputs(IN.normalOS.xyz, IN.tangentOS);
#else
VertexNormalInputs normalInputs = GetVertexNormalInputs(IN.normalOS.xyz);
#endif
OUT.positionCS = positionInputs.positionCS;
OUT.positionWS = positionInputs.positionWS;
half3 viewDirWS = GetWorldSpaceViewDir(positionInputs.positionWS);
half3 vertexLight = VertexLighting(positionInputs.positionWS, normalInputs.normalWS);
half fogFactor = ComputeFogFactor(positionInputs.positionCS.z);
#ifdef _NORMALMAP
OUT.normalWS = half4(normalInputs.normalWS, viewDirWS.x);
OUT.tangentWS = half4(normalInputs.tangentWS, viewDirWS.y);
OUT.bitangentWS = half4(normalInputs.bitangentWS, viewDirWS.z);
#else
OUT.normalWS = NormalizeNormalPerVertex(normalInputs.normalWS);
//OUT.viewDirWS = viewDirWS;
#endif
OUTPUT_LIGHTMAP_UV(IN.lightmapUV, unity_LightmapST, OUT.lightmapUV);
OUTPUT_SH(OUT.normalWS.xyz, OUT.vertexSH);
#ifdef _ADDITIONAL_LIGHTS_VERTEX
OUT.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
#else
OUT.fogFactor = fogFactor;
#endif
#if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
OUT.shadowCoord = GetShadowCoord(positionInputs);
#endif
OUT.uv = TRANSFORM_TEX(IN.uv, _BaseMap);
OUT.color = IN.color;
return OUT;
}
// ---------------------------------------------------------------------------
// Fragment Shader
// ---------------------------------------------------------------------------
half4 LitPassFragment(Varyings IN) : SV_Target {
//UNITY_SETUP_INSTANCE_ID(IN);
//UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(IN);
// Setup SurfaceData
SurfaceData surfaceData;
InitializeSurfaceData(IN, surfaceData);
// Setup InputData
InputData inputData;
InitializeInputData(IN, surfaceData.normalTS, inputData);
// Simple Lighting (Lambert & BlinnPhong)
half4 color = UniversalFragmentPBR(inputData, surfaceData);
// See Lighting.hlsl to see how this is implemented.
// https://github.com/Unity-Technologies/Graphics/blob/master/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl
// Fog
color.rgb = MixFog(color.rgb, inputData.fogCoord);
color.a = color.a;
return color;
}
ENDHLSL
}
// UsePass "Universal Render Pipeline/Lit/ShadowCaster"
// UsePass "Universal Render Pipeline/Lit/DepthOnly"
// Would be nice if we could just use the passes from existing shaders,
// However this breaks SRP Batcher compatibility. Instead, we should define them :
// ShadowCaster, for casting shadows
Pass {
Name "ShadowCaster"
Tags { "LightMode"="ShadowCaster" }
ZWrite On
ZTest LEqual
HLSLPROGRAM
#pragma vertex ShadowPassVertex
#pragma fragment ShadowPassFragment
// Material Keywords
#pragma shader_feature_local_fragment _ALPHATEST_ON
#pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
// GPU Instancing
#pragma multi_compile_instancing
//#pragma multi_compile _ DOTS_INSTANCING_ON
// Universal Pipeline Keywords
// (v11+) This is used during shadow map generation to differentiate between directional and punctual (point/spot) light shadows, as they use different formulas to apply Normal Bias
#pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/SurfaceInput.hlsl"
#include "Packages/com.unity.render-pipelines.universal/Shaders/ShadowCasterPass.hlsl"
// Note if we do any vertex displacement, we'll need to change the vertex function. e.g. :
/*
#pragma vertex DisplacedShadowPassVertex (instead of ShadowPassVertex above)
Varyings DisplacedShadowPassVertex(Attributes input) {
Varyings output = (Varyings)0;
UNITY_SETUP_INSTANCE_ID(input);
// Example Displacement
input.positionOS += float4(0, _SinTime.y, 0, 0);
output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);
output.positionCS = GetShadowPositionHClip(input);
return output;
}
*/
ENDHLSL
}
// DepthOnly, used for Camera Depth Texture (if cannot copy depth buffer instead, and the DepthNormals below isn't used)
Pass {
Name "DepthOnly"
Tags { "LightMode"="DepthOnly" }
ColorMask 0
ZWrite On
ZTest LEqual
HLSLPROGRAM
#pragma vertex DepthOnlyVertex
#pragma fragment DepthOnlyFragment
// Material Keywords
#pragma shader_feature_local_fragment _ALPHATEST_ON
#pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
// GPU Instancing
#pragma multi_compile_instancing
//#pragma multi_compile _ DOTS_INSTANCING_ON
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/SurfaceInput.hlsl"
#include "Packages/com.unity.render-pipelines.universal/Shaders/DepthOnlyPass.hlsl"
// Note if we do any vertex displacement, we'll need to change the vertex function. e.g. :
/*
#pragma vertex DisplacedDepthOnlyVertex (instead of DepthOnlyVertex above)
Varyings DisplacedDepthOnlyVertex(Attributes input) {
Varyings output = (Varyings)0;
UNITY_SETUP_INSTANCE_ID(input);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Example Displacement
input.positionOS += float4(0, _SinTime.y, 0, 0);
output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);
output.positionCS = TransformObjectToHClip(input.position.xyz);
return output;
}
*/
ENDHLSL
}
// DepthNormals, used for SSAO & other custom renderer features that request it
Pass {
Name "DepthNormals"
Tags { "LightMode"="DepthNormals" }
ZWrite On
ZTest LEqual
HLSLPROGRAM
#pragma vertex DepthNormalsVertex
#pragma fragment DepthNormalsFragment
// Material Keywords
#pragma shader_feature_local _NORMALMAP
#pragma shader_feature_local_fragment _ALPHATEST_ON
#pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
// GPU Instancing
#pragma multi_compile_instancing
//#pragma multi_compile _ DOTS_INSTANCING_ON
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/SurfaceInput.hlsl"
#include "Packages/com.unity.render-pipelines.universal/Shaders/DepthNormalsPass.hlsl"
// Note if we do any vertex displacement, we'll need to change the vertex function. e.g. :
/*
#pragma vertex DisplacedDepthNormalsVertex (instead of DepthNormalsVertex above)
Varyings DisplacedDepthNormalsVertex(Attributes input) {
Varyings output = (Varyings)0;
UNITY_SETUP_INSTANCE_ID(input);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Example Displacement
input.positionOS += float4(0, _SinTime.y, 0, 0);
output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);
output.positionCS = TransformObjectToHClip(input.position.xyz);
VertexNormalInputs normalInput = GetVertexNormalInputs(input.normal, input.tangentOS);
output.normalWS = NormalizeNormalPerVertex(normalInput.normalWS);
return output;
}
*/
ENDHLSL
}
// Note, while v10 versions ignore this, if you want normal mapping to affect the _CameraNormalsTexture, we could edit the DepthNormals pass
// (or if in v12+, use the LitDepthNormalsPass.hlsl instead, which additionally includes parallax and detail normals support)
// https://github.com/Unity-Technologies/Graphics/blob/master/com.unity.render-pipelines.universal/Shaders/LitDepthNormalsPass.hlsl
/*
Pass {
Name "DepthNormals"
Tags { "LightMode"="DepthNormals" }
ZWrite On
ZTest LEqual
HLSLPROGRAM
#pragma vertex DepthNormalsVertex
#pragma fragment DepthNormalsFragment
// Material Keywords
#pragma shader_feature_local _NORMALMAP
#pragma shader_feature_local_fragment _ALPHATEST_ON
#pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
// GPU Instancing
#pragma multi_compile_instancing
//#pragma multi_compile _ DOTS_INSTANCING_ON
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/SurfaceInput.hlsl"
#if defined(_NORMALMAP)
#define REQUIRES_WORLD_SPACE_TANGENT_INTERPOLATOR
#endif
struct Attributes {
float4 positionOS : POSITION;
float4 tangentOS : TANGENT;
float2 texcoord : TEXCOORD0;
float3 normal : NORMAL;
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct Varyings {
float4 positionCS : SV_POSITION;
float2 uv : TEXCOORD1;
float3 normalWS : TEXCOORD2;
#if defined(REQUIRES_WORLD_SPACE_TANGENT_INTERPOLATOR)
half4 tangentWS : TEXCOORD4; // xyz: tangent, w: sign
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
Varyings DepthNormalsVertex(Attributes input) {
Varyings output = (Varyings)0;
UNITY_SETUP_INSTANCE_ID(input);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Example Displacement
//input.positionOS += float4(0, _SinTime.y, 0, 0);
output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);
output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
VertexNormalInputs normalInput = GetVertexNormalInputs(input.normal, input.tangentOS);
output.normalWS = NormalizeNormalPerVertex(normalInput.normalWS);
#if defined(REQUIRES_WORLD_SPACE_TANGENT_INTERPOLATOR)
float sign = input.tangentOS.w * float(GetOddNegativeScale());
half4 tangentWS = half4(normalInput.tangentWS.xyz, sign);
output.tangentWS = tangentWS;
#endif
return output;
}
float4 DepthNormalsFragment(Varyings input) : SV_TARGET {
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
Alpha(SampleAlbedoAlpha(input.uv, TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap)).a, _BaseColor, _Cutoff);
#if defined(_NORMALMAP)
float sgn = input.tangentWS.w; // should be either +1 or -1
float3 bitangent = sgn * cross(input.normalWS.xyz, input.tangentWS.xyz);
float3 normalTS = SampleNormal(input.uv, TEXTURE2D_ARGS(_BumpMap, sampler_BumpMap), _BumpScale);
float3 normalWS = TransformTangentToWorld(normalTS, half3x3(input.tangentWS.xyz, bitangent.xyz, input.normalWS.xyz));
#else
float3 normalWS = input.normalWS;
#endif
return float4(PackNormalOctRectEncode(TransformWorldToViewDir(normalWS, true)), 0.0, 0.0);
}
ENDHLSL
}
*/
// Meta, used for baking global illumination / lightmaps
Pass {
Name "Meta"
Tags{"LightMode" = "Meta"}
Cull Off
HLSLPROGRAM
#pragma vertex UniversalVertexMeta
#pragma fragment UniversalFragmentMetaLit
#pragma shader_feature_local_fragment _SPECULAR_SETUP
#pragma shader_feature_local_fragment _EMISSION
#pragma shader_feature_local_fragment _METALLICSPECGLOSSMAP
#pragma shader_feature_local_fragment _ALPHATEST_ON
#pragma shader_feature_local_fragment _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
//#pragma shader_feature_local _ _DETAIL_MULX2 _DETAIL_SCALED
#pragma shader_feature_local_fragment _SPECGLOSSMAP
struct Attributes {
float4 positionOS : POSITION;
float3 normalOS : NORMAL;
float2 uv0 : TEXCOORD0;
float2 uv1 : TEXCOORD1;
float2 uv2 : TEXCOORD2;
#ifdef _TANGENT_TO_WORLD
float4 tangentOS : TANGENT;
#endif
float4 color : COLOR;
};
struct Varyings {
float4 positionCS : SV_POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
#include "PBRSurface.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/MetaInput.hlsl"
Varyings UniversalVertexMeta(Attributes input) {
Varyings output;
output.positionCS = MetaVertexPosition(input.positionOS, input.uv1, input.uv2, unity_LightmapST, unity_DynamicLightmapST);
output.uv = TRANSFORM_TEX(input.uv0, _BaseMap);
output.color = input.color;
return output;
}
half4 UniversalFragmentMetaLit(Varyings input) : SV_Target {
SurfaceData surfaceData;
InitializeSurfaceData(input, surfaceData);
BRDFData brdfData;
InitializeBRDFData(surfaceData.albedo, surfaceData.metallic, surfaceData.specular, surfaceData.smoothness, surfaceData.alpha, brdfData);
MetaInput metaInput;
metaInput.Albedo = brdfData.diffuse + brdfData.specular * brdfData.roughness * 0.5;
metaInput.Emission = surfaceData.emission;
return MetaFragment(metaInput);
}
ENDHLSL
}
// There is also other passes, e.g.
// Universal2D, if you need the shader to support the 2D Renderer
// UniversalGBuffer, for Deferred rendering support (v12 only)
// but not supporting them here. See the URP Shaders source :
// https://github.com/Unity-Technologies/Graphics/tree/master/com.unity.render-pipelines.universal/Shaders
}
}
Reference in New Issue View Git Blame Copy Permalink